@jamiexiongr/panda-hub 0.1.22 → 0.1.24

package/dist/{chunk-SPTBBMUL.mjs → chunk-KWFBUSH3.mjs}

@@ -2273,6 +2273,58 @@ var sessionGitActionResponseSchema = external_exports.object({
   ok: external_exports.literal(true),
   workspace: sessionGitWorkspaceSchema
 });
+var sessionTurnActionSchema = external_exports.enum([
+  "rollback"
+]);
+var sessionTurnActionResponseSchema = external_exports.object({
+  ok: external_exports.literal(true),
+  turn_id: external_exports.string(),
+  change_set_id: external_exports.string(),
+  workspace: sessionGitWorkspaceSchema
+});
+var sessionFilePreviewNodeKindSchema = external_exports.enum([
+  "directory",
+  "file"
+]);
+var sessionFilePreviewFileKindSchema = external_exports.enum([
+  "markdown",
+  "code",
+  "text",
+  "image",
+  "binary"
+]);
+var sessionFilePreviewTreeNodeSchema = external_exports.object({
+  path: external_exports.string(),
+  name: external_exports.string(),
+  kind: sessionFilePreviewNodeKindSchema,
+  has_children: external_exports.boolean(),
+  extension: external_exports.string().nullable().default(null),
+  file_kind: sessionFilePreviewFileKindSchema.nullable().default(null),
+  size_bytes: external_exports.number().int().nonnegative().nullable().default(null)
+});
+var sessionFilePreviewTreeResponseSchema = external_exports.object({
+  session_id: external_exports.string(),
+  project_id: external_exports.string(),
+  root_path: external_exports.string(),
+  parent_path: external_exports.string().nullable().default(null),
+  nodes: external_exports.array(sessionFilePreviewTreeNodeSchema),
+  loaded_at: external_exports.string()
+});
+var sessionFilePreviewContentResponseSchema = external_exports.object({
+  session_id: external_exports.string(),
+  project_id: external_exports.string(),
+  path: external_exports.string(),
+  name: external_exports.string(),
+  extension: external_exports.string().nullable().default(null),
+  file_kind: sessionFilePreviewFileKindSchema,
+  mime_type: external_exports.string().nullable().default(null),
+  size_bytes: external_exports.number().int().nonnegative().nullable().default(null),
+  encoding: external_exports.enum(["utf8", "base64"]).nullable().default(null),
+  is_truncated: external_exports.boolean(),
+  content_text: external_exports.string().nullable().default(null),
+  content_base64: external_exports.string().nullable().default(null),
+  loaded_at: external_exports.string()
+});
 var sessionRunCommandShellSchema = external_exports.enum([
   "auto",
   "powershell",
@@ -3244,6 +3296,7 @@ var APP_SERVER_DIAGNOSTIC_METHODS = /* @__PURE__ */ new Set([
   "config/read"
 ]);
 var defaultCodexHome2 = () => path4.join(os3.homedir(), ".codex");
+var resolveCodexEnvironmentHome = () => process.env.CODEX_HOME?.trim() || process.env.PANDA_CODEX_HOME?.trim() || defaultCodexHome2();
 var truncateText = (value, length) => {
   const trimmed = value.trim();
   if (trimmed.length <= length) {
@@ -5694,14 +5747,20 @@ ${nextFile.diff}`.trim();
   const spawnAppServerChild = () => {
     try {
       const appServerArgs = ["app-server", "--enable", "default_mode_request_user_input"];
+      const childEnv = {
+        ...process.env,
+        CODEX_HOME: resolveCodexEnvironmentHome()
+      };
       if (process.platform === "win32") {
         return spawn(process.env.ComSpec || "cmd.exe", ["/d", "/c", "codex", ...appServerArgs], {
           stdio: ["pipe", "pipe", "pipe"],
-          windowsHide: true
+          windowsHide: true,
+          env: childEnv
         });
       }
       return spawn("codex", appServerArgs, {
-        stdio: ["pipe", "pipe", "pipe"]
+        stdio: ["pipe", "pipe", "pipe"],
+        env: childEnv
       });
     } catch {
       return null;
@@ -5715,6 +5774,7 @@ ${nextFile.diff}`.trim();
     logDiagnostic("info", "Starting Codex app-server bridge.", {
       platform: process.platform,
       execPath: process.execPath,
+      codexHome: resolveCodexEnvironmentHome(),
       codexCommandFound: codexCandidates.length > 0,
       codexCommandCandidates: codexCandidates,
       bridgeExecutable: process.platform === "win32" ? `${process.env.ComSpec || "cmd.exe"} /d /c codex` : "codex"
@@ -10063,6 +10123,72 @@ var USER_OVERLAY_ENTRY_PREFIX = "overlay-user:";
 var USER_ENTRY_MATCH_EARLY_SKEW_MS = 5e3;
 var TIMELINE_TOOL_SUMMARY_LIMIT = 160;
 var HTTP_COMPRESSION_MIN_BYTES = 4 * 1024;
+var DEFAULT_SESSION_TITLE_GENERATION_MODEL = "gpt-5.4-mini";
+var SESSION_TITLE_GENERATION_TIMEOUT_MS = 25e3;
+var SESSION_GENERATED_TITLE_MAX_LENGTH = 30;
+var SESSION_FILE_PREVIEW_ROOT_PATH = "/";
+var SESSION_FILE_PREVIEW_TEXT_BYTE_LIMIT = 256 * 1024;
+var SESSION_FILE_PREVIEW_IMAGE_BYTE_LIMIT = 6 * 1024 * 1024;
+var SESSION_FILE_PREVIEW_MARKDOWN_EXTENSIONS = /* @__PURE__ */ new Set([".md", ".markdown"]);
+var SESSION_FILE_PREVIEW_CODE_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".ts",
+  ".tsx",
+  ".js",
+  ".jsx",
+  ".json",
+  ".css",
+  ".html",
+  ".xml",
+  ".yml",
+  ".yaml",
+  ".sh",
+  ".java"
+]);
+var SESSION_FILE_PREVIEW_TEXT_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".txt",
+  ".log"
+]);
+var SESSION_FILE_PREVIEW_IMAGE_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".png",
+  ".jpg",
+  ".jpeg",
+  ".webp",
+  ".gif",
+  ".svg"
+]);
+var SESSION_FILE_PREVIEW_CODE_FILENAMES = /* @__PURE__ */ new Set([
+  "dockerfile",
+  "makefile",
+  "jenkinsfile"
+]);
+var SESSION_FILE_PREVIEW_CODE_NAME_PATTERNS = [
+  /^\.(?:env(?:\..+)?)$/i,
+  /^\.(?:gitignore|gitattributes|npmrc|yarnrc|editorconfig)$/i,
+  /^\.(?:prettierrc|eslintrc)(?:\..+)?$/i
+];
+var SESSION_FILE_PREVIEW_MIME_TYPES = {
+  ".css": "text/css; charset=utf-8",
+  ".gif": "image/gif",
+  ".html": "text/html; charset=utf-8",
+  ".java": "text/x-java-source; charset=utf-8",
+  ".jpeg": "image/jpeg",
+  ".jpg": "image/jpeg",
+  ".js": "text/javascript; charset=utf-8",
+  ".json": "application/json; charset=utf-8",
+  ".log": "text/plain; charset=utf-8",
+  ".markdown": "text/markdown; charset=utf-8",
+  ".md": "text/markdown; charset=utf-8",
+  ".png": "image/png",
+  ".sh": "text/x-shellscript; charset=utf-8",
+  ".svg": "image/svg+xml",
+  ".ts": "text/typescript; charset=utf-8",
+  ".tsx": "text/typescript; charset=utf-8",
+  ".txt": "text/plain; charset=utf-8",
+  ".webp": "image/webp",
+  ".xml": "application/xml; charset=utf-8",
+  ".yaml": "text/yaml; charset=utf-8",
+  ".yml": "text/yaml; charset=utf-8"
+};
 var WEB_UI_CONTENT_TYPES = {
   ".css": "text/css; charset=utf-8",
   ".html": "text/html; charset=utf-8",
@@ -10082,6 +10208,11 @@ Plan mode is enabled for this message only. Before doing substantial work, creat
 </user_instructions>
 
 `;
+var LATEST_VISIBLE_CODEX_COMMAND_CONFIG_VERSION = 2;
+var REVIEW_VISIBLE_CODEX_COMMAND_ENTRY = {
+  name: "review",
+  reason: "\u5FEB\u901F\u5BA1\u67E5\u5F53\u524D\u5DE5\u4F5C\u533A\u672A\u63D0\u4EA4\u6539\u52A8\uFF0C\u9002\u5408\u5728\u63D0\u4EA4\u524D\u6216\u7EE7\u7EED\u7F16\u7801\u524D\u5148\u81EA\u68C0\u4E00\u904D\u3002"
+};
 var FALLBACK_CODEX_COMMAND_CATALOG = [
   { name: "compact", description: "\u538B\u7F29\u5F53\u524D\u4F1A\u8BDD\u4E0A\u4E0B\u6587\uFF0C\u91CA\u653E\u7A97\u53E3\u5E76\u7EE7\u7EED\u5DE5\u4F5C\u3002", availability: "supported" },
   { name: "copy", description: "\u590D\u5236\u6700\u8FD1\u4E00\u6B21\u52A9\u624B\u8F93\u51FA\u3002", availability: "unsupported" },
@@ -10109,7 +10240,7 @@ var PANDA_SUPPORTED_COMMANDS = /* @__PURE__ */ new Set([
   "status"
 ]);
 var DEFAULT_VISIBLE_CODEX_COMMAND_CONFIG = {
-  version: 1,
+  version: LATEST_VISIBLE_CODEX_COMMAND_CONFIG_VERSION,
   visible_commands: [
     {
       name: "model",
@@ -10119,6 +10250,7 @@ var DEFAULT_VISIBLE_CODEX_COMMAND_CONFIG = {
       name: "status",
       reason: "\u5FEB\u901F\u67E5\u770B\u5F53\u524D\u4F1A\u8BDD\u6A21\u578B\u3001\u4E0A\u4E0B\u6587\u5360\u7528\u548C\u6C99\u7BB1\u7B49\u5173\u952E\u4FE1\u606F\uFF0C\u9002\u5408\u5148\u81EA\u68C0\u3002"
     },
+    REVIEW_VISIBLE_CODEX_COMMAND_ENTRY,
     {
       name: "skills",
       reason: "\u628A\u9879\u76EE\u91CC\u53EF\u7528\u6280\u80FD\u76F4\u63A5\u66B4\u9732\u51FA\u6765\uFF0C\u80FD\u5E2E\u52A9\u7528\u6237\u53D1\u73B0 Panda \u5DF2\u63A5\u5165\u7684\u80FD\u529B\u3002"
@@ -10362,6 +10494,142 @@ var startPandaSessionService = async ({
     }
     return !relativePath.startsWith("..") && !path9.isAbsolute(relativePath);
   };
+  const isAbsolutePathInsideProject = (projectPath, candidatePath) => {
+    const resolvedProjectPath = path9.resolve(projectPath);
+    const resolvedCandidatePath = path9.resolve(candidatePath);
+    const relativePath = path9.relative(resolvedProjectPath, resolvedCandidatePath);
+    if (!relativePath) {
+      return true;
+    }
+    return !relativePath.startsWith("..") && !path9.isAbsolute(relativePath);
+  };
+  const normalizeSessionFilePreviewPath = (value) => normalizeGitWorkspacePath(value?.trim() ?? "").replace(/^\/+|\/+$/g, "");
+  const isMissingPathError = (error) => error instanceof Error && "code" in error && error.code === "ENOENT";
+  const resolveSessionFilePreviewPath = async (projectPath, requestedPath) => {
+    const normalizedPath = normalizeSessionFilePreviewPath(requestedPath);
+    const absolutePath = normalizedPath ? path9.resolve(projectPath, normalizedPath) : path9.resolve(projectPath);
+    if (!isAbsolutePathInsideProject(projectPath, absolutePath)) {
+      throw new Error("\u76EE\u6807\u8DEF\u5F84\u4E0D\u5728\u5F53\u524D\u9879\u76EE\u5185\u3002");
+    }
+    let realPath;
+    try {
+      realPath = await fs8.realpath(absolutePath);
+    } catch (error) {
+      if (isMissingPathError(error)) {
+        throw new Error("File not found.");
+      }
+      throw error;
+    }
+    if (!isAbsolutePathInsideProject(projectPath, realPath)) {
+      throw new Error("\u76EE\u6807\u8DEF\u5F84\u4E0D\u5728\u5F53\u524D\u9879\u76EE\u5185\u3002");
+    }
+    return {
+      normalizedPath,
+      absolutePath,
+      realPath
+    };
+  };
+  const normalizeSessionFilePreviewExtension = (value) => {
+    const extension = path9.extname(value).trim().toLowerCase();
+    return extension || null;
+  };
+  const detectSessionFilePreviewKind = (fileName, extension) => {
+    const normalizedName = fileName.trim().toLowerCase();
+    if (extension && SESSION_FILE_PREVIEW_MARKDOWN_EXTENSIONS.has(extension)) {
+      return "markdown";
+    }
+    if (extension && SESSION_FILE_PREVIEW_IMAGE_EXTENSIONS.has(extension)) {
+      return "image";
+    }
+    if (extension && SESSION_FILE_PREVIEW_TEXT_EXTENSIONS.has(extension)) {
+      return "text";
+    }
+    if (extension && SESSION_FILE_PREVIEW_CODE_EXTENSIONS.has(extension) || SESSION_FILE_PREVIEW_CODE_FILENAMES.has(normalizedName) || SESSION_FILE_PREVIEW_CODE_NAME_PATTERNS.some((pattern) => pattern.test(normalizedName))) {
+      return "code";
+    }
+    return null;
+  };
+  const getSessionFilePreviewMimeType = (extension, fileKind) => {
+    if (extension && SESSION_FILE_PREVIEW_MIME_TYPES[extension]) {
+      return SESSION_FILE_PREVIEW_MIME_TYPES[extension];
+    }
+    if (fileKind === "markdown") {
+      return "text/markdown; charset=utf-8";
+    }
+    if (fileKind === "code" || fileKind === "text") {
+      return "text/plain; charset=utf-8";
+    }
+    return null;
+  };
+  const looksLikeTextBuffer = (buffer) => {
+    if (buffer.length === 0) {
+      return true;
+    }
+    let suspiciousControlCount = 0;
+    for (const byte of buffer.values()) {
+      if (byte === 0) {
+        return false;
+      }
+      const isAllowedWhitespace = byte === 9 || byte === 10 || byte === 13;
+      if (!isAllowedWhitespace && byte < 32) {
+        suspiciousControlCount += 1;
+      }
+    }
+    return suspiciousControlCount / buffer.length < 0.08;
+  };
+  const readPreviewBuffer = async (filePath, byteLimit) => {
+    const handle = await fs8.open(filePath, "r");
+    try {
+      const buffer = Buffer.alloc(byteLimit);
+      const { bytesRead } = await handle.read(buffer, 0, byteLimit, 0);
+      return buffer.subarray(0, bytesRead);
+    } finally {
+      await handle.close();
+    }
+  };
+  const readDirectoryHasChildren = async (directoryPath) => {
+    try {
+      const entries = await fs8.readdir(directoryPath);
+      return entries.length > 0;
+    } catch {
+      return false;
+    }
+  };
+  const buildSessionFilePreviewTreeNode = async (projectPath, parentRelativePath, parentRealPath, entry) => {
+    const nextRelativePath = normalizeGitWorkspacePath(
+      parentRelativePath ? `${parentRelativePath}/${entry.name}` : entry.name
+    );
+    const entryPath = path9.join(parentRealPath, entry.name);
+    if (entry.isSymbolicLink()) {
+      try {
+        const realPath = await fs8.realpath(entryPath);
+        if (!isAbsolutePathInsideProject(projectPath, realPath)) {
+          return null;
+        }
+      } catch {
+        return null;
+      }
+    }
+    const stat = await fs8.stat(entryPath).catch(() => null);
+    if (!stat) {
+      return null;
+    }
+    const kind = stat.isDirectory() ? "directory" : stat.isFile() ? "file" : null;
+    if (!kind) {
+      return null;
+    }
+    const extension = kind === "file" ? normalizeSessionFilePreviewExtension(entry.name) : null;
+    const fileKind = kind === "file" ? detectSessionFilePreviewKind(entry.name, extension) ?? "binary" : null;
+    return {
+      path: nextRelativePath,
+      name: entry.name,
+      kind,
+      has_children: kind === "directory" ? await readDirectoryHasChildren(entryPath) : false,
+      extension,
+      file_kind: fileKind,
+      size_bytes: kind === "file" ? stat.size : null
+    };
+  };
   const runGitCommand = async (cwd, args, options) => new Promise((resolve, reject) => {
     let stdout = "";
     let stderr = "";
@@ -11023,17 +11291,36 @@ var startPandaSessionService = async ({
       return null;
     }
     const candidate = value;
-    if (candidate.version !== void 0 && candidate.version !== 1) {
+    if (candidate.version !== void 0 && candidate.version !== 1 && candidate.version !== LATEST_VISIBLE_CODEX_COMMAND_CONFIG_VERSION) {
       return null;
     }
     if (!Array.isArray(candidate.visible_commands)) {
       return null;
     }
     return {
-      version: 1,
+      version: candidate.version === LATEST_VISIBLE_CODEX_COMMAND_CONFIG_VERSION ? LATEST_VISIBLE_CODEX_COMMAND_CONFIG_VERSION : 1,
       visible_commands: candidate.visible_commands.map((entry) => normalizeVisibleCodexCommandConfigEntry(entry)).filter((entry) => Boolean(entry))
     };
   };
+  const migrateVisibleCodexCommandConfig = (config) => {
+    if (config.version >= LATEST_VISIBLE_CODEX_COMMAND_CONFIG_VERSION) {
+      return config;
+    }
+    const visibleCommands = [...config.visible_commands];
+    const hasReview = visibleCommands.some((entry) => entry.name === REVIEW_VISIBLE_CODEX_COMMAND_ENTRY.name);
+    if (!hasReview) {
+      const skillsIndex = visibleCommands.findIndex((entry) => entry.name === "skills");
+      if (skillsIndex === -1) {
+        visibleCommands.push(REVIEW_VISIBLE_CODEX_COMMAND_ENTRY);
+      } else {
+        visibleCommands.splice(skillsIndex, 0, REVIEW_VISIBLE_CODEX_COMMAND_ENTRY);
+      }
+    }
+    return {
+      version: LATEST_VISIBLE_CODEX_COMMAND_CONFIG_VERSION,
+      visible_commands: visibleCommands
+    };
+  };
   const writeVisibleCodexCommandConfig = async (config) => {
     const configFilePath = await getCodexVisibleCommandsConfigFilePath();
     await fs8.writeFile(configFilePath, `${JSON.stringify(config, null, 2)}
@@ -11045,7 +11332,11 @@ var startPandaSessionService = async ({
       const raw = await fs8.readFile(configFilePath, "utf8");
       const parsed = parseVisibleCodexCommandConfig(JSON.parse(raw));
       if (parsed) {
-        return parsed;
+        const migrated = migrateVisibleCodexCommandConfig(parsed);
+        if (migrated !== parsed) {
+          await writeVisibleCodexCommandConfig(migrated);
+        }
+        return migrated;
       }
     } catch {
     }
@@ -11302,6 +11593,36 @@ var startPandaSessionService = async ({
     }
     return `${trimmed.slice(0, maxLength - 1).trimEnd()}\u2026`;
   };
+  const sanitizeGeneratedSessionTitle = (value, maxLength = SESSION_GENERATED_TITLE_MAX_LENGTH) => {
+    const normalized = value.replace(/\r\n/g, "\n").split("\n").map((line) => line.trim()).filter(Boolean).join(" ").replace(/^["'`\[\]【】()（）\s]+|["'`\[\]【】()（）\s]+$/g, "").replace(/^(标题|Title)\s*[:：-]\s*/i, "").replace(/\s+/g, " ").trim();
+    if (!normalized) {
+      return null;
+    }
+    if (normalized.length <= maxLength) {
+      return normalized;
+    }
+    return normalized.slice(0, maxLength).trimEnd();
+  };
+  const buildSessionTitleGenerationPrompt = (input) => {
+    const message = input.message.trim();
+    const attachmentNames = input.attachments.map((attachment) => attachment.name.trim()).filter(Boolean).slice(0, 5);
+    const contextParts = [
+      message ? `\u7528\u6237\u9996\u6761\u6D88\u606F\uFF1A
+${message}` : null,
+      attachmentNames.length > 0 ? `\u9644\u4EF6\uFF1A
+${attachmentNames.map((name) => `- ${name}`).join("\n")}` : null
+    ].filter(Boolean);
+    return [
+      "\u8BF7\u6839\u636E\u4E0B\u9762\u7684\u65B0\u4F1A\u8BDD\u9996\u6761\u6D88\u606F\u751F\u6210\u4E00\u4E2A\u7B80\u77ED\u7684\u4E2D\u6587\u4F1A\u8BDD\u6807\u9898\u3002",
+      "\u8981\u6C42\uFF1A",
+      "1. \u53EA\u8F93\u51FA\u6807\u9898\u672C\u8EAB\uFF0C\u4E0D\u8981\u89E3\u91CA\uFF0C\u4E0D\u8981\u52A0\u5F15\u53F7\u3002",
+      "2. \u6807\u9898\u8981\u51C6\u786E\u6982\u62EC\u4EFB\u52A1\u76EE\u6807\uFF0C\u4E0D\u8981\u7167\u6284\u539F\u53E5\u3002",
+      "3. \u5C3D\u91CF\u63A7\u5236\u5728 4 \u5230 14 \u4E2A\u6C49\u5B57\uFF0C\u6216\u7B49\u4EF7\u7684\u77ED\u82F1\u6587\u957F\u5EA6\u3002",
+      "4. \u907F\u514D\u7A7A\u6CDB\u8BCD\uFF0C\u6BD4\u5982\u201C\u6C42\u52A9\u201D\u201C\u95EE\u9898\u201D\u201C\u804A\u5929\u201D\u201C\u65B0\u4F1A\u8BDD\u201D\u3002",
+      "",
+      ...contextParts
+    ].join("\n");
+  };
   const createDiagnosticHash2 = (value) => createHash5("sha1").update(value).digest("hex").slice(0, 16);
   const summarizeTextForDiagnostics = (value, options) => {
     const normalized = typeof value === "string" ? value.trim() : "";
@@ -11339,6 +11660,7 @@ var startPandaSessionService = async ({
             dataHash: attachment.dataHash
           })),
           model: input.model,
+          titleGenerationModel: input.titleGenerationModel ?? null,
           reasoningEffort: input.reasoningEffort,
           requestedServiceTier: input.requestedServiceTier ?? null,
           normalizedRequestedServiceTier: input.normalizedRequestedServiceTier,
@@ -11352,6 +11674,7 @@ var startPandaSessionService = async ({
       prompt: promptSummary,
       attachments: attachmentsSummary,
       model: input.model,
+      titleGenerationModel: input.titleGenerationModel ?? null,
       reasoningEffort: input.reasoningEffort,
       requestedServiceTier: input.requestedServiceTier === "fast" || input.requestedServiceTier === "flex" ? input.requestedServiceTier : input.requestedServiceTier ?? null,
       normalizedRequestedServiceTier: input.normalizedRequestedServiceTier,
@@ -11564,7 +11887,7 @@ var startPandaSessionService = async ({
     return nextOverlayEntries;
   };
   const readTimelineFromRollout = async (sessionId) => {
-    const { readCodexTimeline } = await import("./src-M7W7LPHG.mjs");
+    const { readCodexTimeline } = await import("./src-ILWWSZFE.mjs");
     return readCodexTimeline(sessionId, {
       codexHome,
       sessionFiles: discoveredSessionFiles
@@ -12163,6 +12486,14 @@ var startPandaSessionService = async ({
     }
     return [];
   };
+  const readChangeSetForSession = async (sessionId, changeSetId) => {
+    const changeSets = await readChangeSetsForSession(sessionId);
+    return changeSets.find((entry) => entry.id === changeSetId) ?? null;
+  };
+  const readChangeSetForTurn = async (sessionId, turnId) => {
+    const changeSets = await readChangeSetsForSession(sessionId);
+    return changeSets.find((entry) => entry.turn_id === turnId) ?? null;
+  };
   const readPlanForSession = async (sessionId) => {
     const existing = sessionPlans.get(sessionId);
     if (existing !== void 0) {
@@ -12194,8 +12525,7 @@ var startPandaSessionService = async ({
     return [];
   };
   const readChangeSetFileDiffForSession = async (sessionId, input) => {
-    const changeSets = await readChangeSetsForSession(sessionId);
-    const changeSet = changeSets.find((entry) => entry.id === input.changeSetId);
+    const changeSet = await readChangeSetForSession(sessionId, input.changeSetId);
     if (!changeSet) {
       return null;
     }
@@ -12668,7 +12998,7 @@ var startPandaSessionService = async ({
       commands: filterCodexCommandsForDisplay(catalog.commands, visibleConfig)
     };
   };
-  const renameSessionFromCommand = async (sessionId, nextName) => {
+  const renameSession = async (sessionId, nextName) => {
     if (managedSessions.has(sessionId)) {
       const managedSession = managedSessions.get(sessionId);
       managedSessions.set(sessionId, {
@@ -12693,6 +13023,37 @@ var startPandaSessionService = async ({
       }
     });
   };
+  const generateSessionTitleInBackground = async (input) => {
+    const prompt = buildSessionTitleGenerationPrompt({
+      message: input.message,
+      attachments: input.attachments
+    });
+    try {
+      const generated = await liveSessionStream.runOneShotPrompt({
+        cwd: input.project.path,
+        prompt,
+        model: input.model,
+        timeoutMs: SESSION_TITLE_GENERATION_TIMEOUT_MS
+      });
+      const nextTitle = sanitizeGeneratedSessionTitle(generated);
+      if (!nextTitle || nextTitle === input.fallbackTitle) {
+        return;
+      }
+      const currentSession = await findSnapshotSession(input.sessionId);
+      if (!currentSession || currentSession.title !== input.fallbackTitle) {
+        return;
+      }
+      await renameSession(input.sessionId, nextTitle);
+    } catch (error) {
+      diagnosticLogger.warn({
+        sessionId: input.sessionId,
+        projectId: input.project.id,
+        projectPath: input.project.path,
+        model: input.model,
+        error: error instanceof Error ? error.message : "Unknown error"
+      }, "Failed to generate background session title.");
+    }
+  };
   const executeSessionCommand = async (session, project, rawInput) => {
     const parsed = parseSlashCommandInput(rawInput);
     if (!parsed) {
@@ -12794,7 +13155,7 @@ var startPandaSessionService = async ({
     }
     if (command.name === "rename") {
       if (parsed.args) {
-        await renameSessionFromCommand(session.id, parsed.args);
+        await renameSession(session.id, parsed.args);
         return createCommandPanel({
           sessionId: session.id,
           commandName: command.name,
@@ -12864,7 +13225,7 @@ var startPandaSessionService = async ({
       if (!nextName) {
         throw new Error("\u8BF7\u8F93\u5165\u65B0\u7684\u4F1A\u8BDD\u540D\u79F0\u3002");
       }
-      await renameSessionFromCommand(input.sessionId, nextName);
+      await renameSession(input.sessionId, nextName);
       clearStoredCommandPanel(input.panelId);
       return {
         ...stored.panel,
@@ -13032,7 +13393,7 @@ var startPandaSessionService = async ({
         lastSnapshotRefreshAt = Date.now();
         return snapshot;
       }
-      const { discoverLocalCodexData } = await import("./src-M7W7LPHG.mjs");
+      const { discoverLocalCodexData } = await import("./src-ILWWSZFE.mjs");
       const discovery = await discoverLocalCodexData({
         agentId: localAgentId,
         agentName: localAgentName,
@@ -13108,6 +13469,135 @@ var startPandaSessionService = async ({
     return snapshot.projects.find((project) => project.id === projectId) ?? (await buildSnapshot({ force: true })).projects.find((project) => project.id === projectId) ?? null;
   };
   const readProjectForSession = async (session) => findSnapshotProject(session.project_id);
+  const readSessionFilePreviewTree = async (session, project, requestedPath) => {
+    const resolved = await resolveSessionFilePreviewPath(project.path, requestedPath);
+    const stat = await fs8.stat(resolved.realPath).catch((error) => {
+      if (isMissingPathError(error)) {
+        throw new Error("File not found.");
+      }
+      throw error;
+    });
+    if (!stat.isDirectory()) {
+      throw new Error("\u76EE\u6807\u8DEF\u5F84\u4E0D\u662F\u76EE\u5F55\u3002");
+    }
+    const entries = await fs8.readdir(resolved.realPath, {
+      withFileTypes: true
+    });
+    const nodes = (await Promise.all(
+      entries.map(
+        (entry) => buildSessionFilePreviewTreeNode(
+          project.path,
+          resolved.normalizedPath,
+          resolved.realPath,
+          entry
+        )
+      )
+    )).filter((entry) => Boolean(entry)).sort((left, right) => {
+      if (left.kind !== right.kind) {
+        return left.kind === "directory" ? -1 : 1;
+      }
+      return left.name.localeCompare(right.name, "zh-CN");
+    });
+    return {
+      session_id: session.id,
+      project_id: project.id,
+      root_path: SESSION_FILE_PREVIEW_ROOT_PATH,
+      parent_path: resolved.normalizedPath || null,
+      nodes,
+      loaded_at: isoNow5()
+    };
+  };
+  const readSessionFilePreviewContent = async (session, project, requestedPath) => {
+    const resolved = await resolveSessionFilePreviewPath(project.path, requestedPath);
+    const stat = await fs8.stat(resolved.realPath).catch((error) => {
+      if (isMissingPathError(error)) {
+        throw new Error("File not found.");
+      }
+      throw error;
+    });
+    if (!stat.isFile()) {
+      throw new Error("\u76EE\u6807\u8DEF\u5F84\u4E0D\u662F\u6587\u4EF6\u3002");
+    }
+    const fileName = path9.basename(resolved.normalizedPath || resolved.realPath);
+    const extension = normalizeSessionFilePreviewExtension(fileName);
+    let fileKind = detectSessionFilePreviewKind(fileName, extension) ?? null;
+    let previewBuffer = null;
+    if (!fileKind || fileKind === "binary") {
+      previewBuffer = await readPreviewBuffer(
+        resolved.realPath,
+        Math.min(SESSION_FILE_PREVIEW_TEXT_BYTE_LIMIT, Math.max(1024, stat.size))
+      );
+      fileKind = looksLikeTextBuffer(previewBuffer) ? "text" : "binary";
+    }
+    if (fileKind === "image") {
+      if (stat.size > SESSION_FILE_PREVIEW_IMAGE_BYTE_LIMIT) {
+        return {
+          session_id: session.id,
+          project_id: project.id,
+          path: resolved.normalizedPath,
+          name: fileName,
+          extension,
+          file_kind: fileKind,
+          mime_type: getSessionFilePreviewMimeType(extension, fileKind),
+          size_bytes: stat.size,
+          encoding: null,
+          is_truncated: true,
+          content_text: null,
+          content_base64: null,
+          loaded_at: isoNow5()
+        };
+      }
+      const buffer2 = await fs8.readFile(resolved.realPath);
+      return {
+        session_id: session.id,
+        project_id: project.id,
+        path: resolved.normalizedPath,
+        name: fileName,
+        extension,
+        file_kind: fileKind,
+        mime_type: getSessionFilePreviewMimeType(extension, fileKind),
+        size_bytes: stat.size,
+        encoding: "base64",
+        is_truncated: false,
+        content_text: null,
+        content_base64: buffer2.toString("base64"),
+        loaded_at: isoNow5()
+      };
+    }
+    if (fileKind === "binary") {
+      return {
+        session_id: session.id,
+        project_id: project.id,
+        path: resolved.normalizedPath,
+        name: fileName,
+        extension,
+        file_kind: fileKind,
+        mime_type: getSessionFilePreviewMimeType(extension, fileKind),
+        size_bytes: stat.size,
+        encoding: null,
+        is_truncated: false,
+        content_text: null,
+        content_base64: null,
+        loaded_at: isoNow5()
+      };
+    }
+    const buffer = previewBuffer ?? await readPreviewBuffer(resolved.realPath, SESSION_FILE_PREVIEW_TEXT_BYTE_LIMIT);
+    return {
+      session_id: session.id,
+      project_id: project.id,
+      path: resolved.normalizedPath,
+      name: fileName,
+      extension,
+      file_kind: fileKind,
+      mime_type: getSessionFilePreviewMimeType(extension, fileKind),
+      size_bytes: stat.size,
+      encoding: "utf8",
+      is_truncated: stat.size > SESSION_FILE_PREVIEW_TEXT_BYTE_LIMIT,
+      content_text: buffer.toString("utf8"),
+      content_base64: null,
+      loaded_at: isoNow5()
+    };
+  };
   const validateHubControlPlaneAuth = (request) => {
     const expectedApiKey = process.env.PANDA_HUB_API_KEY?.trim() ?? "";
     if (!expectedApiKey) {
@@ -13139,6 +13629,58 @@ var startPandaSessionService = async ({
     }
     await runGitCommand(projectPath, ["restore", "--source=HEAD", "--staged", "--worktree", "--", ...targetPaths]);
   };
+  const normalizeRollbackPatchText = (input) => {
+    const normalized = input.replace(/\r\n/g, "\n").trim();
+    return normalized ? `${normalized}
+` : "";
+  };
+  const buildRollbackPatchText = (changeSet) => {
+    if (changeSet.aggregated_diff.trim()) {
+      return normalizeRollbackPatchText(changeSet.aggregated_diff);
+    }
+    if (changeSet.files.some((file) => file.diff.trim().length === 0)) {
+      return "";
+    }
+    return normalizeRollbackPatchText(
+      changeSet.files.map((file) => file.diff).filter((diff) => diff.trim().length > 0).join("\n\n")
+    );
+  };
+  const ensureChangeSetPathsAreInProject = (projectPath, changeSet) => {
+    for (const file of changeSet.files) {
+      const candidates = [file.path, file.move_path].filter((value) => Boolean(value?.trim()));
+      for (const candidate of candidates) {
+        if (!isPathInsideProject(projectPath, candidate)) {
+          throw new Error("\u8FD9\u8F6E\u6539\u52A8\u5305\u542B\u8D85\u51FA\u5F53\u524D\u5DE5\u4F5C\u533A\u7684\u8DEF\u5F84\uFF0C\u65E0\u6CD5\u5B89\u5168\u56DE\u6EDA\u3002");
+        }
+      }
+    }
+  };
+  const rollbackSessionChangeSet = async (projectPath, changeSet) => {
+    if (changeSet.status !== "completed") {
+      throw new Error("\u5F53\u524D\u8FD9\u8F6E\u6539\u52A8\u5C1A\u672A\u5B8C\u6210\uFF0C\u6682\u65F6\u4E0D\u80FD\u56DE\u6EDA\u3002");
+    }
+    if (changeSet.files.length === 0) {
+      throw new Error("\u8FD9\u8F6E\u5BF9\u8BDD\u6CA1\u6709\u53EF\u56DE\u6EDA\u7684\u6587\u4EF6\u6539\u52A8\u3002");
+    }
+    ensureChangeSetPathsAreInProject(projectPath, changeSet);
+    const patchText = buildRollbackPatchText(changeSet);
+    if (!patchText) {
+      throw new Error("\u8FD9\u8F6E\u6539\u52A8\u7F3A\u5C11\u53EF\u9006\u8865\u4E01\uFF0C\u6682\u65F6\u65E0\u6CD5\u56DE\u6EDA\u3002");
+    }
+    const tempDir = await fs8.mkdtemp(path9.join(os6.tmpdir(), "panda-change-set-rollback-"));
+    const patchFilePath = path9.join(tempDir, "rollback.patch");
+    await fs8.writeFile(patchFilePath, patchText, "utf8");
+    try {
+      const patchArgs = ["apply", "--reverse", "--whitespace=nowarn", "--binary", patchFilePath];
+      await runGitCommand(projectPath, [...patchArgs.slice(0, 1), "--check", ...patchArgs.slice(1)]);
+      await runGitCommand(projectPath, patchArgs);
+    } catch (error) {
+      const reason = error instanceof Error && error.message.trim() ? error.message : "Git \u65E0\u6CD5\u53CD\u5411\u5E94\u7528\u8FD9\u8F6E\u6539\u52A8\u7684\u8865\u4E01\u3002";
+      throw new Error(`\u65E0\u6CD5\u5B89\u5168\u56DE\u6EDA\u8FD9\u8F6E\u6539\u52A8\uFF1A${reason}`);
+    } finally {
+      await fs8.rm(tempDir, { recursive: true, force: true }).catch(() => void 0);
+    }
+  };
   const discardAllGitWorkspaceChanges = async (projectPath) => {
     await runGitCommand(projectPath, ["restore", "--source=HEAD", "--staged", "--worktree", "--", "."]);
     await runGitCommand(projectPath, ["clean", "-fd", "--", "."], {
@@ -13843,6 +14385,107 @@ var startPandaSessionService = async ({
     }
     return diff;
   });
+  app.post("/api/sessions/:sessionId/turns/:turnId/actions", async (request, reply) => {
+    const { sessionId, turnId } = request.params;
+    const session = await findSnapshotSession(sessionId);
+    if (!session) {
+      reply.code(404);
+      return { error: "Session not found." };
+    }
+    if (!session.capability.can_show_git) {
+      reply.code(409);
+      return { error: "This session does not support git workspace actions." };
+    }
+    const project = await readProjectForSession(session);
+    if (!project) {
+      reply.code(404);
+      return { error: "Project not found." };
+    }
+    if (request.body.action !== "rollback") {
+      reply.code(409);
+      return { error: "Unsupported turn action." };
+    }
+    const normalizedTurnId = turnId.trim();
+    if (!normalizedTurnId) {
+      reply.code(400);
+      return { error: "Turn id is required." };
+    }
+    const changeSet = await readChangeSetForTurn(sessionId, normalizedTurnId);
+    if (!changeSet) {
+      reply.code(404);
+      return { error: "Session turn change-set not found." };
+    }
+    try {
+      await rollbackSessionChangeSet(project.path, changeSet);
+      return {
+        ok: true,
+        turn_id: changeSet.turn_id,
+        change_set_id: changeSet.id,
+        workspace: await readSessionGitWorkspace(session, project)
+      };
+    } catch (error) {
+      reply.code(409);
+      return {
+        error: error instanceof Error ? error.message : "Unable to execute turn action."
+      };
+    }
+  });
+  app.get("/api/sessions/:sessionId/file-preview/tree", async (request, reply) => {
+    const { sessionId } = request.params;
+    const { path: requestedPath } = request.query ?? {};
+    const session = await findSnapshotSession(sessionId);
+    if (!session) {
+      reply.code(404);
+      return { error: "Session not found." };
+    }
+    const project = await readProjectForSession(session);
+    if (!project) {
+      reply.code(404);
+      return { error: "Project not found." };
+    }
+    try {
+      return await readSessionFilePreviewTree(session, project, requestedPath ?? null);
+    } catch (error) {
+      if (error instanceof Error && error.message === "File not found.") {
+        reply.code(404);
+        return { error: error.message };
+      }
+      reply.code(409);
+      return {
+        error: error instanceof Error ? error.message : "Unable to read file preview tree."
+      };
+    }
+  });
+  app.get("/api/sessions/:sessionId/file-preview/content", async (request, reply) => {
+    const { sessionId } = request.params;
+    const { path: requestedPath } = request.query ?? {};
+    const session = await findSnapshotSession(sessionId);
+    if (!session) {
+      reply.code(404);
+      return { error: "Session not found." };
+    }
+    if (!requestedPath?.trim()) {
+      reply.code(400);
+      return { error: "path is required." };
+    }
+    const project = await readProjectForSession(session);
+    if (!project) {
+      reply.code(404);
+      return { error: "Project not found." };
+    }
+    try {
+      return await readSessionFilePreviewContent(session, project, requestedPath);
+    } catch (error) {
+      if (error instanceof Error && error.message === "File not found.") {
+        reply.code(404);
+        return { error: error.message };
+      }
+      reply.code(409);
+      return {
+        error: error instanceof Error ? error.message : "Unable to read file preview content."
+      };
+    }
+  });
   app.get("/api/sessions/:sessionId/git-workspace", async (request, reply) => {
     const { sessionId } = request.params;
     const session = await findSnapshotSession(sessionId);
@@ -14543,6 +15186,7 @@ var startPandaSessionService = async ({
     const input = request.body.input?.trim() ?? "";
     const attachments = normalizeSessionInputAttachments(request.body.attachments);
     const model = request.body.model?.trim() || null;
+    const titleGenerationModel = request.body.titleGenerationModel?.trim() || DEFAULT_SESSION_TITLE_GENERATION_MODEL;
     const reasoningEffort = request.body.reasoningEffort?.trim() || null;
     const requestedServiceTier = request.body.serviceTier;
     const normalizedRequestedServiceTier = normalizeServiceTier(requestedServiceTier);
@@ -14571,6 +15215,7 @@ var startPandaSessionService = async ({
       prompt,
       attachments,
       model,
+      titleGenerationModel,
       reasoningEffort,
       requestedServiceTier,
       normalizedRequestedServiceTier,
@@ -14664,6 +15309,14 @@ var startPandaSessionService = async ({
     managedSessions.set(session.id, session);
     upsertSnapshotSession(session);
     broadcastSnapshotChanged();
+    void generateSessionTitleInBackground({
+      sessionId: session.id,
+      project,
+      fallbackTitle: title,
+      message: input,
+      attachments,
+      model: titleGenerationModel
+    });
     reply.code(201);
     return { session };
   });
@@ -14687,29 +15340,7 @@ var startPandaSessionService = async ({
           reply.code(400);
           return { error: "Session name is required." };
         }
-        if (managedSessions.has(sessionId)) {
-          const managedSession = managedSessions.get(sessionId);
-          managedSessions.set(sessionId, {
-            ...managedSession,
-            title: nextName
-          });
-        }
-        await liveSessionStream.setThreadName(sessionId, nextName).catch(() => {
-        });
-        await appendSessionIndexUpdate(
-          sessionId,
-          {
-            thread_name: nextName
-          },
-          codexHome
-        );
-        patchSnapshotSession(sessionId, { title: nextName });
-        broadcastEvent("session.updated", {
-          sessionId,
-          sessionPatch: {
-            title: nextName
-          }
-        });
+        await renameSession(sessionId, nextName);
         return {
           ok: true,
           affectedSessionIds: [sessionId],