diff --git a/packages/app/e2e/regression/command-palette.spec.ts b/packages/app/e2e/regression/command-palette.spec.ts
index 77be50624850..1c3daaad8482 100644
--- a/packages/app/e2e/regression/command-palette.spec.ts
+++ b/packages/app/e2e/regression/command-palette.spec.ts
@@ -48,6 +48,29 @@ test("lists recent sessions before a query is entered", async ({ page }) => {
await expect(page.getByRole("heading", { name: paletteSession.title, exact: true })).toBeVisible()
})
+test("pins the open session from the palette", async ({ page }) => {
+ const { dialog, input } = await openCommandPalette(page)
+ await input.pressSequentially("pin session")
+ const pin = dialog.getByRole("option", { name: /^Pin session/ })
+ await expect(pin).toHaveAttribute("aria-selected", "true")
+ await input.press("Enter")
+ await expect(dialog).toHaveCount(0)
+
+ await page.keyboard.press("ControlOrMeta+Shift+P")
+ const reopened = page.getByRole("dialog").getByRole("textbox")
+ await reopened.pressSequentially("pin session")
+ await expect(page.getByRole("option", { name: /^Unpin session/ })).toHaveAttribute("aria-selected", "true")
+ await page.keyboard.press("Escape")
+
+ await page.getByRole("button", { name: "Home", exact: true }).click()
+ const list = page.getByRole("region", { name: "Recent sessions" })
+ await expect(list.getByText("Pinned", { exact: true })).toBeVisible()
+ await expect(list.locator('[data-component="home-session-row-container"]').first()).toHaveAttribute(
+ "data-session-id",
+ paletteSession.id,
+ )
+})
+
test("reopens from its shortcut as soon as it closes", async ({ page }) => {
const { dialog, input } = await openCommandPalette(page)
await input.press("Escape")
diff --git a/packages/app/e2e/regression/home.spec.ts b/packages/app/e2e/regression/home.spec.ts
index ddc15b838427..2900e587478b 100644
--- a/packages/app/e2e/regression/home.spec.ts
+++ b/packages/app/e2e/regression/home.spec.ts
@@ -26,15 +26,15 @@ test("the session context menu renames, exports, and deletes a Home session", as
await target.focus()
await target.press("Shift+F10")
- await expect(page.getByRole("menuitem", { name: "Rename" })).toBeVisible()
+ await expect(page.getByRole("menuitem", { name: "Pin" })).toBeVisible()
await page.keyboard.press("Escape")
- await expect(page.getByRole("menuitem", { name: "Rename" })).toBeHidden()
+ await expect(page.getByRole("menuitem", { name: "Pin" })).toBeHidden()
await expect(target).toBeFocused()
const box = await target.boundingBox()
await target.click({ button: "right", position: { x: 48, y: 12 } })
await expect(page).toHaveURL("/")
- await expect(page.getByRole("menuitem")).toHaveText(["Rename", "Export…", "Delete…"])
+ await expect(page.getByRole("menuitem")).toHaveText(["Pin", "Rename", "Export…", "Delete…"])
const menu = await page.locator('[data-component="menu-v2-content"]').boundingBox()
expect(Math.abs((menu?.x ?? 0) - (box?.x ?? 0) - 48)).toBeLessThan(4)
@@ -77,6 +77,34 @@ test("the session context menu renames, exports, and deletes a Home session", as
await expect(renamedRow).toBeHidden()
})
+test("pinning a Home session keeps it above the other sessions", async ({ page }) => {
+ await openHome(page)
+ const list = page.getByRole("region", { name: "Recent sessions" })
+ const target = row(page, fixture.expected.targetTitle)
+ await expect(target).toBeVisible()
+ await expect(list.getByText("Pinned", { exact: true })).toHaveCount(0)
+
+ await target.click({ button: "right" })
+ await page.getByRole("menuitem", { name: "Pin", exact: true }).click()
+
+ await expect(list.getByText("Pinned", { exact: true })).toBeVisible()
+ await expect(list.locator('[data-component="home-session-row-container"]').first()).toHaveAttribute(
+ "data-session-id",
+ fixture.targetID,
+ )
+
+ await page.reload()
+ await expect(list.getByText("Pinned", { exact: true })).toBeVisible()
+ await expect(list.locator('[data-component="home-session-row-container"]').first()).toHaveAttribute(
+ "data-session-id",
+ fixture.targetID,
+ )
+
+ await target.click({ button: "right" })
+ await page.getByRole("menuitem", { name: "Unpin", exact: true }).click()
+ await expect(list.getByText("Pinned", { exact: true })).toHaveCount(0)
+})
+
test("the Home shortcut focuses session search, and the Home button leaves focus alone", async ({ page }) => {
await mockStressTimeline(page)
await seed(page, {
diff --git a/packages/app/src/app.tsx b/packages/app/src/app.tsx
index 78d11175f81e..c344bc77c715 100644
--- a/packages/app/src/app.tsx
+++ b/packages/app/src/app.tsx
@@ -10,6 +10,7 @@ import { type Component, createRenderEffect, ErrorBoundary, type JSX, type Paren
import { Dynamic } from "solid-js/web"
import { CommandProvider } from "@/shell/commands/command"
import { DesktopCommands } from "@/shell/commands/desktop"
+import { SessionPinsProvider } from "@/home/sessions/pins"
import { GlobalProvider } from "@/runtime/server/runtime"
import { LanguageProvider, UiI18nBridge, type Locale } from "@/runtime/i18n/language"
import { ServerConnection, ServersProvider } from "@/runtime/server/registry"
@@ -94,16 +95,18 @@ export function AppInterface(props: {
// route changes. Draft and session routes override only their server-bound data
// providers beneath it.
const Root = (rootProps: ParentProps) => (
-
-
-
-
-
- {props.children}
- {rootProps.children}
-
-
-
+
+
+
+
+
+
+ {props.children}
+ {rootProps.children}
+
+
+
+
)
return (
diff --git a/packages/app/src/home/sessions/controller.tsx b/packages/app/src/home/sessions/controller.tsx
index 3e27ebc2f051..a708fbbd05d3 100644
--- a/packages/app/src/home/sessions/controller.tsx
+++ b/packages/app/src/home/sessions/controller.tsx
@@ -4,6 +4,7 @@ import { Button } from "@opencode/ui/button"
import { DialogFooter, DialogHeader, DialogTitleGroup, Dialog } from "@opencode/ui/dialog"
import { skipToken, useQuery, useQueryClient } from "@tanstack/solid-query"
import { type Accessor, createEffect, createMemo, type JSX, startTransition, untrack } from "solid-js"
+import { createStore } from "solid-js/store"
import { notifySessionTabsRemoved } from "@/shell/titlebar/session-events"
import { useCommand } from "@/shell/commands/command"
import {
@@ -27,6 +28,7 @@ import { showToast } from "@/shell/notifications/toast"
import { archiveHomeSession } from "./archive"
import type { HomeController } from "../model"
import { buildHomeSessionRecords, homeProjectForSession, homeSessionLocation, type HomeSessionRecord } from "./records"
+import { useSessionPins } from "./pins"
export type { HomeSessionRecord } from "./records"
@@ -34,7 +36,7 @@ export type { HomeSessionRecord } from "./records"
const selectSessions = (sessions: SessionInfo[]) => () => sessions
export type HomeSessionGroup = {
- id: "today" | "yesterday" | "older"
+ id: "pinned" | "today" | "yesterday" | "older"
title: string
sessions: HomeSessionRecord[]
}
@@ -48,6 +50,7 @@ export function createHomeSessionsController(home: HomeController) {
const language = useLanguage()
const platform = usePlatform()
const queryClient = useQueryClient()
+ const pins = useSessionPins()
const projectDirectories = createMemo(() => {
const selected = home.selection.value().directory
@@ -91,17 +94,70 @@ export function createHomeSessionsController(home: HomeController) {
)
})
- const allRecords = createMemo(() =>
- buildHomeSessionRecords({
- sessions: indexedSessions,
+ const serverKey = createMemo(() => {
+ const conn = home.server.focused()
+
+ return conn ? ServerConnection.key(conn) : undefined
+ })
+
+ const pinnedIDs = createMemo(() => {
+ const server = serverKey()
+
+ return server ? pins.ids(server) : []
+ })
+
+ // Pinned sessions can outlive the fetched index, so resolve the ones it does not hold.
+ const resolvedPins = new Set()
+ const [resolved, setResolved] = createStore<{ sessions: Record }>({ sessions: {} })
+
+ createEffect(() => {
+ const ctx = home.server.focusedContext()
+ const server = serverKey()
+
+ if (!ctx || !server) return
+ const indexed = new Set(indexedSessions().map((session) => session.id))
+
+ pinnedIDs()
+ .filter((sessionID) => !indexed.has(sessionID))
+ .forEach((sessionID) => {
+ const key = `${server}\0${sessionID}`
+
+ if (resolvedPins.has(key)) return
+ resolvedPins.add(key)
+ void untrack(() => ctx.sdk.api.session.get({ sessionID })).then(
+ (session) => setResolved("sessions", key, session),
+ () => undefined,
+ )
+ })
+ })
+
+ const pinnedSessions = createMemo(() => {
+ const server = serverKey()
+
+ if (!server) return []
+ const indexed = new Map(indexedSessions().map((session) => [session.id, session] as const))
+
+ return pinnedIDs().flatMap((sessionID) => {
+ const session = indexed.get(sessionID) ?? resolved.sessions[`${server}\0${sessionID}`]
+
+ return session && !session.parentID && session.time.archived === undefined ? [session] : []
+ })
+ })
+
+ const allRecords = createMemo(() => {
+ const pinned = new Map(pinnedIDs().map((id, index) => [id, index] as const))
+ const rank = (sessionID: string) => pinned.get(sessionID) ?? Number.MAX_SAFE_INTEGER
+
+ return buildHomeSessionRecords({
+ sessions: () => [...pinnedSessions(), ...indexedSessions()],
projectDirectories,
projects: home.project.list,
resolveProject: (session) => home.server.focusedContext()?.projects.forSession(session),
- }),
- )
+ }).toSorted((a, b) => rank(a.session.id) - rank(b.session.id))
+ })
const records = createMemo(() => allRecords().slice(0, HOME_SESSION_LIMIT))
- const groups = createMemo(() => groupSessions(records(), language))
+ const groups = createMemo(() => groupSessions(records(), language, new Set(pinnedIDs())))
const prefetched = new Set()
const location = (record: HomeSessionRecord) => {
@@ -249,10 +305,11 @@ export function createHomeSessionsController(home: HomeController) {
.remove(session.id)
.then(() => {
notifySessionTabsRemoved({
- server: ServerConnection.key(conn),
+ server,
directory: session.location.directory,
sessionIDs: ids,
})
+ pins.forget(server, ids)
return true
})
@@ -388,6 +445,19 @@ export function createHomeSessionsController(home: HomeController) {
return !!server && sessionHasOpenTab(tabs.store, server, record.session)
},
},
+ pin: {
+ is: (record: HomeSessionRecord) => {
+ const server = serverKey()
+
+ return !!server && pins.pinned(server, record.session.id)
+ },
+ toggle: (record: HomeSessionRecord) => {
+ const server = serverKey()
+
+ if (!server) return
+ pins.toggle(server, record.session.id)
+ },
+ },
}
}
@@ -404,14 +474,20 @@ function localDay(date: Date) {
return date.getFullYear() * 10_000 + date.getMonth() * 100 + date.getDate()
}
-function groupSessions(records: HomeSessionRecord[], language: ReturnType): HomeSessionGroup[] {
+function groupSessions(
+ records: HomeSessionRecord[],
+ language: ReturnType,
+ pinned: Set,
+): HomeSessionGroup[] {
const now = new Date()
const today = localDay(now)
const yesterday = localDay(new Date(now.getFullYear(), now.getMonth(), now.getDate() - 1))
const day = (record: HomeSessionRecord) => localDay(new Date(record.session.time.updated ?? record.session.time.created))
- const todaySessions = records.filter((record) => day(record) === today)
- const yesterdaySessions = records.filter((record) => day(record) === yesterday)
- const olderSessions = records.filter((record) => day(record) !== today && day(record) !== yesterday)
+ const pinnedRecords = records.filter((record) => pinned.has(record.session.id))
+ const recent = records.filter((record) => !pinned.has(record.session.id))
+ const todaySessions = recent.filter((record) => day(record) === today)
+ const yesterdaySessions = recent.filter((record) => day(record) === yesterday)
+ const olderSessions = recent.filter((record) => day(record) !== today && day(record) !== yesterday)
const olderTitle =
todaySessions.length === 0 && yesterdaySessions.length === 0
@@ -419,6 +495,7 @@ function groupSessions(records: HomeSessionRecord[], language: ReturnType {
+ test("keeps the order pins were added in and ignores a repeat", () => {
+ const pins = withPin(withPin({}, server, "ses_a"), server, "ses_b")
+
+ expect(pinnedIDs(pins, server)).toEqual(["ses_a", "ses_b"])
+ expect(withPin(pins, server, "ses_a")).toBe(pins)
+ })
+
+ test("keeps the remaining order when unpinning and drops the server once empty", () => {
+ const pins = withPin(withPin({}, server, "ses_a"), server, "ses_b")
+
+ expect(pinnedIDs(withoutPins(pins, server, ["ses_a"]), server)).toEqual(["ses_b"])
+ expect(withoutPins(pins, server, ["ses_a", "ses_b"])).toEqual({})
+ expect(withoutPins(pins, server, ["ses_missing"])).toBe(pins)
+ })
+})
diff --git a/packages/app/src/home/sessions/pins.tsx b/packages/app/src/home/sessions/pins.tsx
new file mode 100644
index 000000000000..63d96ca0a77b
--- /dev/null
+++ b/packages/app/src/home/sessions/pins.tsx
@@ -0,0 +1,67 @@
+import { createSimpleContext } from "@opencode/ui/context"
+import { Schema } from "effect"
+import { reconcile } from "solid-js/store"
+import { Persistence } from "@/runtime/persistence/schema"
+import { Persist, persisted } from "@/runtime/persistence/storage"
+import type { ServerConnection } from "@/runtime/server/registry"
+
+// Session IDs per server, in the order they were pinned.
+export const PinnedSessions = Persistence.record(Persistence.array(Schema.String))
+
+export type PinnedSessions = typeof PinnedSessions.Type
+
+export function pinnedIDs(pins: PinnedSessions, server: ServerConnection.Key) {
+ return pins[server] ?? []
+}
+
+export function isPinned(pins: PinnedSessions, server: ServerConnection.Key, sessionID: string) {
+ return pinnedIDs(pins, server).includes(sessionID)
+}
+
+export function withPin(pins: PinnedSessions, server: ServerConnection.Key, sessionID: string) {
+ const ids = pinnedIDs(pins, server)
+
+ if (ids.includes(sessionID)) return pins
+
+ return { ...pins, [server]: [...ids, sessionID] }
+}
+
+export function withoutPins(pins: PinnedSessions, server: ServerConnection.Key, sessionIDs: readonly string[]) {
+ const current = pinnedIDs(pins, server)
+ const ids = current.filter((id) => !sessionIDs.includes(id))
+
+ if (ids.length === current.length) return pins
+
+ if (ids.length > 0) return { ...pins, [server]: ids }
+
+ const next = { ...pins }
+
+ delete next[server]
+
+ return next
+}
+
+export const { use: useSessionPins, provider: SessionPinsProvider } = createSimpleContext({
+ name: "SessionPins",
+ gate: false,
+ init: () => {
+ const [store, setStore] = persisted(Persist.global("home.sessions.pinned"), PinnedSessions, {})
+
+ return {
+ ids: (server: ServerConnection.Key) => pinnedIDs(store, server),
+ pinned: (server: ServerConnection.Key, sessionID: string) => isPinned(store, server, sessionID),
+ toggle(server: ServerConnection.Key, sessionID: string) {
+ setStore(
+ reconcile(
+ isPinned(store, server, sessionID)
+ ? withoutPins(store, server, [sessionID])
+ : withPin(store, server, sessionID),
+ ),
+ )
+ },
+ forget(server: ServerConnection.Key, sessionIDs: readonly string[]) {
+ setStore(reconcile(withoutPins(store, server, sessionIDs)))
+ },
+ }
+ },
+})
diff --git a/packages/app/src/home/sessions/region.tsx b/packages/app/src/home/sessions/region.tsx
index 979fb7fdf96d..1cb7dfa5e722 100644
--- a/packages/app/src/home/sessions/region.tsx
+++ b/packages/app/src/home/sessions/region.tsx
@@ -31,8 +31,10 @@ export function HomeSessions(props: {
searchNoResultsLabel={props.search.result.noResultsLabel()}
titleOpacity={props.scroll.header.titleOpacity}
isOpenTab={props.sessions.tab.isOpen}
+ isPinned={props.sessions.pin.is}
onCreateSession={props.sessions.session.create}
onOpenSession={props.sessions.session.open}
+ onTogglePin={props.sessions.pin.toggle}
onArchiveSession={props.sessions.session.archive}
onRenameSession={props.sessions.session.rename}
onExportSession={props.sessions.session.export}
diff --git a/packages/app/src/home/sessions/view.tsx b/packages/app/src/home/sessions/view.tsx
index f83940f13fd1..f58a5a70071c 100644
--- a/packages/app/src/home/sessions/view.tsx
+++ b/packages/app/src/home/sessions/view.tsx
@@ -38,7 +38,7 @@ const HOME_SESSION_LONG_PRESS_MS = 500
function isBackgroundOpen(event: MouseEvent) {
return shouldOpenSessionInBackground({
button: event.button,
- mac: typeof navigator === "object" && /(Mac|iPod|iPhone|iPad)/.test(navigator.platform),
+ mac: "navigator" in globalThis && /(Mac|iPod|iPhone|iPad)/.test(navigator.platform),
meta: event.metaKey,
ctrl: event.ctrlKey,
shift: event.shiftKey,
@@ -65,8 +65,10 @@ export type HomeSessionsViewProps = {
searchNoResultsLabel: string
titleOpacity: (id: HomeSessionGroup["id"]) => number
isOpenTab: (record: HomeSessionRecord) => boolean
+ isPinned: (record: HomeSessionRecord) => boolean
onCreateSession: () => void
onOpenSession: (session: SessionInfo, options?: OpenSessionOptions) => void
+ onTogglePin: (record: HomeSessionRecord) => void
onArchiveSession: (session: SessionInfo) => Promise
onRenameSession: (server: ServerConnection.Key, session: SessionInfo, title: string) => Promise
onExportSession: (server: ServerConnection.Key, session: SessionInfo) => Promise
@@ -779,6 +781,9 @@ function HomeSessionRow(
requestAnimationFrame(() => rowButton()?.focus())
}}
>
+ props.onTogglePin(props.record)}>
+ {props.language.t(props.isPinned(props.record) ? "common.unpin" : "common.pin")}
+
{props.language.t("common.rename")}
void props.onExportSession(props.server, props.record.session)}>
{props.language.t("common.export")}…
diff --git a/packages/app/src/runtime/i18n/en.ts b/packages/app/src/runtime/i18n/en.ts
index 6ee0b5aaffaa..14a09742bf44 100644
--- a/packages/app/src/runtime/i18n/en.ts
+++ b/packages/app/src/runtime/i18n/en.ts
@@ -83,6 +83,9 @@ export const dict = {
"command.session.fork.description": "Create a new session from a previous message",
"command.session.export": "Export session",
"command.session.export.description": "Export the full session transcript as JSON",
+ "command.session.pin": "Pin session",
+ "command.session.pin.description": "Keep this session at the top of the session list",
+ "command.session.unpin": "Unpin session",
"command.session.import": "Import session",
"command.session.copyID": "Copy Session ID",
@@ -516,6 +519,7 @@ export const dict = {
"home.sessions.search.noResults": "No sessions found for {{query}}",
"home.sessions.empty": "Nothing here yet",
"home.sessions.empty.description": "Create a session to get started",
+ "home.sessions.group.pinned": "Pinned",
"home.sessions.group.today": "Today",
"home.sessions.group.yesterday": "Yesterday",
"home.sessions.group.older": "Older",
@@ -618,6 +622,8 @@ export const dict = {
"common.learnMore": "Learn more",
"common.rename": "Rename",
"common.export": "Export",
+ "common.pin": "Pin",
+ "common.unpin": "Unpin",
"common.reset": "Reset",
"common.archive": "Archive",
"common.delete": "Delete",
diff --git a/packages/app/src/session/commands/use-session-commands.tsx b/packages/app/src/session/commands/use-session-commands.tsx
index ebfba7abfe6e..e5ee8cb056d0 100644
--- a/packages/app/src/session/commands/use-session-commands.tsx
+++ b/packages/app/src/session/commands/use-session-commands.tsx
@@ -15,6 +15,8 @@ import { fetchSessionExport, saveSessionExport, sessionExportFilename } from "@/
import { usePlatform } from "@/runtime/platform/platform"
import type { SessionModel } from "@/session/model"
import type { SessionRevert } from "@/session/revert"
+import { useServer } from "@/runtime/server/current"
+import { useSessionPins } from "@/home/sessions/pins"
import { Command } from "@opencode/gui-extensions/sdk"
import { useExtensionHost } from "@/runtime/extension/host"
import type { Region } from "@/runtime/extension/panels"
@@ -60,6 +62,8 @@ export const useSessionCommands = (actions: SessionCommandContext) => {
const platform = usePlatform()
const layout = useLayout()
const host = useExtensionHost()
+ const server = useServer()
+ const pins = useSessionPins()
const openDialog = async (load: () => Promise, show: (value: T) => void) => {
const owner = actions.session.ownership.capture()
@@ -301,6 +305,27 @@ export const useSessionCommands = (actions: SessionCommandContext) => {
const undo = actions.revert.undo
const redo = actions.revert.redo
+ // Subagent sessions are not listed on Home, so they cannot be pinned.
+ const pinnableSessionID = () => {
+ const sessionID = actions.session.identity.params.id
+
+ if (!sessionID || actions.session.data.info()?.parentID) return
+
+ return sessionID
+ }
+
+ const pinned = () => {
+ const sessionID = pinnableSessionID()
+
+ return !!sessionID && pins.pinned(server.key, sessionID)
+ }
+
+ const togglePin = () => {
+ const sessionID = pinnableSessionID()
+
+ if (sessionID) pins.toggle(server.key, sessionID)
+ }
+
const compact = async () => {
const sessionID = actions.session.identity.params.id
@@ -382,6 +407,13 @@ export const useSessionCommands = (actions: SessionCommandContext) => {
disabled: !actions.session.identity.params.id,
onSelect: copySessionID,
}),
+ sessionCommand({
+ id: "session.pin",
+ title: language.t(pinned() ? "command.session.unpin" : "command.session.pin"),
+ description: language.t("command.session.pin.description"),
+ disabled: !pinnableSessionID(),
+ onSelect: togglePin,
+ }),
]
const fileCmds = () => {