pinokiod 6.0.19 → 6.0.21

package/server/index.js

@@ -4269,6 +4269,7 @@ class Server {
 
 
     await this.kernel.init({ port: this.port})
+    await Environment.init({}, this.kernel)
     this.kernel.server_port = this.port
     this.kernel.peer.start(this.kernel)
 
@@ -5731,6 +5732,94 @@ class Server {
     const invalidateTerminalSessionDiscoveryCache = () => {
       terminalSessionDiscoveryCache.expires = 0
     }
+    let terminalSessionRegistrySyncPromise = null
+    let terminalSessionRegistryBootScrubbed = false
+    let terminalSessionRegistryBootScrubPromise = null
+
+    const getTerminalSessionRegistryPath = () => {
+      if (this.kernel && typeof this.kernel.path === "function") {
+        return this.kernel.path("cache", "terminals", "sessions.json")
+      }
+      return path.resolve(os.homedir(), "pinokio", "cache", "terminals", "sessions.json")
+    }
+    const coerceTerminalRegistryItems = (items) => {
+      if (!Array.isArray(items)) {
+        return []
+      }
+      return items.filter((entry) => entry && typeof entry === "object")
+    }
+    const terminalRegistryItemsEqual = (left, right) => {
+      return JSON.stringify(coerceTerminalRegistryItems(left)) === JSON.stringify(coerceTerminalRegistryItems(right))
+    }
+    const readTerminalSessionRegistry = async () => {
+      const registryPath = getTerminalSessionRegistryPath()
+      try {
+        const raw = await fs.promises.readFile(registryPath, "utf8")
+        const parsed = JSON.parse(raw)
+        if (!parsed || typeof parsed !== "object") {
+          return { items: [], exists: false }
+        }
+        return {
+          items: coerceTerminalRegistryItems(parsed.items),
+          exists: true
+        }
+      } catch (error) {
+        return { items: [], exists: false }
+      }
+    }
+    const writeTerminalSessionRegistry = async (items) => {
+      const registryPath = getTerminalSessionRegistryPath()
+      const normalizedItems = coerceTerminalRegistryItems(items)
+      const payload = {
+        updated_at: new Date().toISOString(),
+        items: normalizedItems
+      }
+      await fs.promises.mkdir(path.dirname(registryPath), { recursive: true })
+      const tmpPath = `${registryPath}.tmp`
+      await fs.promises.writeFile(tmpPath, JSON.stringify(payload, null, 2), "utf8")
+      await fs.promises.rename(tmpPath, registryPath)
+      return payload
+    }
+    const scrubTerminalSessionRegistryOnlineStateAtBoot = async () => {
+      if (terminalSessionRegistryBootScrubbed) {
+        return
+      }
+      if (!terminalSessionRegistryBootScrubPromise) {
+        terminalSessionRegistryBootScrubPromise = (async () => {
+          const registry = await readTerminalSessionRegistry()
+          if (!registry.exists || !Array.isArray(registry.items) || registry.items.length === 0) {
+            terminalSessionRegistryBootScrubbed = true
+            return
+          }
+          let changed = false
+          const scrubbedItems = registry.items.map((entry) => {
+            if (!entry || typeof entry !== "object") {
+              return entry
+            }
+            const onlineValue = entry.online
+            const isOnline = onlineValue === true
+              || onlineValue === 1
+              || onlineValue === "1"
+              || onlineValue === "true"
+            if (!isOnline) {
+              return entry
+            }
+            changed = true
+            return {
+              ...entry,
+              online: false
+            }
+          })
+          if (changed) {
+            await writeTerminalSessionRegistry(scrubbedItems)
+          }
+          terminalSessionRegistryBootScrubbed = true
+        })().finally(() => {
+          terminalSessionRegistryBootScrubPromise = null
+        })
+      }
+      return terminalSessionRegistryBootScrubPromise
+    }
 
     const getTerminalSkillRoots = () => {
       const roots = []
@@ -6054,6 +6143,45 @@ class Server {
       return `${lines.join("\n").trim()}\n`
     }
 
+    const buildCodexSelectedSkillMarkdown = (mergedBody) => {
+      const body = String(mergedBody || "").trim()
+      const lines = [
+        "---",
+        "name: Pinokio Selected Skills",
+        "description: Session-specific skill bundle generated from the skills selected in Pinokio.",
+        "tags:",
+        "- pinokio",
+        "- session",
+        "- selected-skills",
+        "---",
+        "",
+        body
+      ]
+      return `${lines.join("\n").trim()}\n`
+    }
+
+    const ensureCodexSelectedSkillFrontmatter = async (sessionCwd) => {
+      if (typeof sessionCwd !== "string" || sessionCwd.trim().length === 0) {
+        return
+      }
+      const codexSkillPath = path.resolve(sessionCwd, ".agents", "skills", "pinokio-selected", "SKILL.md")
+      let existing = ""
+      try {
+        existing = await fs.promises.readFile(codexSkillPath, "utf8")
+      } catch (error) {
+        if (error && error.code === "ENOENT") {
+          return
+        }
+        throw error
+      }
+      const normalized = String(existing || "").replace(/\r\n/g, "\n")
+      if (normalized.startsWith("---\n")) {
+        return
+      }
+      const wrapped = buildCodexSelectedSkillMarkdown(normalized)
+      await fs.promises.writeFile(codexSkillPath, wrapped, "utf8")
+    }
+
     const materializeTerminalSkillContext = async (sessionCwd, providerKey, selectedSkills) => {
       if (!Array.isArray(selectedSkills) || selectedSkills.length === 0) {
         return {
@@ -6102,7 +6230,8 @@ class Server {
         const codexSkillDir = path.resolve(sessionCwd, ".agents", "skills", "pinokio-selected")
         await fs.promises.mkdir(codexSkillDir, { recursive: true })
         const codexSkillPath = path.resolve(codexSkillDir, "SKILL.md")
-        await fs.promises.writeFile(codexSkillPath, merged, "utf8")
+        const codexSkillBody = buildCodexSelectedSkillMarkdown(merged)
+        await fs.promises.writeFile(codexSkillPath, codexSkillBody, "utf8")
         const agentsPath = path.resolve(sessionCwd, "AGENTS.md")
         await fs.promises.writeFile(agentsPath, "# Pinokio session instructions\n\nUse the `pinokio-selected` skill from `.agents/skills/pinokio-selected/SKILL.md` for this workspace.\n", "utf8")
       } else if (providerKey === "claude") {
@@ -6324,7 +6453,10 @@ class Server {
             const msg = candidate.messages[i]
             if (msg && typeof msg === "object") {
               const role = typeof msg.role === "string" ? msg.role.toLowerCase() : ""
-              if (role === "user") {
+              const type = typeof msg.type === "string" ? msg.type.toLowerCase() : ""
+              const author = typeof msg.author === "string" ? msg.author.toLowerCase() : ""
+              const isUserMessage = role === "user" || type === "user" || author === "user" || author === "human"
+              if (isUserMessage) {
                 const text = trimSummary(extractTextContent(msg), 160)
                 if (text) {
                   return text
@@ -6416,7 +6548,8 @@ class Server {
         return normalizeClaudeSummary(fallback)
       }
 
-      const buildTerminalSessions = async (forceDiscovery = false) => {
+      const buildTerminalSessions = async (forceDiscovery = false, options = {}) => {
+        const cacheOnly = Boolean(options && options.cacheOnly)
           const buildCodexResumeBaseCommand = (entry) => {
             const defaultCommand = entry && entry.command ? entry.command : "npx -y @openai/codex@latest"
             return {
@@ -6815,31 +6948,38 @@ class Server {
             }
             seenNodes.add(candidate)
             const localCodexHint = inheritedHint || recordHasCodexHint(candidate, 2, 50)
-            const sessionField = findSessionField(candidate)
+            const candidateType = typeof candidate.type === "string" ? candidate.type.toLowerCase() : ""
+            // OpenClaw session logs include many message/tool-call ids. Only treat top-level
+            // session envelopes as resumable session sources.
+            const isOpenClawSessionEnvelope = candidateType === "session" || candidateType === "session_meta"
+            const sessionField = isOpenClawSessionEnvelope ? findSessionField(candidate) : null
             if (sessionField && isCodexFieldAllowed(sessionField, candidate, filePath, localCodexHint)) {
               const sessionId = sessionField.value
               if (!seenIds.has(sessionId)) {
-                seenIds.add(sessionId)
-                const summary = normalizeDiscoveredSessionSummary(buildSessionSummary(candidate) || buildSessionSummary(record))
-                const cwd = extractWorkingDirectory(candidate) || extractWorkingDirectory(record)
-                const timestamp = parseSessionTimestamp(
-                  candidate.timestamp
-                  || candidate.ts
-                  || candidate.updated_at
-                  || candidate.created_at
-                  || record.timestamp
-                  || record.ts
-                  || record.updated_at
-                  || record.created_at
-                )
-                results.push({
-                  id: sessionId,
-                  cwd,
-                  summary,
-                  timestamp,
-                  source: filePath,
-                  metadata: candidate
-                })
+                const cwdValue = extractWorkingDirectory(candidate) || extractWorkingDirectory(record)
+                const cwd = typeof cwdValue === "string" ? cwdValue.trim() : ""
+                if (cwd) {
+                  seenIds.add(sessionId)
+                  const summary = normalizeDiscoveredSessionSummary(buildSessionSummary(candidate) || buildSessionSummary(record))
+                  const timestamp = parseSessionTimestamp(
+                    candidate.timestamp
+                    || candidate.ts
+                    || candidate.updated_at
+                    || candidate.created_at
+                    || record.timestamp
+                    || record.ts
+                    || record.updated_at
+                    || record.created_at
+                  )
+                  results.push({
+                    id: sessionId,
+                    cwd,
+                    summary,
+                    timestamp,
+                    source: filePath,
+                    metadata: candidate
+                  })
+                }
               }
             }
             if (depth >= maxDepth) {
@@ -6950,6 +7090,7 @@ class Server {
         }
 
         const home = os.homedir()
+        const configuredHome = this.kernel && this.kernel.homedir ? path.resolve(this.kernel.homedir) : null
         const openClawAgentSessionRoots = await buildOpenClawAgentSessionRoots(home)
         const codexDiscovery = await buildCodexDiscovery(home, openClawAgentSessionRoots)
         const codexDiscoveryRoots = codexDiscovery.roots
@@ -6975,10 +7116,78 @@ class Server {
           ...buildClaudeDiscoveryRoots(home),
           ...openClawAgentSessionRoots
         ])
-        const geminiCanonicalRoots = normalizeDiscoveryRoots([
-          path.join(home, ".gemini", "tmp"),
-          path.join(home, ".config", "gemini", "tmp")
+        const geminiHomeRoots = normalizeDiscoveryRoots([
+          home,
+          configuredHome
         ])
+        const geminiRootCandidates = []
+        for (let i = 0; i < geminiHomeRoots.length; i++) {
+          const rootHome = geminiHomeRoots[i]
+          geminiRootCandidates.push(path.join(rootHome, ".gemini", "tmp"))
+          geminiRootCandidates.push(path.join(rootHome, ".config", "gemini", "tmp"))
+        }
+        const geminiCanonicalRoots = normalizeDiscoveryRoots(geminiRootCandidates)
+        const geminiProjectRootCache = new Map()
+        const getGeminiCanonicalTokenFromFile = (filePath) => {
+          if (typeof filePath !== "string" || filePath.trim().length === 0) {
+            return null
+          }
+          const resolved = path.resolve(filePath)
+          for (let i = 0; i < geminiCanonicalRoots.length; i++) {
+            const root = geminiCanonicalRoots[i]
+            if (!root) {
+              continue
+            }
+            const resolvedRoot = path.resolve(root)
+            if (!(resolved === resolvedRoot || resolved.startsWith(`${resolvedRoot}${path.sep}`))) {
+              continue
+            }
+            const relative = path.relative(resolvedRoot, resolved)
+            if (!relative || relative.startsWith("..") || path.isAbsolute(relative)) {
+              continue
+            }
+            const token = normalizeSessionToken(relative.split(path.sep)[0])
+            if (token) {
+              return token
+            }
+          }
+          return null
+        }
+        const resolveGeminiProjectRoot = (filePath) => {
+          const token = getGeminiCanonicalTokenFromFile(filePath)
+          if (!token) {
+            return null
+          }
+          if (geminiProjectRootCache.has(token)) {
+            const cached = geminiProjectRootCache.get(token)
+            return cached || null
+          }
+          let projectRoot = null
+          for (let i = 0; i < geminiCanonicalRoots.length; i++) {
+            const root = geminiCanonicalRoots[i]
+            if (!root) {
+              continue
+            }
+            const markerPath = path.resolve(root, token, ".project_root")
+            try {
+              const marker = fs.readFileSync(markerPath, "utf8")
+              const normalized = typeof marker === "string" ? marker.trim() : ""
+              if (normalized.length > 0) {
+                projectRoot = normalized
+                break
+              }
+            } catch (error) {
+            }
+          }
+          if (!projectRoot && this.kernel && typeof this.kernel.path === "function") {
+            const inferredPath = path.resolve(this.kernel.path("terminals", "gemini", token))
+            if (fs.existsSync(inferredPath)) {
+              projectRoot = inferredPath
+            }
+          }
+          geminiProjectRootCache.set(token, projectRoot || "")
+          return projectRoot
+        }
         const isGeminiCanonicalSessionFile = (filePath) => {
           if (typeof filePath !== "string" || filePath.length === 0) {
             return false
@@ -6991,6 +7200,18 @@ class Server {
           }
           return /[\\/]chats[\\/]session-[^\\/]+\.json$/i.test(path.resolve(filePath))
         }
+        const isGeminiCanonicalLogFile = (filePath) => {
+          if (typeof filePath !== "string" || filePath.length === 0) {
+            return false
+          }
+          if (isOpenClawDiscoveryPath(filePath)) {
+            return false
+          }
+          if (!isPathWithinRoots(filePath, geminiCanonicalRoots)) {
+            return false
+          }
+          return /[\\/]logs\.json$/i.test(path.resolve(filePath))
+        }
         const isGeminiForkCapableRecord = (candidate, filePath) => {
           if (!candidate || typeof candidate !== "object") {
             return false
@@ -7121,7 +7342,7 @@ class Server {
             if (isOpenClawDiscoveryPath(filePath)) {
               return true
             }
-            return isGeminiCanonicalSessionFile(filePath)
+            return isGeminiCanonicalSessionFile(filePath) || isGeminiCanonicalLogFile(filePath)
           },
           extract: (record, filePath) => {
             if (!record || typeof record !== "object") {
@@ -7140,10 +7361,35 @@ class Server {
                 }))
               }
             }
+            const candidate = record.payload && typeof record.payload === "object" ? record.payload : record
+            if (isGeminiCanonicalLogFile(filePath)) {
+              const sessionField = findSessionField(candidate, geminiSessionIdKeys)
+              const sessionId = sessionField ? sessionField.value : null
+              if (!sessionId) {
+                return null
+              }
+              const recordType = typeof candidate.type === "string" ? candidate.type.toLowerCase() : ""
+              const isUserRecord = recordType === "user"
+              const summary = normalizeDiscoveredSessionSummary(
+                isUserRecord
+                  ? extractTextContent(candidate.message || candidate.content || candidate.prompt || candidate.text)
+                  : buildSessionSummary(candidate)
+              )
+              return {
+                id: sessionId,
+                cwd: extractWorkingDirectory(candidate) || resolveGeminiProjectRoot(filePath),
+                summary,
+                timestamp: parseSessionTimestamp(candidate.timestamp || candidate.ts || candidate.lastUpdated || candidate.startTime || record.timestamp || record.ts),
+                source: filePath,
+                source_kind: "gemini_log",
+                resume_capable: false,
+                resume_disabled_reason: "Gemini log-only session cannot be resumed directly.",
+                fork_capable: false
+              }
+            }
             if (!isGeminiCanonicalSessionFile(filePath)) {
               return null
             }
-            const candidate = record.payload && typeof record.payload === "object" ? record.payload : record
             const sessionField = findSessionField(candidate, geminiSessionIdKeys)
             const sessionId = sessionField ? sessionField.value : null
             if (!sessionId) {
@@ -7151,13 +7397,15 @@ class Server {
             }
             const rootSessionId = normalizeSessionIdentifier(candidate.sessionId || candidate.session_id)
             const forkCapable = isGeminiForkCapableRecord(candidate, filePath) && rootSessionId === sessionId
-            const summary = buildSessionSummary(candidate)
+            const summary = normalizeDiscoveredSessionSummary(buildSessionSummary(candidate))
             return {
               id: sessionId,
-              cwd: extractWorkingDirectory(candidate),
+              cwd: extractWorkingDirectory(candidate) || resolveGeminiProjectRoot(filePath),
               summary,
               timestamp: parseSessionTimestamp(candidate.timestamp || candidate.ts || candidate.lastUpdated || candidate.startTime || record.timestamp || record.ts),
               source: filePath,
+              source_kind: "gemini_session",
+              resume_capable: true,
               fork_capable: forkCapable
             }
           }
@@ -7290,6 +7538,43 @@ class Server {
           }
           return Array.from(keySet.values())
         }
+        const inferProviderFromCommand = (commandText) => {
+          if (typeof commandText !== "string" || commandText.trim().length === 0) {
+            return ""
+          }
+          for (let i = 0; i < providerKeys.length; i++) {
+            const key = providerKeys[i]
+            const terms = getProviderHintTerms(key)
+            if (stringHasHintTerm(commandText, terms)) {
+              return key
+            }
+          }
+          return ""
+        }
+        const parseSessionTokensFromCommand = (commandText) => {
+          if (typeof commandText !== "string" || commandText.trim().length === 0) {
+            return []
+          }
+          const tokens = new Set()
+          const patterns = [
+            /--resume(?:=|\s+)(?:"([^"]+)"|'([^']+)'|([^\s"'`]+))/gi,
+            /\bresume\s+(?:"([^"]+)"|'([^']+)'|([^\s"'`]+))/gi,
+            /\bfork\s+(?:"([^"]+)"|'([^']+)'|([^\s"'`]+))/gi,
+            /session=(?:"([^"]+)"|'([^']+)'|([^\s"'`&]+))/gi
+          ]
+          for (let i = 0; i < patterns.length; i++) {
+            const pattern = patterns[i]
+            let match = null
+            while ((match = pattern.exec(commandText)) !== null) {
+              const rawToken = match[1] || match[2] || match[3] || ""
+              const normalized = normalizeSessionToken(rawToken)
+              if (normalized) {
+                tokens.add(normalized)
+              }
+            }
+          }
+          return Array.from(tokens.values())
+        }
         const normalizeCwdKey = (value) => {
           if (typeof value !== "string") {
             return ""
@@ -7305,7 +7590,10 @@ class Server {
           return normalized
         }
         const runningSessionKeys = new Set()
+        const runningProviderCwdKeys = new Set()
         const runningForkProviderCwdKeys = new Set()
+        const runningShellIdsByTerminalId = new Map()
+        const runningShellIdByTerminalSession = new Map()
         if (this.kernel && this.kernel.api && this.kernel.api.running) {
           for (const runningId of Object.keys(this.kernel.api.running)) {
             const keys = parseRunningSessionKeys(runningId)
@@ -7329,9 +7617,27 @@ class Server {
         }
         if (this.kernel && this.kernel.shell && Array.isArray(this.kernel.shell.shells)) {
           for (const shellEntry of this.kernel.shell.shells) {
+            const shellIdText = shellEntry && shellEntry.id ? String(shellEntry.id) : ""
+            if (shellIdText) {
+              const querySeparatorIndex = shellIdText.indexOf("?")
+              if (querySeparatorIndex >= 0) {
+                const normalizedQuery = shellIdText.slice(querySeparatorIndex + 1).replace(/&amp;/g, "&")
+                const shellParams = new URLSearchParams(normalizedQuery)
+                const shellTerminalId = normalizeSessionToken(shellParams.get("terminal_id"))
+                if (shellTerminalId) {
+                  if (!runningShellIdsByTerminalId.has(shellTerminalId)) {
+                    runningShellIdsByTerminalId.set(shellTerminalId, [])
+                  }
+                  runningShellIdsByTerminalId.get(shellTerminalId).push(shellIdText)
+                  const shellSessionId = normalizeSessionToken(shellParams.get("session"))
+                  if (shellSessionId) {
+                    runningShellIdByTerminalSession.set(`${shellTerminalId}|${shellSessionId}`, shellIdText)
+                  }
+                }
+              }
+            }
             const keys = parseRunningSessionKeys(shellEntry && shellEntry.id ? shellEntry.id : null)
             let providerKey = ""
-            let hasForkMarker = false
             for (let i = 0; i < keys.length; i++) {
               const key = keys[i]
               runningSessionKeys.add(key)
@@ -7342,17 +7648,29 @@ class Server {
               if (!providerKey) {
                 providerKey = key.slice(0, separatorIndex)
               }
-              if (!hasForkMarker) {
-                const sessionToken = key.slice(separatorIndex + 1).toLowerCase()
-                if (sessionToken.includes("fork:")) {
-                  hasForkMarker = true
+            }
+            if (!providerKey) {
+              const inferredProvider = inferProviderFromCommand(shellEntry && shellEntry.cmd ? shellEntry.cmd : "")
+              if (inferredProvider) {
+                providerKey = inferredProvider
+                const inferredTokens = parseSessionTokensFromCommand(shellEntry && shellEntry.cmd ? shellEntry.cmd : "")
+                for (let i = 0; i < inferredTokens.length; i++) {
+                  const token = inferredTokens[i]
+                  const variants = buildSessionTokenVariants(token)
+                  for (let j = 0; j < variants.length; j++) {
+                    runningSessionKeys.add(`${providerKey}:${variants[j]}`)
+                  }
                 }
               }
             }
-            if (hasForkMarker && providerKey) {
+            if (providerKey) {
               const cwdKey = normalizeCwdKey(shellEntry && shellEntry.path ? shellEntry.path : "")
               if (cwdKey) {
-                runningForkProviderCwdKeys.add(`${providerKey}|${cwdKey}`)
+                const contextKey = `${providerKey}|${cwdKey}`
+                runningProviderCwdKeys.add(contextKey)
+                if (/[?&]session=(?:fork(?:[:]|%3A)|[^&]*(?:[:]|%3A)fork(?:[:]|%3A))/i.test(shellIdText)) {
+                  runningForkProviderCwdKeys.add(contextKey)
+                }
               }
             }
           }
@@ -7587,6 +7905,63 @@ class Server {
 
         const refreshDiscoveryEntries = async () => {
           const byProvider = new Map()
+          const terminalMetadataCache = new Map()
+          const resolveWorkspaceTerminalId = async (providerKey, workingDirectory) => {
+            const normalizedProvider = typeof providerKey === "string" ? providerKey.trim().toLowerCase() : ""
+            const normalizedCwd = typeof workingDirectory === "string" ? workingDirectory.trim() : ""
+            if (!normalizedProvider || !normalizedCwd) {
+              return ""
+            }
+            const resolvedCwd = path.resolve(normalizedCwd)
+            const cacheKey = `${normalizedProvider}|${resolvedCwd}`
+            if (terminalMetadataCache.has(cacheKey)) {
+              return terminalMetadataCache.get(cacheKey)
+            }
+            let terminalId = ""
+            const metadataPath = path.resolve(resolvedCwd, ".pinokio-terminal.json")
+            let parsedMetadata = null
+            try {
+              const rawMetadata = await fs.promises.readFile(metadataPath, "utf8")
+              parsedMetadata = JSON.parse(rawMetadata)
+              if (parsedMetadata && typeof parsedMetadata === "object") {
+                const metadataProvider = typeof parsedMetadata.provider === "string"
+                  ? parsedMetadata.provider.trim().toLowerCase()
+                  : ""
+                const metadataTerminalId = typeof parsedMetadata.terminal_id === "string"
+                  ? parsedMetadata.terminal_id.trim()
+                  : ""
+                if ((!metadataProvider || metadataProvider === normalizedProvider) && metadataTerminalId) {
+                  terminalId = metadataTerminalId
+                }
+              }
+            } catch (error) {
+            }
+            if (!terminalId && this.kernel && typeof this.kernel.path === "function") {
+              const providerRoot = path.resolve(this.kernel.path("terminals", normalizedProvider))
+              if (resolvedCwd === providerRoot || resolvedCwd.startsWith(`${providerRoot}${path.sep}`)) {
+                const relative = path.relative(providerRoot, resolvedCwd)
+                if (relative && !relative.startsWith("..") && !path.isAbsolute(relative)) {
+                  const workspaceId = relative.split(path.sep)[0]
+                  if (workspaceId) {
+                    terminalId = `${normalizedProvider}:${workspaceId}`
+                    const nextMetadata = (parsedMetadata && typeof parsedMetadata === "object")
+                      ? { ...parsedMetadata }
+                      : {}
+                    if (!nextMetadata.provider) {
+                      nextMetadata.provider = normalizedProvider
+                    }
+                    if (!nextMetadata.cwd) {
+                      nextMetadata.cwd = resolvedCwd
+                    }
+                    nextMetadata.terminal_id = terminalId
+                    await fs.promises.writeFile(metadataPath, JSON.stringify(nextMetadata, null, 2), "utf8").catch(() => {})
+                  }
+                }
+              }
+            }
+            terminalMetadataCache.set(cacheKey, terminalId)
+            return terminalId
+          }
           for (let i = 0; i < providers.length; i++) {
             const provider = providers[i]
             for (let j = 0; j < provider.roots.length; j++) {
@@ -7638,14 +8013,34 @@ class Server {
                     if (!extractedEntry || !extractedEntry.id) {
                       continue
                     }
+                    const extractedTerminalId = await resolveWorkspaceTerminalId(provider.key, extractedEntry.cwd)
                     const key = `${provider.key}:${extractedEntry.id}`
                     const ts = parseSessionTimestamp(extractedEntry.timestamp)
                     const existing = byProvider.get(key)
+                    const existingSourceKind = existing && typeof existing.source_kind === "string" ? existing.source_kind : ""
+                    const extractedSourceKind = typeof extractedEntry.source_kind === "string" ? extractedEntry.source_kind : ""
+                    const existingResumeCapable = existing && typeof existing.resume_capable === "boolean" ? existing.resume_capable : null
+                    const extractedResumeCapable = typeof extractedEntry.resume_capable === "boolean" ? extractedEntry.resume_capable : null
+                    const existingResumeDisabledReason = existing && typeof existing.resume_disabled_reason === "string"
+                      ? existing.resume_disabled_reason
+                      : ""
+                    const extractedResumeDisabledReason = typeof extractedEntry.resume_disabled_reason === "string"
+                      ? extractedEntry.resume_disabled_reason
+                      : ""
                     const existingForkCapable = existing && typeof existing.fork_capable === "boolean" ? existing.fork_capable : null
                     const extractedForkCapable = typeof extractedEntry.fork_capable === "boolean" ? extractedEntry.fork_capable : null
                     const mergedForkCapable = provider.key === "gemini"
                       ? Boolean(existingForkCapable || extractedForkCapable)
                       : true
+                    let mergedResumeCapable = null
+                    if (existingResumeCapable === true || extractedResumeCapable === true) {
+                      mergedResumeCapable = true
+                    } else if (existingResumeCapable === false || extractedResumeCapable === false) {
+                      mergedResumeCapable = false
+                    }
+                    const mergedResumeDisabledReason = mergedResumeCapable === false
+                      ? (extractedResumeDisabledReason || existingResumeDisabledReason || "")
+                      : ""
                     const merged = {
                       ...existing,
                       id: extractedEntry.id,
@@ -7658,9 +8053,23 @@ class Server {
                       summary: extractedEntry.summary || (existing && existing.summary),
                       timestamp: existing ? Math.max(existing.timestamp || 0, ts) : ts,
                       source: existing ? existing.source : file,
+                      source_kind: existingSourceKind || extractedSourceKind || null,
                       metadata: existing ? (existing.metadata || extractedEntry.metadata || null) : (extractedEntry.metadata || null),
+                      terminal_id: extractedTerminalId || (existing && typeof existing.terminal_id === "string" ? existing.terminal_id : null),
                       fork_capable: mergedForkCapable
                     }
+                    if (mergedResumeCapable !== null) {
+                      merged.resume_capable = mergedResumeCapable
+                    }
+                    if (mergedResumeDisabledReason) {
+                      merged.resume_disabled_reason = mergedResumeDisabledReason
+                    } else if (mergedResumeCapable === true && Object.prototype.hasOwnProperty.call(merged, "resume_disabled_reason")) {
+                      delete merged.resume_disabled_reason
+                    }
+                    if (extractedSourceKind === "gemini_session") {
+                      merged.source = file
+                      merged.source_kind = extractedSourceKind
+                    }
                     if (!merged.cwd && extractedEntry.cwd) {
                       merged.cwd = extractedEntry.cwd
                     }
@@ -7669,7 +8078,15 @@ class Server {
                     }
                     if (!existing || ts > existing.timestamp) {
                       merged.timestamp = ts
-                      merged.source = file
+                      const preserveGeminiSessionSource = provider.key === "gemini"
+                        && existingSourceKind === "gemini_session"
+                        && extractedSourceKind === "gemini_log"
+                      if (!preserveGeminiSessionSource) {
+                        merged.source = file
+                        if (extractedSourceKind) {
+                          merged.source_kind = extractedSourceKind
+                        }
+                      }
                       if (extractedEntry.summary) {
                         merged.summary = extractedEntry.summary
                       }
@@ -7680,7 +8097,14 @@ class Server {
               }
             }
           }
-          const entries = Array.from(byProvider.values()).sort((a, b) => (b.timestamp || 0) - (a.timestamp || 0))
+          const entries = Array.from(byProvider.values())
+            .filter((entry) => {
+              if (!entry || entry.provider !== "gemini") {
+                return true
+              }
+              return entry.source_kind !== "gemini_log"
+            })
+            .sort((a, b) => (b.timestamp || 0) - (a.timestamp || 0))
           terminalSessionDiscoveryCache.entries = entries
           terminalSessionDiscoveryCache.expires = Date.now() + TERMINAL_SESSION_DISCOVERY_CACHE_TTL_MS
           return entries
@@ -7708,7 +8132,7 @@ class Server {
         const hasCachedEntries = Array.isArray(terminalSessionDiscoveryCache.entries)
         const cacheExpired = !hasCachedEntries || terminalSessionDiscoveryCache.expires <= now
         let discoveredEntries = hasCachedEntries ? terminalSessionDiscoveryCache.entries : []
-        if (forceDiscovery || !hasCachedEntries) {
+        if (forceDiscovery) {
           let refreshed = null
           try {
             refreshed = await startDiscoveryRefresh(true)
@@ -7720,6 +8144,24 @@ class Server {
           } else {
             discoveredEntries = Array.isArray(terminalSessionDiscoveryCache.entries) ? terminalSessionDiscoveryCache.entries : []
           }
+        } else if (!hasCachedEntries) {
+          const pendingRefresh = startDiscoveryRefresh(false)
+          if (pendingRefresh && typeof pendingRefresh.catch === "function") {
+            pendingRefresh.catch(() => {})
+          }
+          if (!cacheOnly) {
+            let refreshed = null
+            try {
+              refreshed = await startDiscoveryRefresh(true)
+            } catch (error) {
+              refreshed = null
+            }
+            if (Array.isArray(refreshed)) {
+              discoveredEntries = refreshed
+            } else {
+              discoveredEntries = Array.isArray(terminalSessionDiscoveryCache.entries) ? terminalSessionDiscoveryCache.entries : []
+            }
+          }
         } else if (cacheExpired) {
           const pendingRefresh = startDiscoveryRefresh(false)
           if (pendingRefresh && typeof pendingRefresh.catch === "function") {
@@ -7740,7 +8182,33 @@ class Server {
             latestDiscoveredByProviderCwd.set(entryKey, entry)
           }
         }
-        const isDiscoveredEntryOnline = (entry) => {
+        const getGeminiSourceSessionToken = (sourcePath) => {
+          if (typeof sourcePath !== "string" || sourcePath.trim().length === 0) {
+            return null
+          }
+          const resolved = path.resolve(sourcePath)
+          for (let i = 0; i < geminiCanonicalRoots.length; i++) {
+            const root = geminiCanonicalRoots[i]
+            if (!root) {
+              continue
+            }
+            const resolvedRoot = path.resolve(root)
+            if (!(resolved === resolvedRoot || resolved.startsWith(`${resolvedRoot}${path.sep}`))) {
+              continue
+            }
+            const relative = path.relative(resolvedRoot, resolved)
+            if (!relative || relative.startsWith("..") || path.isAbsolute(relative)) {
+              continue
+            }
+            const firstSegment = relative.split(path.sep)[0]
+            const normalized = normalizeSessionToken(firstSegment)
+            if (normalized) {
+              return normalized
+            }
+          }
+          return null
+        }
+        const isDiscoveredEntryDirectlyOnline = (entry) => {
           if (!entry) {
             return false
           }
@@ -7748,12 +8216,44 @@ class Server {
             return true
           }
           const providerKey = typeof entry.provider === "string" ? entry.provider.toLowerCase() : ""
+          if (providerKey === "gemini") {
+            const sourceSessionToken = getGeminiSourceSessionToken(entry.source)
+            if (sourceSessionToken && isSessionOnline(providerKey, sourceSessionToken)) {
+              return true
+            }
+          }
+          return false
+        }
+        const directOnlineByProviderCwd = new Set()
+        for (let i = 0; i < discoveredEntries.length; i++) {
+          const entry = discoveredEntries[i]
+          if (!isDiscoveredEntryDirectlyOnline(entry)) {
+            continue
+          }
+          const providerKey = entry && typeof entry.provider === "string" ? entry.provider.toLowerCase() : ""
+          const cwdKey = normalizeCwdKey(entry && entry.cwd ? entry.cwd : "")
+          if (!providerKey || !cwdKey) {
+            continue
+          }
+          directOnlineByProviderCwd.add(`${providerKey}|${cwdKey}`)
+        }
+        const isDiscoveredEntryOnline = (entry) => {
+          if (!entry) {
+            return false
+          }
+          if (isDiscoveredEntryDirectlyOnline(entry)) {
+            return true
+          }
+          const providerKey = typeof entry.provider === "string" ? entry.provider.toLowerCase() : ""
           const cwdKey = normalizeCwdKey(entry.cwd || "")
           if (!providerKey || !cwdKey) {
             return false
           }
           const contextKey = `${providerKey}|${cwdKey}`
-          if (!runningForkProviderCwdKeys.has(contextKey)) {
+          if (!runningProviderCwdKeys.has(contextKey)) {
+            return false
+          }
+          if (directOnlineByProviderCwd.has(contextKey) && !runningForkProviderCwdKeys.has(contextKey)) {
             return false
           }
           const latest = latestDiscoveredByProviderCwd.get(contextKey)
@@ -7764,6 +8264,10 @@ class Server {
         }
 
         return Array.from(discoveredEntries || [])
+          .filter((entry) => {
+            const workingDirectory = entry && typeof entry.cwd === "string" ? entry.cwd.trim() : ""
+            return workingDirectory.length > 0
+          })
           .sort((a, b) => {
             const aOnline = isDiscoveredEntryOnline(a) ? 1 : 0
             const bOnline = isDiscoveredEntryOnline(b) ? 1 : 0
@@ -7775,7 +8279,10 @@ class Server {
             return tb - ta
           })
           .map((entry, index) => {
-            const workingDirectory = entry.cwd || this.kernel.path("api")
+            const workingDirectory = typeof entry.cwd === "string" ? entry.cwd.trim() : ""
+            const terminalId = typeof entry.terminal_id === "string" ? entry.terminal_id.trim() : ""
+            const entryResumeCapable = typeof entry.resume_capable === "boolean" ? entry.resume_capable : null
+            const resumeCapable = workingDirectory.length > 0 && entryResumeCapable !== false
             const codexResumeCommand = buildCodexResumeBaseCommand(entry)
             const resumeBaseCommand = codexResumeCommand.command
             const buildTemplatedSessionCommand = (template, sessionId) => {
@@ -7798,45 +8305,37 @@ class Server {
             const resumeCommand = buildTemplatedSessionCommand(resumeTemplate, entry.id)
             let forkCommand = buildTemplatedSessionCommand(forkTemplate, entry.id)
             let forkCapable = forkCommand !== resumeCommand
+            let resumeDisabledReason = ""
             let forkDisabledReason = ""
+            if (!resumeCapable) {
+              const explicitResumeReason = typeof entry.resume_disabled_reason === "string"
+                ? entry.resume_disabled_reason.trim()
+                : ""
+              if (explicitResumeReason) {
+                resumeDisabledReason = explicitResumeReason
+              } else if (workingDirectory.length === 0) {
+                resumeDisabledReason = `${entry.providerLabel || "Session"} resume unavailable: missing working directory metadata.`
+              } else {
+                resumeDisabledReason = `${entry.providerLabel || "Session"} resume unavailable for this session.`
+              }
+            }
             if (entry.provider === "gemini" && typeof entry.source === "string" && entry.source.length > 0) {
               forkCapable = Boolean(entry.fork_capable)
               if (forkCapable) {
-                const cloneScript = [
-                  'const fs = require("fs")',
-                  'const path = require("path")',
-                  'const crypto = require("crypto")',
-                  'const sourcePath = process.argv[1]',
-                  'const expectedSessionId = process.argv[2]',
-                  'if (!sourcePath) process.exit(1)',
-                  'const raw = fs.readFileSync(sourcePath, "utf8")',
-                  'const payload = JSON.parse(raw)',
-                  'if (!payload || typeof payload !== "object") process.exit(1)',
-                  'const sourceSessionId = typeof payload.sessionId === "string" ? payload.sessionId : (typeof payload.session_id === "string" ? payload.session_id : "")',
-                  'if (!sourceSessionId) process.exit(1)',
-                  'if (expectedSessionId && sourceSessionId !== expectedSessionId) process.exit(1)',
-                  'if (!Array.isArray(payload.messages)) process.exit(1)',
-                  'const newSessionId = typeof crypto.randomUUID === "function" ? crypto.randomUUID() : `${Date.now().toString(16)}-${Math.random().toString(16).slice(2)}-${Math.random().toString(16).slice(2)}`',
-                  'const nowIso = new Date().toISOString()',
-                  'payload.sessionId = newSessionId',
-                  'if (typeof payload.session_id === "string") payload.session_id = newSessionId',
-                  'if (typeof payload.startTime === "string") payload.startTime = nowIso',
-                  'if (typeof payload.lastUpdated === "string") payload.lastUpdated = nowIso',
-                  'const stamp = nowIso.replace(/[:.]/g, "-")',
-                  'const filename = `session-${stamp}-${newSessionId.slice(0, 8)}.json`',
-                  'const targetPath = path.join(path.dirname(sourcePath), filename)',
-                  'fs.writeFileSync(targetPath, JSON.stringify(payload, null, 2), "utf8")',
-                  'process.stdout.write(newSessionId)'
-                ].join(";")
-                const cloneAndResume = `FORK_SESSION_ID=$(node -e ${JSON.stringify(cloneScript)} ${JSON.stringify(entry.source)} ${JSON.stringify(entry.id)}) && ${resumeBaseCommand} --resume "$FORK_SESSION_ID"`
+                const geminiForkResumeScript = path.resolve(__dirname, "scripts", "gemini_fork_and_resume.js")
+                const cloneAndResume = `node ${JSON.stringify(geminiForkResumeScript)} ${JSON.stringify(entry.source)} ${JSON.stringify(entry.id)}`
                 forkCommand = cloneAndResume
               } else {
                 forkCommand = ""
                 forkDisabledReason = "Gemini fork unavailable for this session format. Use /chat save and /chat resume to branch manually."
               }
             }
-            if (entry.provider === "codex" && forkCommand !== resumeCommand) {
-              forkCommand = `(${forkCommand}) || (${resumeCommand})`
+            if (!resumeCapable) {
+              forkCapable = false
+              forkCommand = ""
+              if (!forkDisabledReason) {
+                forkDisabledReason = resumeDisabledReason
+              }
             }
             if (!forkCapable && !forkDisabledReason) {
               forkDisabledReason = `${entry.providerLabel || "Session"} fork unavailable for this session.`
@@ -7849,6 +8348,9 @@ class Server {
               params.set("path", workingDirectory)
               params.set("cwd", workingDirectory)
               params.set("session", sessionValue)
+              if (terminalId) {
+                params.set("terminal_id", terminalId)
+              }
               params.set("message", command)
               params.set("input", "1")
               if (forkMode) {
@@ -7856,11 +8358,23 @@ class Server {
               }
               return `${route}?${params.toString()}`
             }
-            const resumeUrl = buildShellRoute(resumeCommand, entry.id, false)
-            const forkUrl = forkCapable && forkCommand
+            let resumeUrl = resumeCapable ? buildShellRoute(resumeCommand, entry.id, false) : "#"
+            const forkUrl = resumeCapable && forkCapable && forkCommand
               ? buildShellRoute(forkCommand, `fork:${entry.id}`, true)
               : ""
             const online = isDiscoveredEntryOnline(entry)
+            const normalizedTerminalId = normalizeSessionToken(terminalId) || terminalId
+            if (resumeCapable && normalizedTerminalId) {
+              const normalizedEntrySessionId = normalizeSessionToken(entry.id)
+              const exactShellId = normalizedEntrySessionId
+                ? runningShellIdByTerminalSession.get(`${normalizedTerminalId}|${normalizedEntrySessionId}`)
+                : null
+              const terminalShellIds = runningShellIdsByTerminalId.get(normalizedTerminalId) || []
+              const resolvedShellId = exactShellId || terminalShellIds[terminalShellIds.length - 1] || ""
+              if (resolvedShellId) {
+                resumeUrl = resolvedShellId.startsWith("/") ? resolvedShellId : `/${resolvedShellId}`
+              }
+            }
             return {
               name: title,
               description: `${entry.providerLabel} · ${entry.cwd || "cwd unavailable"}`,
@@ -7869,19 +8383,52 @@ class Server {
               index,
               url: resumeUrl,
               browser_url: resumeUrl,
+              resume_capable: resumeCapable,
+              resume_disabled_reason: resumeDisabledReason || null,
               fork_url: forkUrl,
               fork_capable: forkCapable,
               fork_disabled_reason: forkDisabledReason || null,
               filepath: entry.cwd || "",
               provider_label: entry.providerLabel || entry.provider || "Session",
               cwd: entry.cwd || "",
-              timestamp: entry.timestamp || null
+              timestamp: entry.timestamp || null,
+              terminal_id: terminalId || null
+            }
+          })
+      }
+      const syncTerminalSessionRegistry = async () => {
+        if (!terminalSessionRegistrySyncPromise) {
+          terminalSessionRegistrySyncPromise = (async () => {
+            const discoveredItems = await buildTerminalSessions(true)
+            const normalizedDiscoveredItems = coerceTerminalRegistryItems(discoveredItems)
+            const existingRegistry = await readTerminalSessionRegistry()
+            const hasChanged = !terminalRegistryItemsEqual(existingRegistry.items, normalizedDiscoveredItems)
+            if (hasChanged || !existingRegistry.exists) {
+              await writeTerminalSessionRegistry(normalizedDiscoveredItems)
+            }
+            return {
+              items: hasChanged ? normalizedDiscoveredItems : existingRegistry.items,
+              changed: hasChanged
             }
+          })().finally(() => {
+            terminalSessionRegistrySyncPromise = null
           })
+        }
+        return terminalSessionRegistrySyncPromise
       }
 
       if (req.query.mode === "terminals" && (req.query.fetch === "1" || req.query.format === "json")) {
         const includeSkills = req.query.skills === "1"
+        const hasLimitParam = Object.prototype.hasOwnProperty.call(req.query, "limit")
+        const parsedLimit = Number.parseInt(req.query.limit, 10)
+        const pageLimit = hasLimitParam && Number.isFinite(parsedLimit)
+          ? Math.min(Math.max(parsedLimit, 1), 500)
+          : null
+        const parsedCursor = Number.parseInt(req.query.cursor, 10)
+        const pageCursor = pageLimit !== null && Number.isFinite(parsedCursor) && parsedCursor > 0
+          ? parsedCursor
+          : 0
+        const searchQuery = typeof req.query.q === "string" ? req.query.q.trim().toLowerCase() : ""
         let serializedSkills = null
         if (includeSkills) {
           const terminalSkills = await listTerminalSkills()
@@ -7908,15 +8455,60 @@ class Server {
           res.status(400).json(errorPayload)
           return
         }
-        const forceDiscovery = req.query.refresh === "1" || req.query.fresh === "1" || req.query.force === "1"
-        const terminalItems = await buildTerminalSessions(forceDiscovery)
+        await scrubTerminalSessionRegistryOnlineStateAtBoot().catch(() => {})
+        const syncRequested = req.query.sync === "1"
+          || req.query.refresh === "1"
+          || req.query.fresh === "1"
+          || req.query.force === "1"
+        let terminalItems = []
+        if (syncRequested) {
+          const syncResult = await syncTerminalSessionRegistry()
+          terminalItems = Array.isArray(syncResult && syncResult.items) ? syncResult.items : []
+        } else {
+          const registry = await readTerminalSessionRegistry()
+          terminalItems = Array.isArray(registry.items) ? registry.items : []
+          if (terminalItems.length === 0) {
+            const syncResult = await syncTerminalSessionRegistry()
+            terminalItems = Array.isArray(syncResult && syncResult.items) ? syncResult.items : []
+          }
+        }
         for (let i = 0; i < terminalItems.length; i++) {
           terminalItems[i].index = i
         }
+        let filteredItems = terminalItems
+        if (searchQuery) {
+          filteredItems = terminalItems.filter((item) => {
+            const haystack = [
+              item && item.name ? item.name : "",
+              item && item.description ? item.description : "",
+              item && item.provider_label ? item.provider_label : "",
+              item && item.cwd ? item.cwd : "",
+              item && item.uri ? item.uri : ""
+            ].join(" ").toLowerCase()
+            return haystack.includes(searchQuery)
+          })
+        }
+        let responseItems = filteredItems
+        let pagination = null
+        if (pageLimit !== null) {
+          const safeCursor = Math.max(0, Math.min(pageCursor, filteredItems.length))
+          const sliceEnd = Math.min(filteredItems.length, safeCursor + pageLimit)
+          responseItems = filteredItems.slice(safeCursor, sliceEnd)
+          pagination = {
+            cursor: safeCursor,
+            limit: pageLimit,
+            total: filteredItems.length,
+            hasMore: sliceEnd < filteredItems.length,
+            nextCursor: sliceEnd < filteredItems.length ? sliceEnd : null
+          }
+        }
         const responsePayload = {
-          items: terminalItems,
+          items: responseItems,
           providers: getTerminalStarterProviders().map((provider) => ({ key: provider.key, label: provider.label }))
         }
+        if (pagination) {
+          responsePayload.pagination = pagination
+        }
         if (includeSkills) {
           responsePayload.skills = Array.isArray(serializedSkills) ? serializedSkills : []
         }
@@ -7929,28 +8521,13 @@ class Server {
           res.redirect("/home?mode=settings")
           return
         }
-        const initialTerminalItems = await buildTerminalSessions()
-        let terminalItems = Array.isArray(initialTerminalItems) ? initialTerminalItems : []
-        // Avoid serving a stale empty-first paint: if cached result is empty,
-        // force one fresh discovery pass before rendering.
-        if (terminalItems.length === 0) {
-          const freshTerminalItems = await buildTerminalSessions(true)
-          if (Array.isArray(freshTerminalItems) && freshTerminalItems.length > 0) {
-            terminalItems = freshTerminalItems
-          }
-        }
-        let listItems = terminalItems
-        for (let i = 0; i < listItems.length; i++) {
-          listItems[i].index = i
-        }
-
         res.render("terminals", {
           logo: this.logo,
           theme: this.theme,
           agent: req.agent,
           query: req.query,
           uri: "/home?mode=terminals",
-          items: listItems,
+          items: [],
           providers: getTerminalStarterProviders().map((provider) => ({ key: provider.key, label: provider.label })),
           skills: [],
           ishome: false
@@ -8220,6 +8797,160 @@ class Server {
 
     this.app.get("/home", renderHomePage)
 
+    const normalizePathForComparison = (value) => {
+      if (typeof value !== "string" || value.trim().length === 0) {
+        return ""
+      }
+      let resolved = path.resolve(value.trim())
+      if (process.platform === "win32") {
+        resolved = resolved.toLowerCase()
+      }
+      return resolved
+    }
+    const isPathWithin = (candidate, parent) => {
+      const normalizedCandidate = normalizePathForComparison(candidate)
+      const normalizedParent = normalizePathForComparison(parent)
+      if (!normalizedCandidate || !normalizedParent) {
+        return false
+      }
+      if (normalizedCandidate === normalizedParent) {
+        return true
+      }
+      const withSep = normalizedParent.endsWith(path.sep) ? normalizedParent : `${normalizedParent}${path.sep}`
+      return normalizedCandidate.startsWith(withSep)
+    }
+
+    this.app.post("/terminals/deploy/local", ex(async (req, res) => {
+      const body = req.body && typeof req.body === "object" ? req.body : {}
+      const folderName = typeof body.folderName === "string" ? body.folderName.trim() : ""
+      const sessionUri = typeof body.sessionUri === "string" ? body.sessionUri.trim().toLowerCase() : ""
+      const sessionCwdHint = typeof body.sessionCwd === "string" ? body.sessionCwd.trim() : ""
+
+      if (!folderName) {
+        res.status(400).json({
+          ok: false,
+          error: "folderName is required"
+        })
+        return
+      }
+      if (folderName === "." || folderName === ".." || /[\\/]/.test(folderName) || folderName.includes("\0")) {
+        res.status(400).json({
+          ok: false,
+          error: "Invalid folder name"
+        })
+        return
+      }
+
+      const registryPath = this.kernel.path("cache", "terminals", "sessions.json")
+      let registryItems = []
+      try {
+        const rawRegistry = await fs.promises.readFile(registryPath, "utf8")
+        const parsedRegistry = JSON.parse(rawRegistry)
+        if (parsedRegistry && Array.isArray(parsedRegistry.items)) {
+          registryItems = parsedRegistry.items
+        }
+      } catch (error) {
+      }
+
+      let sourcePath = ""
+      if (sessionUri) {
+        for (let i = 0; i < registryItems.length; i++) {
+          const entry = registryItems[i]
+          const entryUri = entry && typeof entry.uri === "string" ? entry.uri.trim().toLowerCase() : ""
+          const entryCwd = entry && typeof entry.cwd === "string" ? entry.cwd.trim() : ""
+          if (entryUri && entryCwd && entryUri === sessionUri) {
+            sourcePath = entryCwd
+            break
+          }
+        }
+      }
+
+      if (!sourcePath && sessionCwdHint) {
+        const normalizedHint = normalizePathForComparison(sessionCwdHint)
+        for (let i = 0; i < registryItems.length; i++) {
+          const entry = registryItems[i]
+          const entryCwd = entry && typeof entry.cwd === "string" ? entry.cwd.trim() : ""
+          if (entryCwd && normalizePathForComparison(entryCwd) === normalizedHint) {
+            sourcePath = entryCwd
+            break
+          }
+        }
+        if (!sourcePath) {
+          const terminalsRoot = this.kernel.path("terminals")
+          if (isPathWithin(normalizedHint, terminalsRoot)) {
+            sourcePath = normalizedHint
+          }
+        }
+      }
+
+      if (!sourcePath) {
+        res.status(400).json({
+          ok: false,
+          error: "Current session folder not found."
+        })
+        return
+      }
+
+      let sourceStats = null
+      try {
+        sourceStats = await fs.promises.stat(sourcePath)
+      } catch (error) {
+      }
+      if (!sourceStats || !sourceStats.isDirectory()) {
+        res.status(400).json({
+          ok: false,
+          error: "Current session folder not found."
+        })
+        return
+      }
+
+      const apiRoot = this.kernel.path("api")
+      await fs.promises.mkdir(apiRoot, { recursive: true })
+      const targetPath = this.kernel.path("api", folderName)
+      const normalizedSourcePath = normalizePathForComparison(sourcePath)
+      const normalizedTargetPath = normalizePathForComparison(targetPath)
+      if (!normalizedTargetPath || !isPathWithin(normalizedTargetPath, apiRoot)) {
+        res.status(400).json({
+          ok: false,
+          error: "Invalid destination path."
+        })
+        return
+      }
+      if (isPathWithin(normalizedTargetPath, normalizedSourcePath)) {
+        res.status(400).json({
+          ok: false,
+          error: "Invalid deployment target."
+        })
+        return
+      }
+
+      const targetExists = await fs.promises.access(targetPath, fs.constants.F_OK).then(() => true).catch(() => false)
+      if (targetExists) {
+        res.json({
+          ok: false,
+          code: "exists",
+          error: "Folder already exists"
+        })
+        return
+      }
+
+      try {
+        await fs.promises.cp(sourcePath, targetPath, { recursive: true })
+      } catch (error) {
+        res.status(500).json({
+          ok: false,
+          error: error && error.message ? error.message : "Failed to copy folder."
+        })
+        return
+      }
+
+      res.json({
+        ok: true,
+        folder: folderName,
+        path: targetPath
+      })
+    }))
+
     this.app.post("/terminals/start", ex(async (req, res) => {
       const providers = getTerminalStarterProviders()
       const providerMap = new Map(providers.map((provider) => [provider.key, provider]))
@@ -8237,6 +8968,7 @@ class Server {
       const timestamp = `${now.getFullYear()}${pad(now.getMonth() + 1)}${pad(now.getDate())}-${pad(now.getHours())}${pad(now.getMinutes())}${pad(now.getSeconds())}`
       const shortId = Math.random().toString(36).slice(2, 8)
       const folderName = `${timestamp}-${shortId}`
+      const terminalId = `${provider.key}:${folderName}`
       const terminalsRoot = this.kernel.path("terminals")
       const providerRoot = path.resolve(terminalsRoot, provider.key)
       const sessionCwd = path.resolve(providerRoot, folderName)
@@ -8288,6 +9020,18 @@ class Server {
       }
 
       await fs.promises.mkdir(sessionCwd, { recursive: true })
+      try {
+        await this.kernel.exec({
+          message: ["git init"],
+          path: sessionCwd
+        }, () => {})
+      } catch (error) {
+        await fs.promises.rm(sessionCwd, { recursive: true, force: true }).catch(() => {})
+        res.status(500).json({
+          error: error && error.message ? error.message : "Failed to initialize git repository for the new session."
+        })
+        return
+      }
       const copiedUploads = []
       if (requestedUploadToken) {
         const uploadDir = path.resolve(this.kernel.path("tmp", "create", requestedUploadToken))
@@ -8331,6 +9075,7 @@ class Server {
       await fs.promises.writeFile(metadataPath, JSON.stringify({
         provider: provider.key,
         label: provider.label,
+        terminal_id: terminalId,
         created_at: now.toISOString(),
         cwd: sessionCwd,
         command: provider.startCommand || provider.command,
@@ -8342,6 +9087,7 @@ class Server {
       const params = new URLSearchParams()
       params.set("path", sessionCwd)
       params.set("cwd", sessionCwd)
+      params.set("terminal_id", terminalId)
       params.set("message", provider.startCommand || provider.command)
       params.set("input", "1")
       const route = `/shell/start-${provider.key}-${folderName}`
@@ -9131,12 +9877,37 @@ class Server {
 
       let baseShellId = "shell/" + decodeURIComponent(req.params.id)
       const sessionId = typeof req.query.session === "string" && req.query.session.length > 0 ? req.query.session : null
+      const terminalId = typeof req.query.terminal_id === "string" && req.query.terminal_id.length > 0 ? req.query.terminal_id : null
+      const isForkRequest = req.query.fork === "1"
       let id = baseShellId
-      if (sessionId) {
-        id = `${baseShellId}?session=${sessionId}`
+      if (sessionId || terminalId) {
+        const idParams = new URLSearchParams()
+        if (sessionId) {
+          idParams.set("session", sessionId)
+        }
+        if (terminalId) {
+          idParams.set("terminal_id", terminalId)
+        }
+        id = `${baseShellId}?${idParams.toString()}`
+      }
+      let shell = this.kernel.shell.get(id)
+      if (shell && terminalId && !isForkRequest) {
+        req.query.message = ""
       }
       let target = req.query.target ? req.query.target : null
-      let cwd = this.kernel.path(this.kernel.api.filePath(decodeURIComponent(req.query.path)))
+      const rawPathParam = typeof req.query.path === "string" && req.query.path.length > 0
+        ? decodeURIComponent(req.query.path)
+        : ""
+      const rawCwdParam = typeof req.query.cwd === "string" && req.query.cwd.length > 0
+        ? decodeURIComponent(req.query.cwd)
+        : ""
+      const shellPath = shell && typeof shell.path === "string" && shell.path.length > 0
+        ? shell.path
+        : ""
+      const resolvedPath = rawPathParam || rawCwdParam || shellPath
+      let cwd = resolvedPath
+        ? this.kernel.path(this.kernel.api.filePath(resolvedPath))
+        : this.kernel.homedir
       let message = req.query.message ? decodeURIComponent(req.query.message) : null
       //let message = req.query.message ? req.query.message : null
       let venv = req.query.venv ? decodeURIComponent(req.query.venv) : null
@@ -9173,8 +9944,7 @@ class Server {
 //          pattern[key] = req.query[pattern_key]
 //        }
 //      }
-
-      let shell = this.kernel.shell.get(id)
+      await ensureCodexSelectedSkillFrontmatter(cwd).catch(() => {})
       res.render("shell", {
         target,
         filepath: cwd,