fix(tui): drop unavailable saved variants

bun.lock

@@ -613,7 +613,6 @@
         "@tsconfig/bun": "catalog:",
         "@types/bun": "catalog:",
         "@typescript/native-preview": "catalog:",
-        "prettier": "3.6.2",
         "typescript": "catalog:",
       },
     },

packages/client/src/effect/api/api.ts

@@ -382,15 +382,6 @@ export type Endpoint5_31Output =
           readonly location?: Location.Ref | undefined
           readonly data: { readonly sessionID: Session.ID; readonly title: string }
         }
-      | {
-          readonly id: Event.ID
-          readonly created: number
-          readonly metadata?: { readonly [x: string]: unknown } | undefined
-          readonly type: "session.viewed"
-          readonly durable: { readonly aggregateID: string; readonly seq: Event.Seq; readonly version: Event.Version }
-          readonly location?: Location.Ref | undefined
-          readonly data: { readonly sessionID: Session.ID }
-        }
       | {
           readonly id: Event.ID
           readonly created: number
@@ -923,10 +914,6 @@ export type Endpoint5_34Input = { readonly sessionID: Session.ID; readonly messa
 export type Endpoint5_34Output = SessionMessage.Info
 export type SessionMessageOperation<E = never> = (input: Endpoint5_34Input) => Effect.Effect<Endpoint5_34Output, E>
 
-export type Endpoint5_35Input = { readonly sessionID: Session.ID }
-export type Endpoint5_35Output = void
-export type SessionViewOperation<E = never> = (input: Endpoint5_35Input) => Effect.Effect<Endpoint5_35Output, E>
-
 export interface SessionApi<E = never> {
   readonly list: SessionListOperation<E>
   readonly create: SessionCreateOperation<E>
@@ -971,7 +958,6 @@ export interface SessionApi<E = never> {
   readonly interrupt: SessionInterruptOperation<E>
   readonly background: SessionBackgroundOperation<E>
   readonly message: SessionMessageOperation<E>
-  readonly view: SessionViewOperation<E>
 }
 
 export type Endpoint6_0Input = {

packages/client/src/effect/generated/client.ts

@@ -86,8 +86,6 @@ import type {
   Endpoint5_33Output,
   Endpoint5_34Input,
   Endpoint5_34Output,
-  Endpoint5_35Input,
-  Endpoint5_35Output,
   Endpoint6_0Input,
   Endpoint6_0Output,
   Endpoint7_0Input,
@@ -612,11 +610,6 @@ const Endpoint5_34 = (raw: RawClient["server.session"]) => (input: Endpoint5_34I
     ),
   )
 
-const Endpoint5_35 = (raw: RawClient["server.session"]) => (input: Endpoint5_35Input) =>
-  preserveEffect<Endpoint5_35Output>()(
-    raw["session.view"]({ params: { sessionID: input["sessionID"] } }).pipe(Effect.mapError(mapClientError)),
-  )
-
 const adaptGroup5 = (raw: RawClient["server.session"]) => ({
   list: Endpoint5_0(raw),
   create: Endpoint5_1(raw),
@@ -646,7 +639,6 @@ const adaptGroup5 = (raw: RawClient["server.session"]) => ({
   interrupt: Endpoint5_32(raw),
   background: Endpoint5_33(raw),
   message: Endpoint5_34(raw),
-  view: Endpoint5_35(raw),
 })
 
 const Endpoint6_0 = (raw: RawClient["server.message"]) => (input: Endpoint6_0Input) =>

packages/client/src/promise/generated/client.ts

@@ -80,8 +80,6 @@ import type {
   SessionBackgroundOutput,
   SessionMessageInput,
   SessionMessageOutput,
-  SessionViewInput,
-  SessionViewOutput,
   MessageListInput,
   MessageListOutput,
   ModelListInput,
@@ -898,17 +896,6 @@ export function make(options: ClientOptions) {
           },
           requestOptions,
         ).then((value) => value.data),
-      view: (input: SessionViewInput, requestOptions?: RequestOptions) =>
-        request<SessionViewOutput>(
-          {
-            method: "POST",
-            path: `/api/session/${encodeURIComponent(input.sessionID)}/view`,
-            successStatus: 204,
-            declaredStatuses: [404, 401, 400],
-            empty: true,
-          },
-          requestOptions,
-        ),
     },
     message: {
       list: (input: MessageListInput, requestOptions?: RequestOptions) =>

packages/client/src/promise/generated/types.ts

@@ -479,16 +479,6 @@ export type SessionRenamed = {
   data: { sessionID: string; title: string }
 }
 
-export type SessionViewed = {
-  id: string
-  created: number
-  metadata?: { [x: string]: any }
-  type: "session.viewed"
-  durable: { aggregateID: string; seq: number; version: 1 }
-  location?: LocationRef
-  data: { sessionID: string }
-}
-
 export type SessionDeleted = {
   id: string
   created: number
@@ -1520,7 +1510,7 @@ export type SessionInfo = {
   model?: ModelRef
   cost: MoneyUSD
   tokens: TokenUsageInfo
-  time: { created: number; updated: number; idle?: number; viewed?: number; archived?: number }
+  time: { created: number; updated: number; archived?: number }
   title?: string
   location: LocationRef
   subpath?: string
@@ -1933,7 +1923,6 @@ export type SessionEventDurable =
   | SessionModelSelected
   | SessionMoved
   | SessionRenamed
-  | SessionViewed
   | SessionDeleted
   | SessionForked
   | SessionInboxDelivered
@@ -2024,7 +2013,6 @@ export type V2Event =
   | SessionModelSelected
   | SessionMoved
   | SessionRenamed
-  | SessionViewed
   | SessionUsageUpdated
   | SessionDeleted
   | SessionForked
@@ -2488,13 +2476,7 @@ export type SessionImportInput = {
         readonly reasoning: number
         readonly cache: { readonly read: number; readonly write: number }
       }
-      readonly time: {
-        readonly created: number
-        readonly updated: number
-        readonly idle?: number
-        readonly viewed?: number
-        readonly archived?: number
-      }
+      readonly time: { readonly created: number; readonly updated: number; readonly archived?: number }
       readonly title?: string
       readonly location: { readonly directory: string; readonly workspaceID?: string }
       readonly subpath?: string
@@ -2761,13 +2743,7 @@ export type SessionImportInput = {
         readonly reasoning: number
         readonly cache: { readonly read: number; readonly write: number }
       }
-      readonly time: {
-        readonly created: number
-        readonly updated: number
-        readonly idle?: number
-        readonly viewed?: number
-        readonly archived?: number
-      }
+      readonly time: { readonly created: number; readonly updated: number; readonly archived?: number }
       readonly title?: string
       readonly location: { readonly directory: string; readonly workspaceID?: string }
       readonly subpath?: string
@@ -3034,13 +3010,7 @@ export type SessionImportInput = {
         readonly reasoning: number
         readonly cache: { readonly read: number; readonly write: number }
       }
-      readonly time: {
-        readonly created: number
-        readonly updated: number
-        readonly idle?: number
-        readonly viewed?: number
-        readonly archived?: number
-      }
+      readonly time: { readonly created: number; readonly updated: number; readonly archived?: number }
       readonly title?: string
       readonly location: { readonly directory: string; readonly workspaceID?: string }
       readonly subpath?: string
@@ -3966,10 +3936,6 @@ export type SessionMessageInput = {
 
 export type SessionMessageOutput = { data: SessionMessageInfo }["data"]
 
-export type SessionViewInput = { readonly sessionID: { readonly sessionID: string }["sessionID"] }
-
-export type SessionViewOutput = void
-
 export type MessageListInput = {
   readonly sessionID: { readonly sessionID: string }["sessionID"]
   readonly limit?: {

packages/client/test/effect.test.ts

@@ -136,10 +136,8 @@ test("event.subscribe terminates on Effect protocol decode failures", async () =
 
 test("session methods retain decoded Effect inputs and outputs", async () => {
   const logQueries: Array<Record<string, string>> = []
-  const requests: Array<{ method: string; url: string }> = []
   const httpClient = HttpClient.make((request) => {
     const url = request.url
-    requests.push({ method: request.method, url })
     if (url.includes("/log")) {
       logQueries.push(Object.fromEntries(request.urlParams.params))
       return Effect.succeed(
@@ -185,7 +183,6 @@ test("session methods retain decoded Effect inputs and outputs", async () => {
     const created = yield* client.session.create({
       location: Location.Ref.make({ directory: AbsolutePath.make("/tmp/project") }),
     })
-    yield* client.session.view({ sessionID: Session.ID.make("ses_test") })
     yield* client.session.switchAgent({ sessionID: Session.ID.make("ses_test"), agent: Agent.ID.make("build") })
     yield* client.session.switchModel({
       sessionID: Session.ID.make("ses_test"),
@@ -210,11 +207,7 @@ test("session methods retain decoded Effect inputs and outputs", async () => {
     return { page, active, created, admitted, context, log, message }
   }).pipe(Effect.provideService(HttpClient.HttpClient, httpClient), Effect.runPromise)
 
-  const listed = result.page.data[0]
-  if (!listed?.time.idle || !listed.time.viewed) throw new Error("Expected attention times")
-  expect(DateTime.toEpochMillis(listed.time.created)).toBe(1_717_171_717_000)
-  expect(DateTime.toEpochMillis(listed.time.idle)).toBe(1_717_171_717_002)
-  expect(DateTime.toEpochMillis(listed.time.viewed)).toBe(1_717_171_717_001)
+  expect(DateTime.toEpochMillis(result.page.data[0].time.created)).toBe(1_717_171_717_000)
   expect(result.active).toEqual({ ses_test: { type: "running" } })
   expect(Object.getPrototypeOf(result.page.data[0])).toBe(Object.prototype)
   expect(Object.getPrototypeOf(result.created)).toBe(Object.prototype)
@@ -224,10 +217,11 @@ test("session methods retain decoded Effect inputs and outputs", async () => {
   expect(DateTime.toEpochMillis(result.admitted.timeCreated)).toBe(1_717_171_717_000)
   expect(result.context).toEqual([])
   expect(logQueries[0]).toEqual({ after: "0" })
-  expect(requests).toContainEqual({ method: "POST", url: "http://localhost:3000/api/session/ses_test/view" })
   const logged = Array.from(result.log)
   expect(logged.map((item) => item.type)).toEqual(["session.model.selected", "log.synced"])
-  expect(logged[0]?.type === "session.model.selected" && logged[0].created).toBe(1_717_171_717_000)
+  expect(logged[0]?.type === "session.model.selected" && DateTime.toEpochMillis(logged[0].created)).toBe(
+    1_717_171_717_000,
+  )
   expect(logged.at(-1)).toEqual(synced)
   expect(result.message).toEqual(expect.objectContaining({ id: "msg_model", type: "model-switched" }))
 })
@@ -266,8 +260,6 @@ const session = {
     time: {
       created: 1_717_171_717_000,
       updated: 1_717_171_717_000,
-      idle: 1_717_171_717_002,
-      viewed: 1_717_171_717_001,
     },
     title: "Test",
     location: { directory: "/tmp/project" },

packages/client/test/promise.test.ts

@@ -539,7 +539,6 @@ test("session methods use the public HTTP contract", async () => {
   const page = await client.session.list({ limit: 10, order: "desc", parentID: null })
   const active = await client.session.active()
   const created = await client.session.create({ location: { directory: "/tmp/project" } })
-  await client.session.view({ sessionID: "ses_test" })
   await client.session.switchAgent({ sessionID: "ses_test", agent: "build" })
   await client.session.switchModel({
     sessionID: "ses_test",
@@ -566,7 +565,6 @@ test("session methods use the public HTTP contract", async () => {
   const message = await client.session.message({ sessionID: "ses_test", messageID: "msg_model" })
 
   expect(page.cursor.next).toBe("next")
-  expect(page.data[0].time).toMatchObject({ idle: 1_717_171_717_002, viewed: 1_717_171_717_001 })
   expect(active).toEqual({ ses_test: { type: "running" } })
   expect(created.id).toBe("ses_test")
   expect(admitted.id).toBe("msg_test")
@@ -579,7 +577,6 @@ test("session methods use the public HTTP contract", async () => {
     ["GET", "http://localhost:3000/api/session?limit=10&order=desc&parentID=null"],
     ["GET", "http://localhost:3000/api/session/active"],
     ["POST", "http://localhost:3000/api/session"],
-    ["POST", "http://localhost:3000/api/session/ses_test/view"],
     ["POST", "http://localhost:3000/api/session/ses_test/agent"],
     ["POST", "http://localhost:3000/api/session/ses_test/model"],
     ["POST", "http://localhost:3000/api/session/ses_test/prompt"],
@@ -654,8 +651,6 @@ const session = {
     time: {
       created: 1_717_171_717_000,
       updated: 1_717_171_717_000,
-      idle: 1_717_171_717_002,
-      viewed: 1_717_171_717_001,
     },
     title: "Test",
     location: { directory: "/tmp/project" },

packages/core/schema.json

@@ -1,8 +1,8 @@
 {
   "version": "7",
   "dialect": "sqlite",
-  "id": "94b6c496-ad84-426f-9d5d-3e1ac3ebfb56",
-  "prevIds": ["dcde8e6b-4bf4-4f6b-b2be-4030c2c3e936"],
+  "id": "dcde8e6b-4bf4-4f6b-b2be-4030c2c3e936",
+  "prevIds": ["5c1aa56b-c3ee-4283-9a84-c0bf626dc604"],
   "ddl": [
     {
       "name": "account_state",
@@ -1350,26 +1350,6 @@
       "entityType": "columns",
       "table": "session_v2"
     },
-    {
-      "type": "integer",
-      "notNull": false,
-      "autoincrement": false,
-      "default": null,
-      "generated": null,
-      "name": "time_idle",
-      "entityType": "columns",
-      "table": "session_v2"
-    },
-    {
-      "type": "integer",
-      "notNull": false,
-      "autoincrement": false,
-      "default": null,
-      "generated": null,
-      "name": "time_viewed",
-      "entityType": "columns",
-      "table": "session_v2"
-    },
     {
       "type": "integer",
       "notNull": false,

packages/core/src/database/migration.gen.ts

@@ -43,7 +43,6 @@ import m40 from "./migration/20260808023530_workspace_domain.js"
 import m41 from "./migration/20260811161259_execution_claim_attempts.js"
 import m42 from "./migration/20260812181746_session_inbox.js"
 import m43 from "./migration/20260812213948_worktree.js"
-import m44 from "./migration/20260815182818_session_viewed_state.js"
 
 export const migrations = [
   m00,
@@ -90,5 +89,4 @@ export const migrations = [
   m41,
   m42,
   m43,
-  m44,
 ] satisfies DatabaseMigration.Migration[]

packages/core/src/database/migration/20260815182818_session_viewed_state.ts

@@ -1,14 +0,0 @@
-import { Effect } from "effect"
-import type { DatabaseMigration } from "../migration.js"
-
-const migration: DatabaseMigration.Migration = {
-  id: "20260815182818_session_viewed_state",
-  up(tx) {
-    return Effect.gen(function* () {
-      yield* tx.run(`ALTER TABLE \`session_v2\` ADD \`time_idle\` integer;`)
-      yield* tx.run(`ALTER TABLE \`session_v2\` ADD \`time_viewed\` integer;`)
-    })
-  },
-}
-
-export default migration

packages/core/src/database/schema.gen.ts

@@ -209,8 +209,6 @@ const schema: Omit<DatabaseMigration.Migration, "id"> = {
           \`model\` text,
           \`time_created\` integer NOT NULL,
           \`time_updated\` integer NOT NULL,
-          \`time_idle\` integer,
-          \`time_viewed\` integer,
           \`time_compacting\` integer,
           \`time_archived\` integer,
           \`time_suspended\` integer,

packages/core/src/session.ts

@@ -165,7 +165,6 @@ export interface Interface {
     input: ForkInput,
   ) => Effect.Effect<SessionSchema.Info, NotFoundError | MessageNotFoundError | ForkEmptyError>
   readonly get: (sessionID: SessionSchema.ID) => Effect.Effect<SessionSchema.Info, NotFoundError>
-  readonly view: (input: { sessionID: SessionSchema.ID }) => Effect.Effect<void, NotFoundError>
   readonly remove: (sessionID: SessionSchema.ID) => Effect.Effect<void, NotFoundError>
   readonly messages: (input: {
     sessionID: SessionSchema.ID
@@ -448,17 +447,6 @@ const layer = Layer.effect(
         if (!session) return yield* new NotFoundError({ sessionID })
         return session
       }),
-      view: Effect.fn("Session.view")(function* (input) {
-        const row = yield* db
-          .select({ idle: SessionTable.time_idle, viewed: SessionTable.time_viewed })
-          .from(SessionTable)
-          .where(eq(SessionTable.id, input.sessionID))
-          .get()
-          .pipe(Effect.orDie)
-        if (!row) return yield* new NotFoundError({ sessionID: input.sessionID })
-        if (row.idle === null || (row.viewed !== null && row.viewed >= row.idle)) return
-        yield* bus.publish(SessionEvent.Viewed, { sessionID: input.sessionID })
-      }),
       remove: Effect.fn("Session.remove")(function* (sessionID) {
         const session = yield* result.get(sessionID)
         yield* execution.interrupt(sessionID)

packages/core/src/session/info.ts

@@ -53,8 +53,6 @@ export function fromRow(row: typeof SessionTable.$inferSelect): SessionSchema.In
     time: {
       created: DateTime.makeUnsafe(row.time_created),
       updated: DateTime.makeUnsafe(row.time_updated),
-      idle: row.time_idle === null ? undefined : DateTime.makeUnsafe(row.time_idle),
-      viewed: row.time_viewed === null ? undefined : DateTime.makeUnsafe(row.time_viewed),
       archived: row.time_archived ? DateTime.makeUnsafe(row.time_archived) : undefined,
     },
   })

packages/core/src/session/message-updater.ts

@@ -60,7 +60,6 @@ export function update(adapter: Adapter, event: SessionEvent.DurableEvent) {
     Match.type<SessionEvent.DurableEvent>(),
     Match.discriminatorsExhaustive("type")({
       "session.created": () => Effect.void,
-      "session.viewed": () => Effect.void,
       "session.usage.recorded": () => Effect.void,
       "session.agent.selected": (event) => {
         return Effect.gen(function* () {

packages/core/src/session/projector.ts

@@ -391,30 +391,6 @@ function insertMessage(db: DatabaseService, event: SessionEvent.DurableEvent, me
     .pipe(Effect.orDie)
 }
 
-function projectIdle(
-  db: DatabaseService,
-  event:
-    | typeof SessionEvent.Execution.Succeeded.Type
-    | typeof SessionEvent.Execution.Failed.Type
-    | typeof SessionEvent.Execution.Interrupted.Type,
-) {
-  return Effect.gen(function* () {
-    yield* run(db, event)
-    if (event.type === SessionEvent.Execution.Interrupted.type && event.data.reason === "shutdown") return
-    const time = event.created
-    yield* db
-      .update(SessionTable)
-      .set({
-        // Unread uses a strict timestamp comparison, so every terminal must advance even within one millisecond.
-        time_idle: sql`max(${time}, coalesce(${SessionTable.time_idle} + 1, ${time}))`,
-        time_updated: sql`${SessionTable.time_updated}`,
-      })
-      .where(eq(SessionTable.id, event.data.sessionID))
-      .run()
-      .pipe(Effect.orDie)
-  })
-}
-
 const layer = Layer.effectDiscard(
   Effect.gen(function* () {
     const bus = yield* Bus.Service
@@ -536,17 +512,6 @@ const layer = Layer.effectDiscard(
         .run()
         .pipe(Effect.orDie),
     )
-    yield* bus.project(SessionEvent.Viewed, (event) =>
-      db
-        .update(SessionTable)
-        .set({
-          time_viewed: sql`${SessionTable.time_idle}`,
-          time_updated: sql`${SessionTable.time_updated}`,
-        })
-        .where(eq(SessionTable.id, event.data.sessionID))
-        .run()
-        .pipe(Effect.orDie),
-    )
     yield* bus.project(SessionEvent.UsageRecorded, (event) => applyUsage(db, event.data.sessionID, event.data))
     yield* bus.project(SessionEvent.Forked, (event) => projectFork(db, event))
     yield* bus.project(SessionEvent.InboxDelivered, (event) =>
@@ -615,9 +580,9 @@ const layer = Layer.effectDiscard(
         delivery: event.data.delivery,
       }),
     )
-    yield* bus.project(SessionEvent.Execution.Succeeded, (event) => projectIdle(db, event))
-    yield* bus.project(SessionEvent.Execution.Failed, (event) => projectIdle(db, event))
-    yield* bus.project(SessionEvent.Execution.Interrupted, (event) => projectIdle(db, event))
+    yield* bus.project(SessionEvent.Execution.Succeeded, (event) => run(db, event))
+    yield* bus.project(SessionEvent.Execution.Failed, (event) => run(db, event))
+    yield* bus.project(SessionEvent.Execution.Interrupted, (event) => run(db, event))
     yield* bus.project(SessionEvent.InstructionsUpdated, (event) =>
       Effect.gen(function* () {
         yield* run(db, event)

packages/core/src/session/sql.ts

@@ -56,8 +56,6 @@ export const SessionTable = sqliteTable(
       variant?: string
     }>(),
     ...Timestamps,
-    time_idle: integer(),
-    time_viewed: integer(),
     time_compacting: integer(),
     time_archived: integer(),
     /** The execution claim timestamp (historical column name; see SessionStore.claim). */

packages/core/src/session/transfer.ts

@@ -117,10 +117,6 @@ const layer = Layer.effect(
                       tokens_cache_write: input.data.info.tokens.cache.write,
                       time_created: DateTime.toEpochMillis(input.data.info.time.created),
                       time_updated: DateTime.toEpochMillis(input.data.info.time.updated),
-                      time_idle: input.data.info.time.idle ? DateTime.toEpochMillis(input.data.info.time.idle) : null,
-                      time_viewed: input.data.info.time.viewed
-                        ? DateTime.toEpochMillis(input.data.info.time.viewed)
-                        : null,
                       time_archived: input.data.info.time.archived
                         ? DateTime.toEpochMillis(input.data.info.time.archived)
                         : null,

packages/core/test/database-migration.test.ts

@@ -13,7 +13,6 @@ import { tmpdir } from "./fixture/tmpdir"
 import type { SqlClient } from "effect/unstable/sql/SqlClient"
 import legacyCredentialsMigration from "@opencode-ai/core/database/migration/20260805200742_import_legacy_credentials"
 import worktreeMigration from "@opencode-ai/core/database/migration/20260812213948_worktree"
-import sessionViewedStateMigration from "@opencode-ai/core/database/migration/20260815182818_session_viewed_state"
 import { Global } from "@opencode-ai/util/global"
 
 const run = <A, E>(
@@ -74,27 +73,6 @@ describe("DatabaseMigration", () => {
     )
   })
 
-  test("adds nullable attention state to existing sessions", async () => {
-    await run(
-      Effect.gen(function* () {
-        const db = yield* makeDb
-        yield* db.run(sql`CREATE TABLE session_v2 (id text PRIMARY KEY, title text)`)
-        yield* db.run(sql`INSERT INTO session_v2 (id, title) VALUES ('ses_existing', 'Existing')`)
-
-        yield* DatabaseMigration.applyOnly(db, [sessionViewedStateMigration])
-        yield* DatabaseMigration.applyOnly(db, [sessionViewedStateMigration])
-
-        expect(yield* db.get(sql`SELECT id, title, time_idle, time_viewed FROM session_v2`)).toEqual({
-          id: "ses_existing",
-          title: "Existing",
-          time_idle: null,
-          time_viewed: null,
-        })
-        expect(yield* db.get(sql`SELECT count(*) AS count FROM migration`)).toEqual({ count: 1 })
-      }),
-    )
-  })
-
   test("rejects a non-empty database without a session table", async () => {
     await expect(
       run(

packages/core/test/session-create.test.ts

@@ -840,15 +840,7 @@ describe("SessionTransfer", () => {
 
       const imported = yield* transfer.import({
         data: {
-          info: {
-            ...template,
-            id: sessionID,
-            time: {
-              ...template.time,
-              idle: DateTime.makeUnsafe(200),
-              viewed: DateTime.makeUnsafe(150),
-            },
-          },
+          info: { ...template, id: sessionID },
           messages: [
             {
               id: sourceMessageID,
@@ -871,18 +863,13 @@ describe("SessionTransfer", () => {
       const messages = yield* session.messages({ sessionID, order: "asc" })
 
       expect(imported).toMatchObject({ id: sessionID, title: "Exported", location })
-      expect(imported.time).toMatchObject({ idle: DateTime.makeUnsafe(200), viewed: DateTime.makeUnsafe(150) })
       expect(messages).toMatchObject([
         { id: sourceMessageID, type: "user", text: "Imported message" },
         { id: errorMessageID, type: "compaction", error: { type: "test_error", message: "Original error" } },
       ])
       expect(yield* Bus.latestSequence(db, sessionID)).toBe(2)
-      const exported = yield* transfer.export({ sessionID })
-      expect(exported.info.time).toMatchObject({ idle: DateTime.makeUnsafe(200), viewed: DateTime.makeUnsafe(150) })
-      expect(exported.messages).toEqual(messages)
-      const sanitized = yield* transfer.export({ sessionID, sanitize: true })
-      expect(sanitized.info.time).toMatchObject({ idle: DateTime.makeUnsafe(200), viewed: DateTime.makeUnsafe(150) })
-      expect(sanitized.messages).toMatchObject([
+      expect((yield* transfer.export({ sessionID })).messages).toEqual(messages)
+      expect((yield* transfer.export({ sessionID, sanitize: true })).messages).toMatchObject([
         { id: sourceMessageID, text: `[redacted:text:${sourceMessageID}]` },
         { id: errorMessageID, error: { type: "test_error", message: "Original error" } },
       ])

packages/core/test/session-view.test.ts

@@ -1,174 +0,0 @@
-import { describe, expect } from "bun:test"
-import path from "path"
-import { Bus } from "@opencode-ai/core/bus"
-import { Database } from "@opencode-ai/core/database/database"
-import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
-import { EventTable } from "@opencode-ai/core/event/sql"
-import { Location } from "@opencode-ai/core/location"
-import { Project } from "@opencode-ai/core/project"
-import { ProjectTable } from "@opencode-ai/core/project/sql"
-import { AbsolutePath } from "@opencode-ai/core/schema"
-import { Session } from "@opencode-ai/core/session"
-import { SessionEvent } from "@opencode-ai/core/session/event"
-import { SessionExecution } from "@opencode-ai/core/session/execution"
-import { SessionProjector } from "@opencode-ai/core/session/projector"
-import { SessionTable } from "@opencode-ai/core/session/sql"
-import { SessionStore } from "@opencode-ai/core/session/store"
-import { LayerNode } from "@opencode-ai/util/effect/layer-node"
-import { DateTime, Effect, Layer } from "effect"
-import { asc, eq } from "drizzle-orm"
-import { tmpdir } from "./fixture/tmpdir"
-import { testEffect } from "./lib/effect"
-import { globalProjectLayer } from "./lib/project"
-
-const it = testEffect(
-  AppNodeBuilder.build(
-    LayerNode.group([Database.node, Bus.node, SessionProjector.node, SessionStore.node, Session.node]),
-    [
-      [Bus.node, Bus.configured({ persist: true })],
-      [Project.node, globalProjectLayer],
-      [SessionExecution.node, SessionExecution.noopLayer],
-    ],
-  ),
-)
-const location = Location.Ref.make({ directory: AbsolutePath.make("/project") })
-
-describe("Session.view", () => {
-  it.effect("copies the latest idle time without changing session recency", () =>
-    Effect.gen(function* () {
-      const session = yield* Session.Service
-      const bus = yield* Bus.Service
-      const { db } = yield* Database.Service
-      const created = yield* session.create({ location })
-
-      expect(created.time.idle).toBeUndefined()
-      expect(created.time.viewed).toBeUndefined()
-
-      yield* session.view({ sessionID: created.id })
-      expect((yield* session.get(created.id)).time.viewed).toBeUndefined()
-
-      yield* bus.publish(SessionEvent.Execution.Succeeded, { sessionID: created.id })
-      const idle = yield* session.get(created.id)
-      expect(idle.time.idle).toBeDefined()
-      expect(idle.time.viewed).toBeUndefined()
-      expect(idle.time.updated).toEqual(created.time.updated)
-
-      yield* session.view({ sessionID: created.id })
-      const viewed = yield* session.get(created.id)
-      if (!viewed.time.idle || !viewed.time.viewed) return yield* Effect.die(new Error("Expected attention times"))
-      expect(viewed.time.viewed).toEqual(viewed.time.idle)
-      expect(viewed.time.updated).toEqual(created.time.updated)
-      expect(
-        yield* db
-          .select({ idle: SessionTable.time_idle, viewed: SessionTable.time_viewed })
-          .from(SessionTable)
-          .where(eq(SessionTable.id, created.id))
-          .get(),
-      ).toEqual({
-        idle: DateTime.toEpochMillis(viewed.time.idle),
-        viewed: DateTime.toEpochMillis(viewed.time.viewed),
-      })
-      expect((yield* session.list()).data.find((item) => item.id === created.id)?.time).toEqual(viewed.time)
-
-      yield* session.view({ sessionID: created.id })
-      expect((yield* session.get(created.id)).time).toEqual(viewed.time)
-
-      yield* bus.publish(SessionEvent.Execution.Failed, {
-        sessionID: created.id,
-        error: { type: "unknown", message: "failed" },
-      })
-      const unread = yield* session.get(created.id)
-      if (!unread.time.idle || !unread.time.viewed) return yield* Effect.die(new Error("Expected attention times"))
-      expect(DateTime.toEpochMillis(unread.time.idle)).toBeGreaterThan(DateTime.toEpochMillis(unread.time.viewed))
-
-      yield* session.view({ sessionID: created.id })
-      expect((yield* session.get(created.id)).time.viewed).toEqual(unread.time.idle)
-
-      yield* bus.publish(SessionEvent.Execution.Interrupted, { sessionID: created.id, reason: "shutdown" })
-      expect((yield* session.get(created.id)).time.idle).toEqual(unread.time.idle)
-
-      yield* bus.publish(SessionEvent.Execution.Interrupted, { sessionID: created.id, reason: "user" })
-      const interrupted = yield* session.get(created.id)
-      if (!interrupted.time.idle || !interrupted.time.viewed)
-        return yield* Effect.die(new Error("Expected attention times"))
-      expect(DateTime.toEpochMillis(interrupted.time.idle)).toBeGreaterThan(
-        DateTime.toEpochMillis(interrupted.time.viewed),
-      )
-      expect(
-        (yield* db
-          .select({ type: EventTable.type })
-          .from(EventTable)
-          .where(eq(EventTable.aggregate_id, created.id))
-          .all()).filter((event) => event.type === "session.viewed.1"),
-      ).toHaveLength(2)
-    }),
-  )
-
-  it.effect("rejects an unknown session", () =>
-    Effect.gen(function* () {
-      const session = yield* Session.Service
-      const sessionID = Session.ID.make("ses_missing_view")
-      expect(yield* Effect.flip(session.view({ sessionID }))).toEqual(new Session.NotFoundError({ sessionID }))
-    }),
-  )
-
-  it.effect("replays viewed state into a fresh database", () =>
-    Effect.gen(function* () {
-      const session = yield* Session.Service
-      const bus = yield* Bus.Service
-      const sourceDb = (yield* Database.Service).db
-      const created = yield* session.create({ id: Session.ID.make("ses_view_replay"), location })
-      yield* bus.publish(SessionEvent.Execution.Succeeded, { sessionID: created.id })
-      yield* session.view({ sessionID: created.id })
-      yield* bus.publish(SessionEvent.Execution.Failed, {
-        sessionID: created.id,
-        error: { type: "unknown", message: "failed" },
-      })
-      const expected = yield* session.get(created.id)
-      if (!expected.time.idle || !expected.time.viewed) return yield* Effect.die(new Error("Expected attention times"))
-      const expectedIdle = DateTime.toEpochMillis(expected.time.idle)
-      const expectedViewed = DateTime.toEpochMillis(expected.time.viewed)
-      const serialized = (yield* sourceDb
-        .select()
-        .from(EventTable)
-        .where(eq(EventTable.aggregate_id, created.id))
-        .orderBy(asc(EventTable.seq))
-        .all()
-        .pipe(Effect.orDie)).map((event) => ({
-        id: event.id,
-        created: event.created,
-        aggregateID: event.aggregate_id,
-        seq: event.seq,
-        type: event.type,
-        data: event.data,
-      }))
-      const tmp = yield* Effect.acquireRelease(
-        Effect.promise(() => tmpdir()),
-        (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]()),
-      )
-      const targetLayer = AppNodeBuilder.build(
-        LayerNode.group([Database.node, Bus.node, SessionProjector.node, SessionStore.node]),
-        [
-          [Database.node, Database.configured({ path: path.join(tmp.path, "target.sqlite") })],
-          [Bus.node, Bus.configured({ persist: true })],
-        ],
-      )
-
-      yield* Effect.gen(function* () {
-        const db = (yield* Database.Service).db
-        const targetBus = yield* Bus.Service
-        const store = yield* SessionStore.Service
-        yield* db
-          .insert(ProjectTable)
-          .values({ id: Project.ID.global, worktree: location.directory, sandboxes: [] })
-          .run()
-          .pipe(Effect.orDie)
-        yield* Effect.forEach(serialized, (event) => targetBus.replay(event), { discard: true })
-
-        expect((yield* store.get(created.id))?.time).toEqual(expected.time)
-        expect(expected.time.updated).toEqual(created.time.updated)
-        expect(expectedIdle).toBeGreaterThan(expectedViewed)
-      }).pipe(Effect.provide(Layer.fresh(targetLayer)))
-    }),
-  )
-})

packages/core/test/v1-migration.test.ts

@@ -60,8 +60,6 @@ const session = (
   model: null,
   time_created: 1,
   time_updated: 2,
-  time_idle: null,
-  time_viewed: null,
   time_compacting: 3,
   time_archived: null,
   time_suspended: null,

packages/protocol/openapi.json

@@ -4127,65 +4127,6 @@
         "summary": "Get session message"
       }
     },
-    "/api/session/{sessionID}/view": {
-      "post": {
-        "tags": ["session"],
-        "operationId": "v2.session.view",
-        "parameters": [
-          {
-            "name": "sessionID",
-            "in": "path",
-            "schema": {
-              "type": "string",
-              "allOf": [
-                {
-                  "pattern": "^ses"
-                }
-              ]
-            },
-            "required": true
-          }
-        ],
-        "security": [],
-        "responses": {
-          "204": {
-            "description": "<No Content>"
-          },
-          "400": {
-            "description": "InvalidRequestError",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "$ref": "#/components/schemas/InvalidRequestError"
-                }
-              }
-            }
-          },
-          "401": {
-            "description": "UnauthorizedError",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "$ref": "#/components/schemas/UnauthorizedError"
-                }
-              }
-            }
-          },
-          "404": {
-            "description": "SessionNotFoundError",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "$ref": "#/components/schemas/SessionNotFoundError"
-                }
-              }
-            }
-          }
-        },
-        "description": "Mark the latest recorded idle transition as viewed.",
-        "summary": "View session"
-      }
-    },
     "/api/session/{sessionID}/message": {
       "get": {
         "tags": ["session"],
@@ -12194,12 +12135,6 @@
               "updated": {
                 "type": "number"
               },
-              "idle": {
-                "type": "number"
-              },
-              "viewed": {
-                "type": "number"
-              },
               "archived": {
                 "type": "number"
               }
@@ -14341,71 +14276,6 @@
         "required": ["id", "created", "type", "durable", "data"],
         "additionalProperties": false
       },
-      "session.viewed": {
-        "type": "object",
-        "properties": {
-          "id": {
-            "type": "string",
-            "allOf": [
-              {
-                "pattern": "^evt_"
-              }
-            ]
-          },
-          "created": {
-            "type": "number"
-          },
-          "metadata": {
-            "type": "object"
-          },
-          "type": {
-            "type": "string",
-            "enum": ["session.viewed"]
-          },
-          "durable": {
-            "type": "object",
-            "properties": {
-              "aggregateID": {
-                "type": "string"
-              },
-              "seq": {
-                "type": "integer",
-                "allOf": [
-                  {
-                    "minimum": 0
-                  }
-                ]
-              },
-              "version": {
-                "type": "number",
-                "enum": [1]
-              }
-            },
-            "required": ["aggregateID", "seq", "version"],
-            "additionalProperties": false
-          },
-          "location": {
-            "$ref": "#/components/schemas/Location.Ref"
-          },
-          "data": {
-            "type": "object",
-            "properties": {
-              "sessionID": {
-                "type": "string",
-                "allOf": [
-                  {
-                    "pattern": "^ses"
-                  }
-                ]
-              }
-            },
-            "required": ["sessionID"],
-            "additionalProperties": false
-          }
-        },
-        "required": ["id", "created", "type", "durable", "data"],
-        "additionalProperties": false
-      },
       "session.deleted": {
         "type": "object",
         "properties": {
@@ -17426,9 +17296,6 @@
           {
             "$ref": "#/components/schemas/session.renamed"
           },
-          {
-            "$ref": "#/components/schemas/session.viewed"
-          },
           {
             "$ref": "#/components/schemas/session.deleted"
           },
@@ -22797,9 +22664,6 @@
           {
             "$ref": "#/components/schemas/session.renamed"
           },
-          {
-            "$ref": "#/components/schemas/session.viewed"
-          },
           {
             "$ref": "#/components/schemas/session.usage.updated"
           },

packages/protocol/package.json

@@ -33,7 +33,6 @@
     "@tsconfig/bun": "catalog:",
     "@types/bun": "catalog:",
     "@typescript/native-preview": "catalog:",
-    "prettier": "3.6.2",
     "typescript": "catalog:"
   }
 }

packages/protocol/script/generate-openapi.ts

@@ -1,9 +1,8 @@
 import { OpenApi } from "effect/unstable/httpapi"
-import { format } from "prettier"
 import { fileURLToPath } from "url"
 import { ClientApi } from "../src/client.js"
 
-const document = await format(JSON.stringify(OpenApi.fromApi(ClientApi), null, 2), { parser: "json", printWidth: 120 })
+const document = JSON.stringify(OpenApi.fromApi(ClientApi), null, 2) + "\n"
 const target = fileURLToPath(new URL("../openapi.json", import.meta.url))
 
 if (process.argv.includes("--check")) {

packages/protocol/src/groups/session.ts

@@ -693,19 +693,6 @@ export const makeSessionGroup = <I extends HttpApiMiddleware.AnyId, S>(sessionLo
         }),
       ),
     )
-    .add(
-      HttpApiEndpoint.post("session.view", "/api/session/:sessionID/view", {
-        params: { sessionID: Session.ID },
-        success: HttpApiSchema.NoContent,
-        error: SessionNotFoundError,
-      }).annotateMerge(
-        OpenApi.annotations({
-          identifier: "v2.session.view",
-          summary: "View session",
-          description: "Mark the latest recorded idle transition as viewed.",
-        }),
-      ),
-    )
     .annotateMerge(
       OpenApi.annotations({
         title: "session",

packages/schema/src/session-event.ts

@@ -105,13 +105,6 @@ export const Renamed = Event.durable({
 })
 export type Renamed = typeof Renamed.Type
 
-export const Viewed = Event.durable({
-  type: "session.viewed",
-  ...options,
-  schema: Base,
-})
-export type Viewed = typeof Viewed.Type
-
 export const UsageRecorded = Event.durable({
   type: "session.usage.recorded",
   ...options,
@@ -587,7 +580,6 @@ export const Definitions = Event.inventory(
   ModelSelected,
   Moved,
   Renamed,
-  Viewed,
   UsageUpdated,
   Deleted,
   Forked,

packages/schema/src/session.ts

@@ -40,8 +40,6 @@ export const Info = Schema.Struct({
   time: Schema.Struct({
     created: DateTimeUtcFromMillis,
     updated: DateTimeUtcFromMillis,
-    idle: DateTimeUtcFromMillis.pipe(optional),
-    viewed: DateTimeUtcFromMillis.pipe(optional),
     archived: DateTimeUtcFromMillis.pipe(optional),
   }),
   title: Schema.String.pipe(optional),

packages/schema/test/contract-hygiene.test.ts

@@ -54,29 +54,17 @@ describe("contract hygiene", () => {
       }),
     ).toEqual({ text: "completed" })
 
-    const info = Session.Info.make({
-      id: Session.ID.make("ses_untitled"),
-      projectID: Project.ID.make("global"),
-      cost: Money.USD.zero,
-      tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } },
-      time: {
-        created: DateTime.makeUnsafe(0),
-        updated: DateTime.makeUnsafe(0),
-        idle: undefined,
-        viewed: undefined,
-      },
-      title: undefined,
-      location: { directory: AbsolutePath.make("/project") },
-    })
-    const encoded = Schema.encodeSync(Session.Info)(info)
-    expect(encoded).not.toHaveProperty("title")
-    expect(encoded.time).toEqual({ created: 0, updated: 0 })
     expect(
       Schema.encodeSync(Session.Info)({
-        ...info,
-        time: { ...info.time, idle: DateTime.makeUnsafe(2), viewed: DateTime.makeUnsafe(1) },
-      }).time,
-    ).toEqual({ created: 0, updated: 0, idle: 2, viewed: 1 })
+        id: Session.ID.make("ses_untitled"),
+        projectID: Project.ID.make("global"),
+        cost: Money.USD.zero,
+        tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } },
+        time: { created: DateTime.makeUnsafe(0), updated: DateTime.makeUnsafe(0) },
+        title: undefined,
+        location: { directory: AbsolutePath.make("/project") },
+      }),
+    ).not.toHaveProperty("title")
   })
 
   test("session inbox items omit the internal enqueue sequence", () => {

packages/schema/test/event-manifest.test.ts

@@ -83,7 +83,6 @@ describe("public event manifest", () => {
         "session.model.selected.1",
         "session.moved.1",
         "session.renamed.1",
-        "session.viewed.1",
         "session.usage.recorded.1",
         "session.forked.2",
         "session.inbox.delivered.1",

packages/server/src/handlers/session.ts

@@ -180,22 +180,6 @@ export const SessionHandler = HttpApiBuilder.group(Api, "server.session", (handl
           }
         }),
       )
-      .handle(
-        "session.view",
-        Effect.fn(function* (ctx) {
-          yield* session.view({ sessionID: ctx.params.sessionID }).pipe(
-            Effect.catchTag(
-              "Session.NotFoundError",
-              (error) =>
-                new SessionNotFoundError({
-                  sessionID: error.sessionID,
-                  message: `Session not found: ${error.sessionID}`,
-                }),
-            ),
-          )
-          return HttpApiSchema.NoContent.make()
-        }),
-      )
       .handle(
         "session.remove",
         Effect.fn(function* (ctx) {

packages/server/test/fetch.test.ts

@@ -52,36 +52,6 @@ it.live("serves unauthenticated and answers CORS preflight when no password is c
   }).pipe(Effect.scoped),
 )
 
-it.live("serves the session view operation and missing-session error", () =>
-  Effect.gen(function* () {
-    const handler = yield* ServerFetch.make(options)
-    const created = yield* Effect.promise(() =>
-      handler(
-        new Request("http://opencode.local/api/session", {
-          method: "POST",
-          headers: { "content-type": "application/json" },
-          body: "{}",
-        }),
-      ).then((response) => response.json()),
-    )
-    if (typeof created !== "object" || created === null || !("data" in created))
-      return yield* Effect.die(new Error("Expected a session response"))
-    const data = created.data
-    if (typeof data !== "object" || data === null || !("id" in data) || typeof data.id !== "string")
-      return yield* Effect.die(new Error("Expected a session ID"))
-
-    const viewed = yield* Effect.promise(() =>
-      handler(new Request(`http://opencode.local/api/session/${data.id}/view`, { method: "POST" })),
-    )
-    expect(viewed.status).toBe(204)
-
-    const missing = yield* Effect.promise(() =>
-      handler(new Request("http://opencode.local/api/session/ses_missing_view/view", { method: "POST" })),
-    )
-    expect(missing.status).toBe(404)
-  }).pipe(Effect.scoped),
-)
-
 // Pins the eager-boot guarantee: the application layer is built before the handler returns, so
 // an aborted first request cannot interrupt layer construction and wedge every later request
 // (the Effect-TS/effect#6319 failure class that lazy first-request builds are prone to).

packages/tui/src/context/data.tsx

@@ -816,13 +816,6 @@ export const { use: useData, provider: DataProvider } = createSimpleContext({
             const currentAssistant = message.activeAssistant(draft)
             if (currentAssistant) currentAssistant.retry = undefined
           })
-          if (event.type === "session.execution.interrupted" && event.data.reason === "shutdown") break
-          result.session.invalidate(event.data.sessionID)
-          void result.session.sync(event.data.sessionID)
-          break
-        case "session.viewed":
-          result.session.invalidate(event.data.sessionID)
-          void result.session.sync(event.data.sessionID)
           break
         case "session.revert.staged":
           if (store.session.info[event.data.sessionID])

packages/tui/src/context/local.tsx

@@ -10,6 +10,7 @@ import { useClient } from "./client"
 import { RGBA } from "@opentui/core"
 import { readJson, writeJsonAtomic } from "../util/persistence"
 import {
+  availableModelVariant,
   createModelPreferenceRepository,
   cycleModelVariant,
   modelPreferenceKey,
@@ -221,7 +222,14 @@ export const { use: useLocal, provider: LocalProvider } = createSimpleContext({
         if (route.data.type === "session") return sessionSelection(route.data.sessionID)
         const model = newSessionModel()
         if (!model) return
-        return { ...model, variant: normalizeModelVariant(preferences.variant[modelPreferenceKey(model)]) }
+        const info = models()?.find((item) => item.providerID === model.providerID && item.id === model.modelID)
+        return {
+          ...model,
+          variant: availableModelVariant(
+            preferences.variant[modelPreferenceKey(model)],
+            info?.variants?.map((item) => item.id) ?? [],
+          ),
+        }
       })
 
       const currentModel = createMemo(() => {
@@ -262,13 +270,12 @@ export const { use: useLocal, provider: LocalProvider } = createSimpleContext({
         if (route.data.type === "session") {
           const sessionID = route.data.sessionID
           const current = sessionSelection(sessionID)
-          const preferred = normalizeModelVariant(
+          const preferred =
             current?.providerID === model.providerID && current.modelID === model.modelID
               ? current.variant
-              : preferences.variant[modelPreferenceKey(model)],
-          )
+              : preferences.variant[modelPreferenceKey(model)]
           const info = models()?.find((item) => item.providerID === model.providerID && item.id === model.modelID)
-          const variant = preferred && info?.variants?.some((item) => item.id === preferred) ? preferred : undefined
+          const variant = availableModelVariant(preferred, info?.variants?.map((item) => item.id) ?? [])
           setSessionDraft(sessionID, { ...model, variant })
           return true
         }

packages/tui/src/context/session-tabs.tsx

@@ -25,12 +25,12 @@ import {
   type ClosedSessionTab,
   type SessionTab,
   type SessionTabHistory,
+  type SessionTabUnread,
 } from "./session-tabs-model"
 
 type TabsState = {
   tabs: SessionTab[]
-  // Read only long enough to remove the former client-owned state from persisted tab files.
-  unread?: Record<string, unknown>
+  unread: Record<string, SessionTabUnread>
 }
 
 type PersistedState = {
@@ -43,7 +43,7 @@ type ScrollAnchor = {
   screenY: number
 }
 
-const empty = (): TabsState => ({ tabs: [] })
+const empty = (): TabsState => ({ tabs: [], unread: {} })
 
 // Deliberately after connect settles: the visible session's mount syncs win the first slots.
 const TAB_PREFETCH_DELAY = 300
@@ -60,7 +60,7 @@ export const { use: useSessionTabs, provider: SessionTabsProvider } = createSimp
     const paths = useTuiPaths()
     const renderer = useRenderer()
     const enabled = () => config.tabs.enabled
-    // Focus reporting emits transitions, so an interactive launch may acknowledge viewed sessions until its first blur.
+    // Focus reporting emits transitions, so an interactive launch owns unread state until its first blur.
     const [focused, setFocused] = createSignal(true)
     // Keyed reconcile keeps tab object identity across reorders, so strip rows move instead of
     // mutating in place, which per-row animations and drag state depend on.
@@ -110,15 +110,16 @@ export const { use: useSessionTabs, provider: SessionTabsProvider } = createSimp
       const session = data.session.get(sessionID)
       return session?.title ?? persisted ?? fallback ?? (session ? withTimestampedFallback(session) : undefined)
     }
-    const isUnread = (sessionID: string) => {
-      const info = data.session.get(sessionID)
-      return info?.time.idle !== undefined && (info.time.viewed === undefined || info.time.idle > info.time.viewed)
-    }
     const normalize = (value: TabsState) => ({
       tabs: value.tabs.reduce<SessionTab[]>((tabs, tab) => {
         const sessionID = root(tab.sessionID)
         return openSessionTab(tabs, { sessionID, title: title(sessionID, tab.title) })
       }, []),
+      unread: Object.entries(value.unread).reduce<Record<string, SessionTabUnread>>((result, entry) => {
+        const sessionID = root(entry[0])
+        result[sessionID] = result[sessionID] === "error" ? "error" : entry[1]
+        return result
+      }, {}),
     })
     const current = () => (route.data.type === "session" ? root(route.data.sessionID) : undefined)
     const newTab = createMemo((open = false) => {
@@ -132,7 +133,7 @@ export const { use: useSessionTabs, provider: SessionTabsProvider } = createSimp
       const members = data.session.family(session)
       const family = members.length > 0 ? members : [session]
       return {
-        unread: family.some(isUnread) ? ("activity" as const) : undefined,
+        unread: state().unread[session],
         promptPulse: promptPulses()[session] ?? 0,
         attention: family.some(
           (id) => (data.session.permission.list(id)?.length ?? 0) > 0 || (data.session.form.list(id)?.length ?? 0) > 0,
@@ -141,6 +142,17 @@ export const { use: useSessionTabs, provider: SessionTabsProvider } = createSimp
       }
     }
 
+    function markUnread(sessionID: string, unread: SessionTabUnread) {
+      if (!enabled() || !focused()) return
+      const session = root(sessionID)
+      if (current() === session || !state().tabs.some((tab) => tab.sessionID === session)) return
+      if (state().unread[session] === unread) return
+      update((draft) => {
+        if (!draft.tabs.some((tab) => tab.sessionID === session)) return
+        draft.unread[session] = unread
+      })
+    }
+
     createEffect(() => {
       if (!enabled()) return
       if (route.data.type !== "session" || route.data.sessionID === "dummy") return
@@ -164,11 +176,10 @@ export const { use: useSessionTabs, provider: SessionTabsProvider } = createSimp
       if (!enabled() || !focused()) return
       if (route.data.type !== "session" || route.data.sessionID === "dummy") return
       const sessionID = root(route.data.sessionID)
-      const members = data.session.family(sessionID)
-      const family = members.length > 0 ? members : [sessionID]
-      const unread = family.filter(isUnread)
-      if (unread.length === 0) return
-      void Promise.allSettled(unread.map((id) => client.api.session.view({ sessionID: id })))
+      if (!state().unread[sessionID]) return
+      update((draft) => {
+        delete draft.unread[sessionID]
+      })
     })
 
     createEffect(() => {
@@ -178,7 +189,7 @@ export const { use: useSessionTabs, provider: SessionTabsProvider } = createSimp
       update((draft) => {
         const next = normalize(draft)
         draft.tabs = next.tabs
-        delete draft.unread
+        draft.unread = next.unread
       })
     })
 
@@ -199,7 +210,7 @@ export const { use: useSessionTabs, provider: SessionTabsProvider } = createSimp
       const sessionIDs = signature.split("\n")
       let stale = false
       void (async () => {
-        await Promise.allSettled(sessionIDs.map((sessionID) => data.session.sync(sessionID, { children: true })))
+        await Promise.allSettled(sessionIDs.map((sessionID) => data.session.sync(sessionID)))
         if (stale) return
         const locations = new Map(
           sessionIDs
@@ -233,6 +244,9 @@ export const { use: useSessionTabs, provider: SessionTabsProvider } = createSimp
       })
     })
 
+    onCleanup(event.on("session.execution.succeeded", (evt) => markUnread(evt.data.sessionID, "activity")))
+    onCleanup(event.on("session.execution.interrupted", (evt) => markUnread(evt.data.sessionID, "activity")))
+    onCleanup(event.on("session.execution.failed", (evt) => markUnread(evt.data.sessionID, "error")))
     onCleanup(
       event.on("session.moved", (evt) => {
         if (!enabled() || !state().tabs.some((tab) => tab.sessionID === root(evt.data.sessionID))) return
@@ -268,6 +282,7 @@ export const { use: useSessionTabs, provider: SessionTabsProvider } = createSimp
       history = previous.history
       update((draft) => {
         draft.tabs = closeSessionTab(draft.tabs, target).tabs
+        delete draft.unread[target]
       })
       setPromptPulses((pulses) => {
         if (pulses[target] === undefined) return pulses
@@ -363,7 +378,7 @@ export const { use: useSessionTabs, provider: SessionTabsProvider } = createSimp
       cycleUnread(direction: 1 | -1) {
         if (!enabled()) return
         const tab = cycleSessionTab(state().tabs, current(), direction, (tab) =>
-          Boolean(status(tab.sessionID).unread || status(tab.sessionID).attention),
+          Boolean(state().unread[tab.sessionID] || status(tab.sessionID).attention),
         )
         if (tab) route.navigate({ type: "session", sessionID: tab.sessionID })
       },

packages/tui/src/model-preference.ts

@@ -39,6 +39,11 @@ export function normalizeModelVariant(value: string | undefined) {
   return value === "default" ? undefined : value
 }
 
+export function availableModelVariant(value: string | undefined, variants: string[]) {
+  const variant = normalizeModelVariant(value)
+  return variant && variants.includes(variant) ? variant : undefined
+}
+
 export function modelPreferenceKey(model: ModelPreferenceModel) {
   return `${model.providerID}/${model.modelID}`
 }

packages/tui/test/context/session-tabs.test.tsx

@@ -35,8 +35,6 @@ async function renderSessionTabs(
     persisted?: string[]
     sessionGate?: Promise<void>
     sessionDirectories?: Record<string, string>
-    sessionParents?: Record<string, string>
-    sessionTimes?: Record<string, { idle?: number; viewed?: number }>
     newLocation?: "launch" | "inherit"
   },
 ) {
@@ -55,13 +53,9 @@ async function renderSessionTabs(
   }
   const events = createEventStream()
   const sessions: string[] = []
-  const views: string[] = []
   const locations: string[] = []
   const vcsLocations: string[] = []
-  const sessionTimes = Object.fromEntries(
-    Object.entries(options?.sessionTimes ?? {}).map(([sessionID, time]) => [sessionID, { ...time }]),
-  )
-  const calls = createFetch(async (url, request) => {
+  const calls = createFetch(async (url) => {
     if (url.pathname === "/api/location") {
       const requested = url.searchParams.get("location[directory]") ?? directory
       locations.push(requested)
@@ -78,13 +72,6 @@ async function renderSessionTabs(
         data: { branch: { current: "main", default: "main" } },
       })
     }
-    const viewed = url.pathname.match(/^\/api\/session\/([^/]+)\/view$/)?.[1]
-    if (viewed && request.method === "POST") {
-      views.push(viewed)
-      const time = (sessionTimes[viewed] ??= {})
-      time.viewed = time.idle
-      return new Response(null, { status: 204 })
-    }
     const sessionID = url.pathname.match(/^\/api\/session\/([^/]+)$/)?.[1]
     if (!sessionID) return undefined
     sessions.push(sessionID)
@@ -92,13 +79,12 @@ async function renderSessionTabs(
     return json({
       data: {
         id: sessionID,
-        parentID: options?.sessionParents?.[sessionID],
         title: sessionID === initialSessionID ? options?.title : undefined,
         projectID: "project",
         location: { directory: options?.sessionDirectories?.[sessionID] ?? directory },
         cost: 0,
         tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } },
-        time: { created: 0, updated: 0, ...sessionTimes[sessionID] },
+        time: { created: 0, updated: 0 },
       },
     })
   }, events)
@@ -152,13 +138,9 @@ async function renderSessionTabs(
     route,
     data,
     sessions,
-    views,
     locations,
     vcsLocations,
     state,
-    setSessionTime(sessionID: string, time: { idle?: number; viewed?: number }) {
-      sessionTimes[sessionID] = time
-    },
     emit: (event: OpenCodeEvent) => events.emit({ ...event, location: { directory } }),
     focus: () => app.renderer.emit("focus"),
     blur: () => app.renderer.emit("blur"),
@@ -171,6 +153,14 @@ async function renderSessionTabs(
   }
 }
 
+const executionSucceeded = (sessionID: string): OpenCodeEvent => ({
+  id: `evt_done_${sessionID}`,
+  created: Date.now(),
+  type: "session.execution.succeeded",
+  durable: { aggregateID: sessionID, seq: 1, version: 1 },
+  data: { sessionID },
+})
+
 test("loads persisted tab metadata concurrently on connect", async () => {
   let release!: () => void
   const sessionGate = new Promise<void>((resolve) => (release = resolve))
@@ -240,94 +230,56 @@ test("stores session tabs for the current working directory by default", async (
     const file = path.join(setup.state, "test", "tui", "tabs.json")
     await wait(() => Bun.file(file).size > 0)
     const stored = await Bun.file(file).json()
-    expect(stored.global).toEqual({ tabs: [] })
+    expect(stored.global).toEqual({ tabs: [], unread: {} })
     expect(Object.keys(stored.cwd)).toEqual([directory])
     expect(stored.cwd[directory].tabs.map((tab: { sessionID: string }) => tab.sessionID)).toEqual(["first"])
-    expect(stored.cwd[directory]).not.toHaveProperty("unread")
+    expect(stored.cwd[directory].unread).toEqual({})
   } finally {
     await setup.destroy()
   }
 })
 
-test("derives unread state from server session times", async () => {
-  const setup = await renderSessionTabs("first", {
-    home: true,
-    persisted: ["first", "second"],
-    sessionTimes: { second: { idle: 2 } },
-  })
+test("only the foreground TUI mutates unread state", async () => {
+  await using temporary = await tmpdir()
+  let foreground: Awaited<ReturnType<typeof renderSessionTabs>> | undefined
+  let background: Awaited<ReturnType<typeof renderSessionTabs>> | undefined
+
   try {
-    await wait(() => setup.tabs.status("second").unread === "activity")
-    expect(setup.tabs.status("first").unread).toBeUndefined()
+    foreground = await renderSessionTabs("first", { state: temporary.path, persisted: ["first", "second"] })
+    background = await renderSessionTabs("second", { state: temporary.path })
+    foreground.focus()
+    background.blur()
+    await wait(() => foreground?.tabs.tabs().length === 2 && background?.tabs.tabs().length === 2, 2_000, "shared tabs")
+
+    const firstDone = executionSucceeded("first")
+    foreground.emit(firstDone)
+    background.emit(firstDone)
+    await Promise.all([foreground.flush(), background.flush()])
+    expect(foreground.tabs.status("first").unread).toBeUndefined()
+    expect(background.tabs.status("first").unread).toBeUndefined()
+
+    const secondDone = executionSucceeded("second")
+    foreground.emit(secondDone)
+    background.emit(secondDone)
+    await wait(
+      () =>
+        foreground?.tabs.status("second").unread === "activity" &&
+        background?.tabs.status("second").unread === "activity",
+      10_000,
+      "shared unread activity",
+    )
+
+    foreground.tabs.select("second")
+    await wait(
+      () =>
+        foreground?.tabs.status("second").unread === undefined &&
+        background?.tabs.status("second").unread === undefined,
+      10_000,
+      "shared unread clearing",
+    )
   } finally {
-    await setup.destroy()
-  }
-})
-
-test("refreshes server session times after terminal events", async () => {
-  const setup = await renderSessionTabs("first", { home: true, persisted: ["first"] })
-  try {
-    setup.setSessionTime("first", { idle: 2 })
-    setup.emit({
-      id: "evt_done_first",
-      created: 2,
-      type: "session.execution.succeeded",
-      durable: { aggregateID: "first", seq: 1, version: 1 },
-      data: { sessionID: "first" },
-    })
-    await wait(() => setup.tabs.status("first").unread === "activity")
-  } finally {
-    await setup.destroy()
-  }
-})
-
-test("views a selected unread session only while focused", async () => {
-  const setup = await renderSessionTabs("first", {
-    home: true,
-    persisted: ["first"],
-    sessionTimes: { first: { idle: 2 } },
-  })
-  try {
-    setup.blur()
-    setup.route.navigate({ type: "session", sessionID: "first" })
-    await wait(() => setup.tabs.current() === "first" && setup.tabs.status("first").unread === "activity")
-    await Bun.sleep(20)
-    expect(setup.views).toEqual([])
-
-    setup.focus()
-    await wait(() => setup.views.includes("first"))
-    setup.emit({
-      id: "evt_viewed_first",
-      created: 3,
-      type: "session.viewed",
-      durable: { aggregateID: "first", seq: 2, version: 1 },
-      data: { sessionID: "first" },
-    })
-    await wait(() => setup.tabs.status("first").unread === undefined)
-  } finally {
-    await setup.destroy()
-  }
-})
-
-test("views unread child sessions through their root tab", async () => {
-  const setup = await renderSessionTabs("root", {
-    home: true,
-    persisted: ["root"],
-    sessionParents: { child: "root" },
-    sessionTimes: { child: { idle: 2 } },
-  })
-  try {
-    setup.blur()
-    await setup.data.session.sync("child")
-    await wait(() => setup.tabs.status("root").unread === "activity")
-
-    setup.route.navigate({ type: "session", sessionID: "root" })
-    await Bun.sleep(20)
-    expect(setup.views).toEqual([])
-    setup.focus()
-    await wait(() => setup.views.includes("child"))
-    expect(setup.views).not.toContain("root")
-  } finally {
-    await setup.destroy()
+    if (foreground) await foreground.destroy()
+    if (background) await background.destroy()
   }
 })
 

packages/tui/test/model-preference.test.ts

@@ -1,6 +1,6 @@
 import { expect, test } from "bun:test"
 import path from "node:path"
-import { createModelPreferenceRepository, decodeModelPreference } from "../src/model-preference"
+import { availableModelVariant, createModelPreferenceRepository, decodeModelPreference } from "../src/model-preference"
 import { tmpdir } from "./fixture/fixture"
 
 test("repairs known model preferences and preserves unrelated fields", () => {
@@ -19,6 +19,12 @@ test("repairs known model preferences and preserves unrelated fields", () => {
   })
 })
 
+test("drops a saved variant that is no longer available", () => {
+  expect(availableModelVariant("medium", [])).toBeUndefined()
+  expect(availableModelVariant("medium", ["low", "high"])).toBeUndefined()
+  expect(availableModelVariant("medium", ["low", "medium", "high"])).toBe("medium")
+})
+
 test("atomically serializes patches and variant updates", async () => {
   await using tmp = await tmpdir()
   const file = path.join(tmp.path, "model.json")

packages/www/openapi.json

@@ -4127,65 +4127,6 @@
         "summary": "Get session message"
       }
     },
-    "/api/session/{sessionID}/view": {
-      "post": {
-        "tags": ["session"],
-        "operationId": "v2.session.view",
-        "parameters": [
-          {
-            "name": "sessionID",
-            "in": "path",
-            "schema": {
-              "type": "string",
-              "allOf": [
-                {
-                  "pattern": "^ses"
-                }
-              ]
-            },
-            "required": true
-          }
-        ],
-        "security": [],
-        "responses": {
-          "204": {
-            "description": "<No Content>"
-          },
-          "400": {
-            "description": "InvalidRequestError",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "$ref": "#/components/schemas/InvalidRequestError"
-                }
-              }
-            }
-          },
-          "401": {
-            "description": "UnauthorizedError",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "$ref": "#/components/schemas/UnauthorizedError"
-                }
-              }
-            }
-          },
-          "404": {
-            "description": "SessionNotFoundError",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "$ref": "#/components/schemas/SessionNotFoundError"
-                }
-              }
-            }
-          }
-        },
-        "description": "Mark the latest recorded idle transition as viewed.",
-        "summary": "View session"
-      }
-    },
     "/api/session/{sessionID}/message": {
       "get": {
         "tags": ["session"],
@@ -12194,12 +12135,6 @@
               "updated": {
                 "type": "number"
               },
-              "idle": {
-                "type": "number"
-              },
-              "viewed": {
-                "type": "number"
-              },
               "archived": {
                 "type": "number"
               }
@@ -14341,71 +14276,6 @@
         "required": ["id", "created", "type", "durable", "data"],
         "additionalProperties": false
       },
-      "session.viewed": {
-        "type": "object",
-        "properties": {
-          "id": {
-            "type": "string",
-            "allOf": [
-              {
-                "pattern": "^evt_"
-              }
-            ]
-          },
-          "created": {
-            "type": "number"
-          },
-          "metadata": {
-            "type": "object"
-          },
-          "type": {
-            "type": "string",
-            "enum": ["session.viewed"]
-          },
-          "durable": {
-            "type": "object",
-            "properties": {
-              "aggregateID": {
-                "type": "string"
-              },
-              "seq": {
-                "type": "integer",
-                "allOf": [
-                  {
-                    "minimum": 0
-                  }
-                ]
-              },
-              "version": {
-                "type": "number",
-                "enum": [1]
-              }
-            },
-            "required": ["aggregateID", "seq", "version"],
-            "additionalProperties": false
-          },
-          "location": {
-            "$ref": "#/components/schemas/Location.Ref"
-          },
-          "data": {
-            "type": "object",
-            "properties": {
-              "sessionID": {
-                "type": "string",
-                "allOf": [
-                  {
-                    "pattern": "^ses"
-                  }
-                ]
-              }
-            },
-            "required": ["sessionID"],
-            "additionalProperties": false
-          }
-        },
-        "required": ["id", "created", "type", "durable", "data"],
-        "additionalProperties": false
-      },
       "session.deleted": {
         "type": "object",
         "properties": {
@@ -17426,9 +17296,6 @@
           {
             "$ref": "#/components/schemas/session.renamed"
           },
-          {
-            "$ref": "#/components/schemas/session.viewed"
-          },
           {
             "$ref": "#/components/schemas/session.deleted"
           },
@@ -22797,9 +22664,6 @@
           {
             "$ref": "#/components/schemas/session.renamed"
           },
-          {
-            "$ref": "#/components/schemas/session.viewed"
-          },
           {
             "$ref": "#/components/schemas/session.usage.updated"
           },

packages/www/public/openapi.json

@@ -4127,65 +4127,6 @@
         "summary": "Get session message"
       }
     },
-    "/api/session/{sessionID}/view": {
-      "post": {
-        "tags": ["session"],
-        "operationId": "v2.session.view",
-        "parameters": [
-          {
-            "name": "sessionID",
-            "in": "path",
-            "schema": {
-              "type": "string",
-              "allOf": [
-                {
-                  "pattern": "^ses"
-                }
-              ]
-            },
-            "required": true
-          }
-        ],
-        "security": [],
-        "responses": {
-          "204": {
-            "description": "<No Content>"
-          },
-          "400": {
-            "description": "InvalidRequestError",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "$ref": "#/components/schemas/InvalidRequestError"
-                }
-              }
-            }
-          },
-          "401": {
-            "description": "UnauthorizedError",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "$ref": "#/components/schemas/UnauthorizedError"
-                }
-              }
-            }
-          },
-          "404": {
-            "description": "SessionNotFoundError",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "$ref": "#/components/schemas/SessionNotFoundError"
-                }
-              }
-            }
-          }
-        },
-        "description": "Mark the latest recorded idle transition as viewed.",
-        "summary": "View session"
-      }
-    },
     "/api/session/{sessionID}/message": {
       "get": {
         "tags": ["session"],
@@ -12194,12 +12135,6 @@
               "updated": {
                 "type": "number"
               },
-              "idle": {
-                "type": "number"
-              },
-              "viewed": {
-                "type": "number"
-              },
               "archived": {
                 "type": "number"
               }
@@ -14341,71 +14276,6 @@
         "required": ["id", "created", "type", "durable", "data"],
         "additionalProperties": false
       },
-      "session.viewed": {
-        "type": "object",
-        "properties": {
-          "id": {
-            "type": "string",
-            "allOf": [
-              {
-                "pattern": "^evt_"
-              }
-            ]
-          },
-          "created": {
-            "type": "number"
-          },
-          "metadata": {
-            "type": "object"
-          },
-          "type": {
-            "type": "string",
-            "enum": ["session.viewed"]
-          },
-          "durable": {
-            "type": "object",
-            "properties": {
-              "aggregateID": {
-                "type": "string"
-              },
-              "seq": {
-                "type": "integer",
-                "allOf": [
-                  {
-                    "minimum": 0
-                  }
-                ]
-              },
-              "version": {
-                "type": "number",
-                "enum": [1]
-              }
-            },
-            "required": ["aggregateID", "seq", "version"],
-            "additionalProperties": false
-          },
-          "location": {
-            "$ref": "#/components/schemas/Location.Ref"
-          },
-          "data": {
-            "type": "object",
-            "properties": {
-              "sessionID": {
-                "type": "string",
-                "allOf": [
-                  {
-                    "pattern": "^ses"
-                  }
-                ]
-              }
-            },
-            "required": ["sessionID"],
-            "additionalProperties": false
-          }
-        },
-        "required": ["id", "created", "type", "durable", "data"],
-        "additionalProperties": false
-      },
       "session.deleted": {
         "type": "object",
         "properties": {
@@ -17426,9 +17296,6 @@
           {
             "$ref": "#/components/schemas/session.renamed"
           },
-          {
-            "$ref": "#/components/schemas/session.viewed"
-          },
           {
             "$ref": "#/components/schemas/session.deleted"
           },
@@ -22797,9 +22664,6 @@
           {
             "$ref": "#/components/schemas/session.renamed"
           },
-          {
-            "$ref": "#/components/schemas/session.viewed"
-          },
           {
             "$ref": "#/components/schemas/session.usage.updated"
           },