@jamiexiongr/panda-hub 0.1.28 → 0.1.30

package/dist/{chunk-KW522MKT.mjs → chunk-VOWZ4V3B.mjs}

@@ -1576,6 +1576,20 @@ var getWorkspaceRootLabels = (state) => {
     )
   );
 };
+var getProjectlessThreadIds = (state) => Array.isArray(state["projectless-thread-ids"]) ? state["projectless-thread-ids"].filter(
+  (entry) => typeof entry === "string" && entry.trim().length > 0
+) : [];
+var getThreadWorkspaceRootHints = (state) => {
+  const hints = state["thread-workspace-root-hints"];
+  if (!hints || typeof hints !== "object" || Array.isArray(hints)) {
+    return {};
+  }
+  return Object.fromEntries(
+    Object.entries(hints).filter(
+      (entry) => typeof entry[0] === "string" && entry[0].trim().length > 0 && typeof entry[1] === "string" && entry[1].trim().length > 0
+    )
+  );
+};
 var readPandaThreadPrefs = async (codexHome) => {
   try {
     const raw = await fs2.readFile(pandaThreadPrefsPath(codexHome), "utf8");
@@ -1735,6 +1749,32 @@ var setWorkspaceRootVisibility = async (workspaceRoot, visible, codexHome) => {
     codexHome
   );
 };
+var registerProjectlessThread = async (sessionId, workspaceRootHint, codexHome) => {
+  const normalizedSessionId = sessionId.trim();
+  const normalizedWorkspaceRootHint = workspaceRootHint.trim();
+  if (!normalizedSessionId || !normalizedWorkspaceRootHint) {
+    return;
+  }
+  const state = await readCodexGlobalState(codexHome);
+  const nextProjectlessThreadIds = [
+    .../* @__PURE__ */ new Set([
+      ...getProjectlessThreadIds(state),
+      normalizedSessionId
+    ])
+  ];
+  const nextWorkspaceRootHints = {
+    ...getThreadWorkspaceRootHints(state),
+    [normalizedSessionId]: normalizePathKey(normalizedWorkspaceRootHint)
+  };
+  await writeCodexGlobalState(
+    {
+      ...state,
+      "projectless-thread-ids": nextProjectlessThreadIds,
+      "thread-workspace-root-hints": nextWorkspaceRootHints
+    },
+    codexHome
+  );
+};
 var isWithinWorkspaceRoot = (targetPath, workspaceRoot) => {
   const normalizedPath = normalizePathKey(targetPath);
   const normalizedRoot = normalizePathKey(workspaceRoot);
@@ -1888,12 +1928,48 @@ var stripInjectedUserText = (value) => {
 import path3 from "path";
 
 // packages/protocol/src/index.ts
-var providerKindSchema = external_exports.enum(["codex", "claude"]);
+var providerKindSchema = external_exports.enum(["codex", "claude", "image"]);
 var sessionModeSchema = external_exports.enum(["managed", "attached-live", "history-only"]);
 var sessionHealthSchema = external_exports.enum(["active", "idle", "attention", "offline"]);
 var sessionRunStateSchema = external_exports.enum(["idle", "running", "completed"]);
 var attachmentKindSchema = external_exports.enum(["image", "file"]);
 var skillScopeSchema = external_exports.enum(["user", "repo", "system", "admin"]);
+var imageModelVendorSchema = external_exports.enum(["openai", "xai", "gemini"]);
+var imageGenerationModelSchema = external_exports.string().trim().min(1).max(120);
+var imageGenerationQualitySchema = external_exports.enum(["auto", "low", "medium", "high"]);
+var imageGenerationSizeSchema = external_exports.enum([
+  "auto",
+  "1024x1024",
+  "1536x1024",
+  "1024x1536",
+  "2048x2048",
+  "2048x1152",
+  "1152x2048",
+  "3840x2160",
+  "2160x3840"
+]);
+var imageEditInputFidelitySchema = external_exports.enum(["low", "high"]);
+var imageOutputFormatSchema = external_exports.enum(["png", "jpeg", "webp"]);
+var imageBackgroundSchema = external_exports.enum(["auto", "opaque"]);
+var imageModerationSchema = external_exports.enum(["auto", "low"]);
+var imageGenerationAspectRatioSchema = external_exports.enum([
+  "auto",
+  "1:1",
+  "4:3",
+  "3:4",
+  "16:9",
+  "9:16"
+]);
+var imageSessionAssetKindSchema = external_exports.enum(["generated", "source", "mask"]);
+var imageSessionSourceKindSchema = external_exports.enum(["upload", "session_asset"]);
+var imageSessionTurnStatusSchema = external_exports.enum(["pending", "completed", "failed"]);
+var imageSessionTurnOperationSchema = external_exports.enum(["generate", "edit"]);
+var imageProviderModelSchema = external_exports.object({
+  id: imageGenerationModelSchema,
+  vendor: imageModelVendorSchema.default("openai"),
+  label: external_exports.string().trim().min(1).max(160),
+  enabled: external_exports.boolean().default(true)
+});
 var sessionCapabilitySchema = external_exports.object({
   can_stream_live: external_exports.boolean(),
   can_send_input: external_exports.boolean(),
@@ -1996,6 +2072,118 @@ var sessionInputAttachmentSchema = external_exports.object({
   size_bytes: external_exports.number().int().nonnegative().nullable().default(null),
   data_url: external_exports.string()
 });
+var imageSessionAssetSchema = external_exports.object({
+  id: external_exports.string(),
+  session_id: external_exports.string(),
+  turn_id: external_exports.string().nullable().default(null),
+  kind: imageSessionAssetKindSchema,
+  name: external_exports.string(),
+  mime_type: external_exports.string().nullable().default(null),
+  size_bytes: external_exports.number().int().nonnegative().nullable().default(null),
+  width: external_exports.number().int().positive().nullable().default(null),
+  height: external_exports.number().int().positive().nullable().default(null),
+  content_url: external_exports.string(),
+  created_at: external_exports.string()
+});
+var imageSessionSourceInputSchema = external_exports.object({
+  id: external_exports.string(),
+  kind: imageSessionSourceKindSchema,
+  name: external_exports.string(),
+  mime_type: external_exports.string().nullable().default(null),
+  size_bytes: external_exports.number().int().nonnegative().nullable().default(null),
+  data_url: external_exports.string().nullable().default(null),
+  asset_id: external_exports.string().nullable().default(null),
+  mask_data_url: external_exports.string().nullable().default(null)
+});
+var imageSessionTurnSchema = external_exports.object({
+  id: external_exports.string(),
+  session_id: external_exports.string(),
+  created_at: external_exports.string(),
+  completed_at: external_exports.string().nullable().default(null),
+  prompt: external_exports.string(),
+  prompt_suffix: external_exports.string().nullable().default(null),
+  operation: imageSessionTurnOperationSchema,
+  status: imageSessionTurnStatusSchema,
+  error: external_exports.string().nullable().default(null),
+  model: imageGenerationModelSchema,
+  quality: imageGenerationQualitySchema,
+  size: imageGenerationSizeSchema,
+  input_fidelity: imageEditInputFidelitySchema.nullable().default(null),
+  aspect_ratio: imageGenerationAspectRatioSchema,
+  output_format: imageOutputFormatSchema.default("png"),
+  output_compression: external_exports.number().int().min(0).max(100).nullable().default(null),
+  background: imageBackgroundSchema.default("auto"),
+  moderation: imageModerationSchema.default("auto"),
+  n: external_exports.number().int().min(1).max(10).default(1),
+  sources: external_exports.array(imageSessionAssetSchema).default([]),
+  outputs: external_exports.array(imageSessionAssetSchema).default([])
+});
+var imageProviderChannelSchema = external_exports.object({
+  id: external_exports.string(),
+  remark: external_exports.string(),
+  base_url: external_exports.string(),
+  models: external_exports.array(imageProviderModelSchema).default([]),
+  resolved_api_key_source: external_exports.enum(["stored", "env", "missing"]).default("missing"),
+  has_stored_api_key: external_exports.boolean().default(false),
+  updated_at: external_exports.string().nullable().default(null)
+});
+var imageProviderChannelUpdateSchema = external_exports.object({
+  id: external_exports.string(),
+  remark: external_exports.string().trim().min(1).max(80),
+  base_url: external_exports.string(),
+  models: external_exports.array(imageProviderModelSchema).default([]),
+  api_key: external_exports.string().optional().nullable(),
+  api_key_mode: external_exports.enum(["keep", "set", "clear"]).default("keep")
+});
+var imageProviderSettingsSchema = external_exports.object({
+  active_channel_id: external_exports.string().nullable().default(null),
+  base_url: external_exports.string(),
+  channels: external_exports.array(imageProviderChannelSchema).default([]),
+  model: imageGenerationModelSchema.default("gpt-image-2"),
+  resolved_api_key_source: external_exports.enum(["stored", "env", "missing"]).default("missing"),
+  has_stored_api_key: external_exports.boolean().default(false),
+  updated_at: external_exports.string().nullable().default(null)
+});
+var imageProviderSettingsUpdateSchema = external_exports.object({
+  active_channel_id: external_exports.string().nullable().default(null),
+  channels: external_exports.array(imageProviderChannelUpdateSchema).default([])
+});
+var imageProviderTestResponseSchema = external_exports.object({
+  ok: external_exports.boolean(),
+  message: external_exports.string(),
+  model_available: external_exports.boolean().default(false),
+  resolved_base_url: external_exports.string()
+});
+var imageProviderModelListRequestSchema = external_exports.object({
+  base_url: external_exports.string(),
+  api_key: external_exports.string().optional().nullable(),
+  api_key_mode: external_exports.enum(["keep", "set", "clear"]).default("keep"),
+  channel_id: external_exports.string().nullable().default(null)
+});
+var imageProviderModelListResponseSchema = external_exports.object({
+  models: external_exports.array(external_exports.object({
+    id: external_exports.string(),
+    label: external_exports.string()
+  }))
+});
+var imageSessionCreateRequestSchema = external_exports.object({
+  title: external_exports.string().trim().min(1).max(80).optional()
+});
+var imageSessionSubmitRequestSchema = external_exports.object({
+  prompt: external_exports.string(),
+  append_to_turn_id: external_exports.string().nullable().default(null),
+  model: imageGenerationModelSchema.default("gpt-image-2"),
+  quality: imageGenerationQualitySchema.default("auto"),
+  size: imageGenerationSizeSchema.default("1024x1024"),
+  input_fidelity: imageEditInputFidelitySchema.nullable().default(null),
+  aspect_ratio: imageGenerationAspectRatioSchema.default("auto"),
+  output_format: imageOutputFormatSchema.default("png"),
+  output_compression: external_exports.number().int().min(0).max(100).nullable().default(null),
+  background: imageBackgroundSchema.default("auto"),
+  moderation: imageModerationSchema.default("auto"),
+  n: external_exports.number().int().min(1).max(10).default(1),
+  sources: external_exports.array(imageSessionSourceInputSchema).default([])
+});
 var projectSkillSchema = external_exports.object({
   name: external_exports.string(),
   description: external_exports.string(),
@@ -2135,6 +2323,27 @@ var timelineEntrySchema = external_exports.object({
   accent: external_exports.enum(["primary", "secondary", "muted"]),
   attachments: external_exports.array(timelineAttachmentSchema).default([])
 });
+var isMeaningfulUserTimelineEntry = (entry) => entry?.kind === "user" && (entry.body.trim().length > 0 || Array.isArray(entry.attachments) && entry.attachments.length > 0);
+var findTailTimelineAnchorEntryIndex = (entries) => {
+  for (let index = entries.length - 1; index >= 0; index -= 1) {
+    if (isMeaningfulUserTimelineEntry(entries[index])) {
+      return index;
+    }
+  }
+  return -1;
+};
+var hasEarlierVisibleConversationTurns = (entries) => {
+  const anchorIndex = findTailTimelineAnchorEntryIndex(entries);
+  if (anchorIndex < 0) {
+    return false;
+  }
+  for (let index = 0; index < anchorIndex; index += 1) {
+    if (isMeaningfulUserTimelineEntry(entries[index])) {
+      return true;
+    }
+  }
+  return false;
+};
 var sessionTimelineViewSchema = external_exports.enum(["tail", "full_compact"]);
 var sessionTimelineSnapshotSchema = external_exports.object({
   session_id: external_exports.string(),
@@ -2719,6 +2928,7 @@ var workspaceSessionListItemSchema = sessionRefSchema.pick({
   id: true,
   agent_id: true,
   project_id: true,
+  provider: true,
   archived: true,
   title: true,
   last_event_at: true,
@@ -2752,6 +2962,11 @@ var workspaceSessionDetailResponseSchema = external_exports.object({
   generated_at: external_exports.string(),
   session: workspaceSessionDetailSchema
 });
+var imageSessionDetailResponseSchema = external_exports.object({
+  generated_at: external_exports.string(),
+  session: workspaceSessionDetailSchema,
+  turns: external_exports.array(imageSessionTurnSchema).default([])
+});
 var hubDirectorySnapshotSchema = external_exports.object({
   generated_at: external_exports.string(),
   agents: external_exports.array(agentNodeSchema)
@@ -3262,6 +3477,8 @@ var APP_SERVER_REQUEST_TIMEOUT_MS = 12e3;
 var APP_SERVER_RUNTIME_DIAGNOSTIC_WINDOW_MS = 2 * 60 * 1e3;
 var APP_SERVER_RUNTIME_DIAGNOSTIC_DEDUPE_MS = 4e3;
 var ANSI_ESCAPE_PATTERN = /\u001b\[[0-9;]*m/g;
+var CODEX_VERSION_PROBE_TIMEOUT_MS = 2500;
+var APP_SERVER_CLIENT_NAME = "Codex Desktop";
 var createDiagnosticHash = (value) => createHash("sha1").update(value).digest("hex").slice(0, 16);
 var listCodexCommandCandidates = () => {
   const locator = process.platform === "win32" ? "where.exe" : "which";
@@ -3278,6 +3495,25 @@ var listCodexCommandCandidates = () => {
     return [];
   }
 };
+var detectCodexCliVersion = () => {
+  try {
+    const result = spawnSync("codex", ["--version"], {
+      encoding: "utf8",
+      windowsHide: true,
+      shell: process.platform === "win32",
+      stdio: ["ignore", "pipe", "ignore"],
+      timeout: CODEX_VERSION_PROBE_TIMEOUT_MS
+    });
+    if (result.status !== 0 || typeof result.stdout !== "string") {
+      return null;
+    }
+    const normalized = result.stdout.trim();
+    const match = /\b(\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?)\b/.exec(normalized);
+    return match?.[1] ?? null;
+  } catch {
+    return null;
+  }
+};
 var YOLO_APPROVAL_POLICY = "never";
 var YOLO_SANDBOX_POLICY = "danger-full-access";
 var resolveExecutionOverrides = (yoloMode) => yoloMode ? {
@@ -4745,6 +4981,7 @@ var createCodexLiveSessionStream = (options) => {
   let appServerInitializeTimer = null;
   let appServerInitializationError = null;
   let appServerStderrBuffer = "";
+  let appServerClientVersion = detectCodexCliVersion();
   const pendingAppServerRequests = /* @__PURE__ */ new Map();
   const planSnapshotsBySessionId = /* @__PURE__ */ new Map();
   const lastAppServerRequestBySessionId = /* @__PURE__ */ new Map();
@@ -5775,12 +6012,14 @@ ${nextFile.diff}`.trim();
       return;
     }
     const codexCandidates = listCodexCommandCandidates();
+    appServerClientVersion = detectCodexCliVersion();
     logDiagnostic("info", "Starting Codex app-server bridge.", {
       platform: process.platform,
       execPath: process.execPath,
       codexHome: resolveCodexEnvironmentHome(),
       codexCommandFound: codexCandidates.length > 0,
       codexCommandCandidates: codexCandidates,
+      detectedCodexVersion: appServerClientVersion,
       bridgeExecutable: process.platform === "win32" ? `${process.env.ComSpec || "cmd.exe"} /d /c codex` : "codex"
     });
     const appServerChild = spawnAppServerChild();
@@ -6285,8 +6524,8 @@ ${nextFile.diff}`.trim();
         method: "initialize",
         params: {
           clientInfo: {
-            name: "panda",
-            version: "0.1.0"
+            name: APP_SERVER_CLIENT_NAME,
+            version: appServerClientVersion ?? "unknown"
           },
           capabilities: {
             experimentalApi: true,
@@ -6765,11 +7004,11 @@ ${nextFile.diff}`.trim();
 };
 
 // packages/provider-codex/src/panda-session-service.ts
-import fs8 from "fs/promises";
+import fs9 from "fs/promises";
 import { spawn as spawn4 } from "child_process";
 import { createHash as createHash5 } from "crypto";
 import os6 from "os";
-import path9 from "path";
+import path11 from "path";
 import Fastify from "fastify";
 import compress from "@fastify/compress";
 import cors from "@fastify/cors";
@@ -7164,162 +7403,1246 @@ var createHubPushSubscriptionStore = ({
   };
 };
 
-// packages/provider-codex/src/timeline-user-dedup.ts
-var normalizeTimelineEntryBody2 = (entry) => entry.body.replace(/\r\n/g, "\n").trim();
-var areAdjacentDuplicateUserEntries = (previous, next, maxSkewMs) => {
-  if (!previous || previous.kind !== "user" || next.kind !== "user") {
-    return false;
-  }
-  if (normalizeTimelineEntryBody2(previous) !== normalizeTimelineEntryBody2(next)) {
-    return false;
+// packages/provider-codex/src/image-provider-config.ts
+var DEFAULT_IMAGE_PROVIDER_BASE_URL = "https://api.openai.com/v1";
+var DEFAULT_IMAGE_PROVIDER_MODEL = "gpt-image-2";
+var DEFAULT_IMAGE_PROVIDER_MODELS = [
+  {
+    id: DEFAULT_IMAGE_PROVIDER_MODEL,
+    vendor: "openai",
+    label: DEFAULT_IMAGE_PROVIDER_MODEL,
+    enabled: true
   }
-  const previousTime = +new Date(previous.timestamp);
-  const nextTime = +new Date(next.timestamp);
-  if (!Number.isFinite(previousTime) || !Number.isFinite(nextTime)) {
-    return true;
+];
+var trimTrailingSlash = (value) => value.replace(/\/+$/, "");
+var resolveApiKeySource = (storedApiKey) => storedApiKey?.trim() ? "stored" : resolveImageProviderApiKey() ? "env" : "missing";
+var normalizeImageProviderBaseUrl = (value) => {
+  const trimmed = value?.trim() ?? "";
+  if (!trimmed) {
+    return DEFAULT_IMAGE_PROVIDER_BASE_URL;
   }
-  return Math.abs(nextTime - previousTime) <= maxSkewMs;
+  return trimTrailingSlash(trimmed);
 };
-var collapseDuplicateUserEntries = (entries, options) => {
-  const maxSkewMs = options?.maxSkewMs ?? 5e3;
-  const collapsed = [];
-  for (const entry of entries) {
-    const previous = collapsed[collapsed.length - 1];
-    if (!areAdjacentDuplicateUserEntries(previous, entry, maxSkewMs)) {
-      collapsed.push(entry);
-      continue;
-    }
-    collapsed[collapsed.length - 1] = {
-      ...entry,
-      attachments: mergeTimelineAttachments(previous?.attachments, entry.attachments)
+var resolveImageProviderBaseUrl = (storedBaseUrl) => normalizeImageProviderBaseUrl(
+  storedBaseUrl ?? process.env.PANDA_IMAGE_PROVIDER_BASE_URL ?? process.env.OPENAI_BASE_URL ?? process.env.OPENAI_API_BASE_URL ?? DEFAULT_IMAGE_PROVIDER_BASE_URL
+);
+var resolveImageProviderApiKey = () => process.env.PANDA_IMAGE_API_KEY?.trim() || process.env.OPENAI_API_KEY?.trim() || "";
+var buildResolvedImageProviderChannel = (input) => ({
+  id: input.id,
+  remark: input.remark?.trim() || "Unnamed channel",
+  base_url: resolveImageProviderBaseUrl(input.baseUrl),
+  models: input.models?.length ? input.models : DEFAULT_IMAGE_PROVIDER_MODELS,
+  resolved_api_key_source: resolveApiKeySource(input.storedApiKey),
+  has_stored_api_key: Boolean(input.storedApiKey?.trim()),
+  updated_at: input.updatedAt ?? null
+});
+var buildResolvedImageProviderSettings = (input) => ({
+  ...(() => {
+    const channels = (input?.channels ?? []).map(
+      (channel) => buildResolvedImageProviderChannel(channel)
+    );
+    const requestedActiveChannelId = input?.activeChannelId ?? null;
+    const activeChannel = channels.find((channel) => channel.id === requestedActiveChannelId) ?? channels[0] ?? null;
+    return {
+      active_channel_id: activeChannel?.id ?? null,
+      base_url: activeChannel?.base_url ?? resolveImageProviderBaseUrl(null),
+      channels,
+      model: DEFAULT_IMAGE_PROVIDER_MODEL,
+      resolved_api_key_source: activeChannel?.resolved_api_key_source ?? resolveApiKeySource(null),
+      has_stored_api_key: activeChannel?.has_stored_api_key ?? false,
+      updated_at: input?.updatedAt ?? null
     };
-  }
-  return collapsed;
-};
+  })()
+});
+var getDefaultImageProviderModel = () => DEFAULT_IMAGE_PROVIDER_MODEL;
 
-// packages/provider-codex/src/session-run-workbench.ts
-import { createHash as createHash3, randomUUID } from "crypto";
-import { spawn as spawn2 } from "child_process";
-import fs6 from "fs/promises";
-import os4 from "os";
+// packages/provider-codex/src/image-provider-client.ts
 import path7 from "path";
-var PANDA_GLOBAL_DIRECTORY_NAME = "Project Workbench Data";
-var RUN_RESOURCES_DIRECTORY_NAME = "run-workbench";
-var RUN_RESOURCE_INDEX_FILE_NAME = "index.json";
-var RUN_COMMANDS_FILE_NAME = "commands.json";
-var RUN_WEBSITES_FILE_NAME = "websites.json";
-var RUN_COMMANDS_SCHEMA_VERSION = 1;
-var RUN_WEBSITES_SCHEMA_VERSION = 1;
-var MAX_TERMINAL_CHUNKS = 1200;
-var MAX_TERMINAL_PREVIEW_LINES = 5;
-var NODE_VERSION_PATTERN = /^\d+\.\d+\.\d+$/;
-var PYTHON_COMMAND_PATTERN = /^\s*(?:py(?:\.exe)?|python(?:\d+(?:\.\d+)?)?(?:\.exe)?)\b/i;
-var isoNow3 = () => (/* @__PURE__ */ new Date()).toISOString();
-var normalizeProjectPathKey = (projectPath) => {
-  const resolved = path7.resolve(projectPath);
-  return process.platform === "win32" ? resolved.toLowerCase() : resolved;
+var toBlobBytes = (buffer) => Uint8Array.from(buffer);
+var createProviderUrl = (baseUrl, endpointPath) => {
+  const normalizedBaseUrl = `${baseUrl.replace(/\/+$/, "")}/`;
+  return new URL(endpointPath.replace(/^\/+/, ""), normalizedBaseUrl);
 };
-var buildProjectStorageKey = (projectPath) => createHash3("sha1").update(normalizeProjectPathKey(projectPath)).digest("hex").slice(0, 16);
-var sanitizeStorageName = (value) => value.normalize("NFKC").replace(/[<>:"/\\|?*\u0000-\u001F]/g, "-").replace(/\s+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "").slice(0, 48);
-var resolveUserDocumentsDirectory = () => {
-  const home = os4.homedir();
-  const userProfile = process.env.USERPROFILE?.trim() || home;
-  if (process.platform === "win32") {
-    const documents = process.env.PUBLIC?.trim() ? path7.join(userProfile, "Documents") : path7.join(userProfile, "Documents");
-    return documents;
+var toErrorMessage = (fallback, body) => {
+  if (body && typeof body === "object") {
+    const message = body.error;
+    if (typeof message === "string" && message.trim()) {
+      return message;
+    }
+    if (message && typeof message === "object" && typeof message.message === "string" && message.message.trim()) {
+      return message.message;
+    }
   }
-  if (process.platform === "darwin") {
-    return path7.join(home, "Documents");
+  return fallback;
+};
+var previewText = (value, maxLength = 160) => {
+  const normalized = value.replace(/\s+/g, " ").trim();
+  if (normalized.length <= maxLength) {
+    return normalized;
   }
-  const xdgDocuments = process.env.XDG_DOCUMENTS_DIR?.trim();
-  if (xdgDocuments) {
-    return xdgDocuments.replace(/^\$HOME\b/, home);
+  return `${normalized.slice(0, maxLength - 1).trimEnd()}...`;
+};
+var redactApiKey = (apiKey) => {
+  const trimmed = apiKey.trim();
+  if (trimmed.length <= 8) {
+    return "***";
   }
-  return path7.join(home, "Documents");
+  return `${trimmed.slice(0, 4)}...${trimmed.slice(-4)}`;
 };
-var resolvePandaGlobalStorageRoot = () => path7.join(resolveUserDocumentsDirectory(), PANDA_GLOBAL_DIRECTORY_NAME, RUN_RESOURCES_DIRECTORY_NAME);
-var normalizeStoredPort = (value) => {
-  if (typeof value !== "number" || !Number.isInteger(value) || value <= 0) {
-    return null;
+var summarizeImageRequest = (input, endpoint, prompt, mappedSize) => ({
+  vendor: input.vendor,
+  endpoint,
+  baseUrl: input.baseUrl,
+  model: input.model,
+  promptPreview: previewText(prompt),
+  promptLength: prompt.length,
+  quality: input.quality,
+  size: input.size,
+  mappedSize,
+  aspectRatio: input.aspectRatio,
+  outputFormat: input.outputFormat,
+  outputCompression: input.outputCompression ?? null,
+  background: input.background,
+  moderation: input.moderation,
+  n: input.n,
+  inputCount: input.inputs?.length ?? 0,
+  hasMask: Boolean(input.mask),
+  apiKeyPreview: redactApiKey(input.apiKey)
+});
+var summarizeResponseBody = (body) => {
+  if (!body || typeof body !== "object") {
+    return body;
   }
-  return value;
+  const record = body;
+  const data = Array.isArray(record.data) ? record.data.map((item, index) => {
+    if (!item || typeof item !== "object") {
+      return { index, type: typeof item };
+    }
+    const imageItem = item;
+    return {
+      index,
+      hasB64Json: typeof imageItem.b64_json === "string" && imageItem.b64_json.length > 0,
+      url: typeof imageItem.url === "string" && imageItem.url.trim() ? imageItem.url : null
+    };
+  }) : void 0;
+  const error = typeof record.error === "string" ? record.error : record.error && typeof record.error === "object" ? {
+    message: typeof record.error.message === "string" ? record.error.message : null,
+    type: typeof record.error.type === "string" ? record.error.type : null,
+    code: typeof record.error.code === "string" ? record.error.code : null
+  } : void 0;
+  return {
+    created: typeof record.created === "number" || typeof record.created === "string" ? record.created : void 0,
+    data,
+    error
+  };
 };
-var normalizePort = (value) => normalizeStoredPort(value);
-var normalizeUrl = (value) => {
-  const trimmed = value?.trim() ?? "";
-  if (!trimmed) {
-    throw new Error("\u8BF7\u8F93\u5165\u7F51\u9875\u5730\u5740\u3002");
+var logImageProviderRequest = (summary) => {
+  console.info("[image-provider] request", summary);
+};
+var logImageProviderResponse = (summary, response, body) => {
+  const payload = {
+    endpoint: summary.endpoint,
+    vendor: summary.vendor,
+    model: summary.model,
+    status: response.status,
+    ok: response.ok,
+    body: summarizeResponseBody(body)
+  };
+  if (response.ok) {
+    console.info("[image-provider] response", payload);
+    return;
   }
-  try {
-    const parsed = new URL(trimmed);
-    if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
-      throw new Error("\u7F51\u9875\u5730\u5740\u53EA\u652F\u6301 http \u6216 https\u3002");
+  console.error("[image-provider] response", payload);
+};
+var mapAspectRatioToSize = (size, aspectRatio) => {
+  if (size !== "auto") {
+    const sizeTier = (() => {
+      switch (size) {
+        case "1024x1024":
+        case "1536x1024":
+        case "1024x1536":
+          return "1k";
+        case "2048x2048":
+        case "2048x1152":
+        case "1152x2048":
+          return "2k";
+        case "3840x2160":
+        case "2160x3840":
+          return "4k";
+        default:
+          return null;
+      }
+    })();
+    if (sizeTier === "1k") {
+      switch (aspectRatio) {
+        case "1:1":
+        case "auto":
+          return "1024x1024";
+        case "4:3":
+          return "1024x768";
+        case "3:4":
+          return "768x1024";
+        case "16:9":
+          return "1024x576";
+        case "9:16":
+          return "576x1024";
+        default:
+          return "1024x1024";
+      }
+    }
+    if (sizeTier === "2k") {
+      switch (aspectRatio) {
+        case "1:1":
+        case "auto":
+          return "2048x2048";
+        case "4:3":
+          return "2048x1536";
+        case "3:4":
+          return "1536x2048";
+        case "16:9":
+          return "2048x1152";
+        case "9:16":
+          return "1152x2048";
+        default:
+          return "2048x2048";
+      }
+    }
+    if (sizeTier === "4k") {
+      switch (aspectRatio) {
+        case "1:1":
+          return "3840x3840";
+        case "4:3":
+          return "3840x2880";
+        case "3:4":
+          return "2880x3840";
+        case "16:9":
+        case "auto":
+          return "3840x2160";
+        case "9:16":
+          return "2160x3840";
+        default:
+          return "3840x2160";
+      }
     }
-    return parsed.toString();
-  } catch {
-    throw new Error("\u7F51\u9875\u5730\u5740\u683C\u5F0F\u65E0\u6548\u3002");
+    return size;
+  }
+  if (aspectRatio === "1:1") {
+    return "1024x1024";
   }
+  if (aspectRatio === "16:9" || aspectRatio === "4:3") {
+    return "1536x1024";
+  }
+  if (aspectRatio === "9:16" || aspectRatio === "3:4") {
+    return "1024x1536";
+  }
+  return "auto";
 };
-var readStoredJson = async (filePath) => {
-  try {
-    const raw = await fs6.readFile(filePath, "utf8");
-    return JSON.parse(raw);
-  } catch {
-    return null;
+var buildPromptSuffix = (options) => {
+  const parts = [];
+  if (options.aspectRatio !== "auto" && options.size === "auto") {
+    parts.push(`?????${options.aspectRatio}`);
   }
+  return parts.join("?");
 };
-var writeStoredJson = async (filePath, payload) => {
-  await fs6.mkdir(path7.dirname(filePath), { recursive: true });
-  await fs6.writeFile(filePath, `${JSON.stringify(payload, null, 2)}
-`, "utf8");
+var createDataUri = (mimeType, buffer) => `data:${mimeType};base64,${buffer.toString("base64")}`;
+var mapSizeToXaiResolution = (size) => {
+  switch (size) {
+    case "auto":
+      return null;
+    case "1024x1024":
+    case "1536x1024":
+    case "1024x1536":
+      return "1k";
+    case "2048x2048":
+    case "2048x1152":
+    case "1152x2048":
+      return "2k";
+    case "3840x2160":
+    case "2160x3840":
+      throw new Error("xAI \u5F53\u524D\u56FE\u7247 API \u4EC5\u652F\u6301 1k / 2k \u5206\u8FA8\u7387\uFF0C\u6682\u4E0D\u652F\u6301 4K \u8F93\u51FA\u3002");
+    default:
+      return null;
+  }
 };
-var normalizeRelativeCommandCwd = (projectPath, cwd) => {
-  const trimmed = cwd?.trim() ?? "";
-  if (!trimmed) {
-    return null;
+var createOutputOptions = (input) => ({
+  output_format: input.outputFormat,
+  ...input.outputFormat === "jpeg" || input.outputFormat === "webp" ? { output_compression: input.outputCompression ?? 85 } : {},
+  background: input.background,
+  moderation: input.moderation
+});
+var shouldFallbackToMultipartForXaiEdit = (body) => {
+  if (!body || typeof body !== "object") {
+    return false;
   }
-  const absoluteCandidate = path7.resolve(projectPath, trimmed);
-  const relative = path7.relative(projectPath, absoluteCandidate);
-  if (!relative || relative === ".") {
-    return null;
+  const error = body.error;
+  const message = typeof error === "string" ? error : error && typeof error === "object" && typeof error.message === "string" ? error.message : "";
+  const code = error && typeof error === "object" && typeof error.code === "string" ? error.code : "";
+  const normalizedMessage = message.toLowerCase();
+  return normalizedMessage.includes("failed to parse multipart form") || code === "convert_request_failed";
+};
+var createOpenAiCompatibleEditForm = (input, prompt, mappedSize) => {
+  const form = new FormData();
+  form.set("model", input.model);
+  form.set("prompt", prompt);
+  form.set("quality", input.quality);
+  form.set("size", mappedSize);
+  form.set("n", String(input.n));
+  form.set("output_format", input.outputFormat);
+  if (input.outputFormat === "jpeg" || input.outputFormat === "webp") {
+    form.set("output_compression", String(input.outputCompression ?? 85));
+  }
+  form.set("background", input.background);
+  form.set("moderation", input.moderation);
+  if (input.model !== "gpt-image-2" && input.inputFidelity) {
+    form.set("input_fidelity", input.inputFidelity);
+  }
+  for (const image of input.inputs ?? []) {
+    const blob = new Blob([toBlobBytes(image.buffer)], {
+      type: image.mimeType
+    });
+    form.append("image[]", blob, image.name);
   }
-  if (relative.startsWith("..") || path7.isAbsolute(relative)) {
-    throw new Error("\u547D\u4EE4\u5DE5\u4F5C\u76EE\u5F55\u5FC5\u987B\u4F4D\u4E8E\u5F53\u524D\u9879\u76EE\u5185\u3002");
+  if (input.mask) {
+    const maskBlob = new Blob([toBlobBytes(input.mask.buffer)], {
+      type: input.mask.mimeType
+    });
+    form.set("mask", maskBlob, input.mask.name);
   }
-  return relative.split(path7.sep).join("/");
+  return form;
 };
-var resolveCommandAbsoluteCwd = (projectPath, cwd) => {
-  const relative = normalizeRelativeCommandCwd(projectPath, cwd);
-  return relative ? path7.resolve(projectPath, relative) : projectPath;
+var toOutputMimeType = (outputFormat) => {
+  switch (outputFormat) {
+    case "jpeg":
+      return "image/jpeg";
+    case "webp":
+      return "image/webp";
+    default:
+      return "image/png";
+  }
 };
-var normalizeNodeVersion = (value) => {
-  const trimmed = value?.trim() ?? "";
-  if (!trimmed) {
-    return null;
+var toOutputExtension = (outputFormat) => {
+  switch (outputFormat) {
+    case "jpeg":
+      return ".jpg";
+    case "webp":
+      return ".webp";
+    default:
+      return ".png";
   }
-  const normalized = trimmed.replace(/^v/i, "");
-  if (!NODE_VERSION_PATTERN.test(normalized)) {
-    throw new Error("Node \u7248\u672C\u683C\u5F0F\u65E0\u6548\uFF0C\u8BF7\u4F7F\u7528 x.y.z\u3002");
+};
+var parseBase64Response = async (response, fallbackName, requestSummary, outputFormat) => {
+  const json = await response.json().catch(() => null);
+  logImageProviderResponse(requestSummary, response, json);
+  if (!response.ok) {
+    throw new Error(
+      toErrorMessage(`Image request failed with ${response.status}`, json)
+    );
   }
-  return normalized;
+  const items = Array.isArray(json?.data) ? json.data : [];
+  const outputs = [];
+  for (let index = 0; index < items.length; index += 1) {
+    const item = items[index];
+    if (typeof item?.b64_json === "string" && item.b64_json.trim()) {
+      outputs.push({
+        buffer: Buffer.from(item.b64_json, "base64"),
+        mimeType: toOutputMimeType(outputFormat),
+        name: `${fallbackName}-${index + 1}${toOutputExtension(outputFormat)}`
+      });
+      continue;
+    }
+    if (typeof item?.url === "string" && item.url.trim()) {
+      const imageResponse = await fetch(item.url);
+      if (!imageResponse.ok) {
+        throw new Error(`Unable to download generated image (${imageResponse.status}).`);
+      }
+      const arrayBuffer = await imageResponse.arrayBuffer();
+      const mimeType = imageResponse.headers.get("content-type") || "image/png";
+      const extension = mimeType === "image/jpeg" ? ".jpg" : mimeType === "image/webp" ? ".webp" : ".png";
+      outputs.push({
+        buffer: Buffer.from(arrayBuffer),
+        mimeType,
+        name: `${fallbackName}-${index + 1}${extension}`
+      });
+    }
+  }
+  if (outputs.length === 0) {
+    throw new Error("Image provider did not return any image data.");
+  }
+  return outputs;
 };
-var normalizeOptionalCommand = (value) => {
-  const trimmed = value?.trim() ?? "";
-  return trimmed || null;
+var createHeaders = (apiKey, contentType) => {
+  const headers = new Headers();
+  headers.set("authorization", `Bearer ${apiKey}`);
+  if (contentType) {
+    headers.set("content-type", contentType);
+  }
+  return headers;
 };
-var compareNodeVersionsDesc = (left, right) => {
-  const leftParts = left.split(".").map((part) => Number.parseInt(part, 10));
-  const rightParts = right.split(".").map((part) => Number.parseInt(part, 10));
-  for (let index = 0; index < Math.max(leftParts.length, rightParts.length); index += 1) {
-    const leftPart = leftParts[index] ?? 0;
-    const rightPart = rightParts[index] ?? 0;
-    if (leftPart !== rightPart) {
-      return rightPart - leftPart;
-    }
+var listImageProviderModels = async (input) => {
+  const response = await fetch(createProviderUrl(input.baseUrl, "/models"), {
+    headers: createHeaders(input.apiKey)
+  });
+  const json = await response.json().catch(() => null);
+  if (!response.ok) {
+    throw new Error(
+      toErrorMessage(`Model list request failed with ${response.status}`, json)
+    );
   }
-  return 0;
+  return (Array.isArray(json?.data) ? json.data : []).map((model) => typeof model?.id === "string" ? model.id.trim() : "").filter((id) => id.length > 0).map((id) => ({ id, label: id }));
 };
-var dedupeNodeVersions = (versions) => [
+var testImageProviderConnection = async (input) => {
+  const response = await fetch(createProviderUrl(input.baseUrl, "/models"), {
+    headers: createHeaders(input.apiKey)
+  });
+  const json = await response.json().catch(() => null);
+  if (!response.ok) {
+    throw new Error(
+      toErrorMessage(`Connection test failed with ${response.status}`, json)
+    );
+  }
+  const modelAvailable = Array.isArray(json?.data) ? json.data.some((item) => item?.id === input.model) : false;
+  return {
+    modelAvailable
+  };
+};
+var submitXaiImageRequest = async (input, prompt, mappedSize, promptSuffix) => {
+  const hasInputs = Array.isArray(input.inputs) && input.inputs.length > 0;
+  if (input.mask) {
+    throw new Error("\u5F53\u524D xAI / Grok \u56FE\u7247\u6E20\u9053\u6682\u4E0D\u652F\u6301\u8499\u7248\u7F16\u8F91\u3002");
+  }
+  const resolution = mapSizeToXaiResolution(input.size);
+  if (!hasInputs) {
+    const requestSummary2 = summarizeImageRequest(
+      input,
+      "/images/generations",
+      prompt,
+      resolution ?? "auto"
+    );
+    logImageProviderRequest(requestSummary2);
+    const response2 = await fetch(createProviderUrl(input.baseUrl, "/images/generations"), {
+      method: "POST",
+      headers: createHeaders(input.apiKey, "application/json"),
+      body: JSON.stringify({
+        model: input.model,
+        prompt,
+        n: input.n,
+        response_format: "b64_json",
+        ...input.aspectRatio !== "auto" ? { aspect_ratio: input.aspectRatio } : {},
+        ...resolution ? { resolution } : {}
+      })
+    });
+    return {
+      outputs: await parseBase64Response(response2, "generated-image", requestSummary2, "png"),
+      promptSuffix: promptSuffix || null
+    };
+  }
+  const images = (input.inputs ?? []).map((image) => ({
+    type: "image_url",
+    url: createDataUri(image.mimeType, image.buffer)
+  }));
+  const requestSummary = summarizeImageRequest(
+    input,
+    "/images/edits",
+    prompt,
+    resolution ?? "auto"
+  );
+  logImageProviderRequest(requestSummary);
+  const response = await fetch(createProviderUrl(input.baseUrl, "/images/edits"), {
+    method: "POST",
+    headers: createHeaders(input.apiKey, "application/json"),
+    body: JSON.stringify({
+      model: input.model,
+      prompt,
+      n: input.n,
+      ...images.length === 1 ? { image: images[0] } : { images },
+      ...images.length > 1 && input.aspectRatio !== "auto" ? { aspect_ratio: input.aspectRatio } : {},
+      ...resolution ? { resolution } : {}
+    })
+  });
+  if (!response.ok) {
+    const errorBody = await response.clone().json().catch(() => null);
+    logImageProviderResponse(requestSummary, response, errorBody);
+    if (shouldFallbackToMultipartForXaiEdit(errorBody)) {
+      const multipartSummary = summarizeImageRequest(
+        input,
+        "/images/edits (multipart fallback)",
+        prompt,
+        mappedSize
+      );
+      logImageProviderRequest(multipartSummary);
+      console.warn("[image-provider] xai edit fallback to multipart", {
+        model: input.model,
+        baseUrl: input.baseUrl
+      });
+      const fallbackResponse = await fetch(createProviderUrl(input.baseUrl, "/images/edits"), {
+        method: "POST",
+        headers: createHeaders(input.apiKey),
+        body: createOpenAiCompatibleEditForm(input, prompt, mappedSize)
+      });
+      return {
+        outputs: await parseBase64Response(
+          fallbackResponse,
+          "edited-image",
+          multipartSummary,
+          input.outputFormat
+        ),
+        promptSuffix: promptSuffix || null
+      };
+    }
+    throw new Error(
+      toErrorMessage(`Image request failed with ${response.status}`, errorBody)
+    );
+  }
+  return {
+    outputs: await parseBase64Response(
+      response,
+      "edited-image",
+      requestSummary,
+      input.outputFormat
+    ),
+    promptSuffix: promptSuffix || null
+  };
+};
+var submitImageRequest = async (input) => {
+  const promptSuffix = buildPromptSuffix({
+    size: input.size,
+    aspectRatio: input.aspectRatio
+  });
+  const prompt = promptSuffix ? `${input.prompt.trim()}
+
+${promptSuffix}` : input.prompt.trim();
+  const mappedSize = mapAspectRatioToSize(input.size, input.aspectRatio);
+  const hasInputs = Array.isArray(input.inputs) && input.inputs.length > 0;
+  if (input.vendor === "xai") {
+    return submitXaiImageRequest(input, prompt, mappedSize, promptSuffix);
+  }
+  if (input.vendor === "gemini") {
+    throw new Error("\u5F53\u524D Gemini \u56FE\u7247\u6E20\u9053\u9700\u8981\u4E13\u7528 API \u9002\u914D\uFF0C\u6682\u4E0D\u652F\u6301\u76F4\u63A5\u8C03\u7528\u3002");
+  }
+  if (!hasInputs) {
+    const requestSummary2 = summarizeImageRequest(
+      input,
+      "/images/generations",
+      prompt,
+      mappedSize
+    );
+    logImageProviderRequest(requestSummary2);
+    const response2 = await fetch(createProviderUrl(input.baseUrl, "/images/generations"), {
+      method: "POST",
+      headers: createHeaders(input.apiKey, "application/json"),
+      body: JSON.stringify({
+        model: input.model,
+        prompt,
+        quality: input.quality,
+        size: mappedSize,
+        n: input.n,
+        ...createOutputOptions(input)
+      })
+    });
+    return {
+      outputs: await parseBase64Response(
+        response2,
+        "generated-image",
+        requestSummary2,
+        input.outputFormat
+      ),
+      promptSuffix: promptSuffix || null
+    };
+  }
+  const form = createOpenAiCompatibleEditForm(input, prompt, mappedSize);
+  const requestSummary = summarizeImageRequest(
+    input,
+    "/images/edits",
+    prompt,
+    mappedSize
+  );
+  logImageProviderRequest(requestSummary);
+  const response = await fetch(createProviderUrl(input.baseUrl, "/images/edits"), {
+    method: "POST",
+    headers: createHeaders(input.apiKey),
+    body: form
+  });
+  return {
+    outputs: await parseBase64Response(
+      response,
+      "edited-image",
+      requestSummary,
+      input.outputFormat
+    ),
+    promptSuffix: promptSuffix || null
+  };
+};
+var toMimeTypeFromFilename = (fileName) => {
+  const extension = path7.extname(fileName).toLowerCase();
+  switch (extension) {
+    case ".jpg":
+    case ".jpeg":
+      return "image/jpeg";
+    case ".webp":
+      return "image/webp";
+    case ".gif":
+      return "image/gif";
+    default:
+      return "image/png";
+  }
+};
+
+// packages/provider-codex/src/image-session-store.ts
+import { randomUUID } from "crypto";
+import fs6 from "fs/promises";
+import path8 from "path";
+var STORE_VERSION = 2;
+var DEFAULT_STATE = {
+  version: STORE_VERSION,
+  settings: {
+    active_channel_id: null,
+    channels: [],
+    updated_at: null
+  },
+  sessions: []
+};
+var isoNow3 = () => (/* @__PURE__ */ new Date()).toISOString();
+var DEFAULT_IMAGE_PROVIDER_MODELS2 = [
+  { id: "gpt-image-2", vendor: "openai", label: "gpt-image-2", enabled: true }
+];
+var imageModelVendors = /* @__PURE__ */ new Set(["openai", "xai", "gemini"]);
+var sanitizeStoredModels = (models) => {
+  const source = Array.isArray(models) ? models : DEFAULT_IMAGE_PROVIDER_MODELS2;
+  const seen = /* @__PURE__ */ new Set();
+  const sanitized = source.flatMap((model) => {
+    if (!model || typeof model !== "object") {
+      return [];
+    }
+    const record = model;
+    const id = typeof record.id === "string" ? record.id.trim() : "";
+    if (!id || seen.has(id)) {
+      return [];
+    }
+    seen.add(id);
+    const vendor = imageModelVendors.has(record.vendor) ? record.vendor : "openai";
+    const label = typeof record.label === "string" && record.label.trim() ? record.label.trim() : id;
+    const enabled = record.enabled !== false;
+    return [{ id, vendor, label, enabled }];
+  });
+  if (sanitized.length === 0) {
+    return DEFAULT_IMAGE_PROVIDER_MODELS2;
+  }
+  if (sanitized.some((model) => model.enabled)) {
+    return sanitized;
+  }
+  return sanitized.map(
+    (model, index) => index === 0 ? { ...model, enabled: true } : model
+  );
+};
+var sanitizeStoredChannel = (channel) => {
+  const id = typeof channel?.id === "string" ? channel.id.trim() : "";
+  if (!id) {
+    return null;
+  }
+  return {
+    id,
+    remark: typeof channel?.remark === "string" && channel.remark.trim() ? channel.remark.trim() : "Unnamed channel",
+    base_url: typeof channel?.base_url === "string" ? channel.base_url : "",
+    models: sanitizeStoredModels(channel?.models),
+    api_key: typeof channel?.api_key === "string" && channel.api_key.trim() ? channel.api_key : null,
+    updated_at: typeof channel?.updated_at === "string" ? channel.updated_at : null
+  };
+};
+var sanitizeStoredSettings = (settings) => {
+  const channels = Array.isArray(settings?.channels) ? settings.channels.map((channel) => sanitizeStoredChannel(channel)).filter((channel) => Boolean(channel)) : [];
+  const requestedActiveChannelId = typeof settings?.active_channel_id === "string" && settings.active_channel_id.trim() ? settings.active_channel_id : null;
+  return {
+    active_channel_id: channels.some((channel) => channel.id === requestedActiveChannelId) ? requestedActiveChannelId : channels[0]?.id ?? null,
+    channels,
+    updated_at: typeof settings?.updated_at === "string" ? settings.updated_at : null
+  };
+};
+var imageSessionCapability = (options) => {
+  const archived = options?.archived === true;
+  const running = options?.running === true;
+  return {
+    can_stream_live: false,
+    can_send_input: !archived && !running,
+    can_interrupt: false,
+    can_approve: false,
+    can_reject: false,
+    can_show_git: false,
+    can_show_terminal: false
+  };
+};
+var summarizePrompt = (prompt) => {
+  const normalized = prompt.trim().replace(/\s+/g, " ");
+  if (!normalized) {
+    return "";
+  }
+  return normalized.length > 88 ? `${normalized.slice(0, 87).trimEnd()}...` : normalized;
+};
+var buildLatestAssistantMessage = (turn) => {
+  if (!turn) {
+    return null;
+  }
+  if (turn.status === "failed") {
+    return turn.error ?? "Image generation failed";
+  }
+  if (turn.status === "pending") {
+    return turn.operation === "edit" ? "Editing image..." : "Generating image...";
+  }
+  const outputCount = turn.output_asset_ids.length;
+  if (outputCount <= 0) {
+    return "Completed";
+  }
+  return `Generated ${outputCount} image(s)`;
+};
+var toSessionTitle = (title) => {
+  const trimmed = title?.trim() ?? "";
+  return trimmed || "New image";
+};
+var createSessionRef = (agentId, title) => {
+  const timestamp = isoNow3();
+  return {
+    id: `image-session-${randomUUID()}`,
+    agent_id: agentId,
+    project_id: "",
+    provider: "image",
+    archived: false,
+    title: toSessionTitle(title),
+    mode: "managed",
+    health: "active",
+    branch: "image",
+    worktree: "drawing",
+    summary: "",
+    latest_assistant_message: null,
+    last_event_at: timestamp,
+    pinned: false,
+    run_state: "idle",
+    run_state_changed_at: null,
+    context_usage: null,
+    subagent: null,
+    capability: imageSessionCapability()
+  };
+};
+var ensureDirectory = async (targetPath) => {
+  await fs6.mkdir(targetPath, { recursive: true });
+};
+var parseDataUrl2 = (dataUrl) => {
+  const match = /^data:([^;,]+)?(?:;charset=[^;,]+)?;base64,(.+)$/i.exec(dataUrl.trim());
+  if (!match) {
+    throw new Error("Invalid image data URL.");
+  }
+  return {
+    mimeType: match[1] ?? "application/octet-stream",
+    buffer: Buffer.from(match[2] ?? "", "base64")
+  };
+};
+var extensionFromMimeType = (mimeType) => {
+  const normalized = mimeType?.trim().toLowerCase() ?? "";
+  switch (normalized) {
+    case "image/jpeg":
+      return ".jpg";
+    case "image/png":
+      return ".png";
+    case "image/webp":
+      return ".webp";
+    case "image/gif":
+      return ".gif";
+    case "image/svg+xml":
+      return ".svg";
+    default:
+      return ".bin";
+  }
+};
+var ImageSessionStore = class {
+  constructor(storageFilePath, assetRootPath) {
+    this.storageFilePath = storageFilePath;
+    this.assetRootPath = assetRootPath;
+  }
+  state = DEFAULT_STATE;
+  loaded = false;
+  async load() {
+    if (this.loaded) {
+      return;
+    }
+    await ensureDirectory(path8.dirname(this.storageFilePath));
+    await ensureDirectory(this.assetRootPath);
+    try {
+      const raw = await fs6.readFile(this.storageFilePath, "utf8");
+      const parsed = JSON.parse(raw);
+      const legacySettings = parsed.settings;
+      const legacyBaseUrl = typeof legacySettings?.base_url === "string" ? legacySettings.base_url : "";
+      const legacyApiKey = typeof legacySettings?.api_key === "string" && legacySettings.api_key.trim() ? legacySettings.api_key : null;
+      const legacyUpdatedAt = typeof legacySettings?.updated_at === "string" ? legacySettings.updated_at : null;
+      this.state = {
+        version: STORE_VERSION,
+        settings: parsed.version === 2 ? sanitizeStoredSettings(parsed.settings) : sanitizeStoredSettings({
+          active_channel_id: legacyBaseUrl.trim() || legacyApiKey || legacyUpdatedAt ? "image-channel-default" : null,
+          channels: legacyBaseUrl.trim() || legacyApiKey || legacyUpdatedAt ? [
+            {
+              id: "image-channel-default",
+              remark: "\u699B\u6A3F\uE17B\u5A13\u72BB\u4EBE",
+              base_url: legacyBaseUrl,
+              models: DEFAULT_IMAGE_PROVIDER_MODELS2,
+              api_key: legacyApiKey,
+              updated_at: legacyUpdatedAt
+            }
+          ] : [],
+          updated_at: legacyUpdatedAt
+        }),
+        sessions: Array.isArray(parsed.sessions) ? parsed.sessions : []
+      };
+    } catch {
+      this.state = DEFAULT_STATE;
+      await this.persist();
+    }
+    this.loaded = true;
+  }
+  async persist() {
+    await ensureDirectory(path8.dirname(this.storageFilePath));
+    await fs6.writeFile(this.storageFilePath, JSON.stringify(this.state, null, 2), "utf8");
+  }
+  ensureLoaded() {
+    if (!this.loaded) {
+      throw new Error("ImageSessionStore must be loaded before use.");
+    }
+  }
+  getSettings() {
+    this.ensureLoaded();
+    return this.state.settings;
+  }
+  getActiveSettingsChannel() {
+    this.ensureLoaded();
+    const activeChannelId = this.state.settings.active_channel_id;
+    return this.state.settings.channels.find((channel) => channel.id === activeChannelId) ?? this.state.settings.channels[0] ?? null;
+  }
+  async updateSettings(input) {
+    this.ensureLoaded();
+    const existingChannelsById = new Map(
+      this.state.settings.channels.map((channel) => [channel.id, channel])
+    );
+    const updatedAt = isoNow3();
+    const nextChannels = input.channels.map((channel) => {
+      const previous = existingChannelsById.get(channel.id);
+      const nextApiKey = channel.apiKeyMode === "set" ? channel.apiKey?.trim() || null : channel.apiKeyMode === "clear" ? null : previous?.api_key ?? null;
+      return {
+        id: channel.id,
+        remark: channel.remark.trim() || "Unnamed channel",
+        base_url: channel.baseUrl,
+        models: sanitizeStoredModels(channel.models),
+        api_key: nextApiKey,
+        updated_at: updatedAt
+      };
+    });
+    this.state = {
+      ...this.state,
+      settings: {
+        active_channel_id: nextChannels.some(
+          (channel) => channel.id === input.activeChannelId
+        ) ? input.activeChannelId : nextChannels[0]?.id ?? null,
+        channels: nextChannels,
+        updated_at: updatedAt
+      }
+    };
+    await this.persist();
+    return this.state.settings;
+  }
+  listSessions() {
+    this.ensureLoaded();
+    return [...this.state.sessions];
+  }
+  getSession(sessionId) {
+    this.ensureLoaded();
+    return this.state.sessions.find((session) => session.session.id === sessionId) ?? null;
+  }
+  async createSession(agentId, title) {
+    this.ensureLoaded();
+    const session = createSessionRef(agentId, title);
+    const record = {
+      session,
+      created_at: session.last_event_at,
+      updated_at: session.last_event_at,
+      turns: [],
+      assets: []
+    };
+    this.state = {
+      ...this.state,
+      sessions: [record, ...this.state.sessions]
+    };
+    await this.persist();
+    return record;
+  }
+  async updateSessionRecord(sessionId, updater) {
+    this.ensureLoaded();
+    let nextRecord = null;
+    this.state = {
+      ...this.state,
+      sessions: this.state.sessions.map((session) => {
+        if (session.session.id !== sessionId) {
+          return session;
+        }
+        nextRecord = updater(session);
+        return nextRecord;
+      })
+    };
+    if (!nextRecord) {
+      throw new Error("Image session not found.");
+    }
+    await this.persist();
+    return nextRecord;
+  }
+  async mutateSessionRef(sessionId, updater) {
+    return this.updateSessionRecord(sessionId, (current) => ({
+      ...current,
+      session: updater(current.session),
+      updated_at: isoNow3()
+    }));
+  }
+  async deleteSession(sessionId) {
+    this.ensureLoaded();
+    const existing = this.getSession(sessionId);
+    if (!existing) {
+      return false;
+    }
+    this.state = {
+      ...this.state,
+      sessions: this.state.sessions.filter((session) => session.session.id !== sessionId)
+    };
+    await this.persist();
+    await Promise.allSettled(
+      existing.assets.map(
+        (asset) => fs6.rm(path8.join(this.assetRootPath, asset.relative_path), { force: true })
+      )
+    );
+    return true;
+  }
+  async saveDataUrlAsset(input) {
+    const parsed = parseDataUrl2(input.dataUrl);
+    const mimeType = input.mimeType?.trim() || parsed.mimeType;
+    return this.saveBufferAsset({
+      sessionId: input.sessionId,
+      turnId: input.turnId ?? null,
+      kind: input.kind,
+      name: input.name,
+      buffer: parsed.buffer,
+      mimeType
+    });
+  }
+  async saveBufferAsset(input) {
+    const assetId = `image-asset-${randomUUID()}`;
+    const extension = extensionFromMimeType(input.mimeType);
+    const relativePath = path8.join(input.sessionId, `${assetId}${extension}`);
+    const absolutePath = path8.join(this.assetRootPath, relativePath);
+    await ensureDirectory(path8.dirname(absolutePath));
+    await fs6.writeFile(absolutePath, input.buffer);
+    const asset = {
+      id: assetId,
+      session_id: input.sessionId,
+      turn_id: input.turnId ?? null,
+      kind: input.kind,
+      name: input.name,
+      mime_type: input.mimeType ?? null,
+      size_bytes: input.buffer.length,
+      width: null,
+      height: null,
+      created_at: isoNow3(),
+      relative_path: relativePath
+    };
+    const nextRecord = await this.updateSessionRecord(input.sessionId, (current) => ({
+      ...current,
+      assets: [...current.assets, asset],
+      updated_at: isoNow3()
+    }));
+    return nextRecord.assets.find((entry) => entry.id === asset.id) ?? asset;
+  }
+  findAsset(sessionId, assetId) {
+    const session = this.getSession(sessionId);
+    if (!session) {
+      return null;
+    }
+    return session.assets.find((asset) => asset.id === assetId) ?? null;
+  }
+  async startTurn(input) {
+    const turnId = `image-turn-${randomUUID()}`;
+    const createdAt = isoNow3();
+    return this.updateSessionRecord(input.sessionId, (current) => {
+      const turn = {
+        id: turnId,
+        session_id: input.sessionId,
+        created_at: createdAt,
+        completed_at: null,
+        prompt: input.prompt,
+        prompt_suffix: input.promptSuffix ?? null,
+        operation: input.operation,
+        status: "pending",
+        error: null,
+        model: input.model,
+        quality: input.quality,
+        size: input.size,
+        input_fidelity: input.inputFidelity ?? null,
+        aspect_ratio: input.aspectRatio,
+        output_format: input.outputFormat ?? "png",
+        output_compression: input.outputCompression ?? null,
+        background: input.background ?? "auto",
+        moderation: input.moderation ?? "auto",
+        n: input.n ?? 1,
+        source_asset_ids: [...input.sourceAssetIds],
+        output_asset_ids: []
+      };
+      const session = {
+        ...current.session,
+        summary: summarizePrompt(input.prompt),
+        latest_assistant_message: buildLatestAssistantMessage(turn),
+        last_event_at: createdAt,
+        run_state: "running",
+        run_state_changed_at: createdAt,
+        capability: imageSessionCapability({
+          archived: current.session.archived,
+          running: true
+        })
+      };
+      return {
+        ...current,
+        session,
+        updated_at: createdAt,
+        turns: [...current.turns, turn]
+      };
+    });
+  }
+  async finishTurn(input) {
+    const completedAt = isoNow3();
+    return this.updateSessionRecord(input.sessionId, (current) => {
+      const turns = current.turns.map((turn) => {
+        if (turn.id !== input.turnId) {
+          return turn;
+        }
+        return {
+          ...turn,
+          completed_at: completedAt,
+          status: input.status,
+          error: input.error ?? null,
+          output_asset_ids: input.appendOutputs ? [...turn.output_asset_ids, ...input.outputAssetIds] : [...input.outputAssetIds]
+        };
+      });
+      const latestTurn = turns.find((turn) => turn.id === input.turnId) ?? null;
+      const session = {
+        ...current.session,
+        latest_assistant_message: buildLatestAssistantMessage(latestTurn),
+        last_event_at: completedAt,
+        run_state: input.status === "failed" ? "completed" : "completed",
+        run_state_changed_at: completedAt,
+        capability: imageSessionCapability({
+          archived: current.session.archived,
+          running: false
+        })
+      };
+      return {
+        ...current,
+        session,
+        updated_at: completedAt,
+        turns
+      };
+    });
+  }
+  toProtocolAsset(asset, resolveContentUrl) {
+    return {
+      id: asset.id,
+      session_id: asset.session_id,
+      turn_id: asset.turn_id,
+      kind: asset.kind,
+      name: asset.name,
+      mime_type: asset.mime_type,
+      size_bytes: asset.size_bytes,
+      width: asset.width,
+      height: asset.height,
+      content_url: resolveContentUrl(asset.id),
+      created_at: asset.created_at
+    };
+  }
+  toProtocolTurn(session, turn, resolveContentUrl) {
+    const assetsById = new Map(session.assets.map((asset) => [asset.id, asset]));
+    return {
+      id: turn.id,
+      session_id: turn.session_id,
+      created_at: turn.created_at,
+      completed_at: turn.completed_at,
+      prompt: turn.prompt,
+      prompt_suffix: turn.prompt_suffix,
+      operation: turn.operation,
+      status: turn.status,
+      error: turn.error,
+      model: turn.model,
+      quality: turn.quality,
+      size: turn.size,
+      input_fidelity: turn.input_fidelity ?? null,
+      aspect_ratio: turn.aspect_ratio,
+      output_format: turn.output_format ?? "png",
+      output_compression: turn.output_compression ?? null,
+      background: turn.background ?? "auto",
+      moderation: turn.moderation ?? "auto",
+      n: turn.n ?? 1,
+      sources: turn.source_asset_ids.map((assetId) => assetsById.get(assetId)).filter((asset) => Boolean(asset)).map((asset) => this.toProtocolAsset(asset, resolveContentUrl)),
+      outputs: turn.output_asset_ids.map((assetId) => assetsById.get(assetId)).filter((asset) => Boolean(asset)).map((asset) => this.toProtocolAsset(asset, resolveContentUrl))
+    };
+  }
+  resolveAssetAbsolutePath(asset) {
+    return path8.join(this.assetRootPath, asset.relative_path);
+  }
+};
+
+// packages/provider-codex/src/timeline-user-dedup.ts
+var normalizeTimelineEntryBody2 = (entry) => entry.body.replace(/\r\n/g, "\n").trim();
+var areAdjacentDuplicateUserEntries = (previous, next, maxSkewMs) => {
+  if (!previous || previous.kind !== "user" || next.kind !== "user") {
+    return false;
+  }
+  if (normalizeTimelineEntryBody2(previous) !== normalizeTimelineEntryBody2(next)) {
+    return false;
+  }
+  const previousTime = +new Date(previous.timestamp);
+  const nextTime = +new Date(next.timestamp);
+  if (!Number.isFinite(previousTime) || !Number.isFinite(nextTime)) {
+    return true;
+  }
+  return Math.abs(nextTime - previousTime) <= maxSkewMs;
+};
+var collapseDuplicateUserEntries = (entries, options) => {
+  const maxSkewMs = options?.maxSkewMs ?? 5e3;
+  const collapsed = [];
+  for (const entry of entries) {
+    const previous = collapsed[collapsed.length - 1];
+    if (!areAdjacentDuplicateUserEntries(previous, entry, maxSkewMs)) {
+      collapsed.push(entry);
+      continue;
+    }
+    collapsed[collapsed.length - 1] = {
+      ...entry,
+      attachments: mergeTimelineAttachments(previous?.attachments, entry.attachments)
+    };
+  }
+  return collapsed;
+};
+
+// packages/provider-codex/src/session-run-workbench.ts
+import { createHash as createHash3, randomUUID as randomUUID2 } from "crypto";
+import { spawn as spawn2 } from "child_process";
+import fs7 from "fs/promises";
+import os4 from "os";
+import path9 from "path";
+var PANDA_GLOBAL_DIRECTORY_NAME = "Project Workbench Data";
+var RUN_RESOURCES_DIRECTORY_NAME = "run-workbench";
+var RUN_RESOURCE_INDEX_FILE_NAME = "index.json";
+var RUN_COMMANDS_FILE_NAME = "commands.json";
+var RUN_WEBSITES_FILE_NAME = "websites.json";
+var RUN_COMMANDS_SCHEMA_VERSION = 1;
+var RUN_WEBSITES_SCHEMA_VERSION = 1;
+var MAX_TERMINAL_CHUNKS = 1200;
+var MAX_TERMINAL_PREVIEW_LINES = 5;
+var NODE_VERSION_PATTERN = /^\d+\.\d+\.\d+$/;
+var PYTHON_COMMAND_PATTERN = /^\s*(?:py(?:\.exe)?|python(?:\d+(?:\.\d+)?)?(?:\.exe)?)\b/i;
+var isoNow4 = () => (/* @__PURE__ */ new Date()).toISOString();
+var normalizeProjectPathKey = (projectPath) => {
+  const resolved = path9.resolve(projectPath);
+  return process.platform === "win32" ? resolved.toLowerCase() : resolved;
+};
+var buildProjectStorageKey = (projectPath) => createHash3("sha1").update(normalizeProjectPathKey(projectPath)).digest("hex").slice(0, 16);
+var sanitizeStorageName = (value) => value.normalize("NFKC").replace(/[<>:"/\\|?*\u0000-\u001F]/g, "-").replace(/\s+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "").slice(0, 48);
+var resolveUserDocumentsDirectory = () => {
+  const home = os4.homedir();
+  const userProfile = process.env.USERPROFILE?.trim() || home;
+  if (process.platform === "win32") {
+    const documents = process.env.PUBLIC?.trim() ? path9.join(userProfile, "Documents") : path9.join(userProfile, "Documents");
+    return documents;
+  }
+  if (process.platform === "darwin") {
+    return path9.join(home, "Documents");
+  }
+  const xdgDocuments = process.env.XDG_DOCUMENTS_DIR?.trim();
+  if (xdgDocuments) {
+    return xdgDocuments.replace(/^\$HOME\b/, home);
+  }
+  return path9.join(home, "Documents");
+};
+var resolvePandaGlobalStorageRoot = () => path9.join(resolveUserDocumentsDirectory(), PANDA_GLOBAL_DIRECTORY_NAME, RUN_RESOURCES_DIRECTORY_NAME);
+var normalizeStoredPort = (value) => {
+  if (typeof value !== "number" || !Number.isInteger(value) || value <= 0) {
+    return null;
+  }
+  return value;
+};
+var normalizePort = (value) => normalizeStoredPort(value);
+var normalizeUrl = (value) => {
+  const trimmed = value?.trim() ?? "";
+  if (!trimmed) {
+    throw new Error("\u8BF7\u8F93\u5165\u7F51\u9875\u5730\u5740\u3002");
+  }
+  try {
+    const parsed = new URL(trimmed);
+    if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+      throw new Error("\u7F51\u9875\u5730\u5740\u53EA\u652F\u6301 http \u6216 https\u3002");
+    }
+    return parsed.toString();
+  } catch {
+    throw new Error("\u7F51\u9875\u5730\u5740\u683C\u5F0F\u65E0\u6548\u3002");
+  }
+};
+var readStoredJson = async (filePath) => {
+  try {
+    const raw = await fs7.readFile(filePath, "utf8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+};
+var writeStoredJson = async (filePath, payload) => {
+  await fs7.mkdir(path9.dirname(filePath), { recursive: true });
+  await fs7.writeFile(filePath, `${JSON.stringify(payload, null, 2)}
+`, "utf8");
+};
+var normalizeRelativeCommandCwd = (projectPath, cwd) => {
+  const trimmed = cwd?.trim() ?? "";
+  if (!trimmed) {
+    return null;
+  }
+  const absoluteCandidate = path9.resolve(projectPath, trimmed);
+  const relative = path9.relative(projectPath, absoluteCandidate);
+  if (!relative || relative === ".") {
+    return null;
+  }
+  if (relative.startsWith("..") || path9.isAbsolute(relative)) {
+    throw new Error("\u547D\u4EE4\u5DE5\u4F5C\u76EE\u5F55\u5FC5\u987B\u4F4D\u4E8E\u5F53\u524D\u9879\u76EE\u5185\u3002");
+  }
+  return relative.split(path9.sep).join("/");
+};
+var resolveCommandAbsoluteCwd = (projectPath, cwd) => {
+  const relative = normalizeRelativeCommandCwd(projectPath, cwd);
+  return relative ? path9.resolve(projectPath, relative) : projectPath;
+};
+var normalizeNodeVersion = (value) => {
+  const trimmed = value?.trim() ?? "";
+  if (!trimmed) {
+    return null;
+  }
+  const normalized = trimmed.replace(/^v/i, "");
+  if (!NODE_VERSION_PATTERN.test(normalized)) {
+    throw new Error("Node \u7248\u672C\u683C\u5F0F\u65E0\u6548\uFF0C\u8BF7\u4F7F\u7528 x.y.z\u3002");
+  }
+  return normalized;
+};
+var normalizeOptionalCommand = (value) => {
+  const trimmed = value?.trim() ?? "";
+  return trimmed || null;
+};
+var compareNodeVersionsDesc = (left, right) => {
+  const leftParts = left.split(".").map((part) => Number.parseInt(part, 10));
+  const rightParts = right.split(".").map((part) => Number.parseInt(part, 10));
+  for (let index = 0; index < Math.max(leftParts.length, rightParts.length); index += 1) {
+    const leftPart = leftParts[index] ?? 0;
+    const rightPart = rightParts[index] ?? 0;
+    if (leftPart !== rightPart) {
+      return rightPart - leftPart;
+    }
+  }
+  return 0;
+};
+var dedupeNodeVersions = (versions) => [
   ...new Set(
     versions.map((version) => normalizeNodeVersion(version)).filter((version) => Boolean(version))
   )
@@ -7327,25 +8650,25 @@ var dedupeNodeVersions = (versions) => [
 var resolveNvmWindowsSettingsPath = () => {
   const configuredRoot = process.env.NVM_HOME?.trim();
   if (configuredRoot) {
-    return path7.join(configuredRoot, "settings.txt");
+    return path9.join(configuredRoot, "settings.txt");
   }
   const appData = process.env.AppData?.trim();
   if (appData) {
-    return path7.join(appData, "nvm", "settings.txt");
+    return path9.join(appData, "nvm", "settings.txt");
   }
-  return path7.join(os4.homedir(), "AppData", "Roaming", "nvm", "settings.txt");
+  return path9.join(os4.homedir(), "AppData", "Roaming", "nvm", "settings.txt");
 };
 var resolveNvmWindowsCandidateRoots = () => [
   process.env.NVM_HOME?.trim() ?? "",
-  process.env.LOCALAPPDATA?.trim() ? path7.join(process.env.LOCALAPPDATA.trim(), "nvm") : "",
-  process.env.AppData?.trim() ? path7.join(process.env.AppData.trim(), "nvm") : "",
-  path7.join(os4.homedir(), "AppData", "Local", "nvm"),
-  path7.join(os4.homedir(), "AppData", "Roaming", "nvm")
+  process.env.LOCALAPPDATA?.trim() ? path9.join(process.env.LOCALAPPDATA.trim(), "nvm") : "",
+  process.env.AppData?.trim() ? path9.join(process.env.AppData.trim(), "nvm") : "",
+  path9.join(os4.homedir(), "AppData", "Local", "nvm"),
+  path9.join(os4.homedir(), "AppData", "Roaming", "nvm")
 ].filter(Boolean);
 var resolveExistingNvmWindowsRoot = async () => {
   for (const candidateRoot of resolveNvmWindowsCandidateRoots()) {
     try {
-      const stat = await fs6.stat(candidateRoot);
+      const stat = await fs7.stat(candidateRoot);
       if (stat.isDirectory()) {
         return candidateRoot;
       }
@@ -7360,7 +8683,7 @@ var readNvmWindowsSettings = async () => {
     return { root: configuredRoot };
   }
   try {
-    const raw = await fs6.readFile(resolveNvmWindowsSettingsPath(), "utf8");
+    const raw = await fs7.readFile(resolveNvmWindowsSettingsPath(), "utf8");
     const entries = raw.split(/\r?\n/).map((line) => line.trim()).filter(Boolean).map((line) => {
       const separatorIndex = line.indexOf(":");
       if (separatorIndex < 0) {
@@ -7386,7 +8709,7 @@ var readNvmWindowsVersionsFromRoot = async (root) => {
     return [];
   }
   try {
-    const entries = await fs6.readdir(root, { withFileTypes: true });
+    const entries = await fs7.readdir(root, { withFileTypes: true });
     return dedupeNodeVersions(
       entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name).filter((name) => /^v?\d+\.\d+\.\d+$/.test(name))
     );
@@ -7400,7 +8723,7 @@ var prependProcessPath = (env, entry) => {
   const currentPath = env[pathKey] ?? "";
   return {
     ...env,
-    [pathKey]: currentPath ? `${entry}${path7.delimiter}${currentPath}` : entry
+    [pathKey]: currentPath ? `${entry}${path9.delimiter}${currentPath}` : entry
   };
 };
 var applyCommandRuntimeEnv = (command, env) => {
@@ -7427,7 +8750,7 @@ var normalizeStoredRunWebsite = (value) => {
   return parsed.data;
 };
 var readStoredRunResourceIndex = async (storageRoot) => {
-  const indexPath = path7.join(storageRoot, RUN_RESOURCE_INDEX_FILE_NAME);
+  const indexPath = path9.join(storageRoot, RUN_RESOURCE_INDEX_FILE_NAME);
   const parsed = await readStoredJson(indexPath);
   const projects = Array.isArray(parsed?.projects) ? parsed.projects.map((entry) => {
     if (!entry || typeof entry !== "object") {
@@ -7443,37 +8766,37 @@ var readStoredRunResourceIndex = async (storageRoot) => {
     }
     return {
       project_id: projectId,
-      project_path: path7.resolve(projectPath),
+      project_path: path9.resolve(projectPath),
       project_key: projectKey,
       resource_dir: resourceDir,
-      updated_at: typeof candidate.updated_at === "string" && candidate.updated_at.trim() ? candidate.updated_at : isoNow3()
+      updated_at: typeof candidate.updated_at === "string" && candidate.updated_at.trim() ? candidate.updated_at : isoNow4()
     };
   }).filter((entry) => Boolean(entry)) : [];
   return {
     version: 1,
-    updated_at: typeof parsed?.updated_at === "string" && parsed.updated_at.trim() ? parsed.updated_at : isoNow3(),
+    updated_at: typeof parsed?.updated_at === "string" && parsed.updated_at.trim() ? parsed.updated_at : isoNow4(),
     projects
   };
 };
 var writeStoredRunResourceIndex = async (storageRoot, index) => {
-  await writeStoredJson(path7.join(storageRoot, RUN_RESOURCE_INDEX_FILE_NAME), index);
+  await writeStoredJson(path9.join(storageRoot, RUN_RESOURCE_INDEX_FILE_NAME), index);
 };
 var resolveProjectRunResourcePaths = async (input) => {
   const storageRoot = resolvePandaGlobalStorageRoot();
   const index = await readStoredRunResourceIndex(storageRoot);
-  const normalizedProjectPath = path7.resolve(input.projectPath);
+  const normalizedProjectPath = path9.resolve(input.projectPath);
   const projectKey = buildProjectStorageKey(normalizedProjectPath);
   const existingEntry = index.projects.find(
     (entry) => normalizeProjectPathKey(entry.project_path) === normalizeProjectPathKey(normalizedProjectPath)
   );
-  const projectName = sanitizeStorageName(path7.basename(normalizedProjectPath) || input.projectId) || input.projectId;
+  const projectName = sanitizeStorageName(path9.basename(normalizedProjectPath) || input.projectId) || input.projectId;
   const resourceDir = existingEntry?.resource_dir?.trim() || `${projectName}-${projectKey}`;
   const nextEntry = {
     project_id: input.projectId,
     project_path: normalizedProjectPath,
     project_key: projectKey,
     resource_dir: resourceDir,
-    updated_at: isoNow3()
+    updated_at: isoNow4()
   };
   const nextProjects = [
     ...index.projects.filter(
@@ -7483,26 +8806,26 @@ var resolveProjectRunResourcePaths = async (input) => {
   ].sort((left, right) => left.project_path.localeCompare(right.project_path, "zh-CN"));
   await writeStoredRunResourceIndex(storageRoot, {
     version: 1,
-    updated_at: isoNow3(),
+    updated_at: isoNow4(),
     projects: nextProjects
   });
-  const resourceRoot = path7.join(storageRoot, resourceDir);
+  const resourceRoot = path9.join(storageRoot, resourceDir);
   return {
     storageRoot,
     resourceRoot,
-    commandsPath: path7.join(resourceRoot, RUN_COMMANDS_FILE_NAME),
-    websitesPath: path7.join(resourceRoot, RUN_WEBSITES_FILE_NAME)
+    commandsPath: path9.join(resourceRoot, RUN_COMMANDS_FILE_NAME),
+    websitesPath: path9.join(resourceRoot, RUN_WEBSITES_FILE_NAME)
   };
 };
 var readStoredCatalog = async (configPath) => {
   try {
-    const raw = await fs6.readFile(configPath, "utf8");
+    const raw = await fs7.readFile(configPath, "utf8");
     const parsed = JSON.parse(raw);
     const rawCommands = Array.isArray(parsed.commands) ? parsed.commands : [];
     const commands = rawCommands.map((entry) => normalizeStoredRunCommand(entry)).filter((entry) => Boolean(entry)).sort((left, right) => left.name.localeCompare(right.name, "zh-CN"));
     return {
       version: RUN_COMMANDS_SCHEMA_VERSION,
-      updated_at: typeof parsed.updated_at === "string" && parsed.updated_at.trim() ? parsed.updated_at : isoNow3(),
+      updated_at: typeof parsed.updated_at === "string" && parsed.updated_at.trim() ? parsed.updated_at : isoNow4(),
       commands
     };
   } catch {
@@ -7511,13 +8834,13 @@ var readStoredCatalog = async (configPath) => {
 };
 var readStoredWebsiteCatalog = async (configPath) => {
   try {
-    const raw = await fs6.readFile(configPath, "utf8");
+    const raw = await fs7.readFile(configPath, "utf8");
     const parsed = JSON.parse(raw);
     const rawWebsites = Array.isArray(parsed.websites) ? parsed.websites : [];
     const websites = rawWebsites.map((entry) => normalizeStoredRunWebsite(entry)).filter((entry) => Boolean(entry)).sort((left, right) => left.name.localeCompare(right.name, "zh-CN"));
     return {
       version: RUN_WEBSITES_SCHEMA_VERSION,
-      updated_at: typeof parsed.updated_at === "string" && parsed.updated_at.trim() ? parsed.updated_at : isoNow3(),
+      updated_at: typeof parsed.updated_at === "string" && parsed.updated_at.trim() ? parsed.updated_at : isoNow4(),
       websites
     };
   } catch {
@@ -7525,24 +8848,24 @@ var readStoredWebsiteCatalog = async (configPath) => {
   }
 };
 var writeStoredCatalog = async (configPath, commands) => {
-  await fs6.mkdir(path7.dirname(configPath), { recursive: true });
+  await fs7.mkdir(path9.dirname(configPath), { recursive: true });
   const payload = {
     version: RUN_COMMANDS_SCHEMA_VERSION,
-    updated_at: isoNow3(),
+    updated_at: isoNow4(),
     commands
   };
-  await fs6.writeFile(configPath, `${JSON.stringify(payload, null, 2)}
+  await fs7.writeFile(configPath, `${JSON.stringify(payload, null, 2)}
 `, "utf8");
   return payload;
 };
 var writeStoredWebsiteCatalog = async (configPath, websites) => {
-  await fs6.mkdir(path7.dirname(configPath), { recursive: true });
+  await fs7.mkdir(path9.dirname(configPath), { recursive: true });
   const payload = {
     version: RUN_WEBSITES_SCHEMA_VERSION,
-    updated_at: isoNow3(),
+    updated_at: isoNow4(),
     websites
   };
-  await fs6.writeFile(configPath, `${JSON.stringify(payload, null, 2)}
+  await fs7.writeFile(configPath, `${JSON.stringify(payload, null, 2)}
 `, "utf8");
   return payload;
 };
@@ -7581,10 +8904,10 @@ var sanitizeRunWebsiteDraft = (draft) => {
   };
 };
 var createRunCommand = (projectPath, draft, source) => {
-  const now = isoNow3();
+  const now = isoNow4();
   const sanitized = sanitizeRunCommandDraft(projectPath, draft);
   return {
-    id: `run-command-${randomUUID()}`,
+    id: `run-command-${randomUUID2()}`,
     name: sanitized.name,
     description: sanitized.description,
     command: sanitized.command,
@@ -7610,14 +8933,14 @@ var updateRunCommand = (current, projectPath, draft) => {
     shell: sanitized.shell,
     node_version: sanitized.node_version,
     port: sanitized.port,
-    updated_at: isoNow3()
+    updated_at: isoNow4()
   };
 };
 var createRunWebsite = (draft, source) => {
-  const now = isoNow3();
+  const now = isoNow4();
   const sanitized = sanitizeRunWebsiteDraft(draft);
   return {
-    id: `run-website-${randomUUID()}`,
+    id: `run-website-${randomUUID2()}`,
     name: sanitized.name,
     description: sanitized.description,
     url: sanitized.url,
@@ -7633,7 +8956,7 @@ var updateRunWebsite = (current, draft) => {
     name: sanitized.name,
     description: sanitized.description,
     url: sanitized.url,
-    updated_at: isoNow3()
+    updated_at: isoNow4()
   };
 };
 var readProjectRunCommandCatalog = async (input) => {
@@ -7645,7 +8968,7 @@ var readProjectRunCommandCatalog = async (input) => {
   const stored = await readStoredCatalog(configPath);
   const payload = stored ?? {
     version: RUN_COMMANDS_SCHEMA_VERSION,
-    updated_at: isoNow3(),
+    updated_at: isoNow4(),
     commands: []
   };
   return {
@@ -7665,7 +8988,7 @@ var readProjectRunWebsiteCatalog = async (input) => {
   const stored = await readStoredWebsiteCatalog(configPath);
   const payload = stored ?? {
     version: RUN_WEBSITES_SCHEMA_VERSION,
-    updated_at: isoNow3(),
+    updated_at: isoNow4(),
     websites: []
   };
   return {
@@ -7901,9 +9224,9 @@ var resolveRunCommandExecution = async (projectPath, command, options) => {
       shell
     };
   }
-  const nodeDirectory = path7.join(settings.root, `v${nodeVersion}`);
+  const nodeDirectory = path9.join(settings.root, `v${nodeVersion}`);
   try {
-    await fs6.access(path7.join(nodeDirectory, "node.exe"));
+    await fs7.access(path9.join(nodeDirectory, "node.exe"));
   } catch {
     return {
       command: resolvedCommand,
@@ -7985,13 +9308,13 @@ var createSessionRunWorkbenchManager = (options) => {
       terminals: /* @__PURE__ */ new Map(),
       order: [],
       activeTerminalId: null,
-      updatedAt: isoNow3()
+      updatedAt: isoNow4()
     };
     states.set(sessionId, created);
     return created;
   };
   const emitSnapshot = (state) => {
-    state.updatedAt = isoNow3();
+    state.updatedAt = isoNow4();
     options.onSnapshot(getSessionStateSnapshot(state));
   };
   const emitDelta = (state, terminal, chunks) => {
@@ -8025,7 +9348,7 @@ var createSessionRunWorkbenchManager = (options) => {
     if (!text) {
       return;
     }
-    const timestamp = isoNow3();
+    const timestamp = isoNow4();
     const chunk = {
       cursor: terminal.baseCursor + terminal.chunks.length,
       stream,
@@ -8044,7 +9367,7 @@ var createSessionRunWorkbenchManager = (options) => {
     emitDelta(state, terminal, [chunk]);
   };
   const finalizeTerminal = (state, terminal, nextStatus, exitCode) => {
-    const timestamp = isoNow3();
+    const timestamp = isoNow4();
     terminal.child = null;
     terminal.meta.status = nextStatus;
     terminal.meta.exit_code = exitCode;
@@ -8120,8 +9443,8 @@ var createSessionRunWorkbenchManager = (options) => {
     },
     runCommand: (input) => {
       const state = ensureState(input.sessionId, input.projectId);
-      const timestamp = isoNow3();
-      const terminalId = `terminal-${randomUUID()}`;
+      const timestamp = isoNow4();
+      const terminalId = `terminal-${randomUUID2()}`;
       const managed = {
         meta: {
           id: terminalId,
@@ -8182,7 +9505,7 @@ var createSessionRunWorkbenchManager = (options) => {
       });
       managed.child = child;
       managed.meta.status = "running";
-      managed.meta.started_at = isoNow3();
+      managed.meta.started_at = isoNow4();
       managed.meta.updated_at = managed.meta.started_at;
       emitSnapshot(state);
       let hasFinalized = false;
@@ -8253,11 +9576,11 @@ var createSessionRunWorkbenchManager = (options) => {
 };
 
 // packages/provider-codex/src/dev-manager.ts
-import fs7 from "fs/promises";
+import fs8 from "fs/promises";
 import net from "net";
 import os5 from "os";
-import path8 from "path";
-import { createHash as createHash4, randomUUID as randomUUID2 } from "crypto";
+import path10 from "path";
+import { createHash as createHash4, randomUUID as randomUUID3 } from "crypto";
 import { spawn as spawn3, spawnSync as spawnSync2 } from "child_process";
 var MANAGED_ENV_PASSTHROUGH_KEYS = [
   "ALLUSERSPROFILE",
@@ -8308,7 +9631,7 @@ var MANAGED_ENV_STRIP_KEYS = /* @__PURE__ */ new Set([
   "npm_config_registry",
   "NPM_CONFIG_REGISTRY"
 ]);
-var DEV_MANAGER_RELATIVE_ROOT = path8.join("state", "panda", "dev-manager");
+var DEV_MANAGER_RELATIVE_ROOT = path10.join("state", "panda", "dev-manager");
 var CONFIG_FILE_NAME = "config.json";
 var CREDENTIALS_FILE_NAME = "credentials.json";
 var SERVICE_PIDS_FILE_NAME = "service-pids.json";
@@ -8328,7 +9651,7 @@ var RELEASE_RESTART_DELAY_MS = 1500;
 var SNAPSHOT_NODE_RUNTIME_CACHE_MS = 3e4;
 var SNAPSHOT_PACKAGE_VERSION_CACHE_MS = 3e4;
 var SNAPSHOT_APK_ARTIFACT_CACHE_MS = 1e4;
-var isoNow4 = () => (/* @__PURE__ */ new Date()).toISOString();
+var isoNow5 = () => (/* @__PURE__ */ new Date()).toISOString();
 var defaultConfig = () => ({
   repo_path: null,
   nvm_version: null,
@@ -8355,12 +9678,12 @@ var defaultConfig = () => ({
   release_agent_args: "",
   updated_at: null
 });
-var resolveStateRoot = (codexHome) => path8.join(codexHome, DEV_MANAGER_RELATIVE_ROOT);
-var resolveConfigPath = (codexHome) => path8.join(resolveStateRoot(codexHome), CONFIG_FILE_NAME);
-var resolveCredentialsPath = (codexHome) => path8.join(resolveStateRoot(codexHome), CREDENTIALS_FILE_NAME);
-var resolveServicePidsPath = (codexHome) => path8.join(resolveStateRoot(codexHome), SERVICE_PIDS_FILE_NAME);
-var resolveJobsDirectory = (codexHome) => path8.join(resolveStateRoot(codexHome), JOBS_DIRECTORY_NAME);
-var resolveHelperDirectory = (codexHome) => path8.join(resolveStateRoot(codexHome), HELPERS_DIRECTORY_NAME);
+var resolveStateRoot = (codexHome) => path10.join(codexHome, DEV_MANAGER_RELATIVE_ROOT);
+var resolveConfigPath = (codexHome) => path10.join(resolveStateRoot(codexHome), CONFIG_FILE_NAME);
+var resolveCredentialsPath = (codexHome) => path10.join(resolveStateRoot(codexHome), CREDENTIALS_FILE_NAME);
+var resolveServicePidsPath = (codexHome) => path10.join(resolveStateRoot(codexHome), SERVICE_PIDS_FILE_NAME);
+var resolveJobsDirectory = (codexHome) => path10.join(resolveStateRoot(codexHome), JOBS_DIRECTORY_NAME);
+var resolveHelperDirectory = (codexHome) => path10.join(resolveStateRoot(codexHome), HELPERS_DIRECTORY_NAME);
 var normalizePort2 = (value, fallback) => {
   if (typeof value === "number" && Number.isInteger(value) && value > 0) {
     return value;
@@ -8384,7 +9707,7 @@ var normalizeConfig = (input) => {
   const repoPath = normalizeNullableText(input?.repo_path);
   const updatedAt = normalizeNullableText(input?.updated_at);
   return devManagerConfigSchema.parse({
-    repo_path: repoPath ? path8.resolve(repoPath) : null,
+    repo_path: repoPath ? path10.resolve(repoPath) : null,
     nvm_version: normalizeNullableText(input?.nvm_version),
     dev_hub_port: devHubPort,
     dev_hub_args: normalizeText(input?.dev_hub_args),
@@ -8412,25 +9735,25 @@ var normalizeConfig = (input) => {
 };
 var readJsonFile = async (filePath) => {
   try {
-    const raw = await fs7.readFile(filePath, "utf8");
+    const raw = await fs8.readFile(filePath, "utf8");
     return JSON.parse(raw);
   } catch {
     return null;
   }
 };
 var writeJsonFile = async (filePath, payload) => {
-  await fs7.mkdir(path8.dirname(filePath), { recursive: true });
-  await fs7.writeFile(filePath, `${JSON.stringify(payload, null, 2)}
+  await fs8.mkdir(path10.dirname(filePath), { recursive: true });
+  await fs8.writeFile(filePath, `${JSON.stringify(payload, null, 2)}
 `, "utf8");
 };
-var ensureDirectory = async (targetPath) => {
-  await fs7.mkdir(targetPath, { recursive: true });
+var ensureDirectory2 = async (targetPath) => {
+  await fs8.mkdir(targetPath, { recursive: true });
 };
 var validateRepoPath = async (repoPath) => {
   if (!repoPath) {
     return;
   }
-  const stat = await fs7.stat(repoPath).catch(() => null);
+  const stat = await fs8.stat(repoPath).catch(() => null);
   if (!stat?.isDirectory()) {
     throw new Error("\u5F00\u53D1\u7248\u4EE3\u7801\u8DEF\u5F84\u4E0D\u5B58\u5728\uFF0C\u6216\u4E0D\u662F\u4E00\u4E2A\u76EE\u5F55\u3002");
   }
@@ -8445,7 +9768,7 @@ var maskTokenHint = (token) => {
   }
   return `${normalized.slice(0, 4)}***${normalized.slice(-4)}`;
 };
-var buildJobFilePath = (codexHome, jobId) => path8.join(resolveJobsDirectory(codexHome), `${jobId}.json`);
+var buildJobFilePath = (codexHome, jobId) => path10.join(resolveJobsDirectory(codexHome), `${jobId}.json`);
 var readStoredJob = async (filePath) => {
   const payload = await readJsonFile(filePath);
   const parsed = devManagerJobSchema.safeParse(payload);
@@ -8453,25 +9776,25 @@ var readStoredJob = async (filePath) => {
 };
 var readAllJobs = async (codexHome) => {
   const jobsDirectory = resolveJobsDirectory(codexHome);
-  const entries = await fs7.readdir(jobsDirectory, { withFileTypes: true }).catch(() => []);
+  const entries = await fs8.readdir(jobsDirectory, { withFileTypes: true }).catch(() => []);
   const jobs = await Promise.all(
-    entries.filter((entry) => entry.isFile() && entry.name.endsWith(".json")).map((entry) => readStoredJob(path8.join(jobsDirectory, entry.name)))
+    entries.filter((entry) => entry.isFile() && entry.name.endsWith(".json")).map((entry) => readStoredJob(path10.join(jobsDirectory, entry.name)))
   );
   return jobs.filter((job) => Boolean(job)).sort((left, right) => +new Date(right.created_at) - +new Date(left.created_at));
 };
 var createJobLogEntry = (level, message) => ({
-  id: `dev-manager-log-${randomUUID2()}`,
-  timestamp: isoNow4(),
+  id: `dev-manager-log-${randomUUID3()}`,
+  timestamp: isoNow5(),
   level,
   message
 });
 var createManagedJob = (kind, title, options) => devManagerJobSchema.parse({
-  id: `dev-manager-job-${randomUUID2()}`,
+  id: `dev-manager-job-${randomUUID3()}`,
   kind,
   title,
   status: "running",
-  created_at: isoNow4(),
-  started_at: isoNow4(),
+  created_at: isoNow5(),
+  started_at: isoNow5(),
   finished_at: null,
   summary: null,
   error: null,
@@ -8639,7 +9962,7 @@ var probeUrl = async (url, options) => {
   const resolvedUrl = withProbePath(url, options?.probePath ?? "/health");
   if (!resolvedUrl) {
     return {
-      checked_at: isoNow4(),
+      checked_at: isoNow5(),
       url: null,
       ok: false,
       status_code: null,
@@ -8658,7 +9981,7 @@ var probeUrl = async (url, options) => {
     const durationMs = Date.now() - startedAt;
     const body = await response.text().catch(() => "");
     return {
-      checked_at: isoNow4(),
+      checked_at: isoNow5(),
       url: resolvedUrl,
       ok: response.ok,
       status_code: response.status,
@@ -8667,7 +9990,7 @@ var probeUrl = async (url, options) => {
     };
   } catch (error) {
     return {
-      checked_at: isoNow4(),
+      checked_at: isoNow5(),
       url: resolvedUrl,
       ok: false,
       status_code: null,
@@ -8681,7 +10004,7 @@ var probeUrl = async (url, options) => {
 var probeLocalPort = async (port, options) => {
   if (!port) {
     return {
-      checked_at: isoNow4(),
+      checked_at: isoNow5(),
       url: null,
       ok: false,
       status_code: null,
@@ -8704,7 +10027,7 @@ var probeLocalPort = async (port, options) => {
     socket.setTimeout(options?.timeoutMs ?? PORT_PROBE_TIMEOUT_MS);
     socket.once("connect", () => {
       finish({
-        checked_at: isoNow4(),
+        checked_at: isoNow5(),
         url: `tcp://${LOCALHOST}:${String(port)}`,
         ok: true,
         status_code: null,
@@ -8714,7 +10037,7 @@ var probeLocalPort = async (port, options) => {
     });
     socket.once("timeout", () => {
       finish({
-        checked_at: isoNow4(),
+        checked_at: isoNow5(),
         url: `tcp://${LOCALHOST}:${String(port)}`,
         ok: false,
         status_code: null,
@@ -8724,7 +10047,7 @@ var probeLocalPort = async (port, options) => {
     });
     socket.once("error", (error) => {
       finish({
-        checked_at: isoNow4(),
+        checked_at: isoNow5(),
         url: `tcp://${LOCALHOST}:${String(port)}`,
         ok: false,
         status_code: null,
@@ -8761,8 +10084,8 @@ var buildSyntheticCommand = (command, nodeVersion) => ({
   node_version: nodeVersion,
   port: null,
   source: "user",
-  created_at: isoNow4(),
-  updated_at: isoNow4()
+  created_at: isoNow5(),
+  updated_at: isoNow5()
 });
 var resolveManagedCommand = async (input) => {
   const execution = await resolveRunCommandExecution(
@@ -8817,14 +10140,14 @@ var buildIsolatedManagedEnv = (baseEnv, overrides) => {
   return nextEnv;
 };
 var createTempNpmPublishUserConfig = async (token) => {
-  const filePath = path8.join(
+  const filePath = path10.join(
     os5.tmpdir(),
     `panda-dev-manager-${process.pid}-${Date.now()}.npmrc`
   );
   const content = `//registry.npmjs.org/:_authToken=${token}
 registry=${NPM_REGISTRY_URL}
 `;
-  await fs7.writeFile(filePath, content, "utf8");
+  await fs8.writeFile(filePath, content, "utf8");
   return filePath;
 };
 var readStoredConfig = async (codexHome) => {
@@ -8883,9 +10206,9 @@ var readApkArtifact = async (config) => {
   if (!repoPath) {
     return null;
   }
-  const apkPath = path8.join(repoPath, "release", "android", "panda-android-release.apk");
-  const latestJsonPath = path8.join(repoPath, "release", "android", "latest.json");
-  const apkStat = await fs7.stat(apkPath).catch(() => null);
+  const apkPath = path10.join(repoPath, "release", "android", "panda-android-release.apk");
+  const latestJsonPath = path10.join(repoPath, "release", "android", "latest.json");
+  const apkStat = await fs8.stat(apkPath).catch(() => null);
   if (!apkStat?.isFile()) {
     return null;
   }
@@ -8893,7 +10216,7 @@ var readApkArtifact = async (config) => {
   const artifactId = createHash4("sha1").update([apkPath, String(apkStat.size), apkStat.mtime.toISOString()].join("::")).digest("hex").slice(0, 16);
   return {
     artifact_id: artifactId,
-    file_name: path8.basename(apkPath),
+    file_name: path10.basename(apkPath),
     size_bytes: Math.max(0, Math.round(apkStat.size)),
     built_at: apkStat.mtime.toISOString(),
     published_at: normalizeNullableText(manifest?.published_at),
@@ -8971,7 +10294,7 @@ const killByPort = async (port) => {
   for (const pid of pids) {
     if (process.platform === 'win32') {
       await new Promise((resolve) => {
-        const child = spawn('taskkill', ['/pid', String(pid), '/t', '/f'], {
+        const child = spawn('taskkill', ['/pid', String(pid), '/f'], {
           stdio: 'ignore',
           windowsHide: true,
         })
@@ -9381,7 +10704,7 @@ var createDevManager = ({
     const current = await readServiceProcessState(codexHome);
     current[serviceKey] = {
       root_pid: rootPid,
-      started_at: isoNow4(),
+      started_at: isoNow5(),
       command
     };
     await writeServiceProcessState(codexHome, current);
@@ -9617,7 +10940,7 @@ var createDevManager = ({
           status: "succeeded",
           summary,
           error: null,
-          finished_at: isoNow4()
+          finished_at: isoNow5()
         };
         await writeJsonFile(filePath, currentJob);
         return currentJob;
@@ -9628,7 +10951,7 @@ var createDevManager = ({
           status: "failed",
           summary: currentJob.summary ?? "\u6267\u884C\u5931\u8D25\u3002",
           error,
-          finished_at: isoNow4()
+          finished_at: isoNow5()
         };
         await writeJsonFile(filePath, currentJob);
         return currentJob;
@@ -9785,7 +11108,7 @@ var createDevManager = ({
       })
     ]);
     return {
-      generated_at: isoNow4(),
+      generated_at: isoNow5(),
       config,
       credentials: {
         has_npm_token: Boolean(credentials.npm_token),
@@ -9803,13 +11126,13 @@ var createDevManager = ({
     const normalized = normalizeConfig({
       ...current.config,
       ...input,
-      updated_at: isoNow4()
+      updated_at: isoNow5()
     });
     await validateRepoPath(normalized.repo_path);
     const nextCredentials = {
       npm_token: input.clear_npm_token ? null : normalizeNullableText(input.npm_token) ?? current.credentials.npm_token
     };
-    await ensureDirectory(resolveStateRoot(codexHome));
+    await ensureDirectory2(resolveStateRoot(codexHome));
     await writeJsonFile(resolveConfigPath(codexHome), normalized);
     await writeJsonFile(resolveCredentialsPath(codexHome), nextCredentials);
     cachedApkArtifact = null;
@@ -9904,7 +11227,7 @@ var createDevManager = ({
         await runCommandWithLogs(command, job, "npm \u53D1\u5E03");
         await job.succeed("npm \u53D1\u5E03\u5B8C\u6210\u3002");
       } finally {
-        await fs7.rm(userConfigPath, { force: true }).catch(() => void 0);
+        await fs8.rm(userConfigPath, { force: true }).catch(() => void 0);
       }
     });
   };
@@ -10009,7 +11332,7 @@ var createDevManager = ({
     const releaseHubCommand = await resolveServiceCommand(config, "release-hub");
     const releaseAgentCommand = await resolveServiceCommand(config, "release-agent");
     const helperDirectory = resolveHelperDirectory(codexHome);
-    await ensureDirectory(helperDirectory);
+    await ensureDirectory2(helperDirectory);
     const job = createManagedJob(input.kind, input.title, {
       disconnectExpected: true
     });
@@ -10023,9 +11346,9 @@ var createDevManager = ({
         )
       ]
     });
-    const helperSourcePath = path8.join(helperDirectory, "release-install-helper.cjs");
-    const helperPayloadPath = path8.join(helperDirectory, `${job.id}.json`);
-    await fs7.writeFile(helperSourcePath, createUpgradeHelperSource(), "utf8");
+    const helperSourcePath = path10.join(helperDirectory, "release-install-helper.cjs");
+    const helperPayloadPath = path10.join(helperDirectory, `${job.id}.json`);
+    await fs8.writeFile(helperSourcePath, createUpgradeHelperSource(), "utf8");
     await writeJsonFile(helperPayloadPath, {
       jobPath,
       workflowLabel: input.workflowLabel,
@@ -10126,7 +11449,7 @@ var createDevManager = ({
     }
     return {
       artifact,
-      filePath: path8.join(config.repo_path, "release", "android", "panda-android-release.apk")
+      filePath: path10.join(config.repo_path, "release", "android", "panda-android-release.apk")
     };
   };
   const executeAction = async (action) => {
@@ -10156,31 +11479,44 @@ var HUB_RECENT_SESSION_LIMIT = 24;
 var DEFAULT_WORKSPACE_SESSION_PAGE_LIMIT = 24;
 var MAX_WORKSPACE_SESSION_PAGE_LIMIT = 100;
 var COMMAND_PANEL_TTL_MS = 30 * 6e4;
-var CODEX_VERSION_PROBE_TIMEOUT_MS = 2500;
+var CODEX_VERSION_PROBE_TIMEOUT_MS2 = 2500;
 var CODEX_SOURCE_FETCH_TIMEOUT_MS = 8e3;
 var GIT_COMMAND_TIMEOUT_MS = 2e4;
+var PROJECTLESS_SESSION_PROJECT_ID = "";
+var PROJECTLESS_WORKTREE = "projectless";
+var PROJECTLESS_DIRECTORY_ROOT = path11.join(os6.homedir(), "Documents", "Codex");
 var HUB_AGENT_HEARTBEAT_INTERVAL_MS = Number(
   process.env.PANDA_HUB_AGENT_HEARTBEAT_INTERVAL_MS ?? 15e3
 );
 var HUB_AGENT_HEARTBEAT_TIMEOUT_MS = Number(
   process.env.PANDA_HUB_AGENT_HEARTBEAT_TIMEOUT_MS ?? 45e3
 );
-var FORWARDING_DIAGNOSTIC_LOG_RELATIVE_PATH = path9.join(
+var FORWARDING_DIAGNOSTIC_LOG_RELATIVE_PATH = path11.join(
   "logs",
   "panda",
   "codex-forwarding-diagnostics.latest.log"
 );
-var HUB_AGENT_REGISTRY_RELATIVE_PATH = path9.join(
+var HUB_AGENT_REGISTRY_RELATIVE_PATH = path11.join(
   "state",
   "panda",
   "hub-agent-registry.json"
 );
-var HUB_PUSH_SUBSCRIPTIONS_RELATIVE_PATH = path9.join(
+var HUB_PUSH_SUBSCRIPTIONS_RELATIVE_PATH = path11.join(
   "state",
   "panda",
   "hub-push-subscriptions.json"
 );
-var HUB_WEB_PUSH_VAPID_RELATIVE_PATH = path9.join(
+var IMAGE_SESSION_STORE_RELATIVE_PATH = path11.join(
+  "state",
+  "panda",
+  "image-sessions.json"
+);
+var IMAGE_SESSION_ASSET_RELATIVE_PATH = path11.join(
+  "state",
+  "panda",
+  "image-assets"
+);
+var HUB_WEB_PUSH_VAPID_RELATIVE_PATH = path11.join(
   "state",
   "panda",
   "hub-web-push-vapid.json"
@@ -10192,6 +11528,7 @@ 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 IMAGE_SESSION_AUTO_TITLE_PLACEHOLDERS = /* @__PURE__ */ new Set(["New image", "\u65B0\u7ED8\u56FE"]);
 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;
@@ -10277,25 +11614,21 @@ Plan mode is enabled for this message only. Before doing substantial work, creat
 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"
+  reason: "Review current workspace changes before continuing."
 };
 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" },
-  { name: "diff", description: "\u67E5\u770B\u5F53\u524D\u5DE5\u4F5C\u533A\u6700\u8FD1\u53D8\u66F4\u3002", availability: "unsupported" },
-  { name: "feedback", description: "\u63D0\u4EA4\u5173\u4E8E Codex \u7684\u53CD\u9988\u3002", availability: "unsupported" },
-  { name: "fork", description: "\u4ECE\u5F53\u524D\u4F1A\u8BDD\u6D3E\u751F\u4E00\u4E2A\u65B0\u7684\u5206\u652F\u4F1A\u8BDD\u3002", availability: "unsupported" },
-  { name: "init", description: "\u521D\u59CB\u5316 Codex \u9879\u76EE\u6587\u4EF6\u3002", availability: "unsupported" },
-  { name: "mcp", description: "\u67E5\u770B\u5F53\u524D\u53EF\u7528\u7684 MCP \u670D\u52A1\u548C\u5DE5\u5177\u3002", availability: "supported" },
-  { name: "model", description: "\u5207\u6362\u540E\u7EED\u5BF9\u8BDD\u4F7F\u7528\u7684\u6A21\u578B\u3002", availability: "supported" },
-  { name: "new", description: "\u5F00\u59CB\u4E00\u4E2A\u65B0\u4F1A\u8BDD\u3002", availability: "unsupported" },
-  { name: "permissions", description: "\u67E5\u770B\u6216\u8C03\u6574\u786E\u8BA4\u7B56\u7565\u3002", availability: "unsupported" },
-  { name: "personality", description: "\u5207\u6362\u54CD\u5E94\u4EBA\u683C\u3002", availability: "unsupported" },
-  { name: "rename", description: "\u91CD\u547D\u540D\u5F53\u524D\u4F1A\u8BDD\u3002", availability: "supported" },
-  { name: "review", description: "\u5BA1\u67E5\u5F53\u524D\u5DE5\u4F5C\u533A\u672A\u63D0\u4EA4\u53D8\u66F4\u3002", availability: "unsupported" },
-  { name: "skills", description: "\u6D4F\u89C8\u5F53\u524D\u9879\u76EE\u53EF\u7528\u6280\u80FD\u3002", availability: "supported" },
-  { name: "status", description: "\u67E5\u770B\u5F53\u524D\u4F1A\u8BDD\u72B6\u6001\u3001\u6A21\u578B\u548C\u4E0A\u4E0B\u6587\u7A97\u53E3\u3002", availability: "supported" },
-  { name: "statusline", description: "\u67E5\u770B\u72B6\u6001\u680F\u914D\u7F6E\u3002", availability: "unsupported" }
+  { name: "compact", description: "Compact current conversation context.", availability: "supported" },
+  { name: "copy", description: "Copy the latest assistant response.", availability: "unsupported" },
+  { name: "diff", description: "Show recent workspace changes.", availability: "unsupported" },
+  { name: "feedback", description: "Send feedback about Codex.", availability: "unsupported" },
+  { name: "fork", description: "Fork the current conversation.", availability: "unsupported" },
+  { name: "init", description: "Initialize Codex project files.", availability: "unsupported" },
+  { name: "mcp", description: "Show available MCP servers and tools.", availability: "supported" },
+  { name: "model", description: "Switch the model for future turns.", availability: "supported" },
+  { name: "new", description: "Start a new conversation.", availability: "unsupported" },
+  { name: "permissions", description: "View or change approval policy.", availability: "unsupported" },
+  { name: "prompts", description: "Show prompt examples.", availability: "unsupported" },
+  { name: "status", description: "Show current session status.", availability: "supported" }
 ];
 var PANDA_SUPPORTED_COMMANDS = /* @__PURE__ */ new Set([
   "compact",
@@ -10310,28 +11643,28 @@ var DEFAULT_VISIBLE_CODEX_COMMAND_CONFIG = {
   visible_commands: [
     {
       name: "model",
-      reason: "\u5207\u6362\u771F\u5B9E Codex CLI \u6A21\u578B\uFF0C\u662F\u6700\u5E38\u7528\u4E5F\u6700\u76F4\u63A5\u5F71\u54CD\u5BF9\u8BDD\u4F53\u9A8C\u7684\u547D\u4EE4\u3002"
+      reason: "Switch the active Codex CLI model."
     },
     {
       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"
+      reason: "Show current session model and status."
     },
     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"
+      reason: "Show available project skills."
     },
     {
       name: "mcp",
-      reason: "\u68C0\u67E5\u5916\u90E8\u5DE5\u5177\u548C\u670D\u52A1\u63A5\u5165\u72B6\u6001\uFF0C\u51FA\u4E86\u95EE\u9898\u65F6\u6392\u67E5\u6548\u7387\u6700\u9AD8\u3002"
+      reason: "Inspect MCP tools and services."
     },
     {
       name: "rename",
-      reason: "\u6574\u7406\u4F1A\u8BDD\u6807\u9898\u6210\u672C\u4F4E\u3001\u9891\u7387\u9AD8\uFF0C\u9002\u5408\u653E\u8FDB\u9996\u5C4F\u547D\u4EE4\u5217\u8868\u3002"
+      reason: "Rename the current conversation."
     },
     {
       name: "compact",
-      reason: "\u4E0A\u4E0B\u6587\u53D8\u957F\u65F6\u5F88\u5B9E\u7528\uFF0C\u4F46\u53C8\u4E0D\u50CF\u5B9E\u9A8C\u6027\u547D\u4EE4\u90A3\u6837\u5BB9\u6613\u8BA9\u4EBA\u56F0\u60D1\u3002"
+      reason: "Compact long conversation context."
     }
   ]
 };
@@ -10364,6 +11697,11 @@ var startPandaSessionService = async ({
   app.log.info({
     diagnosticLogFilePath
   }, "Panda Codex forwarding diagnostics will be written to file.");
+  const imageSessionStore = new ImageSessionStore(
+    path11.join(resolvedCodexHomePath, IMAGE_SESSION_STORE_RELATIVE_PATH),
+    path11.join(resolvedCodexHomePath, IMAGE_SESSION_ASSET_RELATIVE_PATH)
+  );
+  await imageSessionStore.load();
   let discoveredAgent = null;
   let discoveredSessionFiles = {};
   let activeSessionId = "";
@@ -10384,7 +11722,7 @@ var startPandaSessionService = async ({
     approvals: []
   };
   const hubAgentRegistry = mode === "hub" ? createHubAgentRegistry({
-    storageFilePath: path9.join(
+    storageFilePath: path11.join(
       resolvedCodexHomePath,
       HUB_AGENT_REGISTRY_RELATIVE_PATH
     ),
@@ -10392,7 +11730,7 @@ var startPandaSessionService = async ({
     logger: app.log
   }) : null;
   const hubPushSubscriptionStore = mode === "hub" ? createHubPushSubscriptionStore({
-    storageFilePath: path9.join(
+    storageFilePath: path11.join(
       resolvedCodexHomePath,
       HUB_PUSH_SUBSCRIPTIONS_RELATIVE_PATH
     ),
@@ -10400,7 +11738,7 @@ var startPandaSessionService = async ({
   }) : null;
   const hubWebPushNotifier = mode === "hub" ? await import("./hub-web-push-KM4VOXLQ.mjs").then(
     ({ createHubWebPushNotifier }) => createHubWebPushNotifier({
-      storageFilePath: path9.join(
+      storageFilePath: path11.join(
         resolvedCodexHomePath,
         HUB_WEB_PUSH_VAPID_RELATIVE_PATH
       ),
@@ -10428,12 +11766,12 @@ var startPandaSessionService = async ({
   let codexCommandCatalogRefreshPromise = null;
   const wsClients = /* @__PURE__ */ new Set();
   const emittedTurnCompletionKeys = /* @__PURE__ */ new Map();
-  const isoNow5 = () => (/* @__PURE__ */ new Date()).toISOString();
+  const isoNow6 = () => (/* @__PURE__ */ new Date()).toISOString();
   const sendSocketEvent = (client, type, payload) => {
     client.send(
       JSON.stringify({
         type,
-        timestamp: isoNow5(),
+        timestamp: isoNow6(),
         payload
       })
     );
@@ -10441,7 +11779,7 @@ var startPandaSessionService = async ({
   const broadcastEvent = (type, payload, options) => {
     const message = JSON.stringify({
       type,
-      timestamp: isoNow5(),
+      timestamp: isoNow6(),
       payload
     });
     for (const client of wsClients) {
@@ -10487,7 +11825,7 @@ var startPandaSessionService = async ({
   };
   const fileExists = async (targetPath) => {
     try {
-      return (await fs8.stat(targetPath)).isFile();
+      return (await fs9.stat(targetPath)).isFile();
     } catch {
       return false;
     }
@@ -10503,29 +11841,29 @@ var startPandaSessionService = async ({
     if (!pathname.startsWith("/")) {
       pathname = `/${pathname}`;
     }
-    const normalizedPathname = path9.posix.normalize(pathname);
+    const normalizedPathname = path11.posix.normalize(pathname);
     if (normalizedPathname.startsWith("/..")) {
       return null;
     }
-    const webUiRootPath = path9.resolve(webUiRoot);
+    const webUiRootPath = path11.resolve(webUiRoot);
     const relativePath = normalizedPathname === "/" ? "index.html" : normalizedPathname.replace(/^\/+/, "");
-    const candidatePath = path9.resolve(webUiRootPath, relativePath.split("/").join(path9.sep));
-    const candidateRelativePath = path9.relative(webUiRootPath, candidatePath);
-    if (candidateRelativePath.startsWith("..") || path9.isAbsolute(candidateRelativePath)) {
+    const candidatePath = path11.resolve(webUiRootPath, relativePath.split("/").join(path11.sep));
+    const candidateRelativePath = path11.relative(webUiRootPath, candidatePath);
+    if (candidateRelativePath.startsWith("..") || path11.isAbsolute(candidateRelativePath)) {
       return null;
     }
-    const hasExtension = path9.extname(relativePath) !== "";
+    const hasExtension = path11.extname(relativePath) !== "";
     if (await fileExists(candidatePath)) {
       return {
         filePath: candidatePath,
         cacheControl: relativePath.startsWith("assets/") ? "public, max-age=31536000, immutable" : "public, max-age=3600",
-        contentType: WEB_UI_CONTENT_TYPES[path9.extname(candidatePath).toLowerCase()] ?? "application/octet-stream"
+        contentType: WEB_UI_CONTENT_TYPES[path11.extname(candidatePath).toLowerCase()] ?? "application/octet-stream"
       };
     }
     if (hasExtension) {
       return null;
     }
-    const indexPath = path9.join(webUiRootPath, "index.html");
+    const indexPath = path11.join(webUiRootPath, "index.html");
     if (!await fileExists(indexPath)) {
       return null;
     }
@@ -10552,34 +11890,34 @@ var startPandaSessionService = async ({
     }
   };
   const isPathInsideProject = (projectPath, candidatePath) => {
-    const resolvedProjectPath = path9.resolve(projectPath);
-    const resolvedCandidatePath = path9.resolve(projectPath, candidatePath);
-    const relativePath = path9.relative(resolvedProjectPath, resolvedCandidatePath);
+    const resolvedProjectPath = path11.resolve(projectPath);
+    const resolvedCandidatePath = path11.resolve(projectPath, candidatePath);
+    const relativePath = path11.relative(resolvedProjectPath, resolvedCandidatePath);
     if (!relativePath) {
       return true;
     }
-    return !relativePath.startsWith("..") && !path9.isAbsolute(relativePath);
+    return !relativePath.startsWith("..") && !path11.isAbsolute(relativePath);
   };
   const isAbsolutePathInsideProject = (projectPath, candidatePath) => {
-    const resolvedProjectPath = path9.resolve(projectPath);
-    const resolvedCandidatePath = path9.resolve(candidatePath);
-    const relativePath = path9.relative(resolvedProjectPath, resolvedCandidatePath);
+    const resolvedProjectPath = path11.resolve(projectPath);
+    const resolvedCandidatePath = path11.resolve(candidatePath);
+    const relativePath = path11.relative(resolvedProjectPath, resolvedCandidatePath);
     if (!relativePath) {
       return true;
     }
-    return !relativePath.startsWith("..") && !path9.isAbsolute(relativePath);
+    return !relativePath.startsWith("..") && !path11.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);
+    const absolutePath = normalizedPath ? path11.resolve(projectPath, normalizedPath) : path11.resolve(projectPath);
     if (!isAbsolutePathInsideProject(projectPath, absolutePath)) {
-      throw new Error("\u76EE\u6807\u8DEF\u5F84\u4E0D\u5728\u5F53\u524D\u9879\u76EE\u5185\u3002");
+      throw new Error("Target path is outside the current project.");
     }
     let realPath;
     try {
-      realPath = await fs8.realpath(absolutePath);
+      realPath = await fs9.realpath(absolutePath);
     } catch (error) {
       if (isMissingPathError(error)) {
         throw new Error("File not found.");
@@ -10587,7 +11925,7 @@ var startPandaSessionService = async ({
       throw error;
     }
     if (!isAbsolutePathInsideProject(projectPath, realPath)) {
-      throw new Error("\u76EE\u6807\u8DEF\u5F84\u4E0D\u5728\u5F53\u524D\u9879\u76EE\u5185\u3002");
+      throw new Error("Target path is outside the current project.");
     }
     return {
       normalizedPath,
@@ -10596,7 +11934,7 @@ var startPandaSessionService = async ({
     };
   };
   const normalizeSessionFilePreviewExtension = (value) => {
-    const extension = path9.extname(value).trim().toLowerCase();
+    const extension = path11.extname(value).trim().toLowerCase();
     return extension || null;
   };
   const detectSessionFilePreviewKind = (fileName, extension) => {
@@ -10644,7 +11982,7 @@ var startPandaSessionService = async ({
     return suspiciousControlCount / buffer.length < 0.08;
   };
   const readPreviewBuffer = async (filePath, byteLimit) => {
-    const handle = await fs8.open(filePath, "r");
+    const handle = await fs9.open(filePath, "r");
     try {
       const buffer = Buffer.alloc(byteLimit);
       const { bytesRead } = await handle.read(buffer, 0, byteLimit, 0);
@@ -10655,7 +11993,7 @@ var startPandaSessionService = async ({
   };
   const readDirectoryHasChildren = async (directoryPath) => {
     try {
-      const entries = await fs8.readdir(directoryPath);
+      const entries = await fs9.readdir(directoryPath);
       return entries.length > 0;
     } catch {
       return false;
@@ -10665,10 +12003,10 @@ var startPandaSessionService = async ({
     const nextRelativePath = normalizeGitWorkspacePath(
       parentRelativePath ? `${parentRelativePath}/${entry.name}` : entry.name
     );
-    const entryPath = path9.join(parentRealPath, entry.name);
+    const entryPath = path11.join(parentRealPath, entry.name);
     if (entry.isSymbolicLink()) {
       try {
-        const realPath = await fs8.realpath(entryPath);
+        const realPath = await fs9.realpath(entryPath);
         if (!isAbsolutePathInsideProject(projectPath, realPath)) {
           return null;
         }
@@ -10676,7 +12014,7 @@ var startPandaSessionService = async ({
         return null;
       }
     }
-    const stat = await fs8.stat(entryPath).catch(() => null);
+    const stat = await fs9.stat(entryPath).catch(() => null);
     if (!stat) {
       return null;
     }
@@ -10974,7 +12312,7 @@ var startPandaSessionService = async ({
     ["diff", "--no-ext-diff", "--no-color", "--binary", "HEAD", "--", filePath]
   )).stdout;
   const readUntrackedFileDiff = async (projectPath, filePath) => {
-    const absolutePath = path9.join(projectPath, filePath);
+    const absolutePath = path11.join(projectPath, filePath);
     return (await runGitCommand(
       projectPath,
       ["diff", "--no-index", "--no-color", "--binary", "--", "/dev/null", absolutePath],
@@ -10986,9 +12324,9 @@ var startPandaSessionService = async ({
     ["diff", "--numstat", "--find-renames", "HEAD", "--", filePath]
   )).stdout);
   const readUntrackedFileChangeCounts = async (projectPath, filePath) => {
-    const absolutePath = path9.join(projectPath, filePath);
+    const absolutePath = path11.join(projectPath, filePath);
     try {
-      const content = await fs8.readFile(absolutePath, "utf8");
+      const content = await fs9.readFile(absolutePath, "utf8");
       return {
         additions: countTextFileLines(content),
         deletions: 0
@@ -11030,7 +12368,7 @@ var startPandaSessionService = async ({
       ahead_count: branchStatus.aheadCount,
       behind_count: branchStatus.behindCount,
       files,
-      updated_at: isoNow5()
+      updated_at: isoNow6()
     };
   };
   const readSessionGitWorkspaceFileDiff = async (session, project, filePath, previousPath) => {
@@ -11078,7 +12416,7 @@ var startPandaSessionService = async ({
       head_oid: branchStatus.headOid,
       upstream_head_oid: branchStatus.upstreamHeadOid,
       commits: parseGitHistory(logOutput.stdout),
-      updated_at: isoNow5()
+      updated_at: isoNow6()
     };
   };
   const readSessionGitHistoryFileDiff = async (session, project, commitOid, filePath, previousPath) => {
@@ -11136,7 +12474,7 @@ var startPandaSessionService = async ({
       raw: trimmed
     };
   };
-  const detectCodexCliVersion = async () => new Promise((resolve) => {
+  const detectCodexCliVersion2 = async () => new Promise((resolve) => {
     let stdout = "";
     let settled = false;
     const command = process.platform === "win32" ? "codex" : "codex";
@@ -11154,7 +12492,7 @@ var startPandaSessionService = async ({
     const timer = setTimeout(() => {
       child.kill();
       finalize(null);
-    }, CODEX_VERSION_PROBE_TIMEOUT_MS);
+    }, CODEX_VERSION_PROBE_TIMEOUT_MS2);
     child.stdout.on("data", (chunk) => {
       stdout += chunk.toString("utf8");
     });
@@ -11283,8 +12621,8 @@ var startPandaSessionService = async ({
   const getPandaLocalBaseDirectory = async () => {
     if (!pandaLocalBaseDirectoryPromise) {
       pandaLocalBaseDirectoryPromise = (async () => {
-        const baseDirectory = codexHome?.trim() || process.env.PANDA_CODEX_HOME?.trim() || path9.join(os6.homedir(), ".panda");
-        await fs8.mkdir(baseDirectory, { recursive: true });
+        const baseDirectory = codexHome?.trim() || process.env.PANDA_CODEX_HOME?.trim() || path11.join(os6.homedir(), ".panda");
+        await fs9.mkdir(baseDirectory, { recursive: true });
         return baseDirectory;
       })();
     }
@@ -11294,9 +12632,9 @@ var startPandaSessionService = async ({
     if (!codexCommandCatalogCacheFilePathPromise) {
       codexCommandCatalogCacheFilePathPromise = (async () => {
         const baseDirectory = await getPandaLocalBaseDirectory();
-        const cacheDirectory = path9.join(baseDirectory, "cache");
-        await fs8.mkdir(cacheDirectory, { recursive: true });
-        return path9.join(cacheDirectory, "codex-command-catalog.json");
+        const cacheDirectory = path11.join(baseDirectory, "cache");
+        await fs9.mkdir(cacheDirectory, { recursive: true });
+        return path11.join(cacheDirectory, "codex-command-catalog.json");
       })();
     }
     return codexCommandCatalogCacheFilePathPromise;
@@ -11304,7 +12642,7 @@ var startPandaSessionService = async ({
   const readCachedCodexCommandCatalog = async () => {
     const cacheFilePath = await getCodexCommandCatalogCacheFilePath();
     try {
-      const raw = await fs8.readFile(cacheFilePath, "utf8");
+      const raw = await fs9.readFile(cacheFilePath, "utf8");
       return codexCommandCatalogSchema.parse(JSON.parse(raw));
     } catch {
       return null;
@@ -11312,16 +12650,16 @@ var startPandaSessionService = async ({
   };
   const writeCachedCodexCommandCatalog = async (catalog) => {
     const cacheFilePath = await getCodexCommandCatalogCacheFilePath();
-    await fs8.writeFile(cacheFilePath, `${JSON.stringify(catalog, null, 2)}
+    await fs9.writeFile(cacheFilePath, `${JSON.stringify(catalog, null, 2)}
 `, "utf8");
   };
   const getCodexVisibleCommandsConfigFilePath = async () => {
     if (!codexVisibleCommandsConfigFilePathPromise) {
       codexVisibleCommandsConfigFilePathPromise = (async () => {
         const baseDirectory = await getPandaLocalBaseDirectory();
-        const configDirectory = path9.join(baseDirectory, "config");
-        await fs8.mkdir(configDirectory, { recursive: true });
-        return path9.join(configDirectory, "codex-visible-commands.json");
+        const configDirectory = path11.join(baseDirectory, "config");
+        await fs9.mkdir(configDirectory, { recursive: true });
+        return path11.join(configDirectory, "codex-visible-commands.json");
       })();
     }
     return codexVisibleCommandsConfigFilePathPromise;
@@ -11389,13 +12727,13 @@ var startPandaSessionService = async ({
   };
   const writeVisibleCodexCommandConfig = async (config) => {
     const configFilePath = await getCodexVisibleCommandsConfigFilePath();
-    await fs8.writeFile(configFilePath, `${JSON.stringify(config, null, 2)}
+    await fs9.writeFile(configFilePath, `${JSON.stringify(config, null, 2)}
 `, "utf8");
   };
   const readVisibleCodexCommandConfig = async () => {
     const configFilePath = await getCodexVisibleCommandsConfigFilePath();
     try {
-      const raw = await fs8.readFile(configFilePath, "utf8");
+      const raw = await fs9.readFile(configFilePath, "utf8");
       const parsed = parseVisibleCodexCommandConfig(JSON.parse(raw));
       if (parsed) {
         const migrated = migrateVisibleCodexCommandConfig(parsed);
@@ -11432,14 +12770,14 @@ var startPandaSessionService = async ({
   const extractJsonObject = (value) => {
     const trimmed = value.trim();
     if (!trimmed) {
-      throw new Error("Codex \u6CA1\u6709\u8FD4\u56DE\u547D\u4EE4\u8349\u7A3F\u3002");
+      throw new Error("Codex did not return a command draft.");
     }
     const fencedMatch = trimmed.match(/```(?:json)?\s*([\s\S]*?)```/i);
     const candidate = fencedMatch?.[1]?.trim() || trimmed;
     const firstBraceIndex = candidate.indexOf("{");
     const lastBraceIndex = candidate.lastIndexOf("}");
     if (firstBraceIndex < 0 || lastBraceIndex <= firstBraceIndex) {
-      throw new Error("Codex \u8FD4\u56DE\u7684\u547D\u4EE4\u8349\u7A3F\u4E0D\u662F\u6709\u6548 JSON\u3002");
+      throw new Error("Codex command draft is not valid JSON.");
     }
     return candidate.slice(firstBraceIndex, lastBraceIndex + 1);
   };
@@ -11604,7 +12942,7 @@ var startPandaSessionService = async ({
     ].join("\n");
   };
   function resolveCodexHomePath(codexHome2) {
-    return codexHome2?.trim() || path9.join(os6.homedir(), ".codex");
+    return codexHome2?.trim() || path11.join(os6.homedir(), ".codex");
   }
   function formatDiagnosticLogEntry(level, message, payload) {
     const lines = [
@@ -11616,9 +12954,9 @@ var startPandaSessionService = async ({
 `;
   }
   function createDiagnosticLogger(codexHome2, options) {
-    const filePath = path9.join(resolveCodexHomePath(codexHome2), options.relativePath);
-    let writeQueue = fs8.mkdir(path9.dirname(filePath), { recursive: true }).then(
-      () => fs8.writeFile(
+    const filePath = path11.join(resolveCodexHomePath(codexHome2), options.relativePath);
+    let writeQueue = fs9.mkdir(path11.dirname(filePath), { recursive: true }).then(
+      () => fs9.writeFile(
         filePath,
         formatDiagnosticLogEntry("INFO", options.initMessage, {
           filePath,
@@ -11628,7 +12966,7 @@ var startPandaSessionService = async ({
       )
     ).catch(() => void 0);
     const enqueueWrite = (level, message, payload) => {
-      writeQueue = writeQueue.catch(() => void 0).then(() => fs8.appendFile(filePath, formatDiagnosticLogEntry(level, message, payload), "utf8")).catch(() => void 0);
+      writeQueue = writeQueue.catch(() => void 0).then(() => fs9.appendFile(filePath, formatDiagnosticLogEntry(level, message, payload), "utf8")).catch(() => void 0);
     };
     return {
       filePath,
@@ -11650,17 +12988,17 @@ var startPandaSessionService = async ({
   }
   const basenameFromPath = (targetPath) => {
     const normalized = targetPath.replace(/[\\/]+$/, "");
-    return path9.basename(normalized) || normalized;
+    return path11.basename(normalized) || normalized;
   };
   const truncateSummary = (value, maxLength = 88) => {
     const trimmed = value.trim();
     if (trimmed.length <= maxLength) {
       return trimmed;
     }
-    return `${trimmed.slice(0, maxLength - 1).trimEnd()}\u2026`;
+    return `${trimmed.slice(0, maxLength - 1).trimEnd()}...`;
   };
   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();
+    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;
     }
@@ -11673,18 +13011,18 @@ var startPandaSessionService = async ({
     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 ? `First user message:
 ${message}` : null,
-      attachmentNames.length > 0 ? `\u9644\u4EF6\uFF1A
-${attachmentNames.map((name) => `- ${name}`).join("\n")}` : null
+      attachmentNames.length > 0 ? `Attachments:
+` + 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",
+      "Generate a short conversation title from the first message below.",
+      "Requirements:",
+      "1. Output only the title, without quotes or explanation.",
+      "2. Summarize the user goal accurately.",
+      "3. Keep it concise.",
+      "4. Avoid vague words like help, issue, chat, or new conversation.",
       "",
       ...contextParts
     ].join("\n");
@@ -11953,7 +13291,7 @@ ${attachmentNames.map((name) => `- ${name}`).join("\n")}` : null
     return nextOverlayEntries;
   };
   const readTimelineFromRollout = async (sessionId) => {
-    const { readCodexTimeline } = await import("./src-OBU4SE67.mjs");
+    const { readCodexTimeline } = await import("./src-NI7ZHUVP.mjs");
     return readCodexTimeline(sessionId, {
       codexHome,
       sessionFiles: discoveredSessionFiles
@@ -12045,7 +13383,7 @@ ${attachmentNames.map((name) => `- ${name}`).join("\n")}` : null
     }
     return {
       session_id: sessionId,
-      recovered_at: isoNow5(),
+      recovered_at: isoNow6(),
       session_patch: materialized.sessionPatch,
       timeline: materialized.timeline,
       interactions: materialized.interactions,
@@ -12054,16 +13392,8 @@ ${attachmentNames.map((name) => `- ${name}`).join("\n")}` : null
       terminal_snapshot: materialized.terminalSnapshot
     };
   };
-  const findLastUserTimelineEntryIndex = (entries) => {
-    for (let index = entries.length - 1; index >= 0; index -= 1) {
-      if (entries[index]?.kind === "user") {
-        return index;
-      }
-    }
-    return -1;
-  };
   const buildTailTimelineEntries = (entries) => {
-    const lastUserIndex = findLastUserTimelineEntryIndex(entries);
+    const lastUserIndex = findTailTimelineAnchorEntryIndex(entries);
     if (lastUserIndex < 0) {
       return {
         anchorEntryId: null,
@@ -12073,7 +13403,7 @@ ${attachmentNames.map((name) => `- ${name}`).join("\n")}` : null
     }
     return {
       anchorEntryId: entries[lastUserIndex]?.id ?? null,
-      hasEarlierEntries: lastUserIndex > 0,
+      hasEarlierEntries: hasEarlierVisibleConversationTurns(entries),
       entries: entries.slice(lastUserIndex)
     };
   };
@@ -12113,7 +13443,7 @@ ${attachmentNames.map((name) => `- ${name}`).join("\n")}` : null
     if (normalized.length <= limit) {
       return normalized;
     }
-    return `${normalized.slice(0, Math.max(0, limit - 1)).trimEnd()}\u2026`;
+    return `${normalized.slice(0, Math.max(0, limit - 1)).trimEnd()}...`;
   };
   const tryParseTimelineToolBody = (body) => {
     try {
@@ -12168,7 +13498,7 @@ ${attachmentNames.map((name) => `- ${name}`).join("\n")}` : null
       if (patchSummary.files.length === 1) {
         return truncateTimelineToolText(patchSummary.files[0].path);
       }
-      return `${patchSummary.files.length} \u4E2A\u6587\u4EF6`;
+      return `${patchSummary.files.length} files`;
     }
     const parsedBody = tryParseTimelineToolBody(entry.body);
     if (parsedBody) {
@@ -12186,7 +13516,7 @@ ${attachmentNames.map((name) => `- ${name}`).join("\n")}` : null
       }
       return truncateTimelineToolText(entry.body || entry.title);
     }
-    return truncateTimelineToolText(entry.body || "\u5DE5\u5177\u6267\u884C");
+    return truncateTimelineToolText(entry.body || "\u5BB8\u30E5\u53FF\u93B5\u0446\uE511");
   };
   const summarizeTimelineEntryTransport = (entry, options) => {
     if (entry.kind !== "tool") {
@@ -12246,7 +13576,7 @@ ${attachmentNames.map((name) => `- ${name}`).join("\n")}` : null
     ] : tail.entries;
     return {
       session_id: sessionId,
-      generated_at: isoNow5(),
+      generated_at: isoNow6(),
       view,
       anchor_entry_id: tail.anchorEntryId,
       has_earlier_entries: view === "full_compact" ? false : tail.hasEarlierEntries,
@@ -12319,7 +13649,7 @@ ${attachmentNames.map((name) => `- ${name}`).join("\n")}` : null
     }
     return {
       session_id: sessionId,
-      generated_at: isoNow5(),
+      generated_at: isoNow6(),
       session_patch: materialized.sessionPatch,
       timeline: buildTimelineSnapshot(
         sessionId,
@@ -12397,7 +13727,7 @@ ${attachmentNames.map((name) => `- ${name}`).join("\n")}` : null
   const readSessionCompletionTitle = (sessionId) => {
     const session = managedSessions.get(sessionId) ?? snapshot.sessions.find((item) => item.id === sessionId) ?? null;
     const title = session?.title?.trim();
-    return title || "\u5F53\u524D\u4F1A\u8BDD";
+    return title || "\u8930\u64B3\u58A0\u6D7C\u6C33\u763D";
   };
   const resolveCompletionReply = (input) => {
     if (input.completionReason !== "completed") {
@@ -12448,12 +13778,12 @@ ${attachmentNames.map((name) => `- ${name}`).join("\n")}` : null
   const formatCompletionPushBody = (value) => {
     const normalized = (typeof value === "string" ? value : "").replace(/\r\n/g, "\n").replace(/\s+/g, " ").trim();
     if (!normalized) {
-      return "\u70B9\u5F00\u67E5\u770B\u672C\u6B21\u4F1A\u8BDD\u7684\u6700\u7EC8\u56DE\u590D\u3002";
+      return "Open to view the final response.";
     }
     if (normalized.length <= COMPLETION_PUSH_BODY_MAX_LENGTH) {
       return normalized;
     }
-    return `${normalized.slice(0, COMPLETION_PUSH_BODY_MAX_LENGTH - 1).trimEnd()}\u2026`;
+    return `${normalized.slice(0, COMPLETION_PUSH_BODY_MAX_LENGTH - 1).trimEnd()}...`;
   };
   const notifyCompletionPush = async (payload) => {
     if (!hubPushSubscriptionStore || !hubWebPushNotifier?.publicConfig.supported) {
@@ -12464,7 +13794,7 @@ ${attachmentNames.map((name) => `- ${name}`).join("\n")}` : null
       return;
     }
     const notificationPayload = {
-      title: payload.sessionTitle || "Panda \u4F1A\u8BDD\u5DF2\u5B8C\u6210",
+      title: payload.sessionTitle || "Panda session completed",
       body: formatCompletionPushBody(payload.finalReply),
       url: `/session/${payload.sessionId}`,
       tag: `session-completed:${payload.sessionId}:${payload.completedAt}`,
@@ -12517,7 +13847,7 @@ ${attachmentNames.map((name) => `- ${name}`).join("\n")}` : null
     );
     if (result.ok) {
       hubPushSubscriptionStore.markDeliveryResult(endpoint, { success: true });
-      return { ok: true, deliveredAt: isoNow5() };
+      return { ok: true, deliveredAt: isoNow6() };
     }
     hubPushSubscriptionStore.markDeliveryResult(endpoint, {
       success: false,
@@ -12605,7 +13935,7 @@ ${attachmentNames.map((name) => `- ${name}`).join("\n")}` : null
       session_id: sessionId,
       change_set_id: changeSet.id,
       file: match,
-      empty_message: "\u6B64\u53D8\u66F4\u6CA1\u6709\u53EF\u5C55\u793A\u7684\u8865\u4E01\u5185\u5BB9"
+      empty_message: "No displayable patch content."
     };
   };
   const upsertSessionInteractions = (sessionId, incoming) => {
@@ -12722,8 +14052,23 @@ ${attachmentNames.map((name) => `- ${name}`).join("\n")}` : null
     }
     return Math.max(0, parsed);
   };
-  const buildWorkspaceProjectStats = (projects, sessions, selectedSessionId) => projects.map((project) => {
-    const projectSessions = sessions.filter((session) => session.project_id === project.id);
+  const isProjectlessSession = (session) => session.project_id.trim().length === 0;
+  const buildManagedSessionCapability = (options) => {
+    const archived = options?.archived === true;
+    const projectless = options?.projectless === true;
+    const live = options?.live ?? !archived;
+    return {
+      can_stream_live: archived ? false : live,
+      can_send_input: !archived,
+      can_interrupt: !archived,
+      can_approve: archived ? false : live,
+      can_reject: archived ? false : live,
+      can_show_git: projectless ? false : true,
+      can_show_terminal: projectless ? false : !archived
+    };
+  };
+  const buildWorkspaceProjectStatsEntry = (projectId, sessions, selectedSessionId) => {
+    const projectSessions = sessions.filter((session) => session.project_id === projectId);
     const visibleSessionCount = projectSessions.filter(
       (session) => !session.archived && isWorkspaceVisibleSession(session, selectedSessionId)
     ).length;
@@ -12732,12 +14077,22 @@ ${attachmentNames.map((name) => `- ${name}`).join("\n")}` : null
       (session) => !session.archived && !isWorkspaceVisibleSession(session, selectedSessionId)
     ).length;
     return {
-      project_id: project.id,
+      project_id: projectId,
       visible_session_count: visibleSessionCount,
       archived_session_count: archivedSessionCount,
       hidden_history_count: hiddenHistoryCount
     };
-  });
+  };
+  const buildWorkspaceProjectStats = (projects, sessions, selectedSessionId) => [
+    ...projects.map(
+      (project) => buildWorkspaceProjectStatsEntry(project.id, sessions, selectedSessionId)
+    ),
+    buildWorkspaceProjectStatsEntry(
+      PROJECTLESS_SESSION_PROJECT_ID,
+      sessions.filter((session) => isProjectlessSession(session)),
+      selectedSessionId
+    )
+  ];
   const toWorkspaceProjectDirectory = (project) => ({
     id: project.id,
     agent_id: project.agent_id,
@@ -12756,6 +14111,7 @@ ${attachmentNames.map((name) => `- ${name}`).join("\n")}` : null
     id: session.id,
     agent_id: session.agent_id,
     project_id: session.project_id,
+    provider: session.provider,
     archived: session.archived,
     title: session.title,
     last_event_at: session.last_event_at,
@@ -12785,6 +14141,20 @@ ${attachmentNames.map((name) => `- ${name}`).join("\n")}` : null
     context_usage: session.context_usage,
     capability: session.capability
   });
+  const resolveImageModelVendor = (channel, modelId) => channel?.models.find((model) => model.id === modelId)?.vendor ?? (modelId.toLowerCase().startsWith("grok-") ? "xai" : "openai");
+  const readImageSessionDetail = async (sessionId) => {
+    const record = findImageSessionRecord(sessionId);
+    if (!record) {
+      return null;
+    }
+    return {
+      generated_at: isoNow6(),
+      session: toWorkspaceSessionDetail(record.session),
+      turns: record.turns.map(
+        (turn) => imageSessionStore.toProtocolTurn(record, turn, buildImageAssetUrl)
+      )
+    };
+  };
   const buildHubDirectorySnapshot = () => ({
     generated_at: snapshot.generated_at,
     agents: snapshot.agents
@@ -12811,7 +14181,7 @@ ${attachmentNames.map((name) => `- ${name}`).join("\n")}` : null
     const projectIds = new Set(projects.map((project) => project.id));
     const agentSessions = sortSessionsByActivity2(
       snapshot.sessions.filter(
-        (session) => session.agent_id === localAgentId && projectIds.has(session.project_id)
+        (session) => session.agent_id === localAgentId && (isProjectlessSession(session) || projectIds.has(session.project_id))
       )
     );
     const sessions = agentSessions.filter(
@@ -12822,7 +14192,7 @@ ${attachmentNames.map((name) => `- ${name}`).join("\n")}` : null
     ) ?? null : null;
     const displayedSessions = selectedHiddenSession ? sortSessionsByActivity2([selectedHiddenSession, ...sessions]) : sessions;
     return {
-      generated_at: isoNow5(),
+      generated_at: isoNow6(),
       agent: (() => {
         const localAgent = snapshot.agents.find((agent) => agent.id === localAgentId) ?? null;
         return localAgent ? toWorkspaceAgentSummary(localAgent) : null;
@@ -12838,12 +14208,17 @@ ${attachmentNames.map((name) => `- ${name}`).join("\n")}` : null
     const offset = parseWorkspaceSessionCursor(input.cursor);
     const selectedSessionId = input.selectedSessionId?.trim() ?? "";
     const projectId = input.projectId?.trim() ?? "";
+    const projectless = input.projectless === true;
     const filteredSessions = sortSessionsByActivity2(
       snapshot.sessions.filter((session) => {
         if (session.agent_id !== localAgentId) {
           return false;
         }
-        if (projectId && session.project_id !== projectId) {
+        if (projectless) {
+          if (!isProjectlessSession(session)) {
+            return false;
+          }
+        } else if (projectId && session.project_id !== projectId) {
           return false;
         }
         if (input.bucket === "archived") {
@@ -12856,19 +14231,26 @@ ${attachmentNames.map((name) => `- ${name}`).join("\n")}` : null
     const nextOffset = offset + pageSessions.length;
     return {
       bucket: input.bucket,
-      project_id: projectId || null,
+      project_id: projectless ? PROJECTLESS_SESSION_PROJECT_ID : projectId || null,
       sessions: pageSessions.map(toWorkspaceSessionListItem),
       next_cursor: nextOffset < filteredSessions.length ? String(nextOffset) : null,
       total_count: filteredSessions.length
     };
   };
   const readWorkspaceSessionDetail = async (sessionId) => {
+    const imageDetail = await readImageSessionDetail(sessionId);
+    if (imageDetail) {
+      return {
+        generated_at: imageDetail.generated_at,
+        session: imageDetail.session
+      };
+    }
     const session = await findSnapshotSession(sessionId);
     if (!session) {
       return null;
     }
     return {
-      generated_at: isoNow5(),
+      generated_at: isoNow6(),
       session: toWorkspaceSessionDetail(session)
     };
   };
@@ -12910,7 +14292,7 @@ ${attachmentNames.map((name) => `- ${name}`).join("\n")}` : null
       }
       snapshot = {
         ...snapshot,
-        generated_at: isoNow5(),
+        generated_at: isoNow6(),
         agents: snapshot.agents.map((agent) => ({
           ...agent,
           project_count: nextProjectCounts.get(agent.id) ?? 0,
@@ -12923,7 +14305,7 @@ ${attachmentNames.map((name) => `- ${name}`).join("\n")}` : null
     }
     snapshot = {
       ...snapshot,
-      generated_at: isoNow5(),
+      generated_at: isoNow6(),
       agents: discoveredAgent ? [
         {
           ...discoveredAgent,
@@ -12992,7 +14374,7 @@ ${attachmentNames.map((name) => `- ${name}`).join("\n")}` : null
     }
   };
   const createCommandPanel = (input) => {
-    const submittedAt = input.submittedAt ?? isoNow5();
+    const submittedAt = input.submittedAt ?? isoNow6();
     return {
       panel_id: `command-panel-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
       session_id: input.sessionId,
@@ -13035,10 +14417,10 @@ ${attachmentNames.map((name) => `- ${name}`).join("\n")}` : null
   const refreshCodexCommandCatalog = async () => {
     if (!codexCommandCatalogRefreshPromise) {
       codexCommandCatalogRefreshPromise = (async () => {
-        const cliVersion = await detectCodexCliVersion();
+        const cliVersion = await detectCodexCliVersion2();
         const catalog = codexCommandCatalogSchema.parse({
           cli_version: cliVersion,
-          loaded_at: isoNow5(),
+          loaded_at: isoNow6(),
           cache_ttl_ms: 0,
           commands: await loadCodexCommandCatalog(cliVersion)
         });
@@ -13065,6 +14447,21 @@ ${attachmentNames.map((name) => `- ${name}`).join("\n")}` : null
     };
   };
   const renameSession = async (sessionId, nextName) => {
+    const imageSession = findImageSessionRecord(sessionId);
+    if (imageSession) {
+      await imageSessionStore.mutateSessionRef(sessionId, (session) => ({
+        ...session,
+        title: nextName
+      }));
+      syncImageSessionSnapshot(sessionId);
+      broadcastEvent("session.updated", {
+        sessionId,
+        sessionPatch: {
+          title: nextName
+        }
+      });
+      return;
+    }
     if (managedSessions.has(sessionId)) {
       const managedSession = managedSessions.get(sessionId);
       managedSessions.set(sessionId, {
@@ -13096,28 +14493,276 @@ ${attachmentNames.map((name) => `- ${name}`).join("\n")}` : null
     });
     try {
       const generated = await liveSessionStream.runOneShotPrompt({
-        cwd: input.project.path,
+        cwd: input.cwd,
         prompt,
         model: input.model,
-        timeoutMs: SESSION_TITLE_GENERATION_TIMEOUT_MS
+        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 ?? PROJECTLESS_SESSION_PROJECT_ID,
+        projectPath: input.cwd,
+        model: input.model,
+        error: error instanceof Error ? error.message : "Unknown error"
+      }, "Failed to generate background session title.");
+    }
+  };
+  const shouldGenerateImageSessionTitle = (session, turnCount) => turnCount === 0 && IMAGE_SESSION_AUTO_TITLE_PLACEHOLDERS.has(session.title.trim());
+  const submitImageSessionPrompt = async (input) => {
+    const sessionRecord = findImageSessionRecord(input.sessionId);
+    if (!sessionRecord) {
+      throw new Error("Image session not found.");
+    }
+    if (sessionRecord.session.archived) {
+      throw new Error("Archived image sessions cannot accept new input.");
+    }
+    const storedSettings = imageSessionStore.getSettings();
+    const activeChannel = imageSessionStore.getActiveSettingsChannel();
+    const resolvedSettings = buildResolvedImageProviderSettings({
+      activeChannelId: storedSettings.active_channel_id,
+      channels: storedSettings.channels.map((channel) => ({
+        id: channel.id,
+        remark: channel.remark,
+        baseUrl: channel.base_url,
+        storedApiKey: channel.api_key,
+        models: channel.models,
+        updatedAt: channel.updated_at
+      })),
+      updatedAt: storedSettings.updated_at
+    });
+    const apiKey = activeChannel?.api_key?.trim() || resolveImageProviderApiKey();
+    if (!apiKey) {
+      throw new Error("No image API key found. Configure one in settings or environment variables.");
+    }
+    const resolvedVendor = resolveImageModelVendor(activeChannel, input.model);
+    const effectiveModeration = resolvedVendor === "openai" ? input.moderation : "auto";
+    if (resolvedVendor === "xai" && (input.size === "3840x2160" || input.size === "2160x3840")) {
+      throw new Error("xAI \u5F53\u524D\u56FE\u7247 API \u4EC5\u652F\u6301 1k / 2k \u5206\u8FA8\u7387\uFF0C\u6682\u4E0D\u652F\u6301 4K \u8F93\u51FA\u3002");
+    }
+    const sourceAssets = [];
+    let maskAsset = null;
+    let maskedSourceAssetId = null;
+    for (const source of input.sources) {
+      if (source.kind === "upload") {
+        if (!source.data_url) {
+          throw new Error(`Uploaded image ${source.name} is missing content.`);
+        }
+        const savedAsset = await imageSessionStore.saveDataUrlAsset({
+          sessionId: input.sessionId,
+          kind: "source",
+          name: source.name,
+          dataUrl: source.data_url,
+          mimeType: source.mime_type ?? null
+        });
+        sourceAssets.push(savedAsset);
+        if (!maskAsset && source.mask_data_url) {
+          maskAsset = await imageSessionStore.saveDataUrlAsset({
+            sessionId: input.sessionId,
+            kind: "mask",
+            name: `${source.name}-mask.png`,
+            dataUrl: source.mask_data_url,
+            mimeType: "image/png"
+          });
+          maskedSourceAssetId = savedAsset.id;
+        }
+        continue;
+      }
+      const existing = source.asset_id ? findImageAssetRecordById(source.asset_id)?.asset ?? null : null;
+      if (!existing) {
+        throw new Error(`Referenced image ${source.name} was not found.`);
+      }
+      sourceAssets.push(existing);
+      if (!maskAsset && source.mask_data_url) {
+        maskAsset = await imageSessionStore.saveDataUrlAsset({
+          sessionId: input.sessionId,
+          kind: "mask",
+          name: `${source.name}-mask.png`,
+          dataUrl: source.mask_data_url,
+          mimeType: "image/png"
+        });
+        maskedSourceAssetId = existing.id;
+      }
+    }
+    const orderedSourceAssets = maskedSourceAssetId ? [
+      ...sourceAssets.filter((asset) => asset.id === maskedSourceAssetId),
+      ...sourceAssets.filter((asset) => asset.id !== maskedSourceAssetId)
+    ] : sourceAssets;
+    const operation = orderedSourceAssets.length > 0 ? "edit" : "generate";
+    const shouldGenerateTitle = shouldGenerateImageSessionTitle(
+      sessionRecord.session,
+      sessionRecord.turns.length
+    );
+    const appendTargetTurn = input.appendToTurnId ? sessionRecord.turns.find((turn) => turn.id === input.appendToTurnId) ?? null : null;
+    if (input.appendToTurnId && !appendTargetTurn) {
+      throw new Error("Image turn not found.");
+    }
+    if (appendTargetTurn && appendTargetTurn.status !== "completed") {
+      throw new Error("Only completed image turns can be refreshed.");
+    }
+    const startedRecord = appendTargetTurn ? await imageSessionStore.mutateSessionRef(input.sessionId, (current) => ({
+      ...current,
+      latest_assistant_message: appendTargetTurn.operation === "edit" ? "Editing image..." : "Generating image...",
+      last_event_at: isoNow6(),
+      run_state: "running",
+      run_state_changed_at: isoNow6(),
+      capability: {
+        ...current.capability,
+        can_send_input: false
+      }
+    })) : await imageSessionStore.startTurn({
+      sessionId: input.sessionId,
+      prompt: input.prompt,
+      operation,
+      model: input.model,
+      quality: input.quality,
+      size: input.size,
+      inputFidelity: input.inputFidelity,
+      aspectRatio: input.aspectRatio,
+      outputFormat: input.outputFormat,
+      outputCompression: input.outputCompression,
+      background: input.background,
+      moderation: effectiveModeration,
+      n: input.n,
+      sourceAssetIds: orderedSourceAssets.map((asset) => asset.id)
+    });
+    const startedTurn = appendTargetTurn ?? startedRecord.turns[startedRecord.turns.length - 1];
+    if (!startedTurn) {
+      throw new Error("Unable to create image session turn.");
+    }
+    syncImageSessionSnapshot(input.sessionId);
+    broadcastEvent("session.updated", {
+      sessionId: input.sessionId,
+      sessionPatch: {
+        run_state: "running",
+        run_state_changed_at: startedRecord.session.run_state_changed_at,
+        last_event_at: startedRecord.session.last_event_at,
+        summary: startedRecord.session.summary,
+        latest_assistant_message: startedRecord.session.latest_assistant_message
+      }
+    });
+    try {
+      const providerInputs = await Promise.all(
+        orderedSourceAssets.map(async (asset) => ({
+          name: asset.name,
+          mimeType: asset.mime_type ?? toMimeTypeFromFilename(asset.name),
+          buffer: await fs9.readFile(imageSessionStore.resolveAssetAbsolutePath(asset))
+        }))
+      );
+      const providerMask = maskAsset ? {
+        name: maskAsset.name,
+        mimeType: maskAsset.mime_type ?? "image/png",
+        buffer: await fs9.readFile(imageSessionStore.resolveAssetAbsolutePath(maskAsset))
+      } : null;
+      const providerResult = await submitImageRequest({
+        baseUrl: resolveImageProviderBaseUrl(activeChannel?.base_url ?? resolvedSettings.base_url),
+        apiKey,
+        prompt: input.prompt,
+        model: input.model,
+        vendor: resolvedVendor,
+        quality: input.quality,
+        size: input.size,
+        inputFidelity: input.inputFidelity,
+        aspectRatio: input.aspectRatio,
+        outputFormat: input.outputFormat,
+        outputCompression: input.outputCompression,
+        background: input.background,
+        moderation: effectiveModeration,
+        n: input.n,
+        inputs: providerInputs,
+        mask: providerMask
       });
-      const nextTitle = sanitizeGeneratedSessionTitle(generated);
-      if (!nextTitle || nextTitle === input.fallbackTitle) {
-        return;
+      const outputAssetIds = [];
+      for (const output of providerResult.outputs) {
+        const savedOutput = await imageSessionStore.saveBufferAsset({
+          sessionId: input.sessionId,
+          turnId: startedTurn.id,
+          kind: "generated",
+          name: output.name,
+          buffer: output.buffer,
+          mimeType: output.mimeType
+        });
+        outputAssetIds.push(savedOutput.id);
       }
-      const currentSession = await findSnapshotSession(input.sessionId);
-      if (!currentSession || currentSession.title !== input.fallbackTitle) {
-        return;
+      await imageSessionStore.finishTurn({
+        sessionId: input.sessionId,
+        turnId: startedTurn.id,
+        status: "completed",
+        outputAssetIds,
+        appendOutputs: Boolean(appendTargetTurn)
+      });
+      syncImageSessionSnapshot(input.sessionId);
+      const detail = await readImageSessionDetail(input.sessionId);
+      if (!detail) {
+        throw new Error("Unable to load image session detail.");
       }
-      await renameSession(input.sessionId, nextTitle);
-    } catch (error) {
-      diagnosticLogger.warn({
+      broadcastEvent("session.updated", {
         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.");
+        sessionPatch: {
+          run_state: detail.session.run_state,
+          run_state_changed_at: detail.session.run_state_changed_at,
+          last_event_at: detail.session.last_event_at,
+          latest_assistant_message: detail.session.latest_assistant_message
+        }
+      });
+      if (shouldGenerateTitle) {
+        const baseDirectory = await getPandaLocalBaseDirectory();
+        void generateSessionTitleInBackground({
+          sessionId: input.sessionId,
+          project: null,
+          cwd: baseDirectory,
+          fallbackTitle: sessionRecord.session.title,
+          message: input.prompt,
+          attachments: [],
+          model: DEFAULT_SESSION_TITLE_GENERATION_MODEL
+        });
+      }
+      return detail;
+    } catch (error) {
+      if (appendTargetTurn) {
+        await imageSessionStore.mutateSessionRef(input.sessionId, (current) => ({
+          ...current,
+          latest_assistant_message: `Generated ${appendTargetTurn.output_asset_ids.length} image(s)`,
+          last_event_at: isoNow6(),
+          run_state: "completed",
+          run_state_changed_at: isoNow6(),
+          capability: {
+            ...current.capability,
+            can_send_input: !current.archived
+          }
+        }));
+      } else {
+        await imageSessionStore.finishTurn({
+          sessionId: input.sessionId,
+          turnId: startedTurn.id,
+          status: "failed",
+          error: error instanceof Error ? error.message : "Image request failed.",
+          outputAssetIds: []
+        });
+      }
+      syncImageSessionSnapshot(input.sessionId);
+      const detail = await readImageSessionDetail(input.sessionId);
+      if (detail) {
+        broadcastEvent("session.updated", {
+          sessionId: input.sessionId,
+          sessionPatch: {
+            run_state: detail.session.run_state,
+            run_state_changed_at: detail.session.run_state_changed_at,
+            last_event_at: detail.session.last_event_at,
+            latest_assistant_message: detail.session.latest_assistant_message
+          }
+        });
+      }
+      throw error;
     }
   };
   const executeSessionCommand = async (session, project, rawInput) => {
@@ -13127,9 +14772,9 @@ ${attachmentNames.map((name) => `- ${name}`).join("\n")}` : null
         sessionId: session.id,
         commandName: "unknown",
         commandText: rawInput,
-        title: "\u65E0\u6CD5\u8BC6\u522B\u547D\u4EE4",
+        title: "Unknown command",
         status: "failed",
-        body: "\u53EA\u6709\u4EE5 / \u5F00\u5934\u7684\u9996\u4E2A\u8BCD\u4F1A\u88AB\u8BC6\u522B\u4E3A\u547D\u4EE4\u3002"
+        body: "Only input starting with / is recognized as a command."
       });
     }
     const catalog = await readCodexCommandCatalog();
@@ -13139,9 +14784,9 @@ ${attachmentNames.map((name) => `- ${name}`).join("\n")}` : null
         sessionId: session.id,
         commandName: parsed.name,
         commandText: parsed.raw,
-        title: `\u672A\u8BC6\u522B /${parsed.name}`,
+        title: `Unknown command /${parsed.name}`,
         status: "failed",
-        body: "Panda \u8FD8\u6CA1\u6709\u8BC6\u522B\u5230\u8FD9\u4E2A Codex \u547D\u4EE4\u3002"
+        body: "Panda does not recognize this Codex command yet."
       });
     }
     if (command.availability === "unsupported") {
@@ -13149,10 +14794,10 @@ ${attachmentNames.map((name) => `- ${name}`).join("\n")}` : null
         sessionId: session.id,
         commandName: command.name,
         commandText: parsed.raw,
-        title: `/${command.name} \u6682\u672A\u63A5\u5165`,
+        title: `/${command.name} is not implemented`,
         description: command.description,
         status: "completed",
-        body: "\u547D\u4EE4\u76EE\u5F55\u5DF2\u7ECF\u63A5\u5165\uFF0C\u4F46\u8FD9\u4E2A\u547D\u4EE4\u7684\u6267\u884C\u6D41\u8FD8\u6CA1\u6709\u5728 Panda \u4E2D\u5B9E\u73B0\u3002"
+        body: "This command is listed but not implemented in Panda yet."
       });
     }
     if (command.name === "status") {
@@ -13162,17 +14807,17 @@ ${attachmentNames.map((name) => `- ${name}`).join("\n")}` : null
         sessionId: session.id,
         commandName: command.name,
         commandText: parsed.raw,
-        title: "\u5F53\u524D\u4F1A\u8BDD\u72B6\u6001",
+        title: "Current session status",
         description: command.description,
         status: "completed",
         body: [
-          `\u4F1A\u8BDD\uFF1A${session.title}`,
-          `\u8FD0\u884C\u72B6\u6001\uFF1A${session.run_state === "running" ? "\u8FD0\u884C\u4E2D" : session.run_state === "completed" ? "\u5DF2\u5B8C\u6210" : "\u7A7A\u95F2"}`,
-          `\u6A21\u578B\uFF1A${config.model ?? "\u672A\u8BBE\u7F6E"}`,
-          `\u63A8\u7406\u5F3A\u5EA6\uFF1A${config.reasoningEffort ?? "\u9ED8\u8BA4"}`,
-          `\u786E\u8BA4\u7B56\u7565\uFF1A${config.approvalPolicy ?? "\u9ED8\u8BA4"}`,
-          `\u6C99\u7BB1\u6A21\u5F0F\uFF1A${config.sandboxMode ?? "\u9ED8\u8BA4"}`,
-          usage ? `\u4E0A\u4E0B\u6587\u7A97\u53E3\uFF1A${usage.used_tokens}/${usage.total_tokens}\uFF08${usage.percent_used.toFixed(1)}%\uFF09` : "\u4E0A\u4E0B\u6587\u7A97\u53E3\uFF1A\u6682\u65E0\u6570\u636E"
+          `Session: ${session.title}`,
+          `Run state: ${session.run_state}`,
+          `Model: ${config.model ?? "unset"}`,
+          `Reasoning effort: ${config.reasoningEffort ?? "default"}`,
+          `Approval policy: ${config.approvalPolicy ?? "default"}`,
+          `Sandbox mode: ${config.sandboxMode ?? "default"}`,
+          usage ? `Context: ${usage.used_tokens}/${usage.total_tokens} (${usage.percent_used.toFixed(1)}%)` : "Context: unavailable"
         ].join("\n")
       });
     }
@@ -13182,10 +14827,10 @@ ${attachmentNames.map((name) => `- ${name}`).join("\n")}` : null
         sessionId: session.id,
         commandName: command.name,
         commandText: parsed.raw,
-        title: `\u6280\u80FD\u5217\u8868 (${skills.length})`,
+        title: `Skills (${skills.length})`,
         description: command.description,
         status: "completed",
-        body: skills.length > 0 ? skills.map((skill) => `$${skill.name}  ${skill.description}`.trim()).join("\n") : "\u5F53\u524D\u9879\u76EE\u6CA1\u6709\u53EF\u7528\u6280\u80FD\u3002"
+        body: skills.length > 0 ? skills.map((skill) => `$${skill.name}  ${skill.description}`.trim()).join("\n") : "No project skills are currently available."
       });
     }
     if (command.name === "mcp") {
@@ -13194,7 +14839,7 @@ ${attachmentNames.map((name) => `- ${name}`).join("\n")}` : null
         sessionId: session.id,
         commandName: command.name,
         commandText: parsed.raw,
-        title: `MCP \u670D\u52A1 (${servers.length})`,
+        title: `MCP servers (${servers.length})`,
         description: command.description,
         status: "completed",
         body: servers.length > 0 ? servers.map(
@@ -13203,8 +14848,8 @@ ${attachmentNames.map((name) => `- ${name}`).join("\n")}` : null
             `${server.toolCount} tools`,
             `${server.resourceCount} resources`,
             server.authStatus ? `auth: ${server.authStatus}` : null
-          ].filter(Boolean).join(" \xB7 ")
-        ).join("\n") : "\u5F53\u524D\u6CA1\u6709\u53EF\u7528\u7684 MCP \u670D\u52A1\u3002"
+          ].filter(Boolean).join(" ? ")
+        ).join("\n") : "No MCP servers are available."
       });
     }
     if (command.name === "compact") {
@@ -13213,10 +14858,10 @@ ${attachmentNames.map((name) => `- ${name}`).join("\n")}` : null
         sessionId: session.id,
         commandName: command.name,
         commandText: parsed.raw,
-        title: "\u5DF2\u63D0\u4EA4\u4E0A\u4E0B\u6587\u538B\u7F29",
+        title: "Context compaction requested",
         description: command.description,
         status: "completed",
-        body: "\u538B\u7F29\u8BF7\u6C42\u5DF2\u7ECF\u63D0\u4EA4\u7ED9 Codex\uFF0C\u540E\u7EED\u7ED3\u679C\u4F1A\u7EE7\u7EED\u4F53\u73B0\u5728\u5F53\u524D\u4F1A\u8BDD\u91CC\u3002"
+        body: "The compaction request has been sent to Codex."
       });
     }
     if (command.name === "rename") {
@@ -13226,23 +14871,23 @@ ${attachmentNames.map((name) => `- ${name}`).join("\n")}` : null
           sessionId: session.id,
           commandName: command.name,
           commandText: parsed.raw,
-          title: "\u4F1A\u8BDD\u5DF2\u91CD\u547D\u540D",
+          title: "Session renamed",
           description: command.description,
           status: "completed",
-          body: `\u5F53\u524D\u4F1A\u8BDD\u5DF2\u91CD\u547D\u540D\u4E3A \u201C${parsed.args}\u201D\u3002`
+          body: `Current session renamed to ${parsed.args}.`
         });
       }
       const panel = createCommandPanel({
         sessionId: session.id,
         commandName: command.name,
         commandText: parsed.raw,
-        title: "\u91CD\u547D\u540D\u5F53\u524D\u4F1A\u8BDD",
+        title: "Rename current session",
         description: command.description,
         status: "awaiting_input",
-        body: "\u8F93\u5165\u65B0\u7684\u4F1A\u8BDD\u540D\u79F0\uFF0C\u7136\u540E\u5728\u8FD9\u4E2A\u9762\u677F\u91CC\u76F4\u63A5\u63D0\u4EA4\u3002",
+        body: "Enter a new session name, then submit it in this panel.",
         inputType: "text",
-        inputPlaceholder: "\u8F93\u5165\u65B0\u7684\u4F1A\u8BDD\u540D\u79F0",
-        submitLabel: "\u91CD\u547D\u540D"
+        inputPlaceholder: "Enter a new session name",
+        submitLabel: "Rename"
       });
       return storeCommandPanel(panel, {
         mode: "rename",
@@ -13255,10 +14900,10 @@ ${attachmentNames.map((name) => `- ${name}`).join("\n")}` : null
         sessionId: session.id,
         commandName: command.name,
         commandText: parsed.raw,
-        title: "\u9009\u62E9\u6A21\u578B",
-        description: "\u9009\u62E9\u540E\u4F1A\u66F4\u65B0 Panda \u5F53\u524D\u4F1A\u8BDD\u540E\u7EED\u53D1\u9001\u65F6\u4F7F\u7528\u7684\u6A21\u578B\u3002",
+        title: "Select model",
+        description: "Choose the model used for future messages in this Panda session.",
         status: "awaiting_input",
-        body: models.length > 0 ? "\u7EE7\u7EED\u5728\u5217\u8868\u91CC\u9009\u62E9\u4E00\u4E2A\u6A21\u578B\uFF0C\u9762\u677F\u4F1A\u76F4\u63A5\u66F4\u65B0\u7ED3\u679C\u3002" : "\u5F53\u524D\u6CA1\u6709\u53EF\u7528\u6A21\u578B\u3002",
+        body: models.length > 0 ? "Select one model from the list to update the session." : "No models are currently available.",
         inputType: models.length > 0 ? "choice" : "none",
         options: models.map((model) => ({
           id: model.id,
@@ -13275,29 +14920,29 @@ ${attachmentNames.map((name) => `- ${name}`).join("\n")}` : null
       sessionId: session.id,
       commandName: command.name,
       commandText: parsed.raw,
-      title: `/${command.name} \u5DF2\u8BC6\u522B`,
+      title: "/" + command.name + " recognized",
       description: command.description,
       status: "completed",
-      body: "\u547D\u4EE4\u76EE\u5F55\u5DF2\u7ECF\u63A5\u5165\uFF0C\u4F46\u8FD9\u4E2A\u547D\u4EE4\u7684\u6267\u884C\u6D41\u8FD8\u6CA1\u6709\u5728 Panda \u4E2D\u5B9E\u73B0\u3002"
+      body: "This command is recognized but not implemented in Panda yet."
     });
   };
   const respondToSessionCommand = async (input) => {
     const stored = readStoredCommandPanel(input.sessionId, input.panelId);
     if (!stored) {
-      throw new Error("\u547D\u4EE4\u9762\u677F\u5DF2\u5931\u6548\uFF0C\u8BF7\u91CD\u65B0\u6267\u884C\u8BE5\u547D\u4EE4\u3002");
+      throw new Error("Command panel has expired. Run the command again.");
     }
     if (stored.mode === "rename") {
       const nextName = input.text?.trim() ?? "";
       if (!nextName) {
-        throw new Error("\u8BF7\u8F93\u5165\u65B0\u7684\u4F1A\u8BDD\u540D\u79F0\u3002");
+        throw new Error("Please enter a new session name.");
       }
       await renameSession(input.sessionId, nextName);
       clearStoredCommandPanel(input.panelId);
       return {
         ...stored.panel,
         status: "completed",
-        body: `\u5F53\u524D\u4F1A\u8BDD\u5DF2\u91CD\u547D\u540D\u4E3A \u201C${nextName}\u201D\u3002`,
-        updated_at: isoNow5(),
+        body: "Current session renamed to " + nextName + ".",
+        updated_at: isoNow6(),
         input_type: "none",
         input_placeholder: null,
         submit_label: null
@@ -13306,22 +14951,22 @@ ${attachmentNames.map((name) => `- ${name}`).join("\n")}` : null
     if (stored.mode === "model") {
       const selectedModelId = input.optionId?.trim() ?? "";
       if (!selectedModelId) {
-        throw new Error("\u8BF7\u9009\u62E9\u4E00\u4E2A\u6A21\u578B\u3002");
+        throw new Error("Please select a model.");
       }
       const models = await liveSessionStream.listModels();
       const selectedModel = models.find((model) => model.id === selectedModelId);
       if (!selectedModel) {
-        throw new Error("\u6240\u9009\u6A21\u578B\u5DF2\u5931\u6548\uFF0C\u8BF7\u91CD\u65B0\u6253\u5F00 /model\u3002");
+        throw new Error("Selected model is no longer available. Reopen /model.");
       }
       clearStoredCommandPanel(input.panelId);
       return {
         ...stored.panel,
         status: "completed",
         body: [
-          `\u540E\u7EED\u6D88\u606F\u5C06\u4F18\u5148\u4F7F\u7528 ${selectedModel.label}\u3002`,
-          selectedModel.defaultReasoningEffort ? `\u9ED8\u8BA4\u63A8\u7406\u5F3A\u5EA6\uFF1A${selectedModel.defaultReasoningEffort}` : null
+          "Future messages will prefer " + selectedModel.label + ".",
+          selectedModel.defaultReasoningEffort ? "Default reasoning effort: " + selectedModel.defaultReasoningEffort : null
         ].filter(Boolean).join("\n"),
-        updated_at: isoNow5(),
+        updated_at: isoNow6(),
         input_type: "none",
         options: [],
         effect: {
@@ -13335,8 +14980,8 @@ ${attachmentNames.map((name) => `- ${name}`).join("\n")}` : null
     return {
       ...stored.panel,
       status: "failed",
-      body: "\u8FD9\u4E2A\u547D\u4EE4\u9762\u677F\u4E0D\u63A5\u53D7\u540E\u7EED\u8F93\u5165\u3002",
-      updated_at: isoNow5(),
+      body: "This command panel does not accept input.",
+      updated_at: isoNow6(),
       input_type: "none",
       options: []
     };
@@ -13459,7 +15104,7 @@ ${attachmentNames.map((name) => `- ${name}`).join("\n")}` : null
         lastSnapshotRefreshAt = Date.now();
         return snapshot;
       }
-      const { discoverLocalCodexData } = await import("./src-OBU4SE67.mjs");
+      const { discoverLocalCodexData } = await import("./src-NI7ZHUVP.mjs");
       const discovery = await discoverLocalCodexData({
         agentId: localAgentId,
         agentName: localAgentName,
@@ -13472,6 +15117,7 @@ ${attachmentNames.map((name) => `- ${name}`).join("\n")}` : null
         transport
       });
       discoveredAgent = discovery.agent;
+      discoveredAgent.provider_availability = ["codex", "image"];
       discoveredSessionFiles = discovery.sessionFiles;
       const mergedProjects = /* @__PURE__ */ new Map();
       for (const project of discovery.projects) {
@@ -13492,13 +15138,16 @@ ${attachmentNames.map((name) => `- ${name}`).join("\n")}` : null
       for (const session of managedSessions.values()) {
         mergedSessions.set(session.id, applyLiveTrackerPatch(session));
       }
+      for (const session of getImageSessionRefs()) {
+        mergedSessions.set(session.id, session);
+      }
       const threadPrefs = await readPandaThreadPrefs(codexHome);
       const orderedProjects = sortByStoredWorkspaceOrder(
         [...mergedProjects.values()],
         getOrderedWorkspaceRoots(threadPrefs)
       );
       snapshot = {
-        generated_at: isoNow5(),
+        generated_at: isoNow6(),
         agents: [],
         projects: orderedProjects,
         sessions: [...mergedSessions.values()],
@@ -13535,18 +15184,46 @@ ${attachmentNames.map((name) => `- ${name}`).join("\n")}` : null
     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 getImageSessionRefs = () => imageSessionStore.listSessions().map((record) => record.session);
+  const findImageSessionRecord = (sessionId) => imageSessionStore.getSession(sessionId);
+  const buildImageAssetUrl = (assetId) => {
+    const baseUrl = directBaseUrl?.trim() || discoveredAgent?.direct_base_url?.trim() || "";
+    const pathname = "/api/image-assets/" + encodeURIComponent(assetId);
+    return baseUrl ? baseUrl.replace(/\/+$/, "") + pathname : pathname;
+  };
+  const syncImageSessionSnapshot = (sessionId) => {
+    const record = findImageSessionRecord(sessionId);
+    if (!record) {
+      removeSnapshotSessions([sessionId]);
+      return false;
+    }
+    upsertSnapshotSession(record.session);
+    return true;
+  };
+  const findImageAssetRecordById = (assetId) => {
+    for (const session of imageSessionStore.listSessions()) {
+      const asset = session.assets.find((entry) => entry.id === assetId);
+      if (asset) {
+        return {
+          session,
+          asset
+        };
+      }
+    }
+    return null;
+  };
   const readSessionFilePreviewTree = async (session, project, requestedPath) => {
     const resolved = await resolveSessionFilePreviewPath(project.path, requestedPath);
-    const stat = await fs8.stat(resolved.realPath).catch((error) => {
+    const stat = await fs9.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");
+      throw new Error("Target path is not a directory.");
     }
-    const entries = await fs8.readdir(resolved.realPath, {
+    const entries = await fs9.readdir(resolved.realPath, {
       withFileTypes: true
     });
     const nodes = (await Promise.all(
@@ -13570,21 +15247,21 @@ ${attachmentNames.map((name) => `- ${name}`).join("\n")}` : null
       root_path: SESSION_FILE_PREVIEW_ROOT_PATH,
       parent_path: resolved.normalizedPath || null,
       nodes,
-      loaded_at: isoNow5()
+      loaded_at: isoNow6()
     };
   };
   const readSessionFilePreviewContent = async (session, project, requestedPath) => {
     const resolved = await resolveSessionFilePreviewPath(project.path, requestedPath);
-    const stat = await fs8.stat(resolved.realPath).catch((error) => {
+    const stat = await fs9.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");
+      throw new Error("Target path is not a file.");
     }
-    const fileName = path9.basename(resolved.normalizedPath || resolved.realPath);
+    const fileName = path11.basename(resolved.normalizedPath || resolved.realPath);
     const extension = normalizeSessionFilePreviewExtension(fileName);
     let fileKind = detectSessionFilePreviewKind(fileName, extension) ?? null;
     let previewBuffer = null;
@@ -13610,10 +15287,10 @@ ${attachmentNames.map((name) => `- ${name}`).join("\n")}` : null
           is_truncated: true,
           content_text: null,
           content_base64: null,
-          loaded_at: isoNow5()
+          loaded_at: isoNow6()
         };
       }
-      const buffer2 = await fs8.readFile(resolved.realPath);
+      const buffer2 = await fs9.readFile(resolved.realPath);
       return {
         session_id: session.id,
         project_id: project.id,
@@ -13627,7 +15304,7 @@ ${attachmentNames.map((name) => `- ${name}`).join("\n")}` : null
         is_truncated: false,
         content_text: null,
         content_base64: buffer2.toString("base64"),
-        loaded_at: isoNow5()
+        loaded_at: isoNow6()
       };
     }
     if (fileKind === "binary") {
@@ -13644,7 +15321,7 @@ ${attachmentNames.map((name) => `- ${name}`).join("\n")}` : null
         is_truncated: false,
         content_text: null,
         content_base64: null,
-        loaded_at: isoNow5()
+        loaded_at: isoNow6()
       };
     }
     const buffer = previewBuffer ?? await readPreviewBuffer(resolved.realPath, SESSION_FILE_PREVIEW_TEXT_BYTE_LIMIT);
@@ -13661,7 +15338,7 @@ ${attachmentNames.map((name) => `- ${name}`).join("\n")}` : null
       is_truncated: stat.size > SESSION_FILE_PREVIEW_TEXT_BYTE_LIMIT,
       content_text: buffer.toString("utf8"),
       content_base64: null,
-      loaded_at: isoNow5()
+      loaded_at: isoNow6()
     };
   };
   const validateHubControlPlaneAuth = (request) => {
@@ -13675,10 +15352,10 @@ ${attachmentNames.map((name) => `- ${name}`).join("\n")}` : null
   const ensureGitActionPath = (projectPath, targetPath) => {
     const nextPath = normalizeGitWorkspacePath(targetPath?.trim() ?? "");
     if (!nextPath) {
-      throw new Error("\u7F3A\u5C11\u76EE\u6807\u6587\u4EF6\u8DEF\u5F84\u3002");
+      throw new Error("Missing target file path.");
     }
     if (!isPathInsideProject(projectPath, nextPath)) {
-      throw new Error("\u76EE\u6807\u6587\u4EF6\u4E0D\u5728\u5F53\u524D\u5DE5\u4F5C\u533A\u4E2D\u3002");
+      throw new Error("Target file is outside the current workspace.");
     }
     return nextPath;
   };
@@ -13697,8 +15374,7 @@ ${attachmentNames.map((name) => `- ${name}`).join("\n")}` : null
   };
   const normalizeRollbackPatchText = (input) => {
     const normalized = input.replace(/\r\n/g, "\n").trim();
-    return normalized ? `${normalized}
-` : "";
+    return normalized ? normalized + "\n" : "";
   };
   const buildRollbackPatchText = (changeSet) => {
     if (changeSet.aggregated_diff.trim()) {
@@ -13716,35 +15392,35 @@ ${attachmentNames.map((name) => `- ${name}`).join("\n")}` : null
       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");
+          throw new Error("This change set contains paths outside the workspace.");
         }
       }
     }
   };
   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");
+      throw new Error("This change set is not completed yet.");
     }
     if (changeSet.files.length === 0) {
-      throw new Error("\u8FD9\u8F6E\u5BF9\u8BDD\u6CA1\u6709\u53EF\u56DE\u6EDA\u7684\u6587\u4EF6\u6539\u52A8\u3002");
+      throw new Error("This change set has no file changes to roll back.");
     }
     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");
+      throw new Error("This change set does not contain a reversible patch.");
     }
-    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");
+    const tempDir = await fs9.mkdtemp(path11.join(os6.tmpdir(), "panda-change-set-rollback-"));
+    const patchFilePath = path11.join(tempDir, "rollback.patch");
+    await fs9.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}`);
+      const reason = error instanceof Error && error.message.trim() ? error.message : "Git could not reverse-apply this patch.";
+      throw new Error("Unable to safely roll back this change: " + reason);
     } finally {
-      await fs8.rm(tempDir, { recursive: true, force: true }).catch(() => void 0);
+      await fs9.rm(tempDir, { recursive: true, force: true }).catch(() => void 0);
     }
   };
   const discardAllGitWorkspaceChanges = async (projectPath) => {
@@ -13756,7 +15432,7 @@ ${attachmentNames.map((name) => `- ${name}`).join("\n")}` : null
   const commitAllGitWorkspaceChanges = async (projectPath, message) => {
     const nextMessage = message.trim();
     if (!nextMessage) {
-      throw new Error("\u8BF7\u8F93\u5165\u63D0\u4EA4\u4FE1\u606F\u3002");
+      throw new Error("Please enter a commit message.");
     }
     await runGitCommand(projectPath, ["add", "-A"]);
     await runGitCommand(projectPath, ["commit", "-m", nextMessage]);
@@ -13764,7 +15440,7 @@ ${attachmentNames.map((name) => `- ${name}`).join("\n")}` : null
   const switchGitWorkspaceBranch = async (projectPath, branch) => {
     const nextBranch = branch.trim();
     if (!nextBranch) {
-      throw new Error("\u8BF7\u9009\u62E9\u8981\u5207\u6362\u7684\u5206\u652F\u3002");
+      throw new Error("Please select a branch.");
     }
     await runGitCommand(projectPath, ["switch", nextBranch]);
   };
@@ -13796,11 +15472,11 @@ ${attachmentNames.map((name) => `- ${name}`).join("\n")}` : null
     if (process.platform !== "win32") {
       return [os6.homedir()];
     }
-    const candidates = "ABCDEFGHIJKLMNOPQRSTUVWXYZ".split("").map((letter) => `${letter}:\\`);
+    const candidates = "ABCDEFGHIJKLMNOPQRSTUVWXYZ".split("").map((letter) => letter + ":\\");
     const checks = await Promise.all(
       candidates.map(async (candidate) => {
         try {
-          const stat = await fs8.stat(candidate);
+          const stat = await fs9.stat(candidate);
           return stat.isDirectory() ? candidate : null;
         } catch {
           return null;
@@ -13863,11 +15539,11 @@ ${attachmentNames.map((name) => `- ${name}`).join("\n")}` : null
   };
   const toDirectoryNode = async (targetPath) => {
     try {
-      const stat = await fs8.stat(targetPath);
+      const stat = await fs9.stat(targetPath);
       if (!stat.isDirectory()) {
         return null;
       }
-      const entries = await fs8.readdir(targetPath, { withFileTypes: true });
+      const entries = await fs9.readdir(targetPath, { withFileTypes: true });
       const hasChildren = entries.some((entry) => entry.isDirectory());
       return {
         path: targetPath,
@@ -13879,7 +15555,7 @@ ${attachmentNames.map((name) => `- ${name}`).join("\n")}` : null
     }
   };
   const listDirectories = async (targetPath) => {
-    const roots = !targetPath ? await listDriveRoots() : (await fs8.readdir(targetPath, { withFileTypes: true })).filter((entry) => entry.isDirectory()).map((entry) => path9.join(targetPath, entry.name));
+    const roots = !targetPath ? await listDriveRoots() : (await fs9.readdir(targetPath, { withFileTypes: true })).filter((entry) => entry.isDirectory()).map((entry) => path11.join(targetPath, entry.name));
     const nodes = await Promise.all(
       roots.sort((a, b) => a.localeCompare(b)).map(async (directoryPath) => toDirectoryNode(directoryPath))
     );
@@ -13894,15 +15570,15 @@ ${attachmentNames.map((name) => `- ${name}`).join("\n")}` : null
     if (!parentPath) {
       throw new Error("Parent directory path is required.");
     }
-    const resolvedParentPath = path9.resolve(parentPath);
-    const parentStat = await fs8.stat(resolvedParentPath).catch(() => null);
+    const resolvedParentPath = path11.resolve(parentPath);
+    const parentStat = await fs9.stat(resolvedParentPath).catch(() => null);
     if (!parentStat?.isDirectory()) {
       throw new Error("Parent directory does not exist.");
     }
     const directoryName = input.name.trim();
-    const targetPath = path9.join(resolvedParentPath, directoryName);
+    const targetPath = path11.join(resolvedParentPath, directoryName);
     try {
-      await fs8.mkdir(targetPath);
+      await fs9.mkdir(targetPath);
     } catch (error) {
       const errorCode = typeof error === "object" && error !== null && "code" in error ? String(error.code ?? "") : "";
       if (errorCode === "EEXIST") {
@@ -14002,7 +15678,8 @@ ${attachmentNames.map((name) => `- ${name}`).join("\n")}` : null
       can_interrupt: true,
       can_approve: true,
       can_reject: true,
-      can_show_terminal: true
+      can_show_git: session.capability.can_show_git,
+      can_show_terminal: session.capability.can_show_terminal
     }
   });
   const unarchiveManagedSession = (sessionId) => {
@@ -14093,7 +15770,7 @@ ${attachmentNames.map((name) => `- ${name}`).join("\n")}` : null
     service: serviceName,
     mode,
     provider: "codex",
-    timestamp: isoNow5()
+    timestamp: isoNow6()
   }));
   app.get("/api/dev-manager", async (request, reply) => {
     try {
@@ -14148,10 +15825,10 @@ ${attachmentNames.map((name) => `- ${name}`).join("\n")}` : null
       reply.header("cache-control", "no-store");
       reply.header(
         "content-disposition",
-        `attachment; filename="${download.artifact.file_name}"`
+        'attachment; filename="' + download.artifact.file_name + '"'
       );
       reply.type("application/vnd.android.package-archive");
-      return reply.send(await fs8.readFile(download.filePath));
+      return reply.send(await fs9.readFile(download.filePath));
     } catch (error) {
       reply.code(409);
       return {
@@ -14214,8 +15891,8 @@ ${attachmentNames.map((name) => `- ${name}`).join("\n")}` : null
       agent_id: registered.agent.id,
       heartbeat_interval_ms: HUB_AGENT_HEARTBEAT_INTERVAL_MS,
       heartbeat_timeout_ms: HUB_AGENT_HEARTBEAT_TIMEOUT_MS,
-      registered_at: registered.agent.registered_at ?? isoNow5(),
-      received_at: registered.agent.last_seen_at ?? isoNow5()
+      registered_at: registered.agent.registered_at ?? isoNow6(),
+      received_at: registered.agent.last_seen_at ?? isoNow6()
     };
   });
   app.post("/api/agents/heartbeat", async (request, reply) => {
@@ -14240,8 +15917,8 @@ ${attachmentNames.map((name) => `- ${name}`).join("\n")}` : null
       agent_id: registered.agent.id,
       heartbeat_interval_ms: HUB_AGENT_HEARTBEAT_INTERVAL_MS,
       heartbeat_timeout_ms: HUB_AGENT_HEARTBEAT_TIMEOUT_MS,
-      registered_at: registered.agent.registered_at ?? isoNow5(),
-      received_at: registered.agent.last_seen_at ?? isoNow5()
+      registered_at: registered.agent.registered_at ?? isoNow6(),
+      received_at: registered.agent.last_seen_at ?? isoNow6()
     };
   });
   app.post(
@@ -14335,10 +16012,10 @@ ${attachmentNames.map((name) => `- ${name}`).join("\n")}` : null
       return { error: "Invalid Web Push test payload." };
     }
     const delivered = await deliverWebPushToStoredSubscription(parsed.data.endpoint, {
-      title: "Panda \u6D4B\u8BD5\u63A8\u9001",
-      body: "\u8FD9\u662F\u4E00\u6761\u6765\u81EA Hub \u7684\u6D4B\u8BD5\u901A\u77E5\uFF0C\u8BF4\u660E\u540E\u53F0 Web Push \u94FE\u8DEF\u5DF2\u7ECF\u6253\u901A\u3002",
+      title: "Panda test push",
+      body: "This is a test notification from Hub.",
       url: "/",
-      tag: `panda-web-push-test:${Date.now()}`
+      tag: "panda-web-push-test:" + Date.now()
     });
     if (!delivered.ok) {
       reply.code(delivered.error === "Web Push subscription not found." ? 404 : 502);
@@ -14695,7 +16372,7 @@ ${attachmentNames.map((name) => `- ${name}`).join("\n")}` : null
         const targetPath = ensureGitActionPath(project.path, request.body.path);
         const targetFile = workspace.files.find((file) => file.path === targetPath) ?? null;
         if (!targetFile) {
-          throw new Error("\u76EE\u6807\u6587\u4EF6\u5F53\u524D\u6CA1\u6709\u5F85\u5904\u7406\u7684\u6539\u52A8\u3002");
+          throw new Error("Target file has no pending changes.");
         }
         await discardGitWorkspaceFile(project.path, targetFile);
       } else if (request.body.action === "discard-all") {
@@ -14706,16 +16383,16 @@ ${attachmentNames.map((name) => `- ${name}`).join("\n")}` : null
         const workspace = await readSessionGitWorkspace(session, project);
         const targetBranch = request.body.branch?.trim() ?? "";
         if (!targetBranch) {
-          throw new Error("\u8BF7\u9009\u62E9\u8981\u5207\u6362\u7684\u5206\u652F\u3002");
+          throw new Error("Please select a branch.");
         }
         if (workspace.branch === targetBranch) {
-          throw new Error("\u5F53\u524D\u5DF2\u7ECF\u5728\u8BE5\u5206\u652F\u3002");
+          throw new Error("Already on this branch.");
         }
         if (workspace.files.length > 0) {
-          throw new Error("\u5207\u6362\u5206\u652F\u524D\u8BF7\u5148\u63D0\u4EA4\u6216\u64A4\u56DE\u5F53\u524D\u5206\u652F\u6539\u52A8\u3002");
+          throw new Error("Commit or discard current changes before switching branches.");
         }
         if (!workspace.branches.includes(targetBranch)) {
-          throw new Error("\u76EE\u6807\u5206\u652F\u4E0D\u5B58\u5728\u3002");
+          throw new Error("Target branch does not exist.");
         }
         await switchGitWorkspaceBranch(project.path, targetBranch);
       } else if (request.body.action === "push") {
@@ -14817,7 +16494,7 @@ ${attachmentNames.map((name) => `- ${name}`).join("\n")}` : null
       });
       const generation = parseGeneratedRunCommandDrafts(raw);
       if (generation.commands.length === 0) {
-        throw new Error("Codex \u6CA1\u6709\u751F\u6210\u4EFB\u4F55\u53EF\u4FDD\u5B58\u7684\u9879\u76EE\u547D\u4EE4\u3002");
+        throw new Error("Codex did not generate any savable project commands.");
       }
       const catalog = await replaceGeneratedProjectRunCommands({
         sessionId,
@@ -14905,7 +16582,7 @@ ${attachmentNames.map((name) => `- ${name}`).join("\n")}` : null
       const generation = parseGeneratedRunWebsiteDrafts(raw);
       const normalizedWebsites = normalizeGeneratedWebsiteDrafts(generation.websites, request);
       if (normalizedWebsites.length === 0) {
-        throw new Error("Codex \u6CA1\u6709\u751F\u6210\u4EFB\u4F55\u53EF\u4FDD\u5B58\u7684\u7F51\u9875\u5730\u5740\u3002");
+        throw new Error("Codex did not generate any savable website URLs.");
       }
       const catalog = await replaceGeneratedProjectRunWebsites({
         sessionId,
@@ -14947,7 +16624,7 @@ ${attachmentNames.map((name) => `- ${name}`).join("\n")}` : null
       if (request.body.action === "run-command" || request.body.action === "run-kill-command") {
         const commandId = request.body.commandId?.trim() ?? "";
         if (!commandId) {
-          throw new Error("\u8BF7\u9009\u62E9\u8981\u8FD0\u884C\u7684\u547D\u4EE4\u3002");
+          throw new Error("Please select a command to run.");
         }
         const catalog = await readProjectRunCommandCatalog({
           sessionId,
@@ -14956,12 +16633,12 @@ ${attachmentNames.map((name) => `- ${name}`).join("\n")}` : null
         });
         const command = catalog.commands.find((item) => item.id === commandId);
         if (!command) {
-          throw new Error("\u76EE\u6807\u547D\u4EE4\u4E0D\u5B58\u5728\u3002");
+          throw new Error("Target command does not exist.");
         }
         const isKillAction = request.body.action === "run-kill-command";
         const killCommand = command.kill_command?.trim() ?? "";
         if (isKillAction && !killCommand) {
-          throw new Error("\u8BE5\u547D\u4EE4\u6CA1\u6709\u53EF\u6267\u884C\u7684\u505C\u6B62\u547D\u4EE4\u3002");
+          throw new Error("This command has no executable stop command.");
         }
         const resolved = await resolveRunCommandExecution(project.path, command, {
           overrideCommand: isKillAction ? killCommand : null
@@ -14970,7 +16647,7 @@ ${attachmentNames.map((name) => `- ${name}`).join("\n")}` : null
           sessionId,
           projectId: project.id,
           commandId: command.id,
-          title: isKillAction ? `${command.name} \xB7 \u505C\u6B62` : command.name,
+          title: isKillAction ? command.name + " - Stop" : command.name,
           command: resolved.command,
           cwd: resolved.cwd,
           env: resolved.env,
@@ -14981,7 +16658,7 @@ ${attachmentNames.map((name) => `- ${name}`).join("\n")}` : null
       }
       const terminalId = request.body.terminalId?.trim() ?? "";
       if (!terminalId) {
-        throw new Error("\u7F3A\u5C11\u76EE\u6807\u7EC8\u7AEF\u3002");
+        throw new Error("Missing target terminal.");
       }
       if (request.body.action === "stop") {
         return {
@@ -15117,6 +16794,7 @@ ${attachmentNames.map((name) => `- ${name}`).join("\n")}` : null
     return readWorkspaceSessionPage({
       bucket,
       projectId: query.projectId ?? null,
+      projectless: query.projectless === "1" || query.projectless === "true",
       cursor: query.cursor,
       limit: query.limit,
       selectedSessionId: query.selectedSessionId ?? null
@@ -15211,7 +16889,7 @@ ${attachmentNames.map((name) => `- ${name}`).join("\n")}` : null
       return { project: existing, created: false };
     }
     const project = {
-      id: `project-${slugify(name)}-${Date.now()}`,
+      id: "project-" + slugify(name) + "-" + Date.now(),
       agent_id: localAgentId,
       name,
       display_name: null,
@@ -15247,6 +16925,45 @@ ${attachmentNames.map((name) => `- ${name}`).join("\n")}` : null
       return null;
     }
   };
+  const ensureProjectlessConversationDirectory = async (title) => {
+    const slugBase = slugify(title) || "chat";
+    const targetPath = path11.join(
+      PROJECTLESS_DIRECTORY_ROOT,
+      slugBase + "-" + Date.now()
+    );
+    await fs9.mkdir(targetPath, { recursive: true });
+    return targetPath;
+  };
+  const buildManagedSession = (input) => {
+    const projectless = input.projectless === true || !input.project;
+    const project = input.project ?? null;
+    const isRunning = input.messageInput.length > 0 || input.attachments.length > 0;
+    return {
+      id: input.sessionId,
+      agent_id: localAgentId,
+      project_id: project?.id ?? PROJECTLESS_SESSION_PROJECT_ID,
+      provider: "codex",
+      archived: false,
+      title: input.title,
+      mode: "managed",
+      health: "active",
+      branch: project?.branch ?? "unknown",
+      worktree: project?.worktree ?? PROJECTLESS_WORKTREE,
+      summary: input.messageInput ? truncateSummary(input.messageInput) : input.attachments[0]?.name ?? "",
+      latest_assistant_message: null,
+      last_event_at: input.sessionTimestamp,
+      pinned: false,
+      run_state: isRunning ? "running" : "idle",
+      run_state_changed_at: isRunning ? input.sessionTimestamp : null,
+      context_usage: null,
+      subagent: null,
+      capability: buildManagedSessionCapability({
+        archived: false,
+        projectless,
+        live: true
+      })
+    };
+  };
   app.post("/api/sessions", async (request, reply) => {
     const title = request.body.title.trim();
     const input = request.body.input?.trim() ?? "";
@@ -15298,7 +17015,7 @@ ${attachmentNames.map((name) => `- ${name}`).join("\n")}` : null
       codexConfig: configDiagnostics
     }, "Forwarding Panda session creation to Codex.");
     let sessionId = "";
-    const sessionTimestamp = isoNow5();
+    const sessionTimestamp = isoNow6();
     try {
       const created = await liveSessionStream.startThread({
         cwd: project.path,
@@ -15342,35 +17059,14 @@ ${attachmentNames.map((name) => `- ${name}`).join("\n")}` : null
       request: requestDiagnostics,
       codexConfig: configDiagnostics
     }, "Successfully created Codex session from Panda.");
-    const session = {
-      id: sessionId,
-      agent_id: localAgentId,
-      project_id: project.id,
-      provider: "codex",
-      archived: false,
+    const session = buildManagedSession({
+      sessionId,
       title,
-      mode: "managed",
-      health: "active",
-      branch: project.branch,
-      worktree: project.worktree,
-      summary: input ? truncateSummary(input) : attachments[0]?.name ?? "",
-      latest_assistant_message: null,
-      last_event_at: sessionTimestamp,
-      pinned: false,
-      run_state: input || attachments.length > 0 ? "running" : "idle",
-      run_state_changed_at: input || attachments.length > 0 ? sessionTimestamp : null,
-      context_usage: null,
-      subagent: null,
-      capability: {
-        can_stream_live: true,
-        can_send_input: true,
-        can_interrupt: true,
-        can_approve: true,
-        can_reject: true,
-        can_show_git: true,
-        can_show_terminal: true
-      }
-    };
+      messageInput: input,
+      attachments,
+      sessionTimestamp,
+      project
+    });
     setManagedSessionActive(session.id);
     managedSessions.set(session.id, session);
     upsertSnapshotSession(session);
@@ -15378,6 +17074,126 @@ ${attachmentNames.map((name) => `- ${name}`).join("\n")}` : null
     void generateSessionTitleInBackground({
       sessionId: session.id,
       project,
+      cwd: project.path,
+      fallbackTitle: title,
+      message: input,
+      attachments,
+      model: titleGenerationModel
+    });
+    reply.code(201);
+    return { session };
+  });
+  app.post("/api/chats", async (request, reply) => {
+    const title = request.body.title.trim();
+    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);
+    const serviceTier = resolvePandaServiceTier(normalizedRequestedServiceTier);
+    const planMode = request.body.planMode === true;
+    const yoloMode = request.body.yoloMode === true;
+    if (!title) {
+      reply.code(400);
+      return { error: "Session title is required." };
+    }
+    if (!input && attachments.length === 0) {
+      reply.code(400);
+      return { error: "Message input or attachments are required." };
+    }
+    const requestDiagnostics = summarizeForwardingRequest(request);
+    const prompt = buildTurnPrompt(input, planMode) || null;
+    const payloadDiagnostics = summarizeForwardingPayload({
+      title,
+      input,
+      prompt,
+      attachments,
+      model,
+      titleGenerationModel,
+      reasoningEffort,
+      requestedServiceTier,
+      normalizedRequestedServiceTier,
+      effectiveServiceTier: serviceTier,
+      planMode,
+      yoloMode
+    });
+    const projectlessPath = await ensureProjectlessConversationDirectory(title);
+    const configDiagnostics = await readCodexConfigDiagnostics(projectlessPath);
+    diagnosticLogger.info({
+      route: "create-chat",
+      projectId: PROJECTLESS_SESSION_PROJECT_ID,
+      projectPath: projectlessPath,
+      payload: payloadDiagnostics,
+      request: requestDiagnostics,
+      codexConfig: configDiagnostics
+    }, "Forwarding Panda projectless chat creation to Codex.");
+    let sessionId = "";
+    const sessionTimestamp = isoNow6();
+    try {
+      const created = await liveSessionStream.startThread({
+        cwd: projectlessPath,
+        title,
+        prompt,
+        attachments,
+        model,
+        reasoningEffort,
+        serviceTier,
+        yoloMode
+      });
+      sessionId = created.sessionId;
+      await Promise.all([
+        appendSessionIndexUpdate(
+          sessionId,
+          {
+            thread_name: title,
+            updated_at: sessionTimestamp
+          },
+          codexHome
+        ),
+        registerProjectlessThread(sessionId, PROJECTLESS_DIRECTORY_ROOT, codexHome)
+      ]);
+    } catch (error) {
+      diagnosticLogger.error({
+        error: error instanceof Error ? error.message : "Unknown error",
+        route: "create-chat",
+        projectId: PROJECTLESS_SESSION_PROJECT_ID,
+        projectPath: projectlessPath,
+        payload: payloadDiagnostics,
+        request: requestDiagnostics,
+        codexConfig: configDiagnostics
+      }, "Failed to create Codex projectless chat from Panda.");
+      reply.code(502);
+      return {
+        error: error instanceof Error ? error.message : "Unable to start Codex chat."
+      };
+    }
+    diagnosticLogger.info({
+      route: "create-chat",
+      sessionId,
+      projectId: PROJECTLESS_SESSION_PROJECT_ID,
+      projectPath: projectlessPath,
+      payload: payloadDiagnostics,
+      request: requestDiagnostics,
+      codexConfig: configDiagnostics
+    }, "Successfully created Codex projectless chat from Panda.");
+    const session = buildManagedSession({
+      sessionId,
+      title,
+      messageInput: input,
+      attachments,
+      sessionTimestamp,
+      projectless: true
+    });
+    setManagedSessionActive(session.id);
+    managedSessions.set(session.id, session);
+    upsertSnapshotSession(session);
+    broadcastSnapshotChanged();
+    void generateSessionTitleInBackground({
+      sessionId: session.id,
+      project: null,
+      cwd: projectlessPath,
       fallbackTitle: title,
       message: input,
       attachments,
@@ -15386,6 +17202,196 @@ ${attachmentNames.map((name) => `- ${name}`).join("\n")}` : null
     reply.code(201);
     return { session };
   });
+  app.get(
+    "/api/image-provider/settings",
+    async () => buildResolvedImageProviderSettings({
+      activeChannelId: imageSessionStore.getSettings().active_channel_id,
+      channels: imageSessionStore.getSettings().channels.map((channel) => ({
+        id: channel.id,
+        remark: channel.remark,
+        baseUrl: channel.base_url,
+        storedApiKey: channel.api_key,
+        models: channel.models,
+        updatedAt: channel.updated_at
+      })),
+      updatedAt: imageSessionStore.getSettings().updated_at
+    })
+  );
+  app.post("/api/image-provider/settings", async (request, reply) => {
+    const parsed = imageProviderSettingsUpdateSchema.safeParse(request.body ?? {});
+    if (!parsed.success) {
+      reply.code(400);
+      return { error: "Invalid image provider settings payload." };
+    }
+    const saved = await imageSessionStore.updateSettings({
+      activeChannelId: parsed.data.active_channel_id,
+      channels: parsed.data.channels.map((channel) => ({
+        id: channel.id,
+        remark: channel.remark,
+        baseUrl: normalizeImageProviderBaseUrl(channel.base_url),
+        models: channel.models,
+        apiKeyMode: channel.api_key_mode,
+        apiKey: channel.api_key ?? null
+      }))
+    });
+    return buildResolvedImageProviderSettings({
+      activeChannelId: saved.active_channel_id,
+      channels: saved.channels.map((channel) => ({
+        id: channel.id,
+        remark: channel.remark,
+        baseUrl: channel.base_url,
+        storedApiKey: channel.api_key,
+        models: channel.models,
+        updatedAt: channel.updated_at
+      })),
+      updatedAt: saved.updated_at
+    });
+  });
+  app.post("/api/image-provider/models", async (request, reply) => {
+    const parsed = imageProviderModelListRequestSchema.safeParse(request.body ?? {});
+    if (!parsed.success) {
+      reply.code(400);
+      return { error: "Invalid image provider model list payload." };
+    }
+    const storedChannel = parsed.data.channel_id ? imageSessionStore.getSettings().channels.find((channel) => channel.id === parsed.data.channel_id) : null;
+    const baseUrl = normalizeImageProviderBaseUrl(parsed.data.base_url);
+    const requestApiKey = parsed.data.api_key_mode === "set" ? parsed.data.api_key?.trim() || "" : parsed.data.api_key_mode === "clear" ? "" : storedChannel?.api_key?.trim() || "";
+    const apiKey = requestApiKey || resolveImageProviderApiKey();
+    if (!apiKey) {
+      reply.code(400);
+      return { error: "\u672A\u68C0\u6D4B\u5230\u56FE\u7247\u63A5\u53E3 API Key\u3002" };
+    }
+    return imageProviderModelListResponseSchema.parse({
+      models: await listImageProviderModels({ baseUrl, apiKey })
+    });
+  });
+  app.post("/api/image-provider/test", async (request) => {
+    const parsed = imageProviderSettingsUpdateSchema.safeParse(request.body ?? {});
+    const storedSettings = imageSessionStore.getSettings();
+    const requestSettings = parsed.success ? parsed.data : {
+      active_channel_id: storedSettings.active_channel_id,
+      channels: storedSettings.channels.map((channel) => ({
+        id: channel.id,
+        remark: channel.remark,
+        base_url: channel.base_url,
+        api_key: null,
+        api_key_mode: "keep",
+        models: channel.models
+      }))
+    };
+    const testedChannelId = requestSettings.channels.some(
+      (channel) => channel.id === requestSettings.active_channel_id
+    ) ? requestSettings.active_channel_id : requestSettings.channels[0]?.id ?? null;
+    const testedChannel = requestSettings.channels.find(
+      (channel) => channel.id === testedChannelId
+    );
+    const storedChannel = storedSettings.channels.find(
+      (channel) => channel.id === testedChannelId
+    );
+    const baseUrl = normalizeImageProviderBaseUrl(testedChannel?.base_url);
+    const storedApiKey = storedChannel?.api_key?.trim() || "";
+    const requestApiKey = testedChannel?.api_key_mode === "set" ? testedChannel.api_key?.trim() || "" : testedChannel?.api_key_mode === "clear" ? "" : storedApiKey;
+    const apiKey = requestApiKey || resolveImageProviderApiKey();
+    if (!apiKey) {
+      return {
+        ok: false,
+        message: "No image API key found. Configure one in settings or environment variables.",
+        model_available: false,
+        resolved_base_url: baseUrl
+      };
+    }
+    try {
+      const result = await testImageProviderConnection({
+        baseUrl,
+        apiKey,
+        model: getDefaultImageProviderModel(),
+        vendor: "openai"
+      });
+      return {
+        ok: true,
+        message: result.modelAvailable ? "Connection succeeded and gpt-image-2 was found." : "Connection succeeded but gpt-image-2 was not found.",
+        model_available: result.modelAvailable,
+        resolved_base_url: baseUrl
+      };
+    } catch (error) {
+      return {
+        ok: false,
+        message: error instanceof Error ? error.message : "Image provider test failed.",
+        model_available: false,
+        resolved_base_url: baseUrl
+      };
+    }
+  });
+  app.post("/api/image-sessions", async (request, reply) => {
+    if (mode === "hub") {
+      reply.code(409);
+      return { error: "Image sessions can only be created on agent." };
+    }
+    const parsed = imageSessionCreateRequestSchema.safeParse(request.body ?? {});
+    if (!parsed.success) {
+      reply.code(400);
+      return { error: "Invalid image session payload." };
+    }
+    const record = await imageSessionStore.createSession(localAgentId, parsed.data.title ?? null);
+    syncImageSessionSnapshot(record.session.id);
+    reply.code(201);
+    return { session: record.session };
+  });
+  app.get("/api/image-sessions/:sessionId", async (request, reply) => {
+    const { sessionId } = request.params;
+    const detail = await readImageSessionDetail(sessionId);
+    if (!detail) {
+      reply.code(404);
+      return { error: "Image session not found." };
+    }
+    return detail;
+  });
+  app.post("/api/image-sessions/:sessionId/submit", async (request, reply) => {
+    const { sessionId } = request.params;
+    const parsed = imageSessionSubmitRequestSchema.safeParse(request.body ?? {});
+    if (!parsed.success) {
+      reply.code(400);
+      return { error: "Invalid image session payload." };
+    }
+    const prompt = parsed.data.prompt.trim();
+    if (!prompt) {
+      reply.code(400);
+      return { error: "Prompt is required." };
+    }
+    try {
+      return await submitImageSessionPrompt({
+        sessionId,
+        prompt,
+        appendToTurnId: parsed.data.append_to_turn_id,
+        sources: parsed.data.sources,
+        model: parsed.data.model,
+        quality: parsed.data.quality,
+        size: parsed.data.size,
+        inputFidelity: parsed.data.input_fidelity,
+        aspectRatio: parsed.data.aspect_ratio,
+        outputFormat: parsed.data.output_format,
+        outputCompression: parsed.data.output_compression,
+        background: parsed.data.background,
+        moderation: parsed.data.moderation,
+        n: parsed.data.n
+      });
+    } catch (error) {
+      reply.code(409);
+      return {
+        error: error instanceof Error ? error.message : "Unable to submit image session prompt."
+      };
+    }
+  });
+  app.get("/api/image-assets/:assetId", async (request, reply) => {
+    const { assetId } = request.params;
+    const found = findImageAssetRecordById(assetId);
+    if (!found) {
+      reply.code(404);
+      return { error: "Image asset not found." };
+    }
+    reply.type(found.asset.mime_type ?? "application/octet-stream");
+    return reply.send(await fs9.readFile(imageSessionStore.resolveAssetAbsolutePath(found.asset)));
+  });
   app.post(
     "/api/sessions/:sessionId/actions",
     async (request, reply) => {
@@ -15417,6 +17423,49 @@ ${attachmentNames.map((name) => `- ${name}`).join("\n")}` : null
         reply.code(409);
         return { error: "Running sessions cannot be changed right now." };
       }
+      if (session.provider === "image") {
+        if (action === "pin" || action === "unpin") {
+          const pinned = action === "pin";
+          await imageSessionStore.mutateSessionRef(sessionId, (current) => ({
+            ...current,
+            pinned
+          }));
+          syncImageSessionSnapshot(sessionId);
+          broadcastEvent("session.updated", {
+            sessionId,
+            sessionPatch: {
+              pinned
+            }
+          });
+          return {
+            ok: true,
+            affectedSessionIds: [sessionId],
+            nextSessionId: findNextSessionId(snapshot.sessions)
+          };
+        }
+        if (action === "archive") {
+          await imageSessionStore.mutateSessionRef(sessionId, (current) => ({
+            ...current,
+            archived: true,
+            health: "offline",
+            run_state: "idle",
+            run_state_changed_at: null,
+            capability: {
+              ...current.capability,
+              can_send_input: false
+            }
+          }));
+          syncImageSessionSnapshot(sessionId);
+        } else {
+          await imageSessionStore.deleteSession(sessionId);
+          removeSnapshotSessions([sessionId]);
+        }
+        return {
+          ok: true,
+          affectedSessionIds: [sessionId],
+          nextSessionId: findNextSessionId(snapshot.sessions)
+        };
+      }
       const affectedSessionIds = [
         sessionId,
         ...session.subagent ? [] : collectDescendantSessionIds(sessionId, snapshot.sessions)
@@ -15827,8 +17876,8 @@ ${attachmentNames.map((name) => `- ${name}`).join("\n")}` : null
       codexConfig: configDiagnostics
     }, "Successfully forwarded Panda session input to Codex.");
     setManagedSessionActive(sessionId);
-    const runningAt = isoNow5();
-    const summary = input ? truncateSummary(input) : attachments[0]?.name ?? "\u9644\u4EF6";
+    const runningAt = isoNow6();
+    const summary = input ? truncateSummary(input) : attachments[0]?.name ?? "\u95C4\u52EA\u6B22";
     const overlayAttachments = buildInlineTimelineAttachments(attachments);
     managedSessions.set(sessionId, {
       ...toSessionWithRunState(session, {
@@ -15853,9 +17902,9 @@ ${attachmentNames.map((name) => `- ${name}`).join("\n")}` : null
       latest_assistant_message: null
     });
     const overlayUserEntry = {
-      id: `${USER_OVERLAY_ENTRY_PREFIX}${sessionId}:${Date.now()}`,
+      id: USER_OVERLAY_ENTRY_PREFIX + sessionId + ":" + Date.now(),
       kind: "user",
-      title: "\u4F60",
+      title: "You",
       body: input,
       body_truncated: false,
       detail_available: false,
@@ -15901,7 +17950,7 @@ ${attachmentNames.map((name) => `- ${name}`).join("\n")}` : null
       };
     }
     setManagedSessionActive(sessionId);
-    const completedAt = isoNow5();
+    const completedAt = isoNow6();
     const previousSessionState = {
       run_state: session.run_state,
       run_state_changed_at: session.run_state_changed_at,
@@ -15937,10 +17986,10 @@ ${attachmentNames.map((name) => `- ${name}`).join("\n")}` : null
       }
     });
     const interruptEntry = {
-      id: `entry-system-interrupt-${Date.now()}`,
+      id: "entry-system-interrupt-" + Date.now(),
       kind: "system",
-      title: "\u4E2D\u65AD\u8BF7\u6C42",
-      body: "\u5DF2\u63D0\u4EA4\u4E2D\u65AD\u8BF7\u6C42\u3002",
+      title: "Interrupt requested",
+      body: "Interrupt request submitted.",
       body_truncated: false,
       detail_available: false,
       patch_summary: null,
@@ -15976,7 +18025,7 @@ ${attachmentNames.map((name) => `- ${name}`).join("\n")}` : null
         await liveSessionStream.ensureSessionTracker(sessionId, discoveredSessionFiles[sessionId]);
         await liveSessionStream.interruptTurn(sessionId);
       } catch (error) {
-        const failedAt = isoNow5();
+        const failedAt = isoNow6();
         const failureMessage = error instanceof Error ? error.message : "Unable to interrupt Codex session.";
         const nextRunState = previousSessionState.run_state === "running" ? "running" : previousSessionState.run_state;
         const nextRunStateChangedAt = nextRunState === "running" ? failedAt : previousSessionState.run_state_changed_at;
@@ -16010,10 +18059,10 @@ ${attachmentNames.map((name) => `- ${name}`).join("\n")}` : null
           }
         });
         const failureEntry = {
-          id: `entry-system-interrupt-failed-${Date.now()}`,
+          id: "entry-system-interrupt-failed-" + Date.now(),
           kind: "system",
-          title: "\u4E2D\u65AD\u5931\u8D25",
-          body: `\u4E2D\u65AD\u672A\u5B8C\u6210\uFF1A${failureMessage}`,
+          title: "Interrupt failed",
+          body: "Interrupt failed: " + failureMessage,
           body_truncated: false,
           detail_available: false,
           patch_summary: null,
@@ -16209,7 +18258,8 @@ ${attachmentNames.map((name) => `- ${name}`).join("\n")}` : null
         }
         sendSocketEvent(client, "timeline.reset", {
           sessionId: message.sessionId,
-          entries: bootstrap.timeline.entries
+          entries: bootstrap.timeline.entries,
+          hasEarlierEntries: bootstrap.timeline.has_earlier_entries
         });
         sendSocketEvent(client, "interaction.reset", {
           sessionId: message.sessionId,
@@ -16254,7 +18304,7 @@ ${attachmentNames.map((name) => `- ${name}`).join("\n")}` : null
       }
       reply.type(asset.contentType);
       reply.header("cache-control", asset.cacheControl);
-      return reply.send(await fs8.readFile(asset.filePath));
+      return reply.send(await fs9.readFile(asset.filePath));
     });
   }
   await app.listen({
@@ -16283,6 +18333,8 @@ export {
   writeCodexGlobalState,
   getSavedWorkspaceRoots,
   getWorkspaceRootLabels,
+  getProjectlessThreadIds,
+  getThreadWorkspaceRootHints,
   readPandaThreadPrefs,
   writePandaThreadPrefs,
   getPinnedWorkspaceRoots,
@@ -16299,6 +18351,7 @@ export {
   setWorkspaceRootOrder,
   setWorkspaceRootLabel,
   setWorkspaceRootVisibility,
+  registerProjectlessThread,
   isWithinWorkspaceRoot,
   normalizeWorkspacePathKey,
   sortByStoredWorkspaceOrder,