feat(tui): use server viewed state

fix(session): use numeric event timestamps
chore(client): regenerate API
2026-08-16 14:46:27 +00:00 · 2026-08-15 20:52:18 -04:00 · 2026-08-15 20:29:37 -04:00 · 2026-08-15 20:27:12 -04:00 · 2026-08-15 20:26:40 -04:00 · 2026-08-15 20:26:40 -04:00
55 changed files with 1112 additions and 262 deletions
@@ -613,6 +613,7 @@
        "@tsconfig/bun": "catalog:",
        "@types/bun": "catalog:",
        "@typescript/native-preview": "catalog:",
+        "prettier": "3.6.2",
        "typescript": "catalog:",
      },
    },
@@ -27,6 +27,7 @@ const requestedTarget = process.argv.find((arg) => arg.startsWith("--target="))?
 const skipInstall = process.argv.includes("--skip-install")
 const skipWebUi = process.argv.includes("--skip-web-ui")
 const solidPlugin = createSolidTransformPlugin()
+const releaseAssets = new Map<string, Promise<Map<string, string>>>()

 const allTargets: {
  os: string
@@ -161,7 +162,13 @@ async function compileExecutable(item: (typeof allTargets)[number]) {
  if (!release) return

  const platform = item.os === "win32" ? "windows" : item.os
-  const name = ["bun", platform, item.arch, item.abi, item.avx2 === false ? "baseline" : undefined]
+  const name = [
+    "bun",
+    platform,
+    item.arch === "arm64" ? "aarch64" : item.arch,
+    item.abi,
+    item.avx2 === false ? "baseline" : undefined,
+  ]
    .filter(Boolean)
    .join("-")
  const cache = path.join(outdir, ".bun", release)
@@ -170,7 +177,13 @@ async function compileExecutable(item: (typeof allTargets)[number]) {

  await mkdir(cache, { recursive: true })
  const archive = path.join(cache, `${name}.zip`)
-  const response = await fetch(`https://github.com/oven-sh/bun/releases/download/${release}/${name}.zip`)
+  const assets = await compileReleaseAssets(release)
+  const url = assets.get(`${name}.zip`)
+  if (!url) throw new Error(`Bun release ${release} does not include ${name}.zip`)
+  const token = process.env.GH_TOKEN ?? process.env.GITHUB_TOKEN
+  const response = await fetch(url, {
+    headers: { Accept: "application/octet-stream", ...(token ? { Authorization: `Bearer ${token}` } : {}) },
+  })
  if (!response.ok) throw new Error(`Failed to download ${name} from Bun release ${release}: ${response.status}`)
  await Bun.write(archive, response)
  await $`unzip -oq ${archive} -d ${cache}`
@@ -178,6 +191,38 @@ async function compileExecutable(item: (typeof allTargets)[number]) {
  return executable
 }

+function compileReleaseAssets(release: string) {
+  const existing = releaseAssets.get(release)
+  if (existing) return existing
+  const pending = fetch(`https://api.github.com/repos/oven-sh/bun/releases/tags/${release}?cache=${Date.now()}`)
+    .then(async (response) => {
+      if (!response.ok) throw new Error(`Failed to resolve Bun release ${release}: ${response.status}`)
+      const data: unknown = await response.json()
+      if (typeof data !== "object" || data === null || !("assets" in data) || !Array.isArray(data.assets)) {
+        throw new Error(`Bun release ${release} returned invalid metadata`)
+      }
+      return new Map(
+        data.assets
+          .filter(
+            (asset): asset is { name: string; url: string } =>
+              typeof asset === "object" &&
+              asset !== null &&
+              "name" in asset &&
+              typeof asset.name === "string" &&
+              "url" in asset &&
+              typeof asset.url === "string",
+          )
+          .map((asset) => [asset.name, asset.url]),
+      )
+    })
+    .catch((error) => {
+      releaseAssets.delete(release)
+      throw error
+    })
+  releaseAssets.set(release, pending)
+  return pending
+}
+
 function targetName(item: (typeof allTargets)[number]) {
  return [
    binary,
@@ -382,6 +382,15 @@ 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
@@ -914,6 +923,10 @@ 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>
@@ -958,6 +971,7 @@ 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 = {
@@ -86,6 +86,8 @@ import type {
  Endpoint5_33Output,
  Endpoint5_34Input,
  Endpoint5_34Output,
+  Endpoint5_35Input,
+  Endpoint5_35Output,
  Endpoint6_0Input,
  Endpoint6_0Output,
  Endpoint7_0Input,
@@ -610,6 +612,11 @@ 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),
@@ -639,6 +646,7 @@ 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) =>
@@ -80,6 +80,8 @@ import type {
  SessionBackgroundOutput,
  SessionMessageInput,
  SessionMessageOutput,
+  SessionViewInput,
+  SessionViewOutput,
  MessageListInput,
  MessageListOutput,
  ModelListInput,
@@ -896,6 +898,17 @@ 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) =>
@@ -479,6 +479,16 @@ 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
@@ -1510,7 +1520,7 @@ export type SessionInfo = {
  model?: ModelRef
  cost: MoneyUSD
  tokens: TokenUsageInfo
-  time: { created: number; updated: number; archived?: number }
+  time: { created: number; updated: number; idle?: number; viewed?: number; archived?: number }
  title?: string
  location: LocationRef
  subpath?: string
@@ -1923,6 +1933,7 @@ export type SessionEventDurable =
  | SessionModelSelected
  | SessionMoved
  | SessionRenamed
+  | SessionViewed
  | SessionDeleted
  | SessionForked
  | SessionInboxDelivered
@@ -2013,6 +2024,7 @@ export type V2Event =
  | SessionModelSelected
  | SessionMoved
  | SessionRenamed
+  | SessionViewed
  | SessionUsageUpdated
  | SessionDeleted
  | SessionForked
@@ -2476,7 +2488,13 @@ export type SessionImportInput = {
        readonly reasoning: number
        readonly cache: { readonly read: number; readonly write: number }
      }
-      readonly time: { readonly created: number; readonly updated: number; readonly archived?: number }
+      readonly time: {
+        readonly created: number
+        readonly updated: number
+        readonly idle?: number
+        readonly viewed?: number
+        readonly archived?: number
+      }
      readonly title?: string
      readonly location: { readonly directory: string; readonly workspaceID?: string }
      readonly subpath?: string
@@ -2743,7 +2761,13 @@ export type SessionImportInput = {
        readonly reasoning: number
        readonly cache: { readonly read: number; readonly write: number }
      }
-      readonly time: { readonly created: number; readonly updated: number; readonly archived?: number }
+      readonly time: {
+        readonly created: number
+        readonly updated: number
+        readonly idle?: number
+        readonly viewed?: number
+        readonly archived?: number
+      }
      readonly title?: string
      readonly location: { readonly directory: string; readonly workspaceID?: string }
      readonly subpath?: string
@@ -3010,7 +3034,13 @@ export type SessionImportInput = {
        readonly reasoning: number
        readonly cache: { readonly read: number; readonly write: number }
      }
-      readonly time: { readonly created: number; readonly updated: number; readonly archived?: number }
+      readonly time: {
+        readonly created: number
+        readonly updated: number
+        readonly idle?: number
+        readonly viewed?: number
+        readonly archived?: number
+      }
      readonly title?: string
      readonly location: { readonly directory: string; readonly workspaceID?: string }
      readonly subpath?: string
@@ -3936,6 +3966,10 @@ 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?: {
@@ -136,8 +136,10 @@ 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(
@@ -183,6 +185,7 @@ 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"),
@@ -207,7 +210,11 @@ 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)

-  expect(DateTime.toEpochMillis(result.page.data[0].time.created)).toBe(1_717_171_717_000)
+  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(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)
@@ -217,11 +224,10 @@ 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" && DateTime.toEpochMillis(logged[0].created)).toBe(
-    1_717_171_717_000,
-  )
+  expect(logged[0]?.type === "session.model.selected" && 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" }))
 })
@@ -260,6 +266,8 @@ 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" },
@@ -539,6 +539,7 @@ 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",
@@ -565,6 +566,7 @@ 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")
@@ -577,6 +579,7 @@ 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"],
@@ -651,6 +654,8 @@ 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" },
@@ -1,8 +1,8 @@
 {
  "version": "7",
  "dialect": "sqlite",
-  "id": "dcde8e6b-4bf4-4f6b-b2be-4030c2c3e936",
-  "prevIds": ["5c1aa56b-c3ee-4283-9a84-c0bf626dc604"],
+  "id": "94b6c496-ad84-426f-9d5d-3e1ac3ebfb56",
+  "prevIds": ["dcde8e6b-4bf4-4f6b-b2be-4030c2c3e936"],
  "ddl": [
    {
      "name": "account_state",
@@ -1350,6 +1350,26 @@
      "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,
@@ -82,7 +82,7 @@ export const Plugin = define({
      .pipe(
        Stream.filterEffect((update) => Effect.map(config.entries(), (entries) => isAgentSource(entries, update.path))),
      )
-    const configUpdates = ctx.event.subscribe("config.updated")
+    const configUpdates = ctx.event.subscribe().pipe(Stream.filter((event) => event.type === "config.updated"))
    yield* Stream.merge(sourceChanges, configUpdates).pipe(
      Stream.debounce("100 millis"),
      Stream.runForEach(() => reload),
@@ -43,7 +43,7 @@ export const Plugin = define({
          Effect.map(config.entries(), (entries) => isCommandSource(entries, update.path)),
        ),
      )
-    const configUpdates = ctx.event.subscribe("config.updated")
+    const configUpdates = ctx.event.subscribe().pipe(Stream.filter((event) => event.type === "config.updated"))
    yield* Stream.merge(sourceChanges, configUpdates).pipe(
      Stream.debounce("100 millis"),
      Stream.runForEach(() => reload),
@@ -22,7 +22,8 @@ export const Plugin = define({
        if (policy?.effect === "deny") catalog.provider.remove(record.provider.id)
      }
    })
-    yield* ctx.event.subscribe("config.updated").pipe(
+    yield* ctx.event.subscribe().pipe(
+      Stream.filter((event) => event.type === "config.updated"),
      Stream.runForEach(() =>
        config.entries().pipe(
          Effect.tap((entries) => Effect.sync(() => (loaded.entries = entries))),
@@ -97,7 +97,8 @@ export const Plugin = define({
        }
      }
    })
-    yield* ctx.event.subscribe("config.updated").pipe(
+    yield* ctx.event.subscribe().pipe(
+      Stream.filter((event) => event.type === "config.updated"),
      Stream.runForEach(() =>
        config.entries().pipe(
          Effect.tap((entries) => Effect.sync(() => (loaded.entries = entries))),
@@ -49,7 +49,8 @@ export const Plugin = define({
      }
      for (const [name, source] of entries) draft.add(name, source)
    })
-    yield* ctx.event.subscribe("config.updated").pipe(
+    yield* ctx.event.subscribe().pipe(
+      Stream.filter((event) => event.type === "config.updated"),
      Stream.runForEach(() =>
        config.entries().pipe(
          Effect.tap((entries) => Effect.sync(() => (loaded.entries = entries))),
@@ -180,7 +180,8 @@ export const Plugin = define({
    yield* ctx.skill.transform((draft) => {
      for (const skill of loaded.skills) draft.add(skill)
    })
-    yield* ctx.event.subscribe("config.updated").pipe(
+    yield* ctx.event.subscribe().pipe(
+      Stream.filter((event) => event.type === "config.updated"),
      Stream.runForEach(() =>
        config.entries().pipe(
          Effect.tap((entries) => Effect.sync(() => (loaded.entries = entries))),
@@ -14,7 +14,8 @@ export const Plugin = define({
      if (selection === false) websearch.default.set(false)
      if (selection) websearch.default.set(selection.provider)
    })
-    yield* ctx.event.subscribe("config.updated").pipe(
+    yield* ctx.event.subscribe().pipe(
+      Stream.filter((event) => event.type === "config.updated"),
      Stream.runForEach(() =>
        config.entries().pipe(
          Effect.tap((entries) => Effect.sync(() => (loaded.entries = entries))),
@@ -43,6 +43,7 @@ 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,
@@ -89,4 +90,5 @@ export const migrations = [
  m41,
  m42,
  m43,
+  m44,
 ] satisfies DatabaseMigration.Migration[]
@@ -0,0 +1,14 @@
+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
@@ -209,6 +209,8 @@ 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,
@@ -59,12 +59,6 @@ export const make = Effect.fn("PluginHost.make")(function* (plugin: import("../p
    ref.directory === location.directory && ref.workspaceID === location.workspaceID
  const response = <A, E, R>(effect: Effect.Effect<A, E, R>) =>
    effect.pipe(Effect.map((data) => ({ location: locationInfo(), data })))
-  const subscribe: Plugin.Context["event"]["subscribe"] = (type?: EventManifest.ServerEvent["type"]) => {
-    if (type === undefined) return bus.subscribe().pipe(Stream.filter(EventManifest.isServer))
-    const definition = EventManifest.Server.get(type)
-    if (!definition) return Stream.fail(new Error(`Unknown plugin event type: ${type}`))
-    return bus.subscribe(definition).pipe(Stream.filter(EventManifest.isServer))
-  }

  return {
    app,
@@ -186,7 +180,7 @@ export const make = Effect.fn("PluginHost.make")(function* (plugin: import("../p
        }),
    },
    event: {
-      subscribe,
+      subscribe: () => bus.subscribe().pipe(Stream.filter(EventManifest.isServer)),
    },
    integration: {
      list: () => response(integration.list()),
@@ -165,6 +165,7 @@ 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
@@ -447,6 +448,17 @@ 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)
@@ -53,6 +53,8 @@ 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,
    },
  })
@@ -60,6 +60,7 @@ 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* () {
@@ -391,6 +391,30 @@ 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
@@ -512,6 +536,17 @@ 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) =>
@@ -580,9 +615,9 @@ const layer = Layer.effectDiscard(
        delivery: event.data.delivery,
      }),
    )
-    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.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.InstructionsUpdated, (event) =>
      Effect.gen(function* () {
        yield* run(db, event)
@@ -150,6 +150,10 @@ export const createLLMEventPublisher = (bus: Pick<Bus.Interface, "publish">, inp
      if (!current) return yield* Effect.die(new Error(`${name} delta before start: ${id}`))
      if (!current.pending) return undefined
      const now = yield* Clock.currentTimeMillis
+      if (!force && current.publishedAt === undefined) {
+        current.publishedAt = now
+        return undefined
+      }
      if (!force && current.publishedAt !== undefined && now - current.publishedAt < deltaBatchInterval)
        return undefined
      yield* delta(id, current.pending, current.ordinal)
@@ -56,6 +56,8 @@ 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). */
@@ -117,6 +117,10 @@ 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,
@@ -13,6 +13,7 @@ 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>(
@@ -73,6 +74,27 @@ 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(
@@ -20,55 +20,24 @@ class Secret extends Context.Service<Secret, string>()("@opencode/test/PluginSec
 const versioned = <R>(plugin: EffectPlugin.Plugin<R>, version = "1") => ({ ...plugin, version })

 describe("Plugin", () => {
-  it.live("selects one public event type through the plugin context", () =>
+  it.live("exposes public events through the plugin context", () =>
    Effect.gen(function* () {
      const plugins = yield* Plugin.Service
      const bus = yield* Bus.Service
      const host = yield* PluginHost.make(plugins)
-      const received = yield* host.event
-        .subscribe("config.updated")
-        .pipe(Stream.runHead, Effect.forkScoped({ startImmediately: true }))
+      const received = yield* host.event.subscribe().pipe(
+        Stream.filter((event) => event.type === "config.updated"),
+        Stream.runHead,
+        Effect.forkScoped({ startImmediately: true }),
+      )
      yield* Effect.sleep("10 millis")

-      yield* bus.publish(Plugin.Event.Updated, {})
      yield* bus.publish(ConfigSchema.Event.Updated, {})

      expect((yield* Fiber.join(received)).valueOrUndefined?.type).toBe("config.updated")
    }),
  )

-  it.live("exposes all public events through a wildcard plugin subscription", () =>
-    Effect.gen(function* () {
-      const plugins = yield* Plugin.Service
-      const bus = yield* Bus.Service
-      const host = yield* PluginHost.make(plugins)
-      const received = yield* host.event
-        .subscribe()
-        .pipe(Stream.take(2), Stream.runCollect, Effect.forkScoped({ startImmediately: true }))
-      yield* Effect.sleep("10 millis")
-
-      yield* bus.publish(Plugin.Event.Updated, {})
-      yield* bus.publish(ConfigSchema.Event.Updated, {})
-
-      expect(Array.from(yield* Fiber.join(received), (event) => event.type)).toEqual([
-        "plugin.updated",
-        "config.updated",
-      ])
-    }),
-  )
-
-  it.effect("rejects unknown runtime plugin event types", () =>
-    Effect.gen(function* () {
-      const plugins = yield* Plugin.Service
-      const host = yield* PluginHost.make(plugins)
-      const subscribe = host.event.subscribe as unknown as (type: string) => Stream.Stream<never, Error>
-
-      const failure = yield* subscribe("unknown.event").pipe(Stream.runDrain, Effect.flip)
-
-      expect(failure.message).toBe("Unknown plugin event type: unknown.event")
-    }),
-  )
-
  it.effect("replaces plugins by ID and version", () =>
    Effect.gen(function* () {
      const plugins = yield* Plugin.Service
@@ -1,6 +1,6 @@
 import { describe, expect } from "bun:test"
 import { Message, SystemPart } from "@opencode-ai/ai"
-import { DateTime, Effect, Schema, Stream } from "effect"
+import { DateTime, Effect, Schema } from "effect"
 import { Agent } from "@opencode-ai/core/agent"
 import { Catalog } from "@opencode-ai/core/catalog"
 import { Model } from "@opencode-ai/core/model"
@@ -18,8 +18,6 @@ import { Provider } from "@opencode-ai/core/provider"
 import { Project } from "@opencode-ai/core/project"
 import { AbsolutePath } from "@opencode-ai/core/schema"
 import { define } from "@opencode-ai/plugin/promise/plugin"
-import { Plugin as EffectPlugin } from "@opencode-ai/plugin/effect"
-import type { PluginEventType } from "@opencode-ai/plugin/effect/event"
 import { Money } from "@opencode-ai/schema/money"
 import type { SessionHooks } from "@opencode-ai/plugin/effect/session"
 import { testEffect } from "../lib/effect"
@@ -29,28 +27,6 @@ import { host as testHost } from "./host"
 const it = testEffect(PluginTestLayer)

 describe("fromPromise", () => {
-  it.effect("forwards a selected event type", () =>
-    Effect.gen(function* () {
-      let selected: string | undefined
-      const subscribe: EffectPlugin.Context["event"]["subscribe"] = (type?: PluginEventType) => {
-        selected = type
-        return Stream.empty
-      }
-      const host = testHost({ event: { subscribe } })
-
-      yield* PluginPromise.fromPromise(
-        define({
-          id: "promise-event-subscribe",
-          setup: (ctx) => {
-            ctx.event.subscribe("config.updated")
-          },
-        }),
-      ).effect(host)
-
-      expect(selected).toBe("config.updated")
-    }),
-  )
-
  it.effect("adapts session creation through the protocol schema", () =>
    Effect.gen(function* () {
      let seen: unknown
@@ -840,7 +840,15 @@ describe("SessionTransfer", () => {

      const imported = yield* transfer.import({
        data: {
-          info: { ...template, id: sessionID },
+          info: {
+            ...template,
+            id: sessionID,
+            time: {
+              ...template.time,
+              idle: DateTime.makeUnsafe(200),
+              viewed: DateTime.makeUnsafe(150),
+            },
+          },
          messages: [
            {
              id: sourceMessageID,
@@ -863,13 +871,18 @@ 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)
-      expect((yield* transfer.export({ sessionID })).messages).toEqual(messages)
-      expect((yield* transfer.export({ sessionID, sanitize: true })).messages).toMatchObject([
+      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([
        { id: sourceMessageID, text: `[redacted:text:${sourceMessageID}]` },
        { id: errorMessageID, error: { type: "test_error", message: "Original error" } },
      ])
@@ -217,16 +217,13 @@ it.effect("batches text deltas and flushes pending text before the terminal even
      { discard: true },
    )

-    expect(published.filter((event) => event.type === "session.text.delta").map((event) => event.data)).toMatchObject([
-      { delta: "one" },
-    ])
+    expect(published.filter((event) => event.type === "session.text.delta")).toHaveLength(0)
    yield* TestClock.adjust("99 millis")
-    expect(published.filter((event) => event.type === "session.text.delta")).toHaveLength(1)
+    expect(published.filter((event) => event.type === "session.text.delta")).toHaveLength(0)
    yield* TestClock.adjust("1 millis")
    yield* publisher.publish(LLMEvent.textDelta({ id: "text", text: " four" }))
    expect(published.filter((event) => event.type === "session.text.delta").map((event) => event.data)).toMatchObject([
-      { delta: "one" },
-      { delta: " two three four" },
+      { delta: "one two three four" },
    ])

    yield* publisher.publish(LLMEvent.textDelta({ id: "text", text: " five" }))
@@ -253,7 +250,7 @@ it.effect("batches reasoning deltas and flushes pending reasoning before the ter

    expect(
      published.filter((event) => event.type === "session.reasoning.delta").map((event) => event.data),
-    ).toMatchObject([{ delta: "one" }, { delta: " two three" }])
+    ).toMatchObject([{ delta: "one two three" }])
    expect(published.slice(-2).map((event) => event.type)).toEqual([
      "session.reasoning.delta",
      "session.reasoning.ended.1",
@@ -767,7 +767,7 @@ const verifyEphemeralDeltas = (kind: FragmentKind) =>
    yield* admit(session, prompt)
    const bus = yield* Bus.Service
    const live = fixture.delta
-      ? yield* bus.subscribe(fixture.delta).pipe(Stream.take(2), Stream.runCollect, Effect.forkScoped)
+      ? yield* bus.subscribe(fixture.delta).pipe(Stream.take(1), Stream.runCollect, Effect.forkScoped)
      : undefined
    yield* Effect.yieldNow
    yield* TestLLM.push(fixture.completeEvents)
@@ -785,7 +785,7 @@ const verifyEphemeralDeltas = (kind: FragmentKind) =>
      : []
    if (live) {
      const streamed = Array.from(yield* Fiber.join(live))
-      expect(streamed).toHaveLength(2)
+      expect(streamed).toHaveLength(1)
      expect(
        streamed
          .map((event) => {
@@ -0,0 +1,174 @@
+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)))
+    }),
+  )
+})
@@ -60,6 +60,8 @@ 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,
@@ -1,15 +1,3 @@
 import type { EventApi } from "@opencode-ai/client/effect/api"
-import type { OpenCodeEvent } from "@opencode-ai/client/effect"
-import type { Stream } from "effect"

-export type PluginEvent = Exclude<OpenCodeEvent, { readonly type: "server.connected" }>
-export type PluginEventType = PluginEvent["type"]
-
-export interface EventSubscribe {
-  (): Stream.Stream<PluginEvent, unknown>
-  (type: PluginEventType): Stream.Stream<PluginEvent, unknown>
-}
-
-export interface EventDomain extends Omit<EventApi<unknown>, "subscribe"> {
-  readonly subscribe: EventSubscribe
-}
+export interface EventDomain extends Pick<EventApi<unknown>, "subscribe"> {}
@@ -2,7 +2,6 @@ import { Tool } from "@opencode-ai/schema/tool"
 import { Effect, Schema, SchemaAST, Scope, Stream } from "effect"
 import { HttpApiEndpoint, HttpApiSchema } from "effect/unstable/httpapi"
 import { define } from "../effect/plugin.js"
-import type { PluginEventType } from "./event.js"
 import type { Context, Plugin } from "./plugin.js"
 import type { Info } from "./tool.js"

@@ -150,15 +149,13 @@ export function fromPromise(plugin: Plugin) {
            reload: () => run(host.command.reload()),
          },
          event: {
-            subscribe: (type?: PluginEventType) => {
-              const events = type === undefined ? host.event.subscribe() : host.event.subscribe(type)
-              return Stream.toAsyncIterable(
-                events.pipe(
+            subscribe: () =>
+              Stream.toAsyncIterable(
+                host.event.subscribe().pipe(
                  Stream.mapEffect((event) => Schema.encodeUnknownEffect(OpenCodeEvent)(event)),
                  Stream.map((event) => event as unknown as PromiseEvent),
                ),
-              )
-            },
+              ),
          },
          integration: {
            list: adaptApiMethod(IntegrationEndpoints["integration.list"], host.integration.list),
@@ -1,14 +1,3 @@
-import type { OpenCodeEvent } from "@opencode-ai/client"
 import type { EventApi } from "@opencode-ai/client/promise/api"

-export type PluginEvent = Exclude<OpenCodeEvent, { readonly type: "server.connected" }>
-export type PluginEventType = PluginEvent["type"]
-
-export interface EventSubscribe {
-  (): AsyncIterable<PluginEvent>
-  (type: PluginEventType): AsyncIterable<PluginEvent>
-}
-
-export interface EventDomain extends Omit<EventApi, "subscribe"> {
-  readonly subscribe: EventSubscribe
-}
+export interface EventDomain extends Pick<EventApi, "subscribe"> {}
@@ -1,26 +0,0 @@
-import { expect, test } from "bun:test"
-import type { Context as EffectContext } from "../src/effect/plugin.js"
-import type { Context as PromiseContext } from "../src/promise/plugin.js"
-
-function effectSubscriptions(ctx: EffectContext) {
-  ctx.event.subscribe()
-  ctx.event.subscribe("config.updated")
-  // @ts-expect-error server.connected is a network-only marker
-  ctx.event.subscribe("server.connected")
-  // @ts-expect-error plugin subscriptions select at most one event type
-  ctx.event.subscribe(["config.updated"])
-}
-
-function promiseSubscriptions(ctx: PromiseContext) {
-  ctx.event.subscribe()
-  ctx.event.subscribe("config.updated")
-  // @ts-expect-error server.connected is a network-only marker
-  ctx.event.subscribe("server.connected")
-  // @ts-expect-error plugin subscriptions select at most one event type
-  ctx.event.subscribe(["config.updated"])
-}
-
-test("event subscription types support wildcard and one public event", () => {
-  expect(effectSubscriptions).toBeFunction()
-  expect(promiseSubscriptions).toBeFunction()
-})
@@ -4127,6 +4127,65 @@
        "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"],
@@ -12135,6 +12194,12 @@
              "updated": {
                "type": "number"
              },
+              "idle": {
+                "type": "number"
+              },
+              "viewed": {
+                "type": "number"
+              },
              "archived": {
                "type": "number"
              }
@@ -14276,6 +14341,71 @@
        "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": {
@@ -17296,6 +17426,9 @@
          {
            "$ref": "#/components/schemas/session.renamed"
          },
+          {
+            "$ref": "#/components/schemas/session.viewed"
+          },
          {
            "$ref": "#/components/schemas/session.deleted"
          },
@@ -22664,6 +22797,9 @@
          {
            "$ref": "#/components/schemas/session.renamed"
          },
+          {
+            "$ref": "#/components/schemas/session.viewed"
+          },
          {
            "$ref": "#/components/schemas/session.usage.updated"
          },
@@ -33,6 +33,7 @@
    "@tsconfig/bun": "catalog:",
    "@types/bun": "catalog:",
    "@typescript/native-preview": "catalog:",
+    "prettier": "3.6.2",
    "typescript": "catalog:"
  }
 }
@@ -1,8 +1,9 @@
 import { OpenApi } from "effect/unstable/httpapi"
+import { format } from "prettier"
 import { fileURLToPath } from "url"
 import { ClientApi } from "../src/client.js"

-const document = JSON.stringify(OpenApi.fromApi(ClientApi), null, 2) + "\n"
+const document = await format(JSON.stringify(OpenApi.fromApi(ClientApi), null, 2), { parser: "json", printWidth: 120 })
 const target = fileURLToPath(new URL("../openapi.json", import.meta.url))

 if (process.argv.includes("--check")) {
@@ -693,6 +693,19 @@ 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",
@@ -105,6 +105,13 @@ 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,
@@ -580,6 +587,7 @@ export const Definitions = Event.inventory(
  ModelSelected,
  Moved,
  Renamed,
+  Viewed,
  UsageUpdated,
  Deleted,
  Forked,
@@ -40,6 +40,8 @@ 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),
@@ -54,17 +54,29 @@ 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)({
-        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")
+        ...info,
+        time: { ...info.time, idle: DateTime.makeUnsafe(2), viewed: DateTime.makeUnsafe(1) },
+      }).time,
+    ).toEqual({ created: 0, updated: 0, idle: 2, viewed: 1 })
  })

  test("session inbox items omit the internal enqueue sequence", () => {
@@ -83,6 +83,7 @@ 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",
@@ -180,6 +180,22 @@ 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) {
@@ -52,6 +52,36 @@ 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).
@@ -816,6 +816,13 @@ 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])
@@ -25,12 +25,12 @@ import {
  type ClosedSessionTab,
  type SessionTab,
  type SessionTabHistory,
-  type SessionTabUnread,
 } from "./session-tabs-model"

 type TabsState = {
  tabs: SessionTab[]
-  unread: Record<string, SessionTabUnread>
+  // Read only long enough to remove the former client-owned state from persisted tab files.
+  unread?: Record<string, unknown>
 }

 type PersistedState = {
@@ -43,7 +43,7 @@ type ScrollAnchor = {
  screenY: number
 }

-const empty = (): TabsState => ({ tabs: [], unread: {} })
+const empty = (): TabsState => ({ tabs: [] })

 // 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 owns unread state until its first blur.
+    // Focus reporting emits transitions, so an interactive launch may acknowledge viewed sessions 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,16 +110,15 @@ 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) => {
@@ -133,7 +132,7 @@ export const { use: useSessionTabs, provider: SessionTabsProvider } = createSimp
      const members = data.session.family(session)
      const family = members.length > 0 ? members : [session]
      return {
-        unread: state().unread[session],
+        unread: family.some(isUnread) ? ("activity" as const) : undefined,
        promptPulse: promptPulses()[session] ?? 0,
        attention: family.some(
          (id) => (data.session.permission.list(id)?.length ?? 0) > 0 || (data.session.form.list(id)?.length ?? 0) > 0,
@@ -142,17 +141,6 @@ 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
@@ -176,10 +164,11 @@ 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)
-      if (!state().unread[sessionID]) return
-      update((draft) => {
-        delete draft.unread[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 })))
    })

    createEffect(() => {
@@ -189,7 +178,7 @@ export const { use: useSessionTabs, provider: SessionTabsProvider } = createSimp
      update((draft) => {
        const next = normalize(draft)
        draft.tabs = next.tabs
-        draft.unread = next.unread
+        delete draft.unread
      })
    })

@@ -210,7 +199,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)))
+        await Promise.allSettled(sessionIDs.map((sessionID) => data.session.sync(sessionID, { children: true })))
        if (stale) return
        const locations = new Map(
          sessionIDs
@@ -244,9 +233,6 @@ 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
@@ -282,7 +268,6 @@ 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
@@ -378,7 +363,7 @@ export const { use: useSessionTabs, provider: SessionTabsProvider } = createSimp
      cycleUnread(direction: 1 | -1) {
        if (!enabled()) return
        const tab = cycleSessionTab(state().tabs, current(), direction, (tab) =>
-          Boolean(state().unread[tab.sessionID] || status(tab.sessionID).attention),
+          Boolean(status(tab.sessionID).unread || status(tab.sessionID).attention),
        )
        if (tab) route.navigate({ type: "session", sessionID: tab.sessionID })
      },
@@ -35,6 +35,8 @@ 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"
  },
 ) {
@@ -53,9 +55,13 @@ async function renderSessionTabs(
  }
  const events = createEventStream()
  const sessions: string[] = []
+  const views: string[] = []
  const locations: string[] = []
  const vcsLocations: string[] = []
-  const calls = createFetch(async (url) => {
+  const sessionTimes = Object.fromEntries(
+    Object.entries(options?.sessionTimes ?? {}).map(([sessionID, time]) => [sessionID, { ...time }]),
+  )
+  const calls = createFetch(async (url, request) => {
    if (url.pathname === "/api/location") {
      const requested = url.searchParams.get("location[directory]") ?? directory
      locations.push(requested)
@@ -72,6 +78,13 @@ 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)
@@ -79,12 +92,13 @@ 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 },
+        time: { created: 0, updated: 0, ...sessionTimes[sessionID] },
      },
    })
  }, events)
@@ -138,9 +152,13 @@ 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"),
@@ -153,14 +171,6 @@ 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))
@@ -230,56 +240,94 @@ 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: [], unread: {} })
+    expect(stored.global).toEqual({ tabs: [] })
    expect(Object.keys(stored.cwd)).toEqual([directory])
    expect(stored.cwd[directory].tabs.map((tab: { sessionID: string }) => tab.sessionID)).toEqual(["first"])
-    expect(stored.cwd[directory].unread).toEqual({})
+    expect(stored.cwd[directory]).not.toHaveProperty("unread")
  } finally {
    await setup.destroy()
  }
 })

-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
-
+test("derives unread state from server session times", async () => {
+  const setup = await renderSessionTabs("first", {
+    home: true,
+    persisted: ["first", "second"],
+    sessionTimes: { second: { idle: 2 } },
+  })
  try {
-    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",
-    )
+    await wait(() => setup.tabs.status("second").unread === "activity")
+    expect(setup.tabs.status("first").unread).toBeUndefined()
  } finally {
-    if (foreground) await foreground.destroy()
-    if (background) await background.destroy()
+    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()
  }
 })

@@ -184,14 +184,6 @@ and plugin options.
 | `ctx.event`            | `subscribe` to the current public server event stream                                        |
 | `ctx.options`          | Readonly options from the matching config object                                             |

-Event subscriptions can receive every plugin-visible public event, or select
-one event type:
-
-```ts
-ctx.event.subscribe()
-ctx.event.subscribe("config.updated")
-```
-
 ### Transform hooks

 Transform hooks let a plugin modify how OpenCode is configured. Use them to add
@@ -4127,6 +4127,65 @@
        "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"],
@@ -12135,6 +12194,12 @@
              "updated": {
                "type": "number"
              },
+              "idle": {
+                "type": "number"
+              },
+              "viewed": {
+                "type": "number"
+              },
              "archived": {
                "type": "number"
              }
@@ -14276,6 +14341,71 @@
        "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": {
@@ -17296,6 +17426,9 @@
          {
            "$ref": "#/components/schemas/session.renamed"
          },
+          {
+            "$ref": "#/components/schemas/session.viewed"
+          },
          {
            "$ref": "#/components/schemas/session.deleted"
          },
@@ -22664,6 +22797,9 @@
          {
            "$ref": "#/components/schemas/session.renamed"
          },
+          {
+            "$ref": "#/components/schemas/session.viewed"
+          },
          {
            "$ref": "#/components/schemas/session.usage.updated"
          },
@@ -4127,6 +4127,65 @@
        "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"],
@@ -12135,6 +12194,12 @@
              "updated": {
                "type": "number"
              },
+              "idle": {
+                "type": "number"
+              },
+              "viewed": {
+                "type": "number"
+              },
              "archived": {
                "type": "number"
              }
@@ -14276,6 +14341,71 @@
        "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": {
@@ -17296,6 +17426,9 @@
          {
            "$ref": "#/components/schemas/session.renamed"
          },
+          {
+            "$ref": "#/components/schemas/session.viewed"
+          },
          {
            "$ref": "#/components/schemas/session.deleted"
          },
@@ -22664,6 +22797,9 @@
          {
            "$ref": "#/components/schemas/session.renamed"
          },
+          {
+            "$ref": "#/components/schemas/session.viewed"
+          },
          {
            "$ref": "#/components/schemas/session.usage.updated"
          },
Author	SHA1	Message	Date
Kit Langton	e99043faf8	feat(tui): use server viewed state	2026-08-15 20:52:18 -04:00
Kit Langton	1f37f829ed	fix(session): use numeric event timestamps	2026-08-15 20:29:37 -04:00
Kit Langton	c30a6d956b	chore(client): regenerate API	2026-08-15 20:27:12 -04:00
Kit Langton	d297953384	chore(core): normalize generated schema	2026-08-15 20:26:40 -04:00
Kit Langton	04cf35b304	fix(protocol): stabilize OpenAPI generation	2026-08-15 20:26:40 -04:00
Kit Langton	91daa76e33	refactor(session): remove viewed lock	2026-08-15 20:26:40 -04:00
Kit Langton	c316fb7219	refactor(protocol): preserve endpoint ordering	2026-08-15 20:26:40 -04:00
Kit Langton	f6b7181916	feat(session): add viewed state	2026-08-15 20:26:39 -04:00
Dax Raad	8251934007	fix(core): batch initial streamed delta	2026-08-15 19:26:16 -04:00
Dax Raad	42e345e1bc	fix(cli): resolve Bun canary compile assets	2026-08-15 18:56:03 -04:00