refactor(protocol): preserve endpoint ordering

feat(session): add viewed state
chore: generate
2026-08-15 17:08:21 -04:00 · 2026-08-15 15:47:11 -04:00 · 2026-08-15 14:57:56 -04:00 · 2026-08-15 18:35:53 +00:00 · 2026-08-15 18:34:43 +00:00 · 2026-08-15 18:30:35 +00:00
44 changed files with 14416 additions and 3430 deletions
@@ -383,6 +383,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: DateTime.Utc
+          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: DateTime.Utc
@@ -915,6 +924,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>
@@ -959,6 +972,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,6 +224,7 @@ 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(
@@ -260,6 +268,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,10 @@
 {
  "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 +1352,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,
@@ -1481,9 +1503,13 @@
      "table": "worktree"
    },
    {
-      "columns": ["active_account_id"],
+      "columns": [
+        "active_account_id"
+      ],
      "tableTo": "account",
-      "columnsTo": ["id"],
+      "columnsTo": [
+        "id"
+      ],
      "onUpdate": "NO ACTION",
      "onDelete": "SET NULL",
      "nameExplicit": false,
@@ -1492,9 +1518,13 @@
      "table": "account_state"
    },
    {
-      "columns": ["aggregate_id"],
+      "columns": [
+        "aggregate_id"
+      ],
      "tableTo": "event_sequence",
-      "columnsTo": ["aggregate_id"],
+      "columnsTo": [
+        "aggregate_id"
+      ],
      "onUpdate": "NO ACTION",
      "onDelete": "CASCADE",
      "nameExplicit": false,
@@ -1503,9 +1533,13 @@
      "table": "event"
    },
    {
-      "columns": ["project_id"],
+      "columns": [
+        "project_id"
+      ],
      "tableTo": "project",
-      "columnsTo": ["id"],
+      "columnsTo": [
+        "id"
+      ],
      "onUpdate": "NO ACTION",
      "onDelete": "CASCADE",
      "nameExplicit": false,
@@ -1514,9 +1548,13 @@
      "table": "permission"
    },
    {
-      "columns": ["project_id"],
+      "columns": [
+        "project_id"
+      ],
      "tableTo": "project",
-      "columnsTo": ["id"],
+      "columnsTo": [
+        "id"
+      ],
      "onUpdate": "NO ACTION",
      "onDelete": "CASCADE",
      "nameExplicit": false,
@@ -1525,9 +1563,13 @@
      "table": "project_directory"
    },
    {
-      "columns": ["session_id"],
+      "columns": [
+        "session_id"
+      ],
      "tableTo": "session_v2",
-      "columnsTo": ["id"],
+      "columnsTo": [
+        "id"
+      ],
      "onUpdate": "NO ACTION",
      "onDelete": "CASCADE",
      "nameExplicit": false,
@@ -1536,9 +1578,13 @@
      "table": "instruction_entry"
    },
    {
-      "columns": ["session_id"],
+      "columns": [
+        "session_id"
+      ],
      "tableTo": "session_v2",
-      "columnsTo": ["id"],
+      "columnsTo": [
+        "id"
+      ],
      "onUpdate": "NO ACTION",
      "onDelete": "CASCADE",
      "nameExplicit": false,
@@ -1547,9 +1593,13 @@
      "table": "instruction_state"
    },
    {
-      "columns": ["session_id"],
+      "columns": [
+        "session_id"
+      ],
      "tableTo": "session_v2",
-      "columnsTo": ["id"],
+      "columnsTo": [
+        "id"
+      ],
      "onUpdate": "NO ACTION",
      "onDelete": "CASCADE",
      "nameExplicit": false,
@@ -1558,9 +1608,13 @@
      "table": "session_inbox"
    },
    {
-      "columns": ["session_id"],
+      "columns": [
+        "session_id"
+      ],
      "tableTo": "session_v2",
-      "columnsTo": ["id"],
+      "columnsTo": [
+        "id"
+      ],
      "onUpdate": "NO ACTION",
      "onDelete": "CASCADE",
      "nameExplicit": false,
@@ -1569,9 +1623,13 @@
      "table": "session_message"
    },
    {
-      "columns": ["session_id"],
+      "columns": [
+        "session_id"
+      ],
      "tableTo": "session_v2",
-      "columnsTo": ["id"],
+      "columnsTo": [
+        "id"
+      ],
      "onUpdate": "NO ACTION",
      "onDelete": "CASCADE",
      "nameExplicit": false,
@@ -1580,9 +1638,13 @@
      "table": "session_pending"
    },
    {
-      "columns": ["project_id"],
+      "columns": [
+        "project_id"
+      ],
      "tableTo": "project",
-      "columnsTo": ["id"],
+      "columnsTo": [
+        "id"
+      ],
      "onUpdate": "NO ACTION",
      "onDelete": "CASCADE",
      "nameExplicit": false,
@@ -1591,9 +1653,13 @@
      "table": "session_v2"
    },
    {
-      "columns": ["project_id"],
+      "columns": [
+        "project_id"
+      ],
      "tableTo": "project",
-      "columnsTo": ["id"],
+      "columnsTo": [
+        "id"
+      ],
      "onUpdate": "NO ACTION",
      "onDelete": "CASCADE",
      "nameExplicit": false,
@@ -1602,133 +1668,175 @@
      "table": "worktree"
    },
    {
-      "columns": ["email", "url"],
+      "columns": [
+        "email",
+        "url"
+      ],
      "nameExplicit": false,
      "name": "control_account_pk",
      "entityType": "pks",
      "table": "control_account"
    },
    {
-      "columns": ["project_id", "directory"],
+      "columns": [
+        "project_id",
+        "directory"
+      ],
      "nameExplicit": false,
      "name": "project_directory_pk",
      "entityType": "pks",
      "table": "project_directory"
    },
    {
-      "columns": ["session_id", "key"],
+      "columns": [
+        "session_id",
+        "key"
+      ],
      "nameExplicit": false,
      "name": "instruction_entry_pk",
      "entityType": "pks",
      "table": "instruction_entry"
    },
    {
-      "columns": ["project_id", "directory"],
+      "columns": [
+        "project_id",
+        "directory"
+      ],
      "nameExplicit": false,
      "name": "worktree_pk",
      "entityType": "pks",
      "table": "worktree"
    },
    {
-      "columns": ["id"],
+      "columns": [
+        "id"
+      ],
      "nameExplicit": false,
      "name": "account_state_pk",
      "table": "account_state",
      "entityType": "pks"
    },
    {
-      "columns": ["id"],
+      "columns": [
+        "id"
+      ],
      "nameExplicit": false,
      "name": "account_pk",
      "table": "account",
      "entityType": "pks"
    },
    {
-      "columns": ["id"],
+      "columns": [
+        "id"
+      ],
      "nameExplicit": false,
      "name": "credential_pk",
      "table": "credential",
      "entityType": "pks"
    },
    {
-      "columns": ["aggregate_id"],
+      "columns": [
+        "aggregate_id"
+      ],
      "nameExplicit": false,
      "name": "event_sequence_pk",
      "table": "event_sequence",
      "entityType": "pks"
    },
    {
-      "columns": ["id"],
+      "columns": [
+        "id"
+      ],
      "nameExplicit": false,
      "name": "event_pk",
      "table": "event",
      "entityType": "pks"
    },
    {
-      "columns": ["key"],
+      "columns": [
+        "key"
+      ],
      "nameExplicit": false,
      "name": "kv_pk",
      "table": "kv",
      "entityType": "pks"
    },
    {
-      "columns": ["id"],
+      "columns": [
+        "id"
+      ],
      "nameExplicit": false,
      "name": "permission_pk",
      "table": "permission",
      "entityType": "pks"
    },
    {
-      "columns": ["id"],
+      "columns": [
+        "id"
+      ],
      "nameExplicit": false,
      "name": "project_pk",
      "table": "project",
      "entityType": "pks"
    },
    {
-      "columns": ["hash"],
+      "columns": [
+        "hash"
+      ],
      "nameExplicit": false,
      "name": "instruction_blob_pk",
      "table": "instruction_blob",
      "entityType": "pks"
    },
    {
-      "columns": ["session_id"],
+      "columns": [
+        "session_id"
+      ],
      "nameExplicit": false,
      "name": "instruction_state_pk",
      "table": "instruction_state",
      "entityType": "pks"
    },
    {
-      "columns": ["id"],
+      "columns": [
+        "id"
+      ],
      "nameExplicit": false,
      "name": "session_inbox_pk",
      "table": "session_inbox",
      "entityType": "pks"
    },
    {
-      "columns": ["id"],
+      "columns": [
+        "id"
+      ],
      "nameExplicit": false,
      "name": "session_message_pk",
      "table": "session_message",
      "entityType": "pks"
    },
    {
-      "columns": ["id"],
+      "columns": [
+        "id"
+      ],
      "nameExplicit": false,
      "name": "session_pending_pk",
      "table": "session_pending",
      "entityType": "pks"
    },
    {
-      "columns": ["id"],
+      "columns": [
+        "id"
+      ],
      "nameExplicit": false,
      "name": "session_v2_pk",
      "table": "session_v2",
      "entityType": "pks"
    },
    {
-      "columns": ["id"],
+      "columns": [
+        "id"
+      ],
      "nameExplicit": false,
      "name": "workspace_pk",
      "table": "workspace",
@@ -2024,4 +2132,4 @@
    }
  ],
  "renames": []
-}
+}
@@ -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,
@@ -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
@@ -307,6 +308,7 @@ const layer = Layer.effect(
    const scope = yield* Scope.Scope
    const activeShells = new Set<SessionSchema.ID>()
    const shellLocks = KeyedMutex.makeUnsafe<SessionSchema.ID>()
+    const viewLocks = KeyedMutex.makeUnsafe<SessionSchema.ID>()
    const closeTransport = Effect.fn("Session.closeTransport")(function* (session: SessionSchema.Info) {
      const location = Location.Ref.make({
        directory: session.location.directory,
@@ -447,6 +449,21 @@ const layer = Layer.effect(
        if (!session) return yield* new NotFoundError({ sessionID })
        return session
      }),
+      view: Effect.fn("Session.view")((input) =>
+        viewLocks.withLock(input.sessionID)(
+          Effect.gen(function* () {
+            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 === 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)
@@ -789,7 +806,10 @@ const layer = Layer.effect(
            return false
          }),
        )
-        if (recovered) return
+        if (recovered) {
+          yield* execution.wakeActive(input.sessionID)
+          return
+        }
        yield* execution.wake(input.sessionID)
      }),
      compact: Effect.fn("Session.compact")(function* (input) {
@@ -873,12 +893,7 @@ const layer = Layer.effect(
        ),
      ),
      interrupt: Effect.fn("Session.interrupt")((sessionID, options) =>
-        Effect.uninterruptible(
-          Effect.gen(function* () {
-            yield* execution.interrupt(sessionID)
-            if (options?.continue && (yield* SessionInbox.has(db, sessionID, "any"))) yield* execution.wake(sessionID)
-          }),
-        ),
+        Effect.uninterruptible(execution.interrupt(sessionID, options)),
      ),
      revert: {
        stage: Effect.fn("Session.revert.stage")(function* (input) {
@@ -1,7 +1,8 @@
 export * as SessionExecution from "./execution.js"

-import { Cause, Context, Effect, Exit, Layer, Stream } from "effect"
+import { Cause, Context, Effect, Exit, Layer } from "effect"
 import { Bus } from "../bus.js"
+import { Database } from "../database/database.js"
 import { LocationServiceMap } from "../location-service-map.js"
 import { makeGlobalNode } from "@opencode-ai/util/effect/app-node"
 import { SessionEvent } from "./event.js"
@@ -11,6 +12,7 @@ import { SessionSchema } from "./schema.js"
 import { SessionStore } from "./store.js"
 import { toSessionError } from "./to-session-error.js"
 import { UserInterruptedError } from "./error.js"
+import { SessionInbox } from "./inbox.js"

 export interface Interface {
  /** Snapshots active execution owned by this process. */
@@ -19,8 +21,10 @@ export interface Interface {
  readonly resume: (sessionID: SessionSchema.ID) => Effect.Effect<void, SessionRunner.RunError>
  /** Registers newly recorded work. Repeated wakeups may coalesce. */
  readonly wake: (sessionID: SessionSchema.ID) => Effect.Effect<void>
+  /** Wakes only an active execution, preserving its current input eligibility. */
+  readonly wakeActive: (sessionID: SessionSchema.ID) => Effect.Effect<void>
  /** Interrupt active work owned by this process. Idle interruption is a no-op. */
-  readonly interrupt: (sessionID: SessionSchema.ID) => Effect.Effect<void>
+  readonly interrupt: (sessionID: SessionSchema.ID, options?: { readonly continue?: boolean }) => Effect.Effect<void>
  /** Resolves once this process owns no active execution for the Session. Returns immediately when idle and never starts work. */
  readonly awaitIdle: (sessionID: SessionSchema.ID) => Effect.Effect<void>
 }
@@ -45,6 +49,7 @@ export const layer = Layer.effect(
    const store = yield* SessionStore.Service
    const locations = yield* LocationServiceMap.Service
    const bus = yield* Bus.Service
+    const db = (yield* Database.Service).db
    const reportLifecycle = <A>(sessionID: SessionSchema.ID, effect: Effect.Effect<A>) =>
      effect.pipe(
        Effect.tapCause((cause) =>
@@ -71,12 +76,13 @@ export const layer = Layer.effect(
      sessionID: SessionSchema.ID,
      force: boolean,
      continuation?: SessionRunner.Continuation,
+      promotable: SessionInbox.Promotable = "input",
    ): Effect.Effect<void, SessionRunner.RunError> {
      return Effect.gen(function* () {
        const session = yield* store.get(sessionID)
        if (!session) return yield* Effect.die(new Error(`Session not found: ${sessionID}`))
        const result = yield* SessionRunner.Service.use((runner) =>
-          runner.drain({ sessionID, force, continuation }),
+          runner.drain({ sessionID, force, continuation, promotable }),
        ).pipe(
          Effect.provide(locations.get(session.location)),
          Effect.tapCause((cause) =>
@@ -86,7 +92,7 @@ export const layer = Layer.effect(
          ),
        )
        if (result.type === "complete") return
-        return yield* drain(sessionID, false, result.continuation)
+        return yield* drain(sessionID, false, result.continuation, promotable)
      })
    }
    const coordinator = yield* SessionRunCoordinator.make<SessionSchema.ID, SessionRunner.RunError, InterruptReason>({
@@ -95,7 +101,7 @@ export const layer = Layer.effect(
          sessionID,
          bus.publish(SessionEvent.Execution.Started, { sessionID }, claimOnCommit(sessionID)),
        ),
-      drain: (sessionID, force) => drain(sessionID, force),
+      drain: (sessionID, force, promotable) => drain(sessionID, force, undefined, promotable),
      // One terminal observation per busy period, covering every coalesced drain.
      settled: (sessionID, exit, reason) =>
        reportLifecycle(
@@ -127,16 +133,20 @@ export const layer = Layer.effect(
          }),
        ),
    })
-    yield* bus.subscribe(SessionEvent.Moved).pipe(
-      Stream.runForEach((event) => coordinator.wake(event.data.sessionID)),
-      Effect.forkScoped,
-    )

    return Service.of({
      active: coordinator.active,
-      interrupt: (sessionID) => coordinator.interrupt(sessionID, "user"),
+      interrupt: (sessionID, options) =>
+        coordinator.interrupt(
+          sessionID,
+          "user",
+          options?.continue
+            ? { continue: { request: "steer", when: SessionInbox.has(db, sessionID, "steer") } }
+            : undefined,
+        ),
      resume: coordinator.run,
      wake: coordinator.wake,
+      wakeActive: coordinator.wakeActive,
      awaitIdle: coordinator.awaitIdle,
    })
  }),
@@ -145,7 +155,7 @@ export const layer = Layer.effect(
 export const node = makeGlobalNode({
  service: Service,
  layer,
-  deps: [SessionStore.node, LocationServiceMap.node, Bus.node],
+  deps: [SessionStore.node, LocationServiceMap.node, Bus.node, Database.node],
 })

 /** Low-level compatibility layer for callers that only need durable Session recording. */
@@ -155,6 +165,7 @@ export const noopLayer = Layer.succeed(
    active: Effect.succeed(new Set()),
    resume: () => Effect.void,
    wake: () => Effect.void,
+    wakeActive: () => Effect.void,
    interrupt: () => Effect.void,
    awaitIdle: () => Effect.void,
  }),
@@ -349,6 +349,14 @@ export const nextSteer = Effect.fn("SessionInbox.nextSteer")(function* (
  return row ? fromRow(row) : undefined
 })

+export const nextPromotable = Effect.fn("SessionInbox.nextPromotable")(function* (
+  db: DatabaseService,
+  sessionID: SessionSchema.ID,
+  promotable: Promotable,
+) {
+  return (yield* nextSteer(db, sessionID)) ?? (promotable === "input" ? yield* nextQueued(db, sessionID) : undefined)
+})
+
 /**
 * Which pending rows count: "any" counts every row, while "input" means any
 * item in either delivery mode.
@@ -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,
    },
  })
@@ -59,6 +59,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 = DateTime.toEpochMillis(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)
@@ -1,6 +1,7 @@
 export * as SessionRunCoordinator from "./run-coordinator.js"

 import { Deferred, Effect, Exit, Fiber, FiberSet, Scope } from "effect"
+import type { Promotable } from "./inbox.js"

 /** Serializes execution for each key while allowing different keys to run concurrently. */
 export interface Coordinator<Key, E, Reason = never> {
@@ -9,26 +10,41 @@ export interface Coordinator<Key, E, Reason = never> {
  /** Starts an execution while idle, or joins the active execution and returns its exit. */
  readonly run: (key: Key) => Effect.Effect<void, E>
  /** Rings the doorbell: an idle key starts an execution; an active one drains again before settling. */
-  readonly wake: (key: Key) => Effect.Effect<void>
+  readonly wake: (key: Key, request?: Request) => Effect.Effect<void>
+  /** Rings the current execution's doorbell with its existing request. Idle keys remain idle. */
+  readonly wakeActive: (key: Key) => Effect.Effect<void>
  /** Stops the active execution, clears its doorbell, and waits for cleanup. No-op when idle. */
-  readonly interrupt: (key: Key, reason?: Reason) => Effect.Effect<void>
+  readonly interrupt: (
+    key: Key,
+    reason?: Reason,
+    options?: { readonly continue?: { readonly request: Request; readonly when: Effect.Effect<boolean> } },
+  ) => Effect.Effect<void>
  /** Resolves once no execution is active for the key. Returns immediately when already idle and never starts work. */
  readonly awaitIdle: (key: Key) => Effect.Effect<void>
 }

+export type Request = Promotable
+
 /**
 * One execution is a busy period for one key: one fiber that drains from the first wake
 * until the key would stay idle. `pendingWake` is the doorbell: work recorded during the
- * execution rings it, and the execution loop drains again instead of ending. The doorbell
- * closes the gap between a drain's last eligibility check and the idle transition, since
- * those cannot be one atomic step. `done` resolves joiners with this execution's exit.
+ * execution rings it with its eligibility request, and the execution loop drains again
+ * instead of ending. The doorbell closes the gap between a drain's last eligibility check
+ * and the idle transition, since those cannot be one atomic step. `done` resolves joiners
+ * with this execution's exit.
 */
 type Execution<E, Reason> = {
  readonly done: Deferred.Deferred<void, E>
  owner?: Fiber.Fiber<void>
-  pendingWake: boolean
+  request: Request
+  pendingWake?: Request
  stopping: boolean
  interruptionReason?: Reason
+  continuation?: {
+    readonly request: Request
+    readonly when: Effect.Effect<boolean>
+    signaled: boolean
+  }
 }

 /**
@@ -43,7 +59,7 @@ type Execution<E, Reason> = {
 * ```
 */
 export const make = <Key, E, Reason = never>(options: {
-  readonly drain: (key: Key, force: boolean) => Effect.Effect<void, E>
+  readonly drain: (key: Key, force: boolean, request: Request) => Effect.Effect<void, E>
  /** Runs once when a process-local busy period begins, before its first drain. */
  readonly started?: (key: Key) => Effect.Effect<void>
  /**
@@ -57,21 +73,22 @@ export const make = <Key, E, Reason = never>(options: {
    const fork = yield* FiberSet.makeRuntime<never, void, never>()

    const loop = (key: Key, execution: Execution<E, Reason>, force: boolean): Effect.Effect<void, E> =>
-      Effect.suspend(() => options.drain(key, force)).pipe(
+      Effect.suspend(() => options.drain(key, force, execution.request)).pipe(
        Effect.flatMap(() =>
          Effect.suspend(() => {
-            if (execution.stopping || !execution.pendingWake) return Effect.void
-            execution.pendingWake = false
+            if (execution.stopping || execution.pendingWake === undefined) return Effect.void
+            execution.request = execution.pendingWake
+            execution.pendingWake = undefined
            // Trampoline so drains that complete synchronously cannot grow the stack.
            return Effect.yieldNow.pipe(Effect.andThen(loop(key, execution, false)))
          }),
        ),
      )

-    const start = (key: Key, force: boolean) => {
+    const start = (key: Key, force: boolean, request: Request) => {
      const execution: Execution<E, Reason> = {
        done: Deferred.makeUnsafe<void, E>(),
-        pendingWake: false,
+        request,
        stopping: false,
      }
      executions.set(key, execution)
@@ -87,7 +104,7 @@ export const make = <Key, E, Reason = never>(options: {
              execution.owner = undefined
            }).pipe(Effect.andThen(options.settled?.(key, exit, execution.interruptionReason) ?? Effect.void)),
          ),
-          Effect.onExit((exit) => Effect.sync(() => settle(key, execution, exit))),
+          Effect.onExit((exit) => finish(key, execution, exit)),
          Effect.exit,
          Effect.asVoid,
        ),
@@ -97,12 +114,22 @@ export const make = <Key, E, Reason = never>(options: {

    // A doorbell that survives the execution loop (rung after the loop decided to end, or
    // during failure or interruption cleanup) starts a fresh execution for the remaining work.
-    const settle = (key: Key, execution: Execution<E, Reason>, exit: Exit.Exit<void, E>) => {
-      if (execution.pendingWake) start(key, false)
+    const settle = (key: Key, execution: Execution<E, Reason>, exit: Exit.Exit<void, E>, resume: boolean) => {
+      if (resume && execution.continuation) start(key, false, execution.continuation.request)
+      else if (execution.pendingWake) start(key, false, execution.pendingWake)
      else executions.delete(key)
      Deferred.doneUnsafe(execution.done, exit)
    }

+    const finish = (key: Key, execution: Execution<E, Reason>, exit: Exit.Exit<void, E>) => {
+      if (!execution.continuation) return Effect.sync(() => settle(key, execution, exit, false))
+      return execution.continuation.when.pipe(
+        Effect.flatMap((ready) =>
+          Effect.sync(() => settle(key, execution, exit, ready || execution.continuation?.signaled === true)),
+        ),
+      )
+    }
+
    const run = (key: Key): Effect.Effect<void, E> =>
      Effect.suspend(() => {
        const execution = executions.get(key)
@@ -111,26 +138,58 @@ export const make = <Key, E, Reason = never>(options: {
          if (execution.stopping) return Deferred.await(execution.done).pipe(Effect.andThen(run(key)))
          return Deferred.await(execution.done)
        }
-        return Deferred.await(start(key, true).done)
+        return Deferred.await(start(key, true, "input").done)
      })

-    const wake = (key: Key) =>
+    const wake = (key: Key, request: Request = "input") =>
      Effect.sync(() => {
        const execution = executions.get(key)
        if (execution !== undefined) {
-          execution.pendingWake = true
+          if (execution.stopping) {
+            if (execution.continuation) execution.continuation.signaled = true
+            else execution.continuation = { request, when: Effect.succeed(true), signaled: true }
+            return
+          }
+          // Coalesced wakes keep the widest request: "input" subsumes "steer".
+          execution.pendingWake = execution.pendingWake === "input" ? "input" : request
          return
        }
-        start(key, false)
+        start(key, false, request)
      })

-    const interrupt = (key: Key, reason?: Reason): Effect.Effect<void> =>
+    const wakeActive = (key: Key) =>
      Effect.suspend(() => {
        const execution = executions.get(key)
-        if (execution?.owner === undefined || execution.stopping) return Effect.void
+        return execution ? wake(key, execution.request) : Effect.void
+      })
+
+    const interrupt = (
+      key: Key,
+      reason?: Reason,
+      options?: { readonly continue?: { readonly request: Request; readonly when: Effect.Effect<boolean> } },
+    ): Effect.Effect<void> =>
+      Effect.suspend(() => {
+        const execution = executions.get(key)
+        if (execution === undefined) return Effect.void
+        if (execution.stopping) {
+          if (options?.continue)
+            execution.continuation = {
+              ...options.continue,
+              signaled: execution.continuation?.signaled ?? false,
+            }
+          return Deferred.await(execution.done).pipe(Effect.exit, Effect.asVoid)
+        }
+        if (execution.owner === undefined) {
+          if (!options?.continue) return Effect.void
+          execution.stopping = true
+          execution.pendingWake = undefined
+          execution.continuation = { ...options.continue, signaled: false }
+          return Deferred.await(execution.done).pipe(Effect.exit, Effect.asVoid)
+        }
        execution.stopping = true
-        execution.pendingWake = false
+        execution.pendingWake = undefined
        execution.interruptionReason = reason
+        if (options?.continue) execution.continuation = { ...options.continue, signaled: false }
        return Fiber.interrupt(execution.owner)
      })

@@ -143,5 +202,5 @@ export const make = <Key, E, Reason = never>(options: {
        return Deferred.await(execution.done).pipe(Effect.exit, Effect.andThen(awaitIdle(key)))
      })

-    return { active: Effect.sync(() => new Set(executions.keys())), run, wake, interrupt, awaitIdle }
+    return { active: Effect.sync(() => new Set(executions.keys())), run, wake, wakeActive, interrupt, awaitIdle }
  })
@@ -3,6 +3,7 @@ export * as SessionRunner from "./index.js"
 import type { AIError } from "@opencode-ai/ai"
 import { Context, Effect } from "effect"
 import { SessionSchema } from "../schema.js"
+import type { Promotable } from "../inbox.js"
 import type { AgentNotFoundError, MessageDecodeError, StepFailedError, UserInterruptedError } from "../error.js"
 import { SessionRunnerModel } from "./model.js"
 import type { Instructions } from "../../instructions/index.js"
@@ -29,6 +30,8 @@ export interface Interface {
    readonly sessionID: SessionSchema.ID
    readonly force: boolean
    readonly continuation?: Continuation
+    /** "steer" settles the active intent without promoting queued next-turn work. */
+    readonly promotable?: Promotable
  }) => Effect.Effect<DrainResult, RunError>
 }

@@ -128,22 +128,25 @@ const layer = Layer.effect(
      readonly sessionID: SessionSchema.ID
      readonly force: boolean
      readonly continuation?: Continuation
+      readonly promotable?: SessionInbox.Promotable
    }) {
      let force = input.force
      let continuation = input.continuation
-      if (!force && !continuation && !(yield* SessionInbox.has(db, input.sessionID, "any")))
+      const promotable = input.promotable ?? "input"
+      if (!force && !continuation && !(yield* SessionInbox.has(db, input.sessionID, promotable)))
        return { type: "complete" as const }
      yield* settleStaleToolCalls(input.sessionID)
      while (true) {
-        if (yield* runPendingCompaction(input.sessionID)) {
+        if (yield* runPendingCompaction(input.sessionID, promotable)) {
          force = false
          continue
        }
-        if (yield* runPendingMove(input.sessionID, "input")) return { type: "moved" as const }
-        if (!force && !continuation && !(yield* SessionInbox.has(db, input.sessionID, "input")))
+        if (yield* runPendingMove(input.sessionID, promotable)) return { type: "moved" as const }
+        if (!force && !continuation && !(yield* SessionInbox.has(db, input.sessionID, promotable)))
          return { type: "complete" as const }
-        const result = yield* runSteps(input.sessionID, continuation)
+        const result = yield* runSteps(input.sessionID, continuation, promotable)
        if (result.type === "moved") return result
+        if (promotable === "steer") return { type: "complete" as const }
        force = false
        continuation = undefined
      }
@@ -155,14 +158,15 @@ const layer = Layer.effect(
     */
    const runSteps = Effect.fn("SessionRunner.runSteps")(function* (
      sessionID: SessionSchema.ID,
-      continuation?: Continuation,
+      continuation: Continuation | undefined,
+      drainPromotable: SessionInbox.Promotable,
    ) {
-      // Fresh work may promote queued input; later steps absorb steers only.
-      let promotable: SessionInbox.Promotable = continuation ? "steer" : "input"
+      // Fresh work may promote queued input; resumed turns and later steps absorb steers only.
+      let promotable: SessionInbox.Promotable = continuation ? "steer" : drainPromotable
      let step = continuation?.step ?? 1
      let next = continuation
      while (true) {
-        if (yield* runPendingCompaction(sessionID)) continue
+        if (yield* runPendingCompaction(sessionID, "steer")) continue
        if (yield* runPendingMove(sessionID, "steer")) return { type: "moved" as const, continuation: next }
        const result = yield* runStep(sessionID, promotable, step)
        next = result.needsContinuation ? { step: result.step + 1 } : undefined
@@ -515,14 +519,14 @@ const layer = Layer.effect(
    /** Executes a previously admitted manual compaction request, if one is pending. */
    const runPendingCompaction = Effect.fn("SessionRunner.runPendingCompaction")(function* (
      sessionID: SessionSchema.ID,
+      promotable: SessionInbox.Promotable,
    ) {
      return yield* Effect.uninterruptibleMask((restore) =>
        Effect.gen(function* () {
          const pending = yield* SessionInbox.serialized(
            sessionID,
            Effect.gen(function* () {
-              const selected =
-                (yield* SessionInbox.nextSteer(db, sessionID)) ?? (yield* SessionInbox.nextQueued(db, sessionID))
+              const selected = yield* SessionInbox.nextPromotable(db, sessionID, promotable)
              if (selected?.type !== "compaction") return
              yield* bus.publishAll([
                [SessionEvent.InboxDelivered, { sessionID, inboxID: selected.id }],
@@ -564,9 +568,7 @@ const layer = Layer.effect(
      return yield* SessionInbox.serialized(
        sessionID,
        Effect.gen(function* () {
-          const pending =
-            (yield* SessionInbox.nextSteer(db, sessionID)) ??
-            (promotable === "input" ? yield* SessionInbox.nextQueued(db, sessionID) : undefined)
+          const pending = yield* SessionInbox.nextPromotable(db, sessionID, promotable)
          if (pending?.type !== "move") return false
          yield* modelTransport.close(sessionID)
          yield* bus.publishAll([
@@ -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(
@@ -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" } },
      ])
@@ -31,6 +31,7 @@ import { testEffect } from "./lib/effect"

 const executionCalls: Session.ID[] = []
 const interruptCalls: Session.ID[] = []
+const interruptContinuations: Array<boolean | undefined> = []
 const wakeCalls: Session.ID[] = []
 const activeSessions = new Set<Session.ID>()
 const execution = Layer.succeed(
@@ -41,14 +42,16 @@ const execution = Layer.succeed(
      Effect.sync(() => {
        executionCalls.push(sessionID)
      }),
-    interrupt: (sessionID) =>
+    interrupt: (sessionID, options) =>
      Effect.sync(() => {
        interruptCalls.push(sessionID)
+        interruptContinuations.push(options?.continue)
      }),
    wake: (sessionID) =>
      Effect.sync(() => {
        wakeCalls.push(sessionID)
      }),
+    wakeActive: () => Effect.void,
    awaitIdle: () => Effect.void,
  }),
 )
@@ -177,31 +180,18 @@ describe("Session.prompt", () => {
    }),
  )

-  it.effect("continues after interruption when pending work remains", () =>
-    Effect.gen(function* () {
-      yield* setup
-      const session = yield* Session.Service
-      yield* session.synthetic({ sessionID, text: "Continue after interrupt", resume: false })
-      interruptCalls.length = 0
-      wakeCalls.length = 0
-
-      yield* session.interrupt(sessionID, { continue: true })
-
-      expect(interruptCalls).toEqual([sessionID])
-      expect(wakeCalls).toEqual([sessionID])
-    }),
-  )
-
-  it.effect("does not continue after interruption without pending work", () =>
+  it.effect("forwards interrupt continuation policy", () =>
    Effect.gen(function* () {
      yield* setup
      const session = yield* Session.Service
      interruptCalls.length = 0
+      interruptContinuations.length = 0
      wakeCalls.length = 0

      yield* session.interrupt(sessionID, { continue: true })

      expect(interruptCalls).toEqual([sessionID])
+      expect(interruptContinuations).toEqual([true])
      expect(wakeCalls).toEqual([])
    }),
  )
@@ -269,6 +269,35 @@ describe("SessionRunCoordinator", () => {
    ),
  )

+  it.effect("replaces a settlement-window wake with a steer continuation", () =>
+    Effect.scoped(
+      Effect.gen(function* () {
+        const settling = yield* Deferred.make<void>()
+        const release = yield* Deferred.make<void>()
+        const requests: SessionRunCoordinator.Request[] = []
+        const coordinator = yield* SessionRunCoordinator.make({
+          drain: (_key, _force, request) => Effect.sync(() => requests.push(request)),
+          settled: () => Deferred.succeed(settling, undefined).pipe(Effect.andThen(Deferred.await(release))),
+        })
+
+        yield* coordinator.wake("session", "input")
+        yield* Deferred.await(settling)
+        yield* coordinator.wake("session", "input")
+        const interrupted = yield* coordinator
+          .interrupt("session", undefined, {
+            continue: { request: "steer", when: Effect.succeed(true) },
+          })
+          .pipe(Effect.forkChild)
+        yield* Effect.yieldNow
+        yield* Deferred.succeed(release, undefined)
+        yield* Fiber.join(interrupted)
+        yield* coordinator.awaitIdle("session")
+
+        expect(requests).toEqual(["input", "steer"])
+      }),
+    ),
+  )
+
  it.effect("interrupts active execution and clears its pending wake", () =>
    Effect.scoped(
      Effect.gen(function* () {
@@ -342,6 +371,193 @@ describe("SessionRunCoordinator", () => {
    ),
  )

+  it.effect("coalesces drain requests with input taking precedence", () =>
+    Effect.scoped(
+      Effect.gen(function* () {
+        const firstStarted = yield* Deferred.make<void>()
+        const release = yield* Deferred.make<void>()
+        const requests: SessionRunCoordinator.Request[] = []
+        const coordinator = yield* SessionRunCoordinator.make({
+          drain: (_key, _force, request) =>
+            Effect.gen(function* () {
+              requests.push(request)
+              if (requests.length !== 1) return
+              yield* Deferred.succeed(firstStarted, undefined)
+              yield* Deferred.await(release)
+            }),
+        })
+
+        yield* coordinator.wake("session", "steer")
+        yield* Deferred.await(firstStarted)
+        yield* coordinator.wake("session", "steer")
+        yield* coordinator.wake("session", "input")
+        yield* Deferred.succeed(release, undefined)
+        yield* coordinator.awaitIdle("session")
+
+        expect(requests).toEqual(["steer", "input"])
+      }),
+    ),
+  )
+
+  it.effect("does not carry a completed input request into a steer drain", () =>
+    Effect.scoped(
+      Effect.gen(function* () {
+        const firstStarted = yield* Deferred.make<void>()
+        const release = yield* Deferred.make<void>()
+        const requests: SessionRunCoordinator.Request[] = []
+        const coordinator = yield* SessionRunCoordinator.make({
+          drain: (_key, _force, request) =>
+            Effect.gen(function* () {
+              requests.push(request)
+              if (requests.length !== 1) return
+              yield* Deferred.succeed(firstStarted, undefined)
+              yield* Deferred.await(release)
+            }),
+        })
+
+        yield* coordinator.wake("session", "input")
+        yield* Deferred.await(firstStarted)
+        yield* coordinator.wake("session", "steer")
+        yield* Deferred.succeed(release, undefined)
+        yield* coordinator.awaitIdle("session")
+
+        expect(requests).toEqual(["input", "steer"])
+      }),
+    ),
+  )
+
+  it.effect("an active wake inherits scope without starting idle work", () =>
+    Effect.scoped(
+      Effect.gen(function* () {
+        const firstStarted = yield* Deferred.make<void>()
+        const release = yield* Deferred.make<void>()
+        const requests: SessionRunCoordinator.Request[] = []
+        const coordinator = yield* SessionRunCoordinator.make({
+          drain: (_key, _force, request) =>
+            Effect.gen(function* () {
+              requests.push(request)
+              if (requests.length !== 1) return
+              yield* Deferred.succeed(firstStarted, undefined)
+              yield* Deferred.await(release)
+            }),
+        })
+
+        yield* coordinator.wakeActive("session")
+        yield* coordinator.wake("session", "steer")
+        yield* Deferred.await(firstStarted)
+        yield* coordinator.wakeActive("session")
+        yield* Deferred.succeed(release, undefined)
+        yield* coordinator.awaitIdle("session")
+
+        expect(requests).toEqual(["steer", "steer"])
+      }),
+    ),
+  )
+
+  it.effect("coalesces overlapping interrupt continuations into one steer successor", () =>
+    Effect.scoped(
+      Effect.gen(function* () {
+        const firstStarted = yield* Deferred.make<void>()
+        const cleanupStarted = yield* Deferred.make<void>()
+        const cleanupGate = yield* Deferred.make<void>()
+        const requests: SessionRunCoordinator.Request[] = []
+        const coordinator = yield* SessionRunCoordinator.make({
+          drain: (_key, _force, request) =>
+            Effect.gen(function* () {
+              requests.push(request)
+              if (requests.length !== 1) return
+              yield* Deferred.succeed(firstStarted, undefined)
+              yield* Effect.never.pipe(
+                Effect.onInterrupt(() =>
+                  Deferred.succeed(cleanupStarted, undefined).pipe(Effect.andThen(Deferred.await(cleanupGate))),
+                ),
+              )
+            }),
+        })
+        const continuation = { continue: { request: "steer" as const, when: Effect.succeed(false) } }
+
+        yield* coordinator.wake("session")
+        yield* Deferred.await(firstStarted)
+        const first = yield* coordinator.interrupt("session", undefined, continuation).pipe(Effect.forkChild)
+        yield* Deferred.await(cleanupStarted)
+        const second = yield* coordinator.interrupt("session", undefined, continuation).pipe(Effect.forkChild)
+        yield* Effect.yieldNow
+        yield* coordinator.wake("session", "input")
+        yield* Deferred.succeed(cleanupGate, undefined)
+        yield* Effect.all([Fiber.join(first), Fiber.join(second)])
+        yield* coordinator.awaitIdle("session")
+
+        expect(requests).toEqual(["input", "steer"])
+      }),
+    ),
+  )
+
+  it.effect("a continuing interrupt replaces a cleanup-era input wake", () =>
+    Effect.scoped(
+      Effect.gen(function* () {
+        const firstStarted = yield* Deferred.make<void>()
+        const cleanupStarted = yield* Deferred.make<void>()
+        const cleanupGate = yield* Deferred.make<void>()
+        const requests: SessionRunCoordinator.Request[] = []
+        const coordinator = yield* SessionRunCoordinator.make({
+          drain: (_key, _force, request) =>
+            Effect.gen(function* () {
+              requests.push(request)
+              if (requests.length !== 1) return
+              yield* Deferred.succeed(firstStarted, undefined)
+              yield* Effect.never.pipe(
+                Effect.onInterrupt(() =>
+                  Deferred.succeed(cleanupStarted, undefined).pipe(Effect.andThen(Deferred.await(cleanupGate))),
+                ),
+              )
+            }),
+        })
+
+        yield* coordinator.wake("session", "input")
+        yield* Deferred.await(firstStarted)
+        const plain = yield* coordinator.interrupt("session").pipe(Effect.forkChild)
+        yield* Deferred.await(cleanupStarted)
+        yield* coordinator.wake("session", "input")
+        const continuing = yield* coordinator
+          .interrupt("session", undefined, {
+            continue: { request: "steer", when: Effect.succeed(false) },
+          })
+          .pipe(Effect.forkChild)
+        yield* Effect.yieldNow
+        yield* Deferred.succeed(cleanupGate, undefined)
+        yield* Effect.all([Fiber.join(plain), Fiber.join(continuing)])
+        yield* coordinator.awaitIdle("session")
+
+        expect(requests).toEqual(["input", "steer"])
+      }),
+    ),
+  )
+
+  it.effect("does not start a conditional continuation without eligible work", () =>
+    Effect.scoped(
+      Effect.gen(function* () {
+        const started = yield* Deferred.make<void>()
+        const requests: SessionRunCoordinator.Request[] = []
+        const coordinator = yield* SessionRunCoordinator.make({
+          drain: (_key, _force, request) =>
+            Effect.sync(() => requests.push(request)).pipe(
+              Effect.andThen(Deferred.succeed(started, undefined)),
+              Effect.andThen(Effect.never),
+            ),
+        })
+
+        yield* coordinator.wake("session")
+        yield* Deferred.await(started)
+        yield* coordinator.interrupt("session", undefined, {
+          continue: { request: "steer", when: Effect.succeed(false) },
+        })
+        yield* coordinator.awaitIdle("session")
+
+        expect(requests).toEqual(["input"])
+      }),
+    ),
+  )
+
  it.effect("starts a resume registered during interruption cleanup", () =>
    Effect.scoped(
      Effect.gen(function* () {
@@ -126,7 +126,8 @@ const execution = (llmClient: Layer.Layer<typeof LLMClient.Service>) =>
        active: coordinator.active,
        resume: coordinator.run,
        wake: coordinator.wake,
-        interrupt: coordinator.interrupt,
+        wakeActive: coordinator.wakeActive,
+        interrupt: (sessionID) => coordinator.interrupt(sessionID),
        awaitIdle: coordinator.awaitIdle,
      })
    }),
@@ -413,7 +413,8 @@ const execution = Layer.effect(
      active: coordinator.active,
      resume: coordinator.run,
      wake: coordinator.wake,
-      interrupt: coordinator.interrupt,
+      wakeActive: coordinator.wakeActive,
+      interrupt: (sessionID) => coordinator.interrupt(sessionID),
      awaitIdle: coordinator.awaitIdle,
    })
  }),
@@ -1383,6 +1384,44 @@ describe("SessionRunnerLLM", () => {
    }),
  )

+  it.effect("keeps queued input parked across a mid-turn move", () =>
+    Effect.gen(function* () {
+      const session = yield* setup
+      const bus = yield* Bus.Service
+      const { db } = yield* Database.Service
+      yield* admit(session, "Echo before moving")
+      yield* TestLLM.push(
+        TestLLM.tool("call-move", "echo", { text: "moving" }),
+        TestLLM.text("Done", "text-after-move"),
+        TestLLM.text("Handled queue", "text-after-queue"),
+      )
+      const tools = yield* blockTools()
+      const run = yield* session.resume(sessionID).pipe(Effect.forkChild)
+      yield* tools.started
+      yield* session.prompt({ sessionID, text: "Queued for later", delivery: "queue", resume: false })
+      yield* SessionInbox.admit(db, bus, {
+        id: SessionMessage.ID.create(),
+        sessionID,
+        item: {
+          type: "move",
+          payload: {
+            location: Location.Ref.make({ directory: AbsolutePath.make("/project") }),
+            projectID: Project.ID.global,
+          },
+          delivery: "steer",
+        },
+      })
+
+      yield* tools.release
+      yield* Fiber.join(run)
+
+      // The resumed turn absorbs steers only; queued input waits for the turn to end.
+      expect(requests).toHaveLength(3)
+      expect(userTexts(requests[1])).not.toContain("Queued for later")
+      expect(userTexts(requests[2])).toContain("Queued for later")
+    }),
+  )
+
  it.effect("seeds a fork with the parent's newest instruction values", () =>
    Effect.gen(function* () {
      const session = yield* setup
@@ -3088,6 +3127,24 @@ describe("SessionRunnerLLM", () => {
    }),
  )

+  it.effect("stops a steer-scoped drain before queued input", () =>
+    Effect.gen(function* () {
+      const session = yield* setup
+      const { db } = yield* Database.Service
+      yield* session.prompt({ sessionID, text: "Queue for later", delivery: "queue", resume: false })
+      yield* session.prompt({ sessionID, text: "Steer now", resume: false })
+      yield* TestLLM.push(TestLLM.stop())
+
+      const runner = yield* SessionRunner.Service
+      yield* runner.drain({ sessionID, force: false, promotable: "steer" })
+
+      expect(requests).toHaveLength(1)
+      expect(userTexts(requests[0])).toEqual(["Steer now"])
+      expect(yield* SessionInbox.has(db, sessionID, "steer")).toBe(false)
+      expect(yield* SessionInbox.has(db, sessionID, "queue")).toBe(true)
+    }),
+  )
+
  it.effect("promotes queued input after steering continuation ends", () =>
    Effect.gen(function* () {
      const session = yield* setup
@@ -0,0 +1,114 @@
+import { describe, expect } from "bun:test"
+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 { 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 } from "effect"
+import { eq } from "drizzle-orm"
+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* Effect.all([session.view({ sessionID: created.id }), session.view({ sessionID: created.id })], {
+        concurrency: "unbounded",
+        discard: true,
+      })
+      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 }))
+    }),
+  )
+})
@@ -115,6 +115,7 @@ const executionNode = makeGlobalNode({
        active: Effect.succeed(new Set()),
        resume: complete,
        wake: () => Effect.void,
+        wakeActive: () => Effect.void,
        interrupt: () => Effect.void,
        awaitIdle: (id) => complete(id).pipe(Effect.exit, Effect.asVoid),
      })
@@ -86,6 +86,7 @@ const executionNode = makeGlobalNode({
        active: Effect.succeed(new Set()),
        resume: complete,
        wake: () => Effect.void,
+        wakeActive: () => Effect.void,
        interrupt: () => Effect.void,
        awaitIdle: (sessionID) => complete(sessionID).pipe(Effect.exit, Effect.asVoid),
      })
@@ -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,
@@ -660,7 +660,7 @@ export const makeSessionGroup = <I extends HttpApiMiddleware.AnyId, S>(sessionLo
            identifier: "v2.session.interrupt",
            summary: "Interrupt session execution",
            description:
-              "Interrupt active execution owned by this OpenCode process. Idle interruption is a no-op. When continue=true, execution resumes if durable inbox work remains after interruption.",
+              "Interrupt active execution owned by this OpenCode process. Idle interruption is a no-op. When continue=true, execution resumes pending steering input while queued work remains parked.",
          }),
        ),
    )
@@ -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).
@@ -1,6 +1,7 @@
 import { createMemo, createResource, createSignal, onMount, Show } from "solid-js"
 import path from "path"
 import type { SessionInfo } from "@opencode-ai/client"
+import { Project } from "@opencode-ai/schema/project"
 import { TextAttributes } from "@opentui/core"
 import type { RGBA } from "@opentui/core"
 import { useDialog } from "../ui/dialog"
@@ -54,10 +55,12 @@ export function DialogSessionList() {
        const response = await client.api.session.list({
          ...(allProjects
            ? {}
-            : {
-                project: current.project.id,
-                subpath: path.relative(current.project.directory, current.directory).replaceAll("\\", "/"),
-              }),
+            : current.project.id === Project.ID.global
+              ? { directory: current.directory }
+              : {
+                  project: current.project.id,
+                  subpath: path.relative(current.project.directory, current.directory).replaceAll("\\", "/"),
+                }),
          ...(query ? { search: query } : {}),
          limit: 50,
          order: "desc",
@@ -71,6 +71,7 @@ import { DialogImagePreview } from "../dialog-image-preview"
 import { useDirectoryRecents } from "../../prompt/directory-recents"
 import { directoryRecentValue } from "../../prompt/directory-completion"
 import { useWorkingDirectoryActions } from "../../ui/working-directory-actions"
+import { truncateFilePath } from "../../ui/file-path"

 export type PromptProps = {
  sessionID?: string
@@ -1555,6 +1556,12 @@ export function Prompt(props: PromptProps) {
    const branch = data.location.vcs.info(location)?.branch.current
    return branch ? `${directory}:${branch}` : directory
  })
+  const [locationWidth, setLocationWidth] = createSignal(dimensions().width)
+  const locationLabelDisplay = createMemo(() => {
+    const label = locationLabel()
+    if (!label) return
+    return truncateFilePath(label, locationWidth())
+  })
  const locationActions = useWorkingDirectoryActions({
    directory: () => footerLocation()?.directory,
    onMove: () => void move.open(),
@@ -1840,7 +1847,15 @@ export function Prompt(props: PromptProps) {
        <box width="100%" flexDirection="row" justifyContent="space-between" gap={2}>
          <Slot path="prompt.footer" input={footerInput()}>
            <Slot path="prompt.footer.status" input={footerInput()}>
-              <box flexGrow={1} flexShrink={1} minWidth={0}>
+              <box
+                flexGrow={1}
+                flexShrink={1}
+                minWidth={0}
+                onSizeChange={function (this: BoxRenderable) {
+                  const width = this.width
+                  queueMicrotask(() => setLocationWidth(width))
+                }}
+              >
                <Switch>
                  <Match when={status() === "running"}>
                    <box flexDirection="row" gap={1} flexGrow={1} justifyContent="flex-start">
@@ -1877,7 +1892,7 @@ export function Prompt(props: PromptProps) {
                    </box>
                  </Match>
                  <Match when={true}>
-                    <Show when={!props.hint && locationLabel()} fallback={props.hint ?? <text />}>
+                    <Show when={!props.hint && locationLabelDisplay()} fallback={props.hint ?? <text />}>
                      {(location) => (
                        <text
                          id="prompt.footer.location"
@@ -14,6 +14,10 @@ describe("truncateFilePath", () => {
    expect(truncateFilePath(path, 19)).toBe("…/dialog-select.tsx")
  })

+  test("preserves the working directory and branch suffix", () => {
+    expect(truncateFilePath("~/code/experiments/category-theory:main", 30)).toBe("…/experi…/category-theory:main")
+  })
+
  test("uses remaining width for part of a long parent segment", () => {
    const path = "/private/var/folders/run-17f048ec-dbb2-4b36-860c-98637bb51a8d/files"
    expect(truncateFilePath(path, 40)).toBe("/…/run-17f048ec-dbb2-4b36-860c-98…/files")
Author	SHA1	Message	Date
Kit Langton	35288ac778	refactor(protocol): preserve endpoint ordering	2026-08-15 15:47:11 -04:00
Kit Langton	6fc4726d4f	feat(session): add viewed state	2026-08-15 14:57:56 -04:00
opencode-agent[bot]	73700065bf	chore: generate	2026-08-15 18:35:53 +00:00
Kit Langton	07a82a442e	fix(core): keep queued work parked after interrupt (#42682 )	2026-08-15 18:34:43 +00:00
Kit Langton	55be895e14	fix(tui): scope session picker by directory (#42804 )	2026-08-15 18:30:35 +00:00
Kit Langton	58a36a1560	fix(tui): preserve path suffix in prompt footer (#42800 )	2026-08-15 18:21:07 +00:00