flavor-code 1.3.0 → 1.3.2

package/dist/desktop/main.js

@@ -1,9 +1,10 @@
 // src/desktop/main.ts
 import { appendFileSync } from "fs";
-import { readFile as readFile36, stat as stat15, writeFile as writeFile18 } from "fs/promises";
-import { dirname as dirname24, join as join43 } from "path";
+import { createHash as createHash27, randomUUID as randomUUID27 } from "crypto";
+import { readFile as readFile39, stat as stat18, writeFile as writeFile19 } from "fs/promises";
+import { basename as basename11, dirname as dirname24, join as join46, resolve as resolve40 } from "path";
 import { fileURLToPath as fileURLToPath4 } from "url";
-import { app, BrowserWindow as BrowserWindow2, dialog, ipcMain, Menu, nativeImage, shell } from "electron";
+import { app, BrowserWindow as BrowserWindow2, clipboard, dialog, ipcMain, Menu, nativeImage, Notification, shell } from "electron";
 
 // src/desktop/contracts.ts
 import { z as z3 } from "zod";
@@ -450,7 +451,49 @@ var DESKTOP_CHANNELS = {
   chooseWorkspace: "desktop:choose-workspace",
   openWorkspace: "desktop:open-workspace",
   startSession: "desktop:start-session",
+  selectSession: "desktop:select-session",
   deleteSession: "desktop:delete-session",
+  updateSession: "desktop:update-session",
+  acknowledgeSession: "desktop:acknowledge-session",
+  updateProject: "desktop:update-project",
+  closeProject: "desktop:close-project",
+  revealProject: "desktop:reveal-project",
+  copyProjectPath: "desktop:copy-project-path",
+  dismissRecovery: "desktop:dismiss-recovery",
+  gitStatus: "desktop:git-status",
+  gitDiff: "desktop:git-diff",
+  gitStage: "desktop:git-stage",
+  gitUnstage: "desktop:git-unstage",
+  gitDiscard: "desktop:git-discard",
+  gitCommit: "desktop:git-commit",
+  gitReview: "desktop:git-review",
+  gitHistory: "desktop:git-history",
+  listWorktrees: "desktop:list-worktrees",
+  removeWorktree: "desktop:remove-worktree",
+  mergeWorktree: "desktop:merge-worktree",
+  historySnapshot: "desktop:history-snapshot",
+  createCheckpoint: "desktop:create-checkpoint",
+  rewindHistory: "desktop:rewind-history",
+  unrevertHistory: "desktop:unrevert-history",
+  forkHistory: "desktop:fork-history",
+  terminalOpen: "desktop:terminal-open",
+  terminalList: "desktop:terminal-list",
+  terminalRead: "desktop:terminal-read",
+  terminalWrite: "desktop:terminal-write",
+  terminalResize: "desktop:terminal-resize",
+  terminalClose: "desktop:terminal-close",
+  jobRead: "desktop:job-read",
+  previewValidate: "desktop:preview-validate",
+  previewOpen: "desktop:preview-open",
+  inspectWorkbench: "desktop:inspect-workbench",
+  astStatus: "desktop:ast-status",
+  astSearch: "desktop:ast-search",
+  astRelations: "desktop:ast-relations",
+  listPals: "desktop:list-pals",
+  sendPalMessage: "desktop:send-pal-message",
+  startCoWork: "desktop:start-co-work",
+  coWorkStatus: "desktop:co-work-status",
+  cancelCoWork: "desktop:cancel-co-work",
   showAppMenu: "desktop:show-app-menu",
   submit: "desktop:submit",
   finishTask: "desktop:finish-task",
@@ -473,6 +516,7 @@ var DESKTOP_CHANNELS = {
   createMemory: "desktop:create-memory",
   updateMemory: "desktop:update-memory",
   deleteMemory: "desktop:delete-memory",
+  deleteColdMemory: "desktop:delete-cold-memory",
   switchModel: "desktop:switch-model",
   addModel: "desktop:add-model",
   d2cImport: "desktop:d2c-import",
@@ -512,11 +556,49 @@ var DESKTOP_CHANNELS = {
 // src/desktop/contracts.ts
 var OpenWorkspaceInputSchema = z3.object({ path: z3.string().trim().min(1).max(32768) }).strict();
 var StartSessionInputSchema = z3.object({
-  resumeSession: z3.string().trim().min(1).max(128).optional()
+  resumeSession: z3.string().trim().min(1).max(128).optional(),
+  environment: z3.enum(["local", "worktree"]).optional()
 }).strict();
 var DeleteSessionInputSchema = z3.object({
   sessionId: z3.string().regex(/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/, "Invalid session id")
 }).strict();
+var UpdateSessionInputSchema = DeleteSessionInputSchema.extend({
+  title: z3.string().trim().max(120).optional(),
+  pinned: z3.boolean().optional(),
+  archived: z3.boolean().optional()
+}).strict();
+var UpdateProjectInputSchema = z3.object({
+  workspace: z3.string().trim().min(1).max(32768),
+  label: z3.string().trim().max(80).optional(),
+  pinned: z3.boolean().optional()
+}).strict();
+var ProjectPathInputSchema = z3.object({ workspace: z3.string().trim().min(1).max(32768) }).strict();
+var CloseProjectInputSchema = ProjectPathInputSchema.extend({ force: z3.boolean().optional() }).strict();
+var GitPathInputSchema = z3.object({ path: z3.string().min(1).max(32768) }).strict();
+var GitDiffInputSchema = GitPathInputSchema.extend({ staged: z3.boolean().optional() }).strict();
+var GitCommitInputSchema = z3.object({ message: z3.string().trim().min(1).max(2e4) }).strict();
+var GitReviewInputSchema = z3.object({
+  scope: z3.enum(["working", "staged", "commit", "base", "last-turn"]),
+  target: z3.string().trim().min(1).max(256).regex(/^[A-Za-z0-9][A-Za-z0-9._/@{}~^:-]*$/).optional(),
+  paths: z3.array(z3.string().min(1).max(32768)).max(200).optional()
+}).strict();
+var SafeIdInput = z3.string().trim().min(1).max(512).regex(/^[A-Za-z0-9._:/#@+~-]+$/);
+var WorktreeRemoveInputSchema = z3.object({ id: z3.string().regex(/^worktree-[a-z0-9._-]{1,80}$/), force: z3.boolean().optional() }).strict();
+var HistoryNodeInputSchema = z3.object({ nodeId: SafeIdInput }).strict();
+var CheckpointInputSchema = z3.object({ label: z3.string().trim().min(1).max(160).optional() }).strict();
+var TerminalOpenInputSchema = z3.object({ cwd: z3.string().max(32768).optional(), shell: z3.string().max(1024).optional(), columns: z3.number().int().min(20).max(500).optional(), rows: z3.number().int().min(5).max(300).optional() }).strict();
+var TerminalIdInputSchema = z3.object({ id: z3.string().regex(/^term-[A-Za-z0-9-]{1,80}$/) }).strict();
+var TerminalReadInputSchema = TerminalIdInputSchema.extend({ cursor: z3.number().int().min(0).max(Number.MAX_SAFE_INTEGER).optional() }).strict();
+var TerminalWriteInputSchema = TerminalIdInputSchema.extend({ data: z3.string().max(1e5) }).strict();
+var TerminalResizeInputSchema = TerminalIdInputSchema.extend({ columns: z3.number().int().min(20).max(500), rows: z3.number().int().min(5).max(300) }).strict();
+var JobReadInputSchema = z3.object({ id: z3.string().regex(/^job-[A-Za-z0-9-]{1,80}$/), cursor: z3.number().int().min(0).max(Number.MAX_SAFE_INTEGER).optional() }).strict();
+var PreviewUrlInputSchema = z3.object({ url: z3.string().trim().min(1).max(2048) }).strict();
+var PalMessageInputSchema = z3.object({ target: SafeIdInput, message: z3.string().trim().min(1).max(5e4), kind: z3.enum(["chat", "task"]) }).strict();
+var CoWorkStartInputSchema = z3.object({ target: SafeIdInput, goal: z3.string().trim().min(1).max(5e4) }).strict();
+var CoWorkStatusInputSchema = z3.object({ coWorkId: SafeIdInput.optional() }).strict();
+var CoWorkCancelInputSchema = z3.object({ coWorkId: SafeIdInput, reason: z3.string().trim().min(1).max(4e3).optional() }).strict();
+var AstSearchInputSchema = z3.object({ query: z3.string().trim().min(1).max(200) }).strict();
+var AstNodeInputSchema = z3.object({ id: SafeIdInput, hops: z3.number().int().min(1).max(4).optional() }).strict();
 var AppMenuInputSchema = z3.object({
   menu: z3.enum(["file", "edit", "view", "help"]),
   x: z3.number().int().min(0).max(32768),
@@ -1363,7 +1445,7 @@ async function runInteractionManifest(manifest, baseUrl, createDriver) {
       }
       const started = Date.now();
       let driver;
-      let failure;
+      let failure2;
       let apiRequestCount = 0;
       try {
         driver = await createDriver({ id: scenario.id, pageUrl });
@@ -1382,9 +1464,9 @@ async function runInteractionManifest(manifest, baseUrl, createDriver) {
           throw new Error("No API request was observed; the page is still behaving as a static implementation");
         }
       } catch (error) {
-        failure = error instanceof Error ? error.message : String(error);
+        failure2 = error instanceof Error ? error.message : String(error);
         const diagnostics = driver?.diagnostics?.();
-        if (diagnostics !== void 0) failure = `${failure} | ${diagnostics}`;
+        if (diagnostics !== void 0) failure2 = `${failure2} | ${diagnostics}`;
         apiRequestCount = driver?.apiRequestCount() ?? 0;
       } finally {
         await driver?.close().catch(() => void 0);
@@ -1393,14 +1475,14 @@ async function runInteractionManifest(manifest, baseUrl, createDriver) {
       scenarios.push({
         id: scenario.id,
         pageUrl,
-        passed: failure === void 0,
+        passed: failure2 === void 0,
         durationMs: Date.now() - started,
         apiRequestCount,
-        ...failure === void 0 ? {} : { failure },
+        ...failure2 === void 0 ? {} : { failure: failure2 },
         ...capturedRequests === void 0 ? {} : { requests: capturedRequests }
       });
-      if (failure !== void 0 && isAuthenticationPrerequisite(scenario)) {
-        blockedByAuthentication = { id: scenario.id, failure };
+      if (failure2 !== void 0 && isAuthenticationPrerequisite(scenario)) {
+        blockedByAuthentication = { id: scenario.id, failure: failure2 };
       }
     }
   }
@@ -1900,7 +1982,7 @@ function createEmbeddedD2cAutomation(getHost, options = {}) {
         const ready = await candidate.executeJavaScript("document.readyState", false).catch(() => void 0);
         if (ready === "complete" || ready === "interactive") return candidate;
       }
-      await new Promise((resolve36) => setTimeout(resolve36, pollIntervalMs));
+      await new Promise((resolve41) => setTimeout(resolve41, pollIntervalMs));
     }
     throw new Error(`D2C embedded preview did not navigate within ${navigationTimeoutMs} ms: ${url}${observedUrl === void 0 ? "" : `; last observed ${observedUrl}`}${observedFrames.length === 0 ? "; no live frames" : `; live frames ${observedFrames.join(", ")}`}`);
   };
@@ -1915,13 +1997,13 @@ function createEmbeddedD2cAutomation(getHost, options = {}) {
     while (Date.now() <= deadline) {
       last = await frame(baseUrl).executeJavaScript(assertionScript(step), true);
       if (last.passed) return last;
-      await new Promise((resolve36) => setTimeout(resolve36, 50));
+      await new Promise((resolve41) => setTimeout(resolve41, 50));
     }
     return last;
   };
   const settleAfterAction = async (previousUrl) => {
     const origin = new URL(previousUrl).origin;
-    await new Promise((resolve36) => setTimeout(resolve36, Math.min(180, Math.max(20, visualDelayMs * 0.25))));
+    await new Promise((resolve41) => setTimeout(resolve41, Math.min(180, Math.max(20, visualDelayMs * 0.25))));
     const deadline = Date.now() + Math.min(2e3, navigationTimeoutMs);
     while (Date.now() <= deadline) {
       const candidate = host().mainFrame.framesInSubtree.find((item) => !item.isDestroyed() && sameOrigin(item.url, origin));
@@ -1929,7 +2011,7 @@ function createEmbeddedD2cAutomation(getHost, options = {}) {
         const ready = await candidate.executeJavaScript("document.readyState", false).catch(() => void 0);
         if (ready === "complete" || ready === "interactive") return candidate;
       }
-      await new Promise((resolve36) => setTimeout(resolve36, pollIntervalMs));
+      await new Promise((resolve41) => setTimeout(resolve41, pollIntervalMs));
     }
     throw new Error("D2C preview frame was unavailable after an interaction action");
   };
@@ -2016,7 +2098,7 @@ function createEmbeddedD2cAutomation(getHost, options = {}) {
             return result;
           },
           settle: async () => {
-            await new Promise((resolve36) => setTimeout(resolve36, 150));
+            await new Promise((resolve41) => setTimeout(resolve41, 150));
             requests = await frame(activeUrl).executeJavaScript(`performance.getEntriesByType("resource").filter((entry) => {
               try { return ["fetch", "xmlhttprequest"].includes(entry.initiatorType) && new URL(entry.name).origin === ${JSON.stringify(mockOrigin)}; } catch { return false; }
             }).length`, false).catch(() => 0);
@@ -2102,7 +2184,7 @@ function responseText(protocol, value) {
   }
   throw new Error("D2C Judge response did not contain text output");
 }
-function createD2cJudgeClient(fetcher = globalThis.fetch, retryDelay = (ms) => new Promise((resolve36) => setTimeout(resolve36, ms))) {
+function createD2cJudgeClient(fetcher = globalThis.fetch, retryDelay = (ms) => new Promise((resolve41) => setTimeout(resolve41, ms))) {
   const request = async (config, prompt, images, maxTokens) => {
     const openAi = config.protocol === "openai-compatible";
     const imageContent = openAi ? images.map((image) => ({ type: "image_url", image_url: { url: dataUrl(image), detail: "high" } })) : images.map((image) => ({ type: "image", source: { type: "base64", media_type: "image/png", data: image.toString("base64") } }));
@@ -2461,7 +2543,7 @@ import { z as z7 } from "zod";
 import { Worker } from "worker_threads";
 function comparePngsInWorker(left, right, signal) {
   signal?.throwIfAborted();
-  return new Promise((resolve36, reject) => {
+  return new Promise((resolve41, reject) => {
     const worker = new Worker(new URL("./pixel-worker.js", import.meta.url));
     let settled = false;
     const finish = (callback) => {
@@ -2479,7 +2561,7 @@ function comparePngsInWorker(left, right, signal) {
         finish(() => reject(new Error(value.error ?? "D2C pixel worker failed")));
         return;
       }
-      finish(() => resolve36({ ...value.result, heatmapPng: Buffer.from(value.result.heatmapPng) }));
+      finish(() => resolve41({ ...value.result, heatmapPng: Buffer.from(value.result.heatmapPng) }));
     });
     worker.once("error", (error) => finish(() => reject(error)));
     worker.once("exit", (code) => {
@@ -4349,12 +4431,12 @@ function hasCycle(nodes) {
 
 // src/utils/async.ts
 function withTimeout(promise, ms) {
-  return new Promise((resolve36, reject) => {
+  return new Promise((resolve41, reject) => {
     let settled = false;
     const timer = setTimeout(() => {
       if (settled) return;
       settled = true;
-      resolve36({ timedOut: true, value: void 0 });
+      resolve41({ timedOut: true, value: void 0 });
     }, ms);
     timer.unref?.();
     promise.then(
@@ -4362,7 +4444,7 @@ function withTimeout(promise, ms) {
         if (!settled) {
           settled = true;
           clearTimeout(timer);
-          resolve36({ timedOut: false, value });
+          resolve41({ timedOut: false, value });
         }
       },
       (error) => {
@@ -4377,13 +4459,13 @@ function withTimeout(promise, ms) {
 }
 function awaitWithSignal3(promise, signal) {
   signal.throwIfAborted();
-  return new Promise((resolve36, reject) => {
+  return new Promise((resolve41, reject) => {
     const onAbort = () => reject(signal.reason);
     signal.addEventListener("abort", onAbort, { once: true });
     promise.then(
       (value) => {
         signal.removeEventListener("abort", onAbort);
-        resolve36(value);
+        resolve41(value);
       },
       (error) => {
         signal.removeEventListener("abort", onAbort);
@@ -4504,7 +4586,7 @@ var SubagentScheduler = class {
     }
   }
   async #runTask(task, signal) {
-    let failure;
+    let failure2;
     let completion;
     try {
       const start = await this.#options.hooks.emit({
@@ -4521,14 +4603,14 @@ var SubagentScheduler = class {
           completion = { id: task.id, result: parsed.data };
           break;
         }
-        failure = parsed.success ? new Error(`Subagent result taskId ${parsed.data.taskId} does not match ${task.id}`) : parsed.error;
+        failure2 = parsed.success ? new Error(`Subagent result taskId ${parsed.data.taskId} does not match ${task.id}`) : parsed.error;
       }
       completion ??= {
         id: task.id,
-        result: syntheticResult(task, "failed", `Invalid structured result after repair: ${message(failure)}`)
+        result: syntheticResult(task, "failed", `Invalid structured result after repair: ${message(failure2)}`)
       };
     } catch (error) {
-      failure = error;
+      failure2 = error;
       if (!signal.aborted) completion = { id: task.id, result: syntheticResult(task, "failed", message(error)) };
     } finally {
       try {
@@ -4538,18 +4620,18 @@ var SubagentScheduler = class {
           payload: {
             taskId: task.id,
             status: signal.aborted ? "cancelled" : completion?.result.status ?? "failed",
-            ...failure === void 0 ? {} : { error: message(failure) }
+            ...failure2 === void 0 ? {} : { error: message(failure2) }
           }
         });
       } catch (stopError) {
         if (!signal.aborted) {
-          failure = stopError;
+          failure2 = stopError;
           completion = { id: task.id, result: syntheticResult(task, "failed", message(stopError)) };
         }
       }
     }
     if (signal.aborted) throw signal.reason;
-    return completion ?? { id: task.id, result: syntheticResult(task, "failed", message(failure)) };
+    return completion ?? { id: task.id, result: syntheticResult(task, "failed", message(failure2)) };
   }
 };
 function isReady(task, states) {
@@ -6292,10 +6374,10 @@ function sanitize(message2, secrets) {
 }
 function waitForRetry(delayMs, signal) {
   if (signal?.aborted) return Promise.reject(signal.reason);
-  return new Promise((resolve36, reject) => {
+  return new Promise((resolve41, reject) => {
     const timer = setTimeout(() => {
       signal?.removeEventListener("abort", onAbort);
-      resolve36();
+      resolve41();
     }, delayMs);
     const onAbort = () => {
       clearTimeout(timer);
@@ -6897,10 +6979,10 @@ function serializeToolInput(input) {
 }
 function waitForRetry2(delayMs, signal) {
   if (signal?.aborted) return Promise.reject(signal.reason);
-  return new Promise((resolve36, reject) => {
+  return new Promise((resolve41, reject) => {
     const timer = setTimeout(() => {
       signal?.removeEventListener("abort", onAbort);
-      resolve36();
+      resolve41();
     }, delayMs);
     const onAbort = () => {
       clearTimeout(timer);
@@ -8385,7 +8467,7 @@ var HookBus = class {
   }
 };
 function runShellHandler(descriptor, event, signal) {
-  return new Promise((resolve36, reject) => {
+  return new Promise((resolve41, reject) => {
     const child = spawn(descriptor.command, [...descriptor.args ?? []], {
       env: { ...process.env, ...descriptor.env },
       shell: false,
@@ -8428,7 +8510,7 @@ function runShellHandler(descriptor, event, signal) {
         return;
       }
       try {
-        resolve36(HookDecisionSchema.parse(JSON.parse(stdout)));
+        resolve41(HookDecisionSchema.parse(JSON.parse(stdout)));
       } catch (error) {
         reject(error);
       }
@@ -8467,7 +8549,7 @@ function zodRecord(payload) {
 // src/utils/execFileNoThrow.ts
 import { execFile } from "child_process";
 function execFileNoThrow(file, args, options = {}) {
-  return new Promise((resolve36) => {
+  return new Promise((resolve41) => {
     const child = execFile(file, args, {
       timeout: options.timeout,
       cwd: options.useCwd === false ? void 0 : process.cwd(),
@@ -8475,7 +8557,7 @@ function execFileNoThrow(file, args, options = {}) {
       encoding: "utf8",
       windowsHide: true
     }, (error, stdout, stderr) => {
-      resolve36({
+      resolve41({
         stdout,
         stderr,
         code: typeof error?.code === "number" ? error.code : error ? 1 : 0,
@@ -9777,7 +9859,7 @@ var USAGE = [
   "  clear     reset signals, done markers, and verified markers"
 ].join("\n");
 function runCommand(command, cwd, timeoutMs) {
-  return new Promise((resolve36) => {
+  return new Promise((resolve41) => {
     const isWindows = process.platform === "win32";
     const child = spawn2(isWindows ? "cmd.exe" : "/bin/sh", isWindows ? ["/d", "/s", "/c", command] : ["-c", command], {
       cwd,
@@ -9787,7 +9869,7 @@ function runCommand(command, cwd, timeoutMs) {
     let stderr = "";
     const timer = setTimeout(() => {
       child.kill();
-      resolve36({ ok: false, stdout, stderr: `${stderr}
+      resolve41({ ok: false, stdout, stderr: `${stderr}
 [killed: exceeded ${timeoutMs}ms]`, code: "timeout" });
     }, timeoutMs);
     child.stdout.on("data", (chunk) => {
@@ -9798,12 +9880,12 @@ function runCommand(command, cwd, timeoutMs) {
     });
     child.on("error", (error) => {
       clearTimeout(timer);
-      resolve36({ ok: false, stdout, stderr: `${stderr}
+      resolve41({ ok: false, stdout, stderr: `${stderr}
 ${error.message}`, code: "spawn" });
     });
     child.on("close", (code) => {
       clearTimeout(timer);
-      resolve36({ ok: code === 0, stdout, stderr, code: code ?? "unknown" });
+      resolve41({ ok: code === 0, stdout, stderr, code: code ?? "unknown" });
     });
   });
 }
@@ -13846,8 +13928,8 @@ var OAuthCallbackAuthProvider = class {
   async #startCallbackServer(expectedState, signal) {
     let serverResolve;
     let serverReject;
-    const codePromise = new Promise((resolve36, reject) => {
-      serverResolve = resolve36;
+    const codePromise = new Promise((resolve41, reject) => {
+      serverResolve = resolve41;
       serverReject = reject;
     });
     const server = createServer2((req, res) => {
@@ -13881,7 +13963,7 @@ var OAuthCallbackAuthProvider = class {
       );
       serverResolve(code);
     });
-    return new Promise((resolve36, reject) => {
+    return new Promise((resolve41, reject) => {
       server.once("error", (error) => {
         reject(new Error(`OAuth callback server failed: ${error.message}`));
       });
@@ -13898,7 +13980,7 @@ var OAuthCallbackAuthProvider = class {
         signal.addEventListener("abort", () => {
           serverReject(new Error("OAuth flow aborted"));
         }, { once: true });
-        resolve36({ redirectUri, promise: codePromise });
+        resolve41({ redirectUri, promise: codePromise });
       });
     });
   }
@@ -18527,8 +18609,8 @@ var LspConnection = class {
     const id = this.#nextId++;
     const request = { jsonrpc: "2.0", id, method, params };
     const timeout = AbortSignal.timeout(LSP_REQUEST_TIMEOUT_MS);
-    const promise = new Promise((resolve36, reject) => {
-      this.#pending.set(id, { resolve: resolve36, reject });
+    const promise = new Promise((resolve41, reject) => {
+      this.#pending.set(id, { resolve: resolve41, reject });
       timeout.addEventListener("abort", () => {
         if (this.#pending.has(id)) {
           this.#pending.delete(id);
@@ -18932,19 +19014,19 @@ async function changeSummary(workspace) {
   };
 }
 async function stagedDiff(workspace, maxChars = 96e3) {
-  const stat16 = await git2(workspace, ["diff", "--staged", "--stat"]);
+  const stat19 = await git2(workspace, ["diff", "--staged", "--stat"]);
   const diff = await git2(workspace, ["diff", "--staged", "--no-ext-diff", "--no-color"]);
   if (!diff.ok) throw gitFailure(diff, "diff --staged");
   const text = diff.stdout;
   return {
     diff: text.length > maxChars ? `${text.slice(0, maxChars)}
 \u2026[diff truncated]` : text,
-    stat: stat16.stdout.trim(),
+    stat: stat19.stdout.trim(),
     truncated: text.length > maxChars
   };
 }
 async function uncommittedDiff(workspace, maxChars = 96e3) {
-  const stat16 = await git2(workspace, ["diff", "HEAD", "--stat"]);
+  const stat19 = await git2(workspace, ["diff", "HEAD", "--stat"]);
   const diff = await git2(workspace, ["diff", "HEAD", "--no-ext-diff", "--no-color"]);
   if (!diff.ok && !diff.stderr.includes("unknown revision")) throw gitFailure(diff, "diff HEAD");
   const summary2 = await changeSummary(workspace);
@@ -18952,7 +19034,7 @@ async function uncommittedDiff(workspace, maxChars = 96e3) {
   return {
     diff: text.length > maxChars ? `${text.slice(0, maxChars)}
 \u2026[diff truncated]` : text,
-    stat: stat16.stdout.trim(),
+    stat: stat19.stdout.trim(),
     untracked: summary2.untrackedFiles
   };
 }
@@ -19166,7 +19248,7 @@ var QuestionBridge = class {
   ask(questions, signal) {
     if (this.#pending !== void 0) return Promise.reject(new Error("A question is already pending"));
     if (signal.aborted) return Promise.reject(signal.reason);
-    return new Promise((resolve36, reject) => {
+    return new Promise((resolve41, reject) => {
       const onAbort = () => {
         this.#pending = void 0;
         reject(signal.reason instanceof Error ? signal.reason : new Error(String(signal.reason)));
@@ -19178,7 +19260,7 @@ var QuestionBridge = class {
           signal.removeEventListener("abort", onAbort);
           this.#pending = void 0;
           this.#onChange?.();
-          resolve36(answers);
+          resolve41(answers);
         },
         reject: (error) => {
           signal.removeEventListener("abort", onAbort);
@@ -20795,9 +20877,9 @@ var FlavorSession = class {
   }
   #waitForPlanningIdle(key) {
     if (!this.#activePlanning.has(key)) return Promise.resolve();
-    return new Promise((resolve36) => {
+    return new Promise((resolve41) => {
       const check2 = () => {
-        if (!this.#activePlanning.has(key)) resolve36();
+        if (!this.#activePlanning.has(key)) resolve41();
         else this.#planningIdleWaiters.add(check2);
       };
       this.#planningIdleWaiters.add(check2);
@@ -22800,8 +22882,8 @@ var JobRegistry = class {
     const id = `job-${randomUUID17().slice(0, 12)}`;
     const now = (/* @__PURE__ */ new Date()).toISOString();
     let settle;
-    const done = new Promise((resolve36) => {
-      settle = resolve36;
+    const done = new Promise((resolve41) => {
+      settle = resolve41;
     });
     const record3 = {
       id,
@@ -23305,15 +23387,15 @@ async function acquirePalFileLock(options) {
 // src/pals/broker-cli.ts
 var startupAttempts = /* @__PURE__ */ new Map();
 function delay3(milliseconds) {
-  return new Promise((resolve36) => setTimeout(resolve36, milliseconds));
+  return new Promise((resolve41) => setTimeout(resolve41, milliseconds));
 }
 function canConnect(address) {
-  return new Promise((resolve36) => {
+  return new Promise((resolve41) => {
     const socket = new Socket2();
     const finish = (connected) => {
       socket.removeAllListeners();
       socket.destroy();
-      resolve36(connected);
+      resolve41(connected);
     };
     socket.once("connect", () => finish(true));
     socket.once("error", () => finish(false));
@@ -23327,18 +23409,25 @@ function startupLockPath(address) {
 async function spawnProductionBroker(address) {
   const entry2 = process.argv[1];
   if (entry2 === void 0) throw new Error("Cannot auto-start pals broker without a CLI entry point");
+  return spawnPalBrokerProcess({ address, executable: process.execPath, args: [entry2, "--pals-broker", address] });
+}
+async function spawnPalBrokerProcess(options) {
+  if (options.executable.trim() === "" || options.args.length === 0) throw new Error("Pals broker process requires an executable and entry arguments");
+  const address = options.address;
   const lockPath = startupLockPath(address);
   const lock = await acquirePalFileLock({ path: lockPath, endpointLive: () => canConnect(address) });
   if (lock === void 0) return;
   try {
-    const child = spawn7(process.execPath, [entry2, "--pals-broker", address], {
+    const child = spawn7(options.executable, [...options.args], {
       detached: true,
       stdio: "ignore",
-      windowsHide: true
+      windowsHide: true,
+      ...options.environment === void 0 ? {} : { env: options.environment }
     });
     child.unref();
     const deadline = Date.now() + 5e3;
     while (Date.now() < deadline && !await canConnect(address)) await delay3(25);
+    if (!await canConnect(address)) throw new Error(`Pals broker process did not become ready at '${address}'`);
   } finally {
     await lock.release();
   }
@@ -23497,8 +23586,8 @@ var PalClient = class {
       let disconnectTimer;
       await Promise.race([
         this.request({ version: 1, type: "disconnect", requestId: randomUUID22() }).catch(() => void 0),
-        new Promise((resolve36) => {
-          disconnectTimer = setTimeout(resolve36, Math.min(this.requestTimeoutMs, 250));
+        new Promise((resolve41) => {
+          disconnectTimer = setTimeout(resolve41, Math.min(this.requestTimeoutMs, 250));
         })
       ]);
       if (disconnectTimer !== void 0) clearTimeout(disconnectTimer);
@@ -23544,7 +23633,7 @@ var PalClient = class {
     return presence;
   }
   openSocket() {
-    return new Promise((resolve36, reject) => {
+    return new Promise((resolve41, reject) => {
       let settled = false;
       const rejectConnection = (error) => {
         if (settled) return;
@@ -23567,7 +23656,7 @@ var PalClient = class {
         settled = true;
         if (this.connectingReject === rejectConnection) this.connectingReject = void 0;
         socket.off("error", onInitialError);
-        resolve36();
+        resolve41();
       };
       const onInitialError = (error) => {
         socket.off("connect", onConnect);
@@ -23598,12 +23687,12 @@ var PalClient = class {
     if (this.closed || socket === void 0 || socket.destroyed || !socket.writable) {
       return Promise.reject(new Error(this.closed ? "Pal client is closed" : "Pal client is not connected"));
     }
-    return new Promise((resolve36, reject) => {
+    return new Promise((resolve41, reject) => {
       const timer = setTimeout(() => {
         this.pending.delete(request.requestId);
         reject(new Error(`Pal request '${request.type}' timed out`));
       }, this.requestTimeoutMs);
-      this.pending.set(request.requestId, { resolve: resolve36, reject, timer });
+      this.pending.set(request.requestId, { resolve: resolve41, reject, timer });
       let frame;
       try {
         frame = encodeControlFrame(BrokerRequestSchema.parse(request));
@@ -23916,6 +24005,51 @@ var INTERRUPTED_TASK_PLAN_CONTEXT = [
   "Reassess the current query independently.",
   "If the current work needs a plan, create a fresh one with TaskPlan before using TaskUpdate."
 ].join(" ");
+function recoverablePalClient(client, onRecovered) {
+  let presence;
+  let starting;
+  const ensure = () => {
+    if (presence !== void 0) return Promise.resolve(presence);
+    if (starting !== void 0) return starting;
+    starting = client.start().then((value) => {
+      presence = value;
+      onRecovered();
+      return value;
+    }).finally(() => {
+      starting = void 0;
+    });
+    return starting;
+  };
+  const invoke = async (run) => {
+    await ensure();
+    try {
+      return await run();
+    } catch (error) {
+      const detail = message(error);
+      if (!/not connected|connection closed|ECONNRESET|ECONNREFUSED|EPIPE/i.test(detail)) throw error;
+      presence = void 0;
+      await ensure();
+      return run();
+    }
+  };
+  return {
+    start: ensure,
+    list: () => invoke(() => client.list()),
+    rename: (alias) => invoke(() => client.rename(alias)),
+    sendTask: (target, value) => invoke(() => client.sendTask(target, value)),
+    sendChat: (target, value) => invoke(() => client.sendChat(target, value)),
+    startCoWork: (input) => invoke(() => client.startCoWork(input)),
+    coWorkAction: (action) => invoke(() => client.coWorkAction(action)),
+    coWorkStatus: (coWorkId) => invoke(() => client.coWorkStatus(coWorkId)),
+    integrateCoWork: (input) => invoke(() => client.integrateCoWork(input)),
+    cancelCoWork: (coWorkId, reason) => invoke(() => client.cancelCoWork(coWorkId, reason)),
+    subscribe: (listener) => client.subscribe(listener),
+    close: async () => {
+      presence = void 0;
+      await client.close();
+    }
+  };
+}
 var DEFAULT_SHUTDOWN_STEP_TIMEOUT_MS = 3e3;
 function createPromptEnvironment(input = {}) {
   const now = input.now ?? /* @__PURE__ */ new Date();
@@ -24236,6 +24370,7 @@ async function createProductionRuntime(options) {
   tools.push(evolveService.toolDefinition());
   let sleepScheduler;
   let collaborationClient;
+  let collaborationUnavailableDiagnostic;
   let unsubscribeCollaboration;
   let collaborationSession;
   let deliverCollaborationEvent;
@@ -24278,7 +24413,7 @@ async function createProductionRuntime(options) {
         userScope: home,
         runtimeDir: join31(tmpdir3(), `flavor-code-pals-${createHash20("sha256").update(home).digest("hex").slice(0, 16)}`)
       });
-      collaborationClient = collaboration.client ?? collaboration.createClient?.({
+      const baseCollaborationClient = collaboration.client ?? collaboration.createClient?.({
         instanceId: collaboration.instanceId,
         alias,
         projectPath: workspace
@@ -24286,8 +24421,13 @@ async function createProductionRuntime(options) {
         address,
         authHome: home,
         registration: { id: collaboration.instanceId, alias, projectPath: workspace },
-        startBroker: () => ensurePalBrokerRunning({ address })
+        startBroker: () => ensurePalBrokerRunning({ address, ...collaboration.startBroker === void 0 ? {} : { startBroker: () => collaboration.startBroker(address) } })
       });
+      collaborationClient = collaboration.optional ? recoverablePalClient(baseCollaborationClient, () => {
+        if (collaborationUnavailableDiagnostic === void 0) return;
+        remove(diagnostics, collaborationUnavailableDiagnostic);
+        collaborationUnavailableDiagnostic = void 0;
+      }) : baseCollaborationClient;
       deliverCollaborationEvent = async (event) => {
         const session2 = collaborationSession;
         const client = collaborationClient;
@@ -24342,11 +24482,19 @@ async function createProductionRuntime(options) {
         }
       };
       unsubscribeCollaboration = collaborationClient.subscribe(enqueueCollaborationEvent);
-      tools.push(...createPalsTools(collaborationClient, {
-        selfId: collaboration.instanceId,
-        shareGuard: new CollaborationShareGuard({ redact: (value) => redactSecrets(value, secrets) })
-      }));
-      await collaborationClient.start();
+      try {
+        await collaborationClient.start();
+      } catch (error) {
+        if (!collaboration.optional) throw error;
+        collaborationUnavailableDiagnostic = `Pals unavailable: ${message(error)}`;
+        diagnostics.push(collaborationUnavailableDiagnostic);
+      }
+      if (collaborationClient !== void 0) {
+        tools.push(...createPalsTools(collaborationClient, {
+          selfId: collaboration.instanceId,
+          shareGuard: new CollaborationShareGuard({ redact: (value) => redactSecrets(value, secrets) })
+        }));
+      }
     }
     const syncMcpTools = () => {
       for (const tool of mcpTools) remove(tools, tool);
@@ -25103,6 +25251,7 @@ async function createProductionRuntime(options) {
       }),
       rename: (alias) => collaborationClient.rename(alias),
       info: (target) => resolveCollaborationTarget(target),
+      sendChat: (target, message2) => collaborationClient.sendChat(target, message2),
       sendTask: (target, goal) => collaborationClient.sendTask(target, goal),
       startCoWork: async (target, goal) => {
         const recipient = await resolveCollaborationTarget(target);
@@ -25363,6 +25512,7 @@ ${summary2}`;
         return sessionHistory.checkpoint(tagged, harness.main.context.snapshot());
       },
       tree: () => sessionHistory.tree(),
+      historyLeaf: () => sessionHistory.leafId,
       rewind: async (nodeId) => {
         await sessionHistory.rewind(nodeId, harness.main.context.snapshot());
         await persist();
@@ -25551,7 +25701,7 @@ ${renderMemoryDocument(entries)}`;
       approvals,
       memoryReviews,
       restoredTranscript,
-      jobs: { list: () => jobs.list(), subscribe: (listener) => jobs.subscribe(listener) },
+      jobs: { list: () => jobs.list(), read: (id, owner2, cursor) => jobs.read(id, owner2, cursor), subscribe: (listener) => jobs.subscribe(listener) },
       get sessionId() {
         return sessionId;
       },
@@ -25832,23 +25982,23 @@ async function* persistEach(source, persist) {
   }
 }
 async function* durableTurn(source, journal, turnId, config) {
-  let failure;
+  let failure2;
   let completed = false;
   try {
     for await (const event of source) {
-      if (event.type === "error") failure = event.error.message;
+      if (event.type === "error") failure2 = event.error.message;
       yield event;
     }
     completed = true;
   } catch (error) {
-    failure = message(error);
+    failure2 = message(error);
     throw error;
   } finally {
-    if (completed && failure === void 0) {
+    if (completed && failure2 === void 0) {
       journal.completeTurn(turnId);
       journal.savepoint("turn-complete", config);
     } else {
-      journal.interruptTurn(turnId, failure ?? "turn consumer interrupted before completion");
+      journal.interruptTurn(turnId, failure2 ?? "turn consumer interrupted before completion");
     }
   }
 }
@@ -28232,11 +28382,22 @@ var ProjectMemoryManager = class {
     this.#store = store;
     this.#enabled = enabled;
   }
-  async snapshot() {
+  async snapshot(now = /* @__PURE__ */ new Date()) {
+    const references = this.#enabled ? await this.#store.references() : [];
     return {
       enabled: this.#enabled,
       path: this.#store.path,
-      entries: this.#enabled ? await this.#store.list() : []
+      entries: references.map((reference) => {
+        const lastRecalledAt = Object.values(reference.recalls).sort().at(-1);
+        return {
+          id: reference.id,
+          type: reference.type,
+          content: reference.summary,
+          recallTotal: reference.recallTotal,
+          heat: classifyMemoryHeat(reference, now),
+          ...lastRecalledAt === void 0 ? {} : { lastRecalledAt }
+        };
+      })
     };
   }
   async remember(candidate) {
@@ -28253,6 +28414,10 @@ var ProjectMemoryManager = class {
     this.#assertEnabled();
     return this.#store.delete(id);
   }
+  async deleteCold(now = /* @__PURE__ */ new Date()) {
+    this.#assertEnabled();
+    return this.#store.forgetCold(now);
+  }
   #assertEnabled() {
     if (!this.#enabled) throw new Error("Long-term memory is disabled for this project");
   }
@@ -28577,6 +28742,7 @@ async function d2cBackendSourceFingerprint(project) {
 var DesktopRuntimeController = class {
   #home;
   #createRuntime;
+  #createTerminalService;
   #listSessions;
   #deleteStoredSession;
   #loadModels;
@@ -28599,8 +28765,10 @@ var DesktopRuntimeController = class {
   #skillManager;
   #memoryManager;
   #mcpManager;
+  #terminal;
   #models = DEFAULT_DESKTOP_MODELS;
   #busy = false;
+  #tasks;
   #disposeJobSubscription;
   #d2cMocks = /* @__PURE__ */ new Map();
   #d2cPreviews = /* @__PURE__ */ new Map();
@@ -28612,6 +28780,7 @@ var DesktopRuntimeController = class {
   constructor(options) {
     this.#home = resolve35(options.home ?? homedir4());
     this.#createRuntime = options.createRuntime ?? (async (runtimeOptions) => createProductionRuntime(runtimeOptions));
+    this.#createTerminalService = options.createTerminalService ?? ((workspace) => new TerminalService(workspace));
     this.#listSessions = options.listSessions ?? (async (workspace) => {
       const store = new SessionStore({ workspace });
       const entries = await store.list();
@@ -28678,7 +28847,8 @@ var DesktopRuntimeController = class {
       },
       diagnostics: runtime?.diagnostics ?? [],
       models: this.#models,
-      jobs: runtime?.jobs?.list() ?? []
+      jobs: runtime?.jobs?.list() ?? [],
+      ...this.#tasks === void 0 ? {} : { tasks: this.#tasks }
     };
   }
   async openWorkspace(path) {
@@ -28690,6 +28860,8 @@ var DesktopRuntimeController = class {
       await this.#stopAllD2cMocks();
     }
     this.#workspace = workspace;
+    this.#terminal?.dispose();
+    this.#terminal = this.#createTerminalService(workspace);
     this.#skillManager = new SkillManager({ workspace, home: this.#home });
     this.#memoryManager = await this.#loadMemoryManager(workspace, this.#home);
     this.#mcpManager = this.#loadMcpManager(workspace);
@@ -28720,6 +28892,7 @@ var DesktopRuntimeController = class {
           bufferedOutput.push(event);
           return;
         }
+        this.#captureSessionOutput(event);
         this.#emit({ type: "session-output", sessionId: outputSessionId, event });
       },
       onApprovalChange: () => {
@@ -28743,6 +28916,7 @@ var DesktopRuntimeController = class {
     this.#emit({ type: "session-started", payload });
     outputReady = true;
     for (const event of bufferedOutput) {
+      this.#captureSessionOutput(event);
       this.#emit({ type: "session-output", sessionId: runtime.sessionId, event });
     }
     this.#publishSnapshot();
@@ -28913,6 +29087,83 @@ var DesktopRuntimeController = class {
     if (deleted) await this.#runtime?.services.refreshMemory?.();
     return deleted;
   }
+  async deleteColdMemory() {
+    const manager = this.#requireMemoryManager();
+    if (manager.deleteCold === void 0) throw new Error("Cold-memory cleanup is unavailable");
+    const result = await manager.deleteCold();
+    if (result.removed > 0) await this.#runtime?.services.refreshMemory?.();
+    return result.removed;
+  }
+  async historySnapshot() {
+    const services = this.#requireRuntime().services;
+    if (services.tree === void 0) throw new Error("Session history is unavailable");
+    return { leafId: services.historyLeaf?.() ?? null, nodes: services.tree() };
+  }
+  async createCheckpoint(label) {
+    const checkpoint = this.#requireRuntime().services.checkpoint;
+    if (checkpoint === void 0) throw new Error("Session checkpoints are unavailable");
+    return checkpoint(label?.trim() || void 0);
+  }
+  async rewindHistory(nodeId) {
+    const rewind = this.#requireRuntime().services.rewind;
+    if (rewind === void 0) throw new Error("Session rewind is unavailable");
+    await rewind(nodeId);
+  }
+  async unrevertHistory() {
+    const unrevert = this.#requireRuntime().services.unrevert;
+    if (unrevert === void 0) throw new Error("Session unrevert is unavailable");
+    await unrevert();
+  }
+  async forkHistory(nodeId) {
+    const fork = this.#requireRuntime().services.fork;
+    if (fork === void 0) throw new Error("Session fork is unavailable");
+    await fork(nodeId);
+  }
+  openTerminal(input = {}) {
+    return this.#requireTerminal().open({ ...input, owner: this.#requireRuntime().sessionId });
+  }
+  listTerminals() {
+    return this.#requireTerminal().list(this.#requireRuntime().sessionId).filter((terminal) => terminal.state !== "closed");
+  }
+  readTerminal(id, cursor = 0) {
+    return this.#requireTerminal().read(id, this.#requireRuntime().sessionId, cursor);
+  }
+  writeTerminal(id, data2) {
+    this.#requireTerminal().write(id, this.#requireRuntime().sessionId, data2);
+  }
+  resizeTerminal(id, columns, rows) {
+    this.#requireTerminal().resize(id, this.#requireRuntime().sessionId, columns, rows);
+  }
+  closeTerminal(id) {
+    this.#requireTerminal().close(id, this.#requireRuntime().sessionId);
+  }
+  readJob(id, cursor = 0) {
+    const runtime = this.#requireRuntime();
+    if (runtime.jobs === void 0) throw new Error("Background job output is unavailable");
+    const job = runtime.jobs.list().find((item) => item.id === id);
+    if (job === void 0) throw new Error(`Unknown background job: ${id}`);
+    return runtime.jobs.read(id, job.owner, cursor);
+  }
+  async listPals(verbose = true) {
+    return this.#requirePals().list(verbose);
+  }
+  async sendPalMessage(target, message2, kind) {
+    const pals = this.#requirePals();
+    if (kind === "chat") {
+      if (pals.sendChat === void 0) throw new Error("Pal chat is unavailable");
+      return pals.sendChat(target, message2);
+    }
+    return pals.sendTask(target, message2);
+  }
+  async startCoWork(target, goal) {
+    return this.#requirePals().startCoWork(target, goal);
+  }
+  async coWorkStatus(coWorkId) {
+    return this.#requirePals().coWorkStatus(coWorkId);
+  }
+  async cancelCoWork(coWorkId, reason) {
+    return this.#requirePals().cancelCoWork(coWorkId, reason);
+  }
   async switchModel(modelId) {
     if (this.#busy) throw new Error("Stop the active task before switching models");
     if (!this.#models.some((model) => model.id === modelId)) {
@@ -29675,6 +29926,8 @@ VITE_API_BASE_URL=${running.url}
     await this.#disposeRuntime();
     await this.#stopAllD2cPreviews();
     await this.#stopAllD2cMocks();
+    this.#terminal?.dispose();
+    this.#terminal = void 0;
   }
   #publishSnapshot() {
     const snapshot4 = this.snapshot();
@@ -29695,6 +29948,7 @@ VITE_API_BASE_URL=${running.url}
     this.#disposeJobSubscription = void 0;
     this.#runtime = void 0;
     this.#busy = false;
+    this.#tasks = void 0;
     if (runtime === void 0) return;
     await runtime.session.close();
     await runtime.dispose();
@@ -29732,6 +29986,23 @@ VITE_API_BASE_URL=${running.url}
     if (this.#mcpManager === void 0) throw new Error("Open a project before managing MCP services");
     return this.#mcpManager;
   }
+  #captureSessionOutput(event) {
+    if (event.type === "tasks") this.#tasks = event.snapshot;
+    else if (event.type === "tasks-cleared") this.#tasks = void 0;
+  }
+  #requireRuntime() {
+    if (this.#runtime === void 0) throw new Error("Start a session before using this feature");
+    return this.#runtime;
+  }
+  #requireTerminal() {
+    if (this.#terminal === void 0) throw new Error("Open a project before using the terminal");
+    return this.#terminal;
+  }
+  #requirePals() {
+    const pals = this.#requireRuntime().services.pals;
+    if (pals === void 0) throw new Error("Pals are unavailable for this session");
+    return pals;
+  }
 };
 
 // src/desktop/security.ts
@@ -29748,6 +30019,16 @@ function normalizePersistedWorkspace(value) {
   const workspace = value.workspace;
   return typeof workspace === "string" && workspace.trim().length > 0 && workspace.length <= 32768 ? workspace : void 0;
 }
+function normalizePersistedDesktopProjects(value) {
+  const workspace = normalizePersistedWorkspace(value);
+  if (typeof value !== "object" || value === null) {
+    return { ...workspace === void 0 ? {} : { workspace }, projects: workspace === void 0 ? [] : [workspace] };
+  }
+  const rawProjects = value.projects;
+  const projects = Array.isArray(rawProjects) ? rawProjects.filter((item) => typeof item === "string" && item.trim().length > 0 && item.length <= 32768) : [];
+  const unique = [.../* @__PURE__ */ new Set([...workspace === void 0 ? [] : [workspace], ...projects])].slice(0, 50);
+  return { ...workspace === void 0 ? {} : { workspace }, projects: unique };
+}
 function isTrustedNavigation(target, current, trustedRenderer) {
   return target === trustedRenderer || current === trustedRenderer && target === current;
 }
@@ -29831,6 +30112,472 @@ ${reason.stack ?? ""}`;
   process.on("uncaughtException", (error) => crash("uncaughtException", error));
 }
 
+// src/desktop/git-manager.ts
+import { readFile as readFile36, rm as rm16 } from "fs/promises";
+import { isAbsolute as isAbsolute18, relative as relative26, resolve as resolve36 } from "path";
+function failure(action, stderr, stdout) {
+  return new Error(`${action}\u5931\u8D25\uFF1A${(stderr.trim() || stdout.trim() || "\u672A\u77E5 Git \u9519\u8BEF").split("\n")[0]}`);
+}
+async function desktopGitStatus(workspace) {
+  if (!await isGitRepository(workspace)) return { repository: false, branch: "", head: "", files: [] };
+  const summary2 = await changeSummary(workspace);
+  return {
+    repository: true,
+    branch: summary2.branch,
+    head: summary2.head,
+    files: summary2.statusLines.map((line) => {
+      const index = line[0] ?? " ";
+      const worktree = line[1] ?? " ";
+      return {
+        path: line.slice(3).replace(/^.* -> /, ""),
+        index,
+        worktree,
+        staged: index !== " " && index !== "?",
+        unstaged: worktree !== " " && worktree !== "?",
+        untracked: index === "?" && worktree === "?"
+      };
+    })
+  };
+}
+async function desktopGitDiff(workspace, path, staged = false) {
+  const status = await desktopGitStatus(workspace);
+  const file = status.files.find((item) => item.path === path);
+  if (file === void 0) throw new Error("\u8BE5\u6587\u4EF6\u5DF2\u4E0D\u5728\u53D8\u66F4\u5217\u8868\u4E2D");
+  if (file.untracked) {
+    const target = safeWorkspacePath(workspace, path);
+    const value = await readFile36(target, "utf8");
+    return value.length > 12e4 ? `${value.slice(0, 12e4)}
+\u2026[\u5185\u5BB9\u5DF2\u622A\u65AD]` : value;
+  }
+  const result = await git2(workspace, ["diff", ...staged ? ["--staged"] : [], "--no-ext-diff", "--no-color", "--", path]);
+  if (!result.ok) throw failure("\u8BFB\u53D6\u5DEE\u5F02", result.stderr, result.stdout);
+  return result.stdout || "\uFF08\u6B64\u533A\u57DF\u6CA1\u6709\u5DEE\u5F02\uFF09";
+}
+async function desktopGitStage(workspace, path) {
+  await assertListed(workspace, path);
+  const result = await git2(workspace, ["add", "--", path]);
+  if (!result.ok) throw failure("\u6682\u5B58", result.stderr, result.stdout);
+  return desktopGitStatus(workspace);
+}
+async function desktopGitUnstage(workspace, path) {
+  const file = await assertListed(workspace, path);
+  if (!file.staged) return desktopGitStatus(workspace);
+  const head = await git2(workspace, ["rev-parse", "--verify", "HEAD"]);
+  const result = head.ok ? await git2(workspace, ["restore", "--staged", "--", path]) : await git2(workspace, ["rm", "--cached", "--", path]);
+  if (!result.ok) throw failure("\u53D6\u6D88\u6682\u5B58", result.stderr, result.stdout);
+  return desktopGitStatus(workspace);
+}
+async function desktopGitDiscard(workspace, path) {
+  const file = await assertListed(workspace, path);
+  if (file.untracked) await rm16(safeWorkspacePath(workspace, path), { recursive: false, force: false });
+  else {
+    const result = await git2(workspace, ["restore", "--worktree", "--", path]);
+    if (!result.ok) throw failure("\u8FD8\u539F", result.stderr, result.stdout);
+  }
+  return desktopGitStatus(workspace);
+}
+async function desktopGitCommit(workspace, message2) {
+  return { result: await commit(workspace, message2), status: await desktopGitStatus(workspace) };
+}
+async function desktopGitReviewDiff(workspace, input) {
+  if (!await isGitRepository(workspace)) throw new Error("Review requires a Git repository");
+  const paths = [...new Set(input.paths ?? [])].slice(0, 200);
+  for (const path of paths) safeWorkspacePath(workspace, path);
+  const suffix = paths.length === 0 ? [] : ["--", ...paths];
+  let args;
+  if (input.scope === "working") args = ["diff", "HEAD", "--no-ext-diff", "--no-color", ...suffix];
+  else if (input.scope === "staged") args = ["diff", "--staged", "--no-ext-diff", "--no-color", ...suffix];
+  else if (input.scope === "last-turn") args = ["diff", "HEAD", "--no-ext-diff", "--no-color", ...suffix];
+  else {
+    const target = safeGitTarget(input.target);
+    args = input.scope === "commit" ? ["show", "--format=", "--no-ext-diff", "--no-color", target] : ["diff", `${target}...HEAD`, "--no-ext-diff", "--no-color"];
+  }
+  const result = await git2(workspace, args, 3e4);
+  if (!result.ok) throw failure("\u8BFB\u53D6\u5BA1\u67E5\u5DEE\u5F02", result.stderr, result.stdout);
+  return result.stdout.length > 24e4 ? `${result.stdout.slice(0, 24e4)}
+\u2026[diff truncated]` : result.stdout || "\uFF08\u6B64\u8303\u56F4\u6CA1\u6709\u5DEE\u5F02\uFF09";
+}
+function desktopGitHistory(workspace) {
+  return fileHistory(workspace, void 0, 50);
+}
+async function desktopLastTurnDiff(workspace, sessionId, paths = []) {
+  if (!/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/.test(sessionId)) throw new Error("Invalid session id");
+  const requested = new Set(paths.map((path) => {
+    safeWorkspacePath(workspace, path);
+    return path.replaceAll("\\", "/");
+  }));
+  try {
+    const tree = JSON.parse(await readFile36(resolve36(workspace, ".flavor", "session-trees", sessionId, "tree.json"), "utf8"));
+    const leaf = tree.nodes?.find((node) => node.id === tree.leafId);
+    const parent = leaf?.parentId == null ? void 0 : tree.nodes?.find((node) => node.id === leaf.parentId);
+    if (leaf === void 0 || parent === void 0) return desktopGitReviewDiff(workspace, { scope: "last-turn", paths });
+    const load = async (id) => {
+      if (!/^checkpoint-[A-Za-z0-9-]+$/.test(id)) throw new Error("Invalid checkpoint id");
+      return JSON.parse(await readFile36(resolve36(workspace, ".flavor", "checkpoints", "manifests", `${id}.json`), "utf8"));
+    };
+    const [before, after] = await Promise.all([load(parent.checkpointId), load(leaf.checkpointId)]);
+    const oldFiles = new Map(before.files.map((file) => [file.path, file.digest]));
+    const newFiles = new Map(after.files.map((file) => [file.path, file.digest]));
+    const changed = [.../* @__PURE__ */ new Set([...oldFiles.keys(), ...newFiles.keys()])].filter((path) => oldFiles.get(path) !== newFiles.get(path) && (requested.size === 0 || requested.has(path))).slice(0, 200);
+    const object = async (digest) => {
+      if (digest === void 0) return "";
+      if (!/^[a-f0-9]{64}$/.test(digest)) throw new Error("Invalid checkpoint object");
+      const value = await readFile36(resolve36(workspace, ".flavor", "checkpoints", "objects", digest));
+      return value.includes(0) ? "[binary content]" : value.toString("utf8");
+    };
+    const chunks = await Promise.all(changed.map(async (path) => wholeFileDiff(path, await object(oldFiles.get(path)), await object(newFiles.get(path)))));
+    const result = chunks.join("\n");
+    return result.length > 24e4 ? `${result.slice(0, 24e4)}
+\u2026[diff truncated]` : result || "\uFF08\u4E0A\u4E00\u4E2A assistant turn \u6CA1\u6709\u6587\u4EF6\u53D8\u5316\uFF09";
+  } catch (error) {
+    if (error.code === "ENOENT") return desktopGitReviewDiff(workspace, { scope: "last-turn", paths });
+    throw error;
+  }
+}
+function wholeFileDiff(path, before, after) {
+  const oldLines = before.replace(/\n$/, "").split("\n");
+  const newLines = after.replace(/\n$/, "").split("\n");
+  return [`diff --flavor a/${path} b/${path}`, `--- ${before === "" ? "/dev/null" : `a/${path}`}`, `+++ ${after === "" ? "/dev/null" : `b/${path}`}`, `@@ -1,${before === "" ? 0 : oldLines.length} +1,${after === "" ? 0 : newLines.length} @@`, ...before === "" ? [] : oldLines.map((line) => `-${line}`), ...after === "" ? [] : newLines.map((line) => `+${line}`)].join("\n");
+}
+async function assertListed(workspace, path) {
+  const file = (await desktopGitStatus(workspace)).files.find((item) => item.path === path);
+  if (file === void 0) throw new Error("\u8BE5\u6587\u4EF6\u5DF2\u4E0D\u5728\u53D8\u66F4\u5217\u8868\u4E2D");
+  safeWorkspacePath(workspace, path);
+  return file;
+}
+function safeWorkspacePath(workspace, path) {
+  if (isAbsolute18(path)) throw new Error("Git \u6587\u4EF6\u8DEF\u5F84\u5FC5\u987B\u662F\u9879\u76EE\u5185\u7684\u76F8\u5BF9\u8DEF\u5F84");
+  const root = resolve36(workspace);
+  const target = resolve36(root, path);
+  const child = relative26(root, target);
+  if (child === "" || child.startsWith("..") || isAbsolute18(child)) throw new Error("\u62D2\u7EDD\u8BBF\u95EE\u9879\u76EE\u4E4B\u5916\u7684\u8DEF\u5F84");
+  return target;
+}
+function safeGitTarget(value) {
+  const target = value?.trim();
+  if (target === void 0 || target.length === 0 || target.length > 256 || target.startsWith("-") || !/^[A-Za-z0-9][A-Za-z0-9._/@{}~^:-]*$/.test(target)) throw new Error("Invalid Git review target");
+  return target;
+}
+
+// src/desktop/worktree-manager.ts
+import { randomUUID as randomUUID26 } from "crypto";
+import { mkdir as mkdir28, readFile as readFile37, readdir as readdir13, rm as rm17, stat as stat15, writeFile as writeFile18 } from "fs/promises";
+import { basename as basename10, isAbsolute as isAbsolute19, join as join43, relative as relative27, resolve as resolve37, sep as sep27 } from "path";
+var DesktopWorktreeManager = class {
+  #repository;
+  #storage;
+  constructor(options) {
+    this.#repository = resolve37(options.repository);
+    this.#storage = resolve37(options.storage);
+  }
+  async create(label) {
+    if (!await isGitRepository(this.#repository)) throw new Error("Task worktrees require a Git repository");
+    const safe = label.trim().toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 36) || "task";
+    const suffix = randomUUID26().slice(0, 8);
+    const id = `worktree-${safe}-${suffix}`;
+    const branch = `flavor/desktop-${safe}-${suffix}`;
+    const path = this.#safeStoragePath(id);
+    await mkdir28(this.#storage, { recursive: true, mode: 448 });
+    const result = await git2(this.#repository, ["worktree", "add", "-b", branch, path, "HEAD"], 6e4);
+    if (!result.ok) throw new Error(`git worktree add failed: ${(result.stderr || result.stdout).trim().split("\n")[0]}`);
+    const stored = {
+      version: 1,
+      id,
+      mode: "worktree",
+      repository: this.#repository,
+      path,
+      branch,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    try {
+      await writeFile18(this.#metadataPath(id), `${JSON.stringify(stored)}
+`, { encoding: "utf8", mode: 384 });
+    } catch (error) {
+      await git2(this.#repository, ["worktree", "remove", "--force", path], 6e4).catch(() => void 0);
+      throw error;
+    }
+    return { ...stored, dirty: false, merged: false };
+  }
+  async list() {
+    let names;
+    try {
+      names = await readdir13(this.#storage);
+    } catch (error) {
+      if (error.code === "ENOENT") return [];
+      throw error;
+    }
+    const values = await Promise.all(names.filter((name) => name.endsWith(".json")).map(async (name) => {
+      try {
+        const stored = validateStored(JSON.parse(await readFile37(join43(this.#storage, name), "utf8")), this.#repository, this.#storage);
+        if ((await stat15(stored.path).catch(() => void 0))?.isDirectory() !== true) return void 0;
+        const status = await git2(stored.path, ["status", "--porcelain"]);
+        const merged = await git2(this.#repository, ["merge-base", "--is-ancestor", stored.branch, "HEAD"]);
+        const { version: _version, ...item } = stored;
+        return { ...item, dirty: status.ok ? status.stdout.trim().length > 0 : true, merged: merged.ok };
+      } catch {
+        return void 0;
+      }
+    }));
+    return values.filter((item) => item !== void 0).sort((left, right) => right.createdAt.localeCompare(left.createdAt));
+  }
+  async remove(id, force = false) {
+    const item = await this.#load(id);
+    const status = await git2(item.path, ["status", "--porcelain"]);
+    const dirty = !status.ok || status.stdout.trim().length > 0;
+    if (dirty && !force) throw new Error("Worktree is dirty; review or explicitly force removal");
+    const result = await git2(this.#repository, ["worktree", "remove", ...force ? ["--force"] : [], item.path], 6e4);
+    if (!result.ok) throw new Error(`git worktree remove failed: ${(result.stderr || result.stdout).trim().split("\n")[0]}`);
+    await rm17(this.#metadataPath(id), { force: true });
+  }
+  async merge(id) {
+    const item = await this.#load(id);
+    const [taskStatus, repositoryStatus] = await Promise.all([
+      git2(item.path, ["status", "--porcelain"]),
+      git2(this.#repository, ["status", "--porcelain"])
+    ]);
+    if (!taskStatus.ok || taskStatus.stdout.trim().length > 0) throw new Error("Commit or discard task worktree changes before handoff");
+    if (!repositoryStatus.ok || repositoryStatus.stdout.trim().length > 0) throw new Error("The destination checkout must be clean before handoff");
+    const result = await git2(this.#repository, ["merge", "--no-ff", "--no-edit", item.branch], 6e4);
+    if (!result.ok) throw new Error(`Worktree handoff merge failed: ${(result.stderr || result.stdout).trim().split("\n")[0]}`);
+  }
+  async #load(id) {
+    const path = this.#metadataPath(id);
+    return validateStored(JSON.parse(await readFile37(path, "utf8")), this.#repository, this.#storage);
+  }
+  #metadataPath(id) {
+    if (!/^worktree-[a-z0-9._-]{1,80}$/.test(id)) throw new Error("Invalid worktree id");
+    return this.#safeStoragePath(`${id}.json`);
+  }
+  #safeStoragePath(name) {
+    const target = resolve37(this.#storage, name);
+    const delta = relative27(this.#storage, target);
+    if (delta === "" || delta === ".." || delta.startsWith(`..${sep27}`) || isAbsolute19(delta)) throw new Error("Worktree path escapes storage");
+    return target;
+  }
+};
+function validateStored(value, repository, storage) {
+  if (typeof value !== "object" || value === null) throw new Error("Invalid worktree metadata");
+  const item = value;
+  if (item.version !== 1 || item.mode !== "worktree" || typeof item.id !== "string" || typeof item.path !== "string" || typeof item.branch !== "string" || typeof item.createdAt !== "string" || resolve37(item.repository ?? "") !== repository) {
+    throw new Error("Invalid worktree metadata");
+  }
+  const path = resolve37(item.path);
+  const delta = relative27(storage, path);
+  if (delta === "" || delta === ".." || delta.startsWith(`..${sep27}`) || isAbsolute19(delta) || basename10(path) !== item.id) {
+    throw new Error("Worktree metadata escapes storage");
+  }
+  return { version: 1, id: item.id, mode: "worktree", repository, path, branch: item.branch, createdAt: item.createdAt };
+}
+
+// src/desktop/workbench-service.ts
+import { readFile as readFile38, readdir as readdir14, stat as stat16 } from "fs/promises";
+import { homedir as homedir5 } from "os";
+import { join as join44, resolve as resolve38 } from "path";
+var MAX_TEXT = 128e3;
+var MAX_ITEMS = 200;
+var DesktopWorkbenchService = class {
+  #workspace;
+  #home;
+  constructor(workspace, home = homedir5()) {
+    this.#workspace = resolve38(workspace);
+    this.#home = resolve38(home);
+  }
+  async inspect(sessionId) {
+    const [goals, instructions, permissionFiles, audit, context] = await Promise.all([
+      this.#goals(),
+      this.#instructions(),
+      this.#permissionFiles(),
+      this.#audit(),
+      this.#context(sessionId)
+    ]);
+    return { goals, instructions, permissionFiles, audit, ...context === void 0 ? {} : { context } };
+  }
+  static normalizePreviewUrl(input) {
+    let url;
+    try {
+      url = new URL(input.trim());
+    } catch {
+      throw new Error("Preview URL must be a valid loopback HTTP(S) URL");
+    }
+    if (!["http:", "https:"].includes(url.protocol) || !["127.0.0.1", "localhost", "::1", "[::1]"].includes(url.hostname.toLowerCase()) || url.username !== "" || url.password !== "") {
+      throw new Error("Preview URL must use a loopback HTTP(S) origin");
+    }
+    return url.toString().replace(/\/$/, input.trim().endsWith("/") ? "/" : "");
+  }
+  async #goals() {
+    const root = join44(this.#workspace, ".flavor", "goals");
+    const names = await readdir14(root).catch((error) => error.code === "ENOENT" ? [] : Promise.reject(error));
+    const values = await Promise.all(names.filter((name) => /^goal-[A-Za-z0-9._-]+\.json$/.test(name)).slice(0, MAX_ITEMS).map(async (name) => {
+      try {
+        return GoalStateSchema.parse(JSON.parse(await boundedRead2(join44(root, name))));
+      } catch {
+        return void 0;
+      }
+    }));
+    return values.filter((item) => item !== void 0).sort((left, right) => right.updatedAt.localeCompare(left.updatedAt));
+  }
+  async #instructions() {
+    const names = ["FLAVOR.md", "AGENTS.md", "CLAUDE.md", "AGENTS.local.md", "CLAUDE.local.md"];
+    const items = await Promise.all(names.map(async (name) => {
+      const path = join44(this.#workspace, name);
+      try {
+        return { name, path, content: redactErrorText(await boundedRead2(path)) };
+      } catch (error) {
+        if (error.code === "ENOENT") return void 0;
+        throw error;
+      }
+    }));
+    return items.filter((item) => item !== void 0);
+  }
+  async #permissionFiles() {
+    const candidates = [
+      ...process.env.FLAVOR_MANAGED_PERMISSIONS ? [{ tier: "managed", path: resolve38(process.env.FLAVOR_MANAGED_PERMISSIONS), content: "" }] : [],
+      { tier: "user", path: join44(this.#home, ".flavor-code", "permissions.json"), content: "" },
+      { tier: "project", path: join44(this.#workspace, ".flavor", "permissions.json"), content: "" },
+      { tier: "local", path: join44(this.#workspace, ".flavor", "permissions.local.json"), content: "" }
+    ];
+    const values = await Promise.all(candidates.map(async (item) => {
+      try {
+        return { ...item, content: redactErrorText(await boundedRead2(item.path)) };
+      } catch (error) {
+        if (error.code === "ENOENT") return void 0;
+        throw error;
+      }
+    }));
+    return values.filter((item) => item !== void 0);
+  }
+  async #audit() {
+    let raw;
+    try {
+      raw = await boundedRead2(join44(this.#workspace, ".flavor", "audit.jsonl"));
+    } catch (error) {
+      if (error.code === "ENOENT") return [];
+      throw error;
+    }
+    return raw.split(/\r?\n/).filter(Boolean).slice(-MAX_ITEMS).flatMap((line) => {
+      try {
+        const value = JSON.parse(line);
+        return typeof value === "object" && value !== null && !Array.isArray(value) ? [redact2(value)] : [];
+      } catch {
+        return [];
+      }
+    }).reverse();
+  }
+  async #context(sessionId) {
+    const usage = await readJsonLines2(join44(this.#workspace, ".flavor", "usage.jsonl"));
+    if (sessionId === void 0) return { visibility: [], usage };
+    try {
+      const document = await new SessionStore({ workspace: this.#workspace }).load(sessionId);
+      return { ...document.conversation.epoch === void 0 ? {} : { epoch: redact2(document.conversation.epoch) }, visibility: (document.conversation.visibilityLog ?? []).slice(-MAX_ITEMS).map((item) => redact2(item)), usage };
+    } catch {
+      return { visibility: [], usage };
+    }
+  }
+};
+async function boundedRead2(path) {
+  const info = await stat16(path);
+  if (!info.isFile()) throw new Error(`Expected a file: ${path}`);
+  if (info.size > MAX_TEXT) throw new Error(`Workbench file exceeds ${MAX_TEXT} bytes: ${path}`);
+  return readFile38(path, "utf8");
+}
+async function readJsonLines2(path) {
+  try {
+    return (await boundedRead2(path)).split(/\r?\n/).filter(Boolean).slice(-MAX_ITEMS).flatMap((line) => {
+      try {
+        const value = JSON.parse(line);
+        return typeof value === "object" && value !== null && !Array.isArray(value) ? [redact2(value)] : [];
+      } catch {
+        return [];
+      }
+    }).reverse();
+  } catch (error) {
+    if (error.code === "ENOENT") return [];
+    throw error;
+  }
+}
+function redact2(value, key = "") {
+  if (/token|secret|password|authorization|api[-_]?key/i.test(key)) return "[REDACTED]";
+  if (Array.isArray(value)) return value.slice(0, MAX_ITEMS).map((item) => redact2(item));
+  if (typeof value === "object" && value !== null) return Object.fromEntries(Object.entries(value).slice(0, MAX_ITEMS).map(([name, item]) => [name, redact2(item, name)]));
+  return typeof value === "string" && value.length > MAX_TEXT ? `${value.slice(0, MAX_TEXT)}\u2026` : value;
+}
+
+// src/desktop/astgraph-service.ts
+import { stat as stat17 } from "fs/promises";
+import { createRequire as nodeCreateRequire2 } from "module";
+import { join as join45, resolve as resolve39 } from "path";
+var FIELDS = "id, kind, name, qualified_name, file_path, language, start_line, end_line, signature";
+var DesktopAstGraphService = class {
+  #path;
+  constructor(workspace) {
+    this.#path = join45(resolve39(workspace), ".flavor", "astgraph", "index.db");
+  }
+  async status() {
+    if ((await stat17(this.#path).catch(() => void 0))?.isFile() !== true) {
+      return { available: false, path: this.#path, files: 0, nodes: 0, edges: 0 };
+    }
+    return this.#read((db) => {
+      const count = (table) => Number(db.prepare(`SELECT COUNT(*) AS count FROM ${table}`).get().count);
+      const metadata = db.prepare("SELECT value FROM project_metadata WHERE key = 'last_index'").get();
+      let indexedAt;
+      try {
+        const at = Number(JSON.parse(metadata?.value ?? "{}").at);
+        if (Number.isFinite(at)) indexedAt = new Date(at).toISOString();
+      } catch {
+      }
+      return { available: true, path: this.#path, files: count("files"), nodes: count("nodes"), edges: count("edges"), ...indexedAt === void 0 ? {} : { indexedAt } };
+    });
+  }
+  async search(query, limit = 40) {
+    const value = query.trim().slice(0, 200);
+    if (value.length === 0 || !(await this.status()).available) return [];
+    return this.#read((db) => db.prepare(`SELECT ${FIELDS} FROM nodes WHERE lower(name) LIKE ? OR lower(qualified_name) LIKE ? ORDER BY CASE WHEN lower(name) = ? THEN 0 ELSE 1 END, name LIMIT ?`).all(`%${value.toLowerCase()}%`, `%${value.toLowerCase()}%`, value.toLowerCase(), Math.min(Math.max(limit, 1), 100)).map(mapNode));
+  }
+  async relations(id, hops = 2) {
+    if (!/^[A-Za-z0-9._:/#@+~-]{1,512}$/.test(id)) throw new Error("Invalid AST node id");
+    if (!(await this.status()).available) return { callers: [], callees: [], impact: [] };
+    return this.#read((db) => {
+      const originRow = db.prepare(`SELECT ${FIELDS} FROM nodes WHERE id = ?`).get(id);
+      const linked = (direction) => {
+        const source = direction === "callers" ? "e.source" : "e.target";
+        const predicate = direction === "callers" ? "e.target = ?" : "e.source = ?";
+        return db.prepare(`SELECT DISTINCT n.${FIELDS.split(", ").join(", n.")} FROM edges e JOIN nodes n ON n.id = ${source} WHERE ${predicate} AND e.kind IN ('calls','imports') LIMIT 100`).all(id).map(mapNode);
+      };
+      const seen = /* @__PURE__ */ new Map();
+      let frontier = [id];
+      for (let hop = 1; hop <= Math.min(Math.max(hops, 1), 4) && frontier.length > 0 && seen.size < 200; hop += 1) {
+        const next = [];
+        for (const current of frontier) {
+          const rows = db.prepare("SELECT source AS other FROM edges WHERE target = ? UNION SELECT target AS other FROM edges WHERE source = ? LIMIT 200").all(current, current);
+          for (const row of rows) if (row.other !== id && !seen.has(row.other)) {
+            seen.set(row.other, hop);
+            next.push(row.other);
+          }
+        }
+        frontier = next;
+      }
+      const impact = [...seen].flatMap(([nodeId, hop]) => {
+        const row = db.prepare(`SELECT ${FIELDS} FROM nodes WHERE id = ?`).get(nodeId);
+        return row === void 0 ? [] : [{ ...mapNode(row), hop }];
+      });
+      return { ...originRow === void 0 ? {} : { origin: mapNode(originRow) }, callers: linked("callers"), callees: linked("callees"), impact };
+    });
+  }
+  #read(run) {
+    const sqlite = nodeCreateRequire2(import.meta.url)("node:sqlite");
+    const db = new sqlite.DatabaseSync(this.#path, { readOnly: true });
+    try {
+      return run(db);
+    } finally {
+      db.close();
+    }
+  }
+};
+function mapNode(value) {
+  const row = value;
+  return { id: String(row.id), kind: String(row.kind), name: String(row.name), qualifiedName: String(row.qualified_name), filePath: String(row.file_path), language: String(row.language), startLine: Number(row.start_line), endLine: Number(row.end_line), ...row.signature == null ? {} : { signature: String(row.signature) } };
+}
+
 // src/desktop/main.ts
 installCrashGuard();
 var moduleDirectory = dirname24(fileURLToPath4(import.meta.url));
@@ -29840,7 +30587,7 @@ var appMenu;
 var quitting = false;
 function logStartup(step, detail) {
   try {
-    const logPath = join43(dirname24(process.execPath), "flavor-code-startup.log");
+    const logPath = join46(dirname24(process.execPath), "flavor-code-startup.log");
     const ts = (/* @__PURE__ */ new Date()).toISOString();
     appendFileSync(logPath, `[${ts}] ${step}${detail ? ` | ${detail}` : ""}
 `);
@@ -29865,7 +30612,7 @@ var d2cEmbedded = createEmbeddedD2cAutomation(() => {
   };
 });
 var d2cJudgeClient = createD2cJudgeClient();
-var judgeStore = () => createD2cJudgeConfigStore(join43(app.getPath("userData"), "d2c-judge.json"));
+var judgeStore = () => createD2cJudgeConfigStore(join46(app.getPath("userData"), "d2c-judge.json"));
 function judgeImage(png) {
   const image = nativeImage.createFromBuffer(png);
   const size = image.getSize();
@@ -29874,70 +30621,342 @@ function judgeImage(png) {
   const ratio = 2048 / longest;
   return image.resize({ width: Math.max(1, Math.round(size.width * ratio)), height: Math.max(1, Math.round(size.height * ratio)), quality: "best" }).toPNG();
 }
-var controller = new DesktopRuntimeController({
-  emit: emitDesktopEvent,
-  runD2cInteractionTests: (manifest, baseUrl, mockUrl) => d2cEmbedded.run(manifest, baseUrl, mockUrl),
-  observeD2cPages: (manifest, baseUrl) => d2cEmbedded.observe(manifest, baseUrl),
-  captureD2cPreview: (url) => d2cEmbedded.capture(url),
-  d2cJudge: {
-    config: () => judgeStore().view(),
-    saveConfig: (input) => judgeStore().save(input),
-    evaluate: async ({ report, interaction, designPng, implementationPng }) => {
-      const config = await judgeStore().load();
-      if (config === void 0) throw new Error("Configure a multimodal D2C judge model before running the quality gate");
-      const assessment = await d2cJudgeClient.evaluate(config, {
-        prompt: buildD2cJudgePrompt({ report, interaction }),
-        designPng: judgeImage(designPng),
-        implementationPng: judgeImage(implementationPng)
-      });
-      return finalizeD2cQualityJudgment({ assessment, report, interaction, model: config.model, passThreshold: config.passThreshold });
+var workbench = {
+  projectMeta: {},
+  sessionMeta: {},
+  activities: [],
+  recoveryItems: [],
+  runningSessions: [],
+  taskCheckouts: [],
+  cleanShutdown: true
+};
+var managedProjects = /* @__PURE__ */ new Map();
+var projectOrder = [];
+var activeWorkspace;
+function sessionMetaKey(workspace, sessionId) {
+  return `${workspace}\0${sessionId}`;
+}
+function worktreeManager(workspace) {
+  const key = createHash27("sha256").update(resolve40(workspace)).digest("hex").slice(0, 20);
+  return new DesktopWorktreeManager({ repository: workspace, storage: join46(app.getPath("userData"), "task-worktrees", key) });
+}
+function activeWorkingDirectory() {
+  if (activeWorkspace === void 0) throw new Error("\u8BF7\u5148\u6253\u5F00\u9879\u76EE");
+  return managedProjects.get(activeWorkspace)?.selectedTask?.workingDirectory ?? activeWorkspace;
+}
+function projectSessions(workspace, project) {
+  const merged = new Map(project.snapshot.sessions.map((session) => [session.sessionId, session]));
+  const taskBySession = new Map([...project.tasks].flatMap((task) => task.sessionId === void 0 ? [] : [[task.sessionId, task]]));
+  for (const task of project.tasks) for (const session of task.snapshot.sessions) {
+    const previous = merged.get(session.sessionId);
+    if (previous === void 0 || session.updatedAt >= previous.updatedAt) merged.set(session.sessionId, session);
+  }
+  return [...merged.values()].map((session) => {
+    const meta = workbench.sessionMeta[sessionMetaKey(workspace, session.sessionId)] ?? {};
+    const activity = workbench.activities.find((item) => item.workspace === workspace && item.sessionId === session.sessionId);
+    const running = [...project.tasks].some((task2) => task2.sessionId === session.sessionId && task2.snapshot.activeSession?.busy);
+    const task = taskBySession.get(session.sessionId);
+    return { ...session, ...meta, ...task === void 0 ? {} : { environment: task.environment, workingDirectory: task.workingDirectory, ...task.worktreeId === void 0 ? {} : { worktreeId: task.worktreeId } }, ...running ? { activity: "running" } : activity === void 0 ? {} : { activity: activity.kind, unread: activity.unread } };
+  }).sort((left, right) => Number(Boolean(right.pinned)) - Number(Boolean(left.pinned)) || right.updatedAt.localeCompare(left.updatedAt));
+}
+function projectSummaries() {
+  return [...projectOrder].sort((left, right) => Number(Boolean(workbench.projectMeta[right]?.pinned)) - Number(Boolean(workbench.projectMeta[left]?.pinned))).flatMap((workspace) => {
+    const project = managedProjects.get(workspace);
+    if (project === void 0) return [];
+    const snapshot4 = project.selectedTask?.snapshot ?? project.snapshot;
+    const active = snapshot4.activeSession;
+    const runningSessions = [...project.tasks].flatMap((task) => task.sessionId !== void 0 && task.snapshot.activeSession?.busy ? [task.sessionId] : []);
+    return [{
+      workspace,
+      ...workbench.projectMeta[workspace],
+      sessions: projectSessions(workspace, project),
+      ...active === void 0 ? {} : { activeSession: { sessionId: active.sessionId, busy: active.busy } },
+      running: runningSessions.length > 0 || snapshot4.jobs.some((job) => job.state === "running"),
+      runningSessions,
+      unreadCount: workbench.activities.filter((item) => item.workspace === workspace && item.unread).length
+    }];
+  });
+}
+function decorateSnapshot(snapshot4) {
+  const workspace = snapshot4.workspace !== void 0 && managedProjects.has(snapshot4.workspace) ? snapshot4.workspace : activeWorkspace ?? snapshot4.workspace;
+  const selected = workspace === void 0 ? void 0 : managedProjects.get(workspace)?.selectedTask;
+  return {
+    ...snapshot4,
+    ...workspace === void 0 ? {} : { workspace },
+    ...snapshot4.activeSession === void 0 || selected === void 0 ? {} : { activeSession: { ...snapshot4.activeSession, environment: selected.environment, workingDirectory: selected.workingDirectory, ...selected.worktreeId === void 0 ? {} : { worktreeId: selected.worktreeId } } },
+    sessions: workspace === void 0 ? snapshot4.sessions : projectSessions(workspace, managedProjects.get(workspace) ?? { controller, snapshot: snapshot4, tasks: /* @__PURE__ */ new Set() }),
+    projects: projectSummaries(),
+    activities: workbench.activities,
+    recoveryItems: workbench.recoveryItems
+  };
+}
+function decorateSessionStarted(payload) {
+  return { ...payload, snapshot: decorateSnapshot(payload.snapshot) };
+}
+function emitManagedDesktopEvent(workspace, owner2, event) {
+  if (workspace === void 0) {
+    emitDesktopEvent(event.type === "snapshot" ? { ...event, snapshot: decorateSnapshot(event.snapshot) } : event);
+    return;
+  }
+  const project = managedProjects.get(workspace);
+  if (project !== void 0) {
+    if (event.type === "snapshot") {
+      event = { ...event, snapshot: { ...event.snapshot, workspace } };
+      const previous = owner2?.snapshot;
+      if (owner2 !== void 0) {
+        owner2.snapshot = event.snapshot;
+        if (owner2.payload !== void 0) owner2.payload = { ...owner2.payload, snapshot: event.snapshot };
+      } else project.snapshot = event.snapshot;
+      trackTaskTransition(workspace, owner2, previous, event.snapshot);
+    } else if (event.type === "session-started") {
+      event = { ...event, payload: { ...event.payload, snapshot: { ...event.payload.snapshot, workspace } } };
+      if (owner2 !== void 0) {
+        owner2.sessionId = event.payload.sessionId;
+        owner2.payload = event.payload;
+        owner2.snapshot = event.payload.snapshot;
+      } else project.snapshot = event.payload.snapshot;
+    } else if (event.type === "session-output" && owner2 !== void 0) {
+      if (event.event.type === "done") owner2.terminal = "completed";
+      else if (event.event.type === "error") owner2.terminal = "failed";
+      else if (event.event.type === "exit") owner2.terminal = "interrupted";
+    } else if (event.type === "runtime-error") {
+      if (owner2 !== void 0) owner2.terminal = "failed";
+      addActivity(workspace, event.sessionId ?? owner2?.sessionId, "failed", "\u4EFB\u52A1\u6267\u884C\u5931\u8D25", event.message);
+    }
+  }
+  const ownerSelected = owner2 === void 0 ? project?.selectedTask === void 0 : project?.selectedTask === owner2;
+  if (workspace === activeWorkspace && ownerSelected) {
+    if (event.type === "snapshot") emitDesktopEvent({ ...event, workspace, snapshot: decorateSnapshot(event.snapshot) });
+    else if (event.type === "session-started") emitDesktopEvent({ ...event, workspace, payload: decorateSessionStarted(event.payload) });
+    else emitDesktopEvent({ ...event, workspace });
+    return;
+  }
+  if (event.type === "session-output") emitDesktopEvent({ ...event, workspace });
+  if ((event.type === "snapshot" || event.type === "session-started") && activeWorkspace !== void 0) {
+    emitDesktopEvent({ type: "snapshot", workspace: activeWorkspace, snapshot: decorateSnapshot(controller.snapshot()) });
+  }
+}
+function createDesktopController(workspace, owner2) {
+  const collaborationId = randomUUID27();
+  return new DesktopRuntimeController({
+    emit: (event) => emitManagedDesktopEvent(workspace, owner2, event),
+    runD2cInteractionTests: (manifest, baseUrl, mockUrl) => d2cEmbedded.run(manifest, baseUrl, mockUrl),
+    observeD2cPages: (manifest, baseUrl) => d2cEmbedded.observe(manifest, baseUrl),
+    captureD2cPreview: (url) => d2cEmbedded.capture(url),
+    d2cJudge: {
+      config: () => judgeStore().view(),
+      saveConfig: (input) => judgeStore().save(input),
+      evaluate: async ({ report, interaction, designPng, implementationPng }) => {
+        const config = await judgeStore().load();
+        if (config === void 0) throw new Error("Configure a multimodal D2C judge model before running the quality gate");
+        const assessment = await d2cJudgeClient.evaluate(config, {
+          prompt: buildD2cJudgePrompt({ report, interaction }),
+          designPng: judgeImage(designPng),
+          implementationPng: judgeImage(implementationPng)
+        });
+        return finalizeD2cQualityJudgment({ assessment, report, interaction, model: config.model, passThreshold: config.passThreshold });
+      },
+      planInteractions: async (input) => {
+        const config = await judgeStore().load();
+        if (config === void 0) throw new Error("Configure a multimodal D2C judge model before autonomous interaction review");
+        return d2cJudgeClient.planInteractions(config, {
+          prompt: buildD2cAutonomousPlanPrompt(input),
+          screenshots: input.observations.map((page) => judgeImage(page.screenshot)),
+          observedPages: input.observations.map((page) => page.url),
+          observedSelectors: input.observations.flatMap((page) => page.elements.map((element) => element.selector))
+        });
+      }
     },
-    planInteractions: async (input) => {
-      const config = await judgeStore().load();
-      if (config === void 0) throw new Error("Configure a multimodal D2C judge model before autonomous interaction review");
-      return d2cJudgeClient.planInteractions(config, {
-        prompt: buildD2cAutonomousPlanPrompt(input),
-        screenshots: input.observations.map((page) => judgeImage(page.screenshot)),
-        observedPages: input.observations.map((page) => page.url),
-        observedSelectors: input.observations.flatMap((page) => page.elements.map((element) => element.selector))
-      });
-    }
-  },
-  createRuntime: async (runtimeOptions) => createProductionRuntime({
-    ...runtimeOptions,
-    ...runtimeOptions.workspace === void 0 ? {} : {
-      extraTools: createD2cTools(runtimeOptions.workspace, {
-        capture: d2cCapture,
-        onProgress: (progress) => emitDesktopEvent({ type: "d2c-progress", payload: progress }),
-        onReport: (report) => emitDesktopEvent({ type: "d2c-report", payload: report })
-      })
-    }
-  })
-});
+    createRuntime: async (runtimeOptions) => createProductionRuntime({
+      ...runtimeOptions,
+      collaboration: {
+        instanceId: collaborationId,
+        alias: `desktop-${basename11(workspace ?? runtimeOptions.workspace ?? "flavor")}`.slice(0, 64),
+        optional: true,
+        startBroker: (address) => {
+          const entry2 = app.isPackaged ? join46(process.resourcesPath, "app.asar.unpacked", "dist", "desktop", "pals-broker-entry.js") : join46(moduleDirectory, "pals-broker-entry.js");
+          return spawnPalBrokerProcess({
+            address,
+            executable: process.execPath,
+            args: [entry2, address],
+            environment: { ...process.env, ELECTRON_RUN_AS_NODE: "1" }
+          });
+        }
+      },
+      ...runtimeOptions.workspace === void 0 ? {} : {
+        extraTools: createD2cTools(runtimeOptions.workspace, {
+          capture: d2cCapture,
+          onProgress: (progress) => emitManagedDesktopEvent(workspace, owner2, { type: "d2c-progress", payload: progress }),
+          onReport: (report) => emitManagedDesktopEvent(workspace, owner2, { type: "d2c-report", payload: report })
+        })
+      }
+    })
+  });
+}
+var detachedController = createDesktopController();
+var controller = detachedController;
 function statePath() {
-  return join43(app.getPath("userData"), "desktop-state.json");
+  return join46(app.getPath("userData"), "desktop-state.json");
 }
-async function loadPersistedWorkspace() {
+async function loadPersistedProjects() {
   try {
-    const raw = await readFile36(statePath(), "utf8");
-    if (raw.length > 4e4) return void 0;
-    return normalizePersistedWorkspace(JSON.parse(raw));
+    const raw = await readFile39(statePath(), "utf8");
+    if (raw.length > 1e5) return { projects: [] };
+    const parsed = JSON.parse(raw);
+    Object.assign(workbench, {
+      projectMeta: validRecord(parsed.projectMeta),
+      sessionMeta: validRecord(parsed.sessionMeta),
+      activities: Array.isArray(parsed.activities) ? parsed.activities.slice(0, 500) : [],
+      recoveryItems: Array.isArray(parsed.recoveryItems) ? parsed.recoveryItems.slice(0, 100) : [],
+      runningSessions: Array.isArray(parsed.runningSessions) ? parsed.runningSessions.slice(0, 100) : [],
+      taskCheckouts: Array.isArray(parsed.taskCheckouts) ? parsed.taskCheckouts.filter((item) => typeof item === "object" && item !== null && item.environment === "worktree" && typeof item.workspace === "string" && typeof item.sessionId === "string" && typeof item.workingDirectory === "string" && typeof item.worktreeId === "string").slice(0, 100) : [],
+      cleanShutdown: parsed.cleanShutdown !== false
+    });
+    if (!workbench.cleanShutdown) {
+      const interruptedAt = (/* @__PURE__ */ new Date()).toISOString();
+      workbench.recoveryItems = workbench.runningSessions.map((item) => ({ ...item, interruptedAt, reason: "\u5E94\u7528\u4E0A\u6B21\u9000\u51FA\u65F6\u4EFB\u52A1\u4ECD\u5728\u8FD0\u884C" }));
+      workbench.activities = [...workbench.runningSessions.map((item, index) => ({
+        id: `recovery-${Date.now()}-${index}`,
+        ...item,
+        kind: "interrupted",
+        title: "\u4EFB\u52A1\u56E0\u5E94\u7528\u9000\u51FA\u800C\u4E2D\u65AD",
+        detail: "\u53EF\u4EE5\u6062\u590D\u4F1A\u8BDD\u5E76\u7EE7\u7EED\u6267\u884C",
+        createdAt: interruptedAt,
+        unread: true
+      })), ...workbench.activities].slice(0, 500);
+    }
+    return normalizePersistedDesktopProjects(parsed);
   } catch {
-    return void 0;
+    return { projects: [] };
   }
 }
-async function savePersistedWorkspace(workspace) {
-  await writeFile18(statePath(), `${JSON.stringify({ workspace })}
+async function savePersistedProjects() {
+  await writeFile19(statePath(), `${JSON.stringify({ workspace: activeWorkspace, projects: projectOrder, ...workbench })}
 `, { encoding: "utf8", mode: 384 });
 }
+function validRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : {};
+}
 async function assertDirectory(path) {
-  if (!(await stat15(path)).isDirectory()) throw new Error("The selected project is not a directory");
+  if (!(await stat18(path)).isDirectory()) throw new Error("The selected project is not a directory");
 }
 async function openWorkspace(path) {
-  await assertDirectory(path);
-  const snapshot4 = await controller.openWorkspace(path);
-  await savePersistedWorkspace(path);
-  return snapshot4;
+  const workspace = resolve40(path);
+  await assertDirectory(workspace);
+  let project = managedProjects.get(workspace);
+  if (project === void 0) {
+    const nextController = createDesktopController(workspace);
+    project = { controller: nextController, snapshot: nextController.snapshot(), tasks: /* @__PURE__ */ new Set() };
+    managedProjects.set(workspace, project);
+    projectOrder.unshift(workspace);
+    activeWorkspace = workspace;
+    controller = nextController;
+    project.snapshot = await nextController.openWorkspace(workspace);
+    for (const saved of workbench.taskCheckouts.filter((item) => resolve40(item.workspace) === workspace)) {
+      try {
+        await assertDirectory(saved.workingDirectory);
+        const task = { environment: "worktree", workingDirectory: resolve40(saved.workingDirectory), worktreeId: saved.worktreeId };
+        task.controller = createDesktopController(workspace, task);
+        task.snapshot = await task.controller.openWorkspace(task.workingDirectory);
+        task.sessionId = saved.sessionId;
+        project.tasks.add(task);
+      } catch {
+      }
+    }
+  } else {
+    activeWorkspace = workspace;
+    controller = project.selectedTask?.controller ?? project.controller;
+    project.snapshot = await project.controller.refreshSessions();
+  }
+  await savePersistedProjects();
+  return decorateSnapshot(project.selectedTask?.snapshot ?? project.snapshot);
+}
+function trackTaskTransition(workspace, task, previous, next) {
+  const sessionId = task?.sessionId ?? next.activeSession?.sessionId;
+  if (sessionId === void 0) return;
+  const wasBusy = previous?.activeSession?.busy ?? false;
+  const busy = next.activeSession?.busy ?? false;
+  const key = sessionMetaKey(workspace, sessionId);
+  if (!wasBusy && busy) {
+    if (task !== void 0) delete task.terminal;
+    workbench.activities = workbench.activities.filter((item) => !(item.workspace === workspace && item.sessionId === sessionId));
+    workbench.runningSessions = [...workbench.runningSessions.filter((item) => sessionMetaKey(item.workspace, item.sessionId) !== key), { workspace, sessionId }];
+  } else if (wasBusy && !busy) {
+    workbench.runningSessions = workbench.runningSessions.filter((item) => sessionMetaKey(item.workspace, item.sessionId) !== key);
+    const outcome = task?.terminal ?? "completed";
+    addActivity(workspace, sessionId, outcome, outcome === "failed" ? "\u4EFB\u52A1\u6267\u884C\u5931\u8D25" : outcome === "interrupted" ? "\u4EFB\u52A1\u5DF2\u4E2D\u65AD" : "\u4EFB\u52A1\u5DF2\u8FD0\u884C\u5B8C\u6210");
+  }
+  const needsAttention = next.approval !== void 0 || (next.questions?.length ?? 0) > 0;
+  const hadAttention = previous?.approval !== void 0 || (previous?.questions?.length ?? 0) > 0;
+  if (needsAttention && !hadAttention) addActivity(workspace, sessionId, "attention", "\u4EFB\u52A1\u7B49\u5F85\u4F60\u7684\u786E\u8BA4");
+  void savePersistedProjects();
+}
+function addActivity(workspace, sessionId, kind, title, detail) {
+  const item = { id: `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`, workspace, ...sessionId === void 0 ? {} : { sessionId }, kind, title, ...detail === void 0 ? {} : { detail }, createdAt: (/* @__PURE__ */ new Date()).toISOString(), unread: true };
+  workbench.activities = [item, ...workbench.activities.filter((old) => !(old.workspace === workspace && old.sessionId === sessionId && old.kind === kind))].slice(0, 500);
+  if (Notification.isSupported()) {
+    const notification = new Notification({ title, body: detail ?? `${workbench.projectMeta[workspace]?.label ?? workspace.split(/[\\/]/).pop() ?? workspace}` });
+    notification.on("click", () => {
+      void activateManagedSession(workspace, sessionId);
+    });
+    notification.show();
+  }
+  void savePersistedProjects();
+}
+async function startManagedSession(resumeSession, environment = "local") {
+  if (activeWorkspace === void 0) throw new Error("Open a project before starting a session");
+  const project = managedProjects.get(activeWorkspace);
+  if (resumeSession !== void 0) {
+    const existing = [...project.tasks].find((task2) => task2.sessionId === resumeSession);
+    if (existing?.payload !== void 0) {
+      project.selectedTask = existing;
+      controller = existing.controller;
+      return decorateSessionStarted(existing.payload);
+    }
+  }
+  if ([...project.tasks].filter((task2) => task2.snapshot.activeSession?.busy).length >= 4) throw new Error("\u6BCF\u4E2A\u9879\u76EE\u6700\u591A\u540C\u65F6\u8FD0\u884C 4 \u4E2A\u4EFB\u52A1");
+  const isolated = environment === "worktree" ? await worktreeManager(activeWorkspace).create(`task-${Date.now()}`) : void 0;
+  const task = {
+    environment,
+    workingDirectory: isolated?.path ?? activeWorkspace,
+    ...isolated === void 0 ? {} : { worktreeId: isolated.id }
+  };
+  task.controller = createDesktopController(activeWorkspace, task);
+  task.snapshot = task.controller.snapshot();
+  project.tasks.add(task);
+  project.selectedTask = task;
+  controller = task.controller;
+  await task.controller.openWorkspace(task.workingDirectory);
+  const payload = await task.controller.startSession(resumeSession);
+  task.sessionId = payload.sessionId;
+  task.payload = payload;
+  task.snapshot = payload.snapshot;
+  if (task.environment === "worktree" && task.worktreeId !== void 0) {
+    workbench.taskCheckouts = [...workbench.taskCheckouts.filter((item) => !(item.workspace === activeWorkspace && item.sessionId === payload.sessionId)), { workspace: activeWorkspace, sessionId: payload.sessionId, environment: "worktree", workingDirectory: task.workingDirectory, worktreeId: task.worktreeId }];
+  }
+  project.snapshot = { ...project.snapshot, sessions: payload.snapshot.sessions };
+  await savePersistedProjects();
+  return decorateSessionStarted(payload);
+}
+async function activateManagedSession(workspace, sessionId) {
+  await openWorkspace(workspace);
+  if (sessionId === void 0) return void 0;
+  const project = managedProjects.get(workspace);
+  const task = [...project.tasks].find((item) => item.sessionId === sessionId);
+  let payload;
+  if (task !== void 0) {
+    project.selectedTask = task;
+    controller = task.controller;
+    payload = task.payload ?? await task.controller.startSession(sessionId);
+    task.payload = payload;
+    task.snapshot = payload.snapshot;
+  } else payload = await startManagedSession(sessionId);
+  workbench.activities = workbench.activities.map((item) => item.workspace === workspace && item.sessionId === sessionId ? { ...item, unread: false } : item);
+  mainWindow?.show();
+  mainWindow?.focus();
+  emitDesktopEvent({ type: "session-started", workspace, payload: decorateSessionStarted(payload) });
+  await savePersistedProjects();
+  return decorateSessionStarted(payload);
 }
 async function chooseAndOpenWorkspace() {
   const result = await dialog.showOpenDialog(mainWindow, {
@@ -29950,7 +30969,7 @@ async function chooseAndOpenWorkspace() {
 var cachedAppIconDataUrl;
 function appIconDataUrl() {
   if (cachedAppIconDataUrl !== void 0) return cachedAppIconDataUrl;
-  const icon = nativeImage.createFromPath(join43(app.getAppPath(), "assets", "icon.png"));
+  const icon = nativeImage.createFromPath(join46(app.getAppPath(), "assets", "icon.png"));
   if (icon.isEmpty()) return void 0;
   cachedAppIconDataUrl = icon.toDataURL();
   return cachedAppIconDataUrl;
@@ -29958,13 +30977,23 @@ function appIconDataUrl() {
 function installIpcHandlers() {
   ipcMain.handle(DESKTOP_CHANNELS.appIcon, () => appIconDataUrl());
   ipcMain.handle(DESKTOP_CHANNELS.bootstrap, async () => {
-    const workspace = await loadPersistedWorkspace();
-    if (workspace === void 0) return controller.snapshot();
-    try {
-      return await openWorkspace(workspace);
-    } catch {
-      return controller.snapshot();
+    const persisted = await loadPersistedProjects();
+    workbench.cleanShutdown = false;
+    for (const path of [...persisted.projects].reverse()) {
+      try {
+        await openWorkspace(path);
+      } catch {
+      }
+    }
+    if (persisted.workspace !== void 0 && managedProjects.has(resolve40(persisted.workspace))) {
+      try {
+        return await openWorkspace(persisted.workspace);
+      } catch {
+      }
     }
+    const fallback = projectOrder[0];
+    if (fallback !== void 0) return openWorkspace(fallback);
+    return decorateSnapshot(controller.snapshot());
   });
   ipcMain.handle(DESKTOP_CHANNELS.chooseWorkspace, chooseAndOpenWorkspace);
   ipcMain.handle(DESKTOP_CHANNELS.openWorkspace, async (_event, value) => {
@@ -29972,12 +31001,170 @@ function installIpcHandlers() {
     return openWorkspace(path);
   });
   ipcMain.handle(DESKTOP_CHANNELS.startSession, async (_event, value) => {
-    const { resumeSession } = StartSessionInputSchema.parse(value);
-    return controller.startSession(resumeSession);
+    const { resumeSession, environment } = StartSessionInputSchema.parse(value);
+    return startManagedSession(resumeSession, environment);
+  });
+  ipcMain.handle(DESKTOP_CHANNELS.selectSession, async (_event, value) => {
+    const { sessionId } = DeleteSessionInputSchema.parse(value);
+    if (activeWorkspace === void 0) throw new Error("\u8BF7\u5148\u6253\u5F00\u9879\u76EE");
+    return activateManagedSession(activeWorkspace, sessionId);
   });
   ipcMain.handle(DESKTOP_CHANNELS.deleteSession, async (_event, value) => {
     const { sessionId } = DeleteSessionInputSchema.parse(value);
-    return controller.deleteSession(sessionId);
+    if (activeWorkspace === void 0) return decorateSnapshot(await controller.deleteSession(sessionId));
+    const project = managedProjects.get(activeWorkspace);
+    const task = [...project.tasks].find((item) => item.sessionId === sessionId);
+    if (task !== void 0) {
+      if (task.snapshot.activeSession?.busy) throw new Error("\u8BF7\u5148\u505C\u6B62\u6B63\u5728\u8FD0\u884C\u7684\u4EFB\u52A1");
+      await task.controller.dispose();
+      project.tasks.delete(task);
+      if (project.selectedTask === task) {
+        delete project.selectedTask;
+        controller = project.controller;
+      }
+    }
+    delete workbench.sessionMeta[sessionMetaKey(activeWorkspace, sessionId)];
+    workbench.taskCheckouts = workbench.taskCheckouts.filter((item) => !(item.workspace === activeWorkspace && item.sessionId === sessionId));
+    workbench.activities = workbench.activities.filter((item) => !(item.workspace === activeWorkspace && item.sessionId === sessionId));
+    project.snapshot = await project.controller.deleteSession(sessionId);
+    await savePersistedProjects();
+    return decorateSnapshot(project.selectedTask?.snapshot ?? project.snapshot);
+  });
+  ipcMain.handle(DESKTOP_CHANNELS.updateSession, async (_event, value) => {
+    const input = UpdateSessionInputSchema.parse(value);
+    if (activeWorkspace === void 0) throw new Error("\u8BF7\u5148\u6253\u5F00\u9879\u76EE");
+    const key = sessionMetaKey(activeWorkspace, input.sessionId);
+    workbench.sessionMeta[key] = { ...workbench.sessionMeta[key], ...input.title === void 0 ? {} : { title: input.title || void 0 }, ...input.pinned === void 0 ? {} : { pinned: input.pinned }, ...input.archived === void 0 ? {} : { archived: input.archived } };
+    await savePersistedProjects();
+    return decorateSnapshot(controller.snapshot());
+  });
+  ipcMain.handle(DESKTOP_CHANNELS.acknowledgeSession, async (_event, value) => {
+    const sessionId = Object.keys(value).length === 0 ? void 0 : DeleteSessionInputSchema.parse(value).sessionId;
+    workbench.activities = workbench.activities.map((item) => item.workspace === activeWorkspace && (sessionId === void 0 || item.sessionId === sessionId) ? { ...item, unread: false } : item);
+    await savePersistedProjects();
+    return decorateSnapshot(controller.snapshot());
+  });
+  ipcMain.handle(DESKTOP_CHANNELS.updateProject, async (_event, value) => {
+    const input = UpdateProjectInputSchema.parse(value);
+    const workspace = resolve40(input.workspace);
+    if (!managedProjects.has(workspace)) throw new Error("\u9879\u76EE\u672A\u6253\u5F00");
+    workbench.projectMeta[workspace] = { ...workbench.projectMeta[workspace], ...input.label === void 0 ? {} : { label: input.label || void 0 }, ...input.pinned === void 0 ? {} : { pinned: input.pinned } };
+    await savePersistedProjects();
+    return decorateSnapshot(controller.snapshot());
+  });
+  ipcMain.handle(DESKTOP_CHANNELS.closeProject, async (_event, value) => {
+    const input = CloseProjectInputSchema.parse(value);
+    const workspace = resolve40(input.workspace);
+    const project = managedProjects.get(workspace);
+    if (project === void 0) return decorateSnapshot(controller.snapshot());
+    if ([...project.tasks].some((task) => task.snapshot.activeSession?.busy) && !input.force) throw new Error("\u9879\u76EE\u4E2D\u4ECD\u6709\u4EFB\u52A1\u8FD0\u884C\uFF1B\u786E\u8BA4\u540E\u518D\u5173\u95ED\u9879\u76EE");
+    await Promise.all([project.controller, ...[...project.tasks].map((task) => task.controller)].map((item) => item.dispose()));
+    managedProjects.delete(workspace);
+    projectOrder.splice(projectOrder.indexOf(workspace), 1);
+    if (activeWorkspace === workspace) {
+      activeWorkspace = projectOrder[0];
+      const next = activeWorkspace === void 0 ? void 0 : managedProjects.get(activeWorkspace);
+      controller = next?.selectedTask?.controller ?? next?.controller ?? detachedController;
+    }
+    await savePersistedProjects();
+    return decorateSnapshot(controller.snapshot());
+  });
+  ipcMain.handle(DESKTOP_CHANNELS.revealProject, async (_event, value) => {
+    const workspace = resolve40(ProjectPathInputSchema.parse(value).workspace);
+    await assertDirectory(workspace);
+    await shell.openPath(workspace);
+  });
+  ipcMain.handle(DESKTOP_CHANNELS.copyProjectPath, async (_event, value) => {
+    clipboard.writeText(resolve40(ProjectPathInputSchema.parse(value).workspace));
+  });
+  ipcMain.handle(DESKTOP_CHANNELS.dismissRecovery, async (_event, value) => {
+    const { sessionId } = DeleteSessionInputSchema.parse(value);
+    workbench.recoveryItems = workbench.recoveryItems.filter((item) => !(item.workspace === activeWorkspace && item.sessionId === sessionId));
+    await savePersistedProjects();
+    return decorateSnapshot(controller.snapshot());
+  });
+  ipcMain.handle(DESKTOP_CHANNELS.gitStatus, async () => activeWorkspace === void 0 ? { repository: false, branch: "", head: "", files: [] } : desktopGitStatus(activeWorkingDirectory()));
+  ipcMain.handle(DESKTOP_CHANNELS.gitDiff, async (_event, value) => {
+    const input = GitDiffInputSchema.parse(value);
+    return desktopGitDiff(activeWorkingDirectory(), input.path, input.staged);
+  });
+  ipcMain.handle(DESKTOP_CHANNELS.gitStage, async (_event, value) => desktopGitStage(activeWorkingDirectory(), GitPathInputSchema.parse(value).path));
+  ipcMain.handle(DESKTOP_CHANNELS.gitUnstage, async (_event, value) => desktopGitUnstage(activeWorkingDirectory(), GitPathInputSchema.parse(value).path));
+  ipcMain.handle(DESKTOP_CHANNELS.gitDiscard, async (_event, value) => desktopGitDiscard(activeWorkingDirectory(), GitPathInputSchema.parse(value).path));
+  ipcMain.handle(DESKTOP_CHANNELS.gitCommit, async (_event, value) => desktopGitCommit(activeWorkingDirectory(), GitCommitInputSchema.parse(value).message));
+  ipcMain.handle(DESKTOP_CHANNELS.gitReview, async (_event, value) => {
+    const input = GitReviewInputSchema.parse(value);
+    const workspace = activeWorkingDirectory();
+    return input.scope === "last-turn" && controller.snapshot().activeSession !== void 0 ? desktopLastTurnDiff(workspace, controller.snapshot().activeSession.sessionId, input.paths ?? []) : desktopGitReviewDiff(workspace, { scope: input.scope, ...input.target === void 0 ? {} : { target: input.target }, ...input.paths === void 0 ? {} : { paths: input.paths } });
+  });
+  ipcMain.handle(DESKTOP_CHANNELS.gitHistory, async () => desktopGitHistory(activeWorkingDirectory()));
+  ipcMain.handle(DESKTOP_CHANNELS.listWorktrees, async () => activeWorkspace === void 0 ? [] : worktreeManager(activeWorkspace).list());
+  ipcMain.handle(DESKTOP_CHANNELS.removeWorktree, async (_event, value) => {
+    if (activeWorkspace === void 0) throw new Error("\u8BF7\u5148\u6253\u5F00\u9879\u76EE");
+    const input = WorktreeRemoveInputSchema.parse(value);
+    const task = [...managedProjects.get(activeWorkspace).tasks].find((item) => item.worktreeId === input.id);
+    if (task?.snapshot.activeSession?.busy) throw new Error("\u4E0D\u80FD\u5220\u9664\u6B63\u5728\u8FD0\u884C\u4EFB\u52A1\u7684\u5DE5\u4F5C\u6811");
+    if (task !== void 0) {
+      await task.controller.dispose();
+      managedProjects.get(activeWorkspace).tasks.delete(task);
+    }
+    await worktreeManager(activeWorkspace).remove(input.id, input.force);
+    workbench.taskCheckouts = workbench.taskCheckouts.filter((item) => !(item.workspace === activeWorkspace && item.worktreeId === input.id));
+    await savePersistedProjects();
+  });
+  ipcMain.handle(DESKTOP_CHANNELS.mergeWorktree, async (_event, value) => {
+    if (activeWorkspace === void 0) throw new Error("\u8BF7\u5148\u6253\u5F00\u9879\u76EE");
+    await worktreeManager(activeWorkspace).merge(WorktreeRemoveInputSchema.parse(value).id);
+  });
+  ipcMain.handle(DESKTOP_CHANNELS.historySnapshot, async () => controller.historySnapshot());
+  ipcMain.handle(DESKTOP_CHANNELS.createCheckpoint, async (_event, value) => controller.createCheckpoint(CheckpointInputSchema.parse(value).label));
+  ipcMain.handle(DESKTOP_CHANNELS.rewindHistory, async (_event, value) => controller.rewindHistory(HistoryNodeInputSchema.parse(value).nodeId));
+  ipcMain.handle(DESKTOP_CHANNELS.unrevertHistory, async () => controller.unrevertHistory());
+  ipcMain.handle(DESKTOP_CHANNELS.forkHistory, async (_event, value) => controller.forkHistory(HistoryNodeInputSchema.parse(value).nodeId));
+  ipcMain.handle(DESKTOP_CHANNELS.terminalOpen, async (_event, value) => {
+    const input = TerminalOpenInputSchema.parse(value);
+    return controller.openTerminal({ ...input.cwd === void 0 ? {} : { cwd: input.cwd }, ...input.shell === void 0 ? {} : { shell: input.shell }, ...input.columns === void 0 ? {} : { columns: input.columns }, ...input.rows === void 0 ? {} : { rows: input.rows } });
+  });
+  ipcMain.handle(DESKTOP_CHANNELS.terminalList, async () => controller.listTerminals());
+  ipcMain.handle(DESKTOP_CHANNELS.terminalRead, async (_event, value) => {
+    const input = TerminalReadInputSchema.parse(value);
+    return controller.readTerminal(input.id, input.cursor);
+  });
+  ipcMain.handle(DESKTOP_CHANNELS.terminalWrite, async (_event, value) => {
+    const input = TerminalWriteInputSchema.parse(value);
+    controller.writeTerminal(input.id, input.data);
+  });
+  ipcMain.handle(DESKTOP_CHANNELS.terminalResize, async (_event, value) => {
+    const input = TerminalResizeInputSchema.parse(value);
+    controller.resizeTerminal(input.id, input.columns, input.rows);
+  });
+  ipcMain.handle(DESKTOP_CHANNELS.terminalClose, async (_event, value) => controller.closeTerminal(TerminalIdInputSchema.parse(value).id));
+  ipcMain.handle(DESKTOP_CHANNELS.jobRead, async (_event, value) => {
+    const input = JobReadInputSchema.parse(value);
+    return controller.readJob(input.id, input.cursor);
+  });
+  ipcMain.handle(DESKTOP_CHANNELS.previewValidate, async (_event, value) => DesktopWorkbenchService.normalizePreviewUrl(PreviewUrlInputSchema.parse(value).url));
+  ipcMain.handle(DESKTOP_CHANNELS.previewOpen, async (_event, value) => shell.openExternal(DesktopWorkbenchService.normalizePreviewUrl(PreviewUrlInputSchema.parse(value).url)));
+  ipcMain.handle(DESKTOP_CHANNELS.inspectWorkbench, async () => new DesktopWorkbenchService(activeWorkingDirectory()).inspect(controller.snapshot().activeSession?.sessionId));
+  ipcMain.handle(DESKTOP_CHANNELS.astStatus, async () => new DesktopAstGraphService(activeWorkingDirectory()).status());
+  ipcMain.handle(DESKTOP_CHANNELS.astSearch, async (_event, value) => new DesktopAstGraphService(activeWorkingDirectory()).search(AstSearchInputSchema.parse(value).query));
+  ipcMain.handle(DESKTOP_CHANNELS.astRelations, async (_event, value) => {
+    const input = AstNodeInputSchema.parse(value);
+    return new DesktopAstGraphService(activeWorkingDirectory()).relations(input.id, input.hops);
+  });
+  ipcMain.handle(DESKTOP_CHANNELS.listPals, async () => controller.listPals());
+  ipcMain.handle(DESKTOP_CHANNELS.sendPalMessage, async (_event, value) => {
+    const input = PalMessageInputSchema.parse(value);
+    return controller.sendPalMessage(input.target, input.message, input.kind);
+  });
+  ipcMain.handle(DESKTOP_CHANNELS.startCoWork, async (_event, value) => {
+    const input = CoWorkStartInputSchema.parse(value);
+    return controller.startCoWork(input.target, input.goal);
+  });
+  ipcMain.handle(DESKTOP_CHANNELS.coWorkStatus, async (_event, value) => controller.coWorkStatus(CoWorkStatusInputSchema.parse(value).coWorkId));
+  ipcMain.handle(DESKTOP_CHANNELS.cancelCoWork, async (_event, value) => {
+    const input = CoWorkCancelInputSchema.parse(value);
+    return controller.cancelCoWork(input.coWorkId, input.reason);
   });
   ipcMain.handle(DESKTOP_CHANNELS.showAppMenu, async (_event, value) => {
     const { menu, x, y } = AppMenuInputSchema.parse(value);
@@ -30046,11 +31233,13 @@ function installIpcHandlers() {
   ipcMain.handle(DESKTOP_CHANNELS.deleteMemory, async (_event, value) => {
     return controller.deleteMemory(DeleteMemoryInputSchema.parse(value).id);
   });
+  ipcMain.handle(DESKTOP_CHANNELS.deleteColdMemory, async () => controller.deleteColdMemory());
   ipcMain.handle(DESKTOP_CHANNELS.switchModel, async (_event, value) => {
-    return controller.switchModel(SwitchDesktopModelInputSchema.parse(value).modelId);
+    return decorateSnapshot(await controller.switchModel(SwitchDesktopModelInputSchema.parse(value).modelId));
   });
   ipcMain.handle(DESKTOP_CHANNELS.addModel, async (_event, value) => {
-    return controller.addModel(AddDesktopModelInputSchema.parse(value));
+    const result = await controller.addModel(AddDesktopModelInputSchema.parse(value));
+    return { ...result, snapshot: decorateSnapshot(result.snapshot) };
   });
   ipcMain.handle(DESKTOP_CHANNELS.d2cImport, async (_event, value) => {
     const { task } = D2cImportInputSchema.parse(value);
@@ -30198,7 +31387,7 @@ function applicationMenu() {
   ]);
 }
 async function createWindow() {
-  const rendererPath = join43(app.getAppPath(), "dist", "desktop-renderer", "index.html");
+  const rendererPath = join46(app.getAppPath(), "dist", "desktop-renderer", "index.html");
   mainWindow = new BrowserWindow2({
     title: "Flavor Code",
     width: 1280,
@@ -30209,14 +31398,14 @@ async function createWindow() {
     show: false,
     ...desktopWindowChrome(),
     webPreferences: {
-      preload: join43(moduleDirectory, "preload.cjs"),
+      preload: join46(moduleDirectory, "preload.cjs"),
       contextIsolation: true,
       nodeIntegration: false,
       sandbox: false,
       webSecurity: true
     }
   });
-  const iconPath = join43(app.getAppPath(), "assets", "icon.png");
+  const iconPath = join46(app.getAppPath(), "assets", "icon.png");
   const icon = nativeImage.createFromPath(iconPath);
   if (!icon.isEmpty()) {
     mainWindow.setIcon(icon);
@@ -30231,7 +31420,9 @@ async function createWindow() {
     if (quitting) return;
     event.preventDefault();
     quitting = true;
-    void controller.dispose().finally(() => {
+    workbench.cleanShutdown = true;
+    const controllers = [detachedController, ...[...managedProjects.values()].flatMap((project) => [project.controller, ...[...project.tasks].map((task) => task.controller)])];
+    void savePersistedProjects().catch(() => void 0).then(() => Promise.all(controllers.map((item) => item.dispose()))).finally(() => {
       mainWindow?.destroy();
       app.quit();
     });
@@ -30264,8 +31455,16 @@ app.whenReady().then(async () => {
   dialog.showErrorBox("Flavor Code \u65E0\u6CD5\u542F\u52A8", error instanceof Error ? error.message : String(error));
   app.quit();
 });
-app.on("before-quit", () => {
+app.on("before-quit", (event) => {
+  if (quitting) return;
+  event.preventDefault();
   quitting = true;
+  workbench.cleanShutdown = true;
+  const controllers = [detachedController, ...[...managedProjects.values()].flatMap((project) => [project.controller, ...[...project.tasks].map((task) => task.controller)])];
+  void savePersistedProjects().catch(() => void 0).then(() => Promise.all(controllers.map((item) => item.dispose()))).finally(() => {
+    mainWindow?.destroy();
+    app.quit();
+  });
 });
 app.on("window-all-closed", () => {
   if (process.platform !== "darwin") app.quit();