fix(opencode): keep shared-session TUI activity with its owning pane

.github/workflows/pr.yml

@@ -705,7 +705,7 @@ jobs:
   # after the last shard. Deliberately absent from verify's needs for the same reason.
   unit_selection_evidence:
     needs: [test]
-    if: ${{ !cancelled() && needs.test.result == 'success' }}
+    if: ${{ !cancelled() && (needs.test.result == 'success' || needs.test.result == 'failure') }}
     uses: ./.github/workflows/unit-selection-evidence.yml
 
   # Why a separate job: the test needs a real Chrome, and the sharded `test` matrix

.github/workflows/terminal-perf.yml

@@ -68,25 +68,60 @@ jobs:
       - name: Install native build tools and xvfb
         run: sudo apt-get update && sudo apt-get install -y build-essential python3 xvfb zsh
 
+      - name: Select dependency preparation
+        id: install-mode
+        shell: bash
+        env:
+          RUNNER_KIND: ${{ runner.environment }}
+          JOB_CONTAINER: ${{ job.container.id }}
+        run: |
+          node <<'NODE'
+          const fs = require('node:fs')
+          const manifest = JSON.parse(fs.readFileSync('package.json', 'utf8'))
+          const actionPath = '.github/actions/install-node-dependencies/action.yml'
+          const action = fs.existsSync(actionPath) ? fs.readFileSync(actionPath, 'utf8') : ''
+          const inputs = action.split(/^inputs:[ \t]*\r?$/m)[1]?.split(/^\S/m)[0] ?? ''
+          const shared = process.env.RUNNER_KIND === 'github-hosted' && !process.env.JOB_CONTAINER &&
+            process.env.RUNNER_OS === 'Linux' && process.env.RUNNER_ARCH === 'X64' &&
+            manifest.engines?.node === '24' && typeof manifest.packageManager === 'string' &&
+            manifest.packageManager.split('+')[0] === 'pnpm@12.8.1' &&
+            manifest.scripts?.postinstall === 'node config/scripts/rebuild-native-deps.mjs' &&
+            /^  native-runtime:/m.test(inputs) && /^  cache-pnpm-store-lookup-only:/m.test(inputs) &&
+            fs.existsSync('.github/actions/prepare-native-runtime/action.yml') &&
+            fs.existsSync('config/scripts/ensure-native-runtime.mjs')
+          fs.appendFileSync(process.env.GITHUB_OUTPUT, `shared=${shared}\n`)
+          NODE
+
+      - name: Prepare current dependencies
+        if: steps.install-mode.outputs.shared == 'true'
+        uses: ./.github/actions/install-node-dependencies
+        with:
+          native-runtime: electron
+          cache-electron-package: 'true'
+          cache-pnpm-store-lookup-only: 'true'
+
       - name: Setup pnpm
+        if: steps.install-mode.outputs.shared != 'true'
         uses: pnpm/setup@v2
         with:
           install: false
 
       - name: Setup Node.js
+        if: steps.install-mode.outputs.shared != 'true'
         uses: actions/setup-node@v6
         with:
           node-version-file: package.json
           cache: pnpm
 
-      # Why: this scheduled/manual workflow uses the same native install path as
-      # PR and E2E CI, which needs pnpm to bypass its bundled gyp_main.py.
+      # Historical refs can lack the shared action; retain their original install path.
       - name: Use external node-gyp to avoid pnpm's bundled copy
+        if: steps.install-mode.outputs.shared != 'true'
         run: |
           npm install -g node-gyp@11.5.0
           echo "npm_config_node_gyp=$(npm root -g)/node-gyp/bin/node-gyp.js" >> "$GITHUB_ENV"
 
       - name: Install dependencies
+        if: steps.install-mode.outputs.shared != 'true'
         run: pnpm install --frozen-lockfile
 
       - name: Build Electron app for terminal perf

.gitignore

@@ -128,6 +128,7 @@ docs/**
 !docs/reference/git-compatibility.md
 !docs/reference/headless-linux-server.md
 !docs/reference/ime-regression-checklist.md
+!docs/reference/jcode-hook-events.md
 !docs/reference/linux-glibc-compatibility.md
 !docs/reference/macos-press-and-hold.md
 !docs/reference/orcad-operations.md

cloud/apps/push/src/durable-push-payload-parse-budget.test.ts

@@ -0,0 +1,244 @@
+import { createHash } from 'node:crypto'
+import { afterEach, expect, it, vi } from 'vitest'
+import { DurablePushStore } from './durable-push-store.js'
+import { buildPushDelivery } from './push-delivery-message.js'
+import type { PushDatabase } from './push-database.js'
+import {
+  cleanupDurablePushFixtures,
+  fixture,
+  notification
+} from './durable-push-store.test-fixture.js'
+
+type QueryCall = { sql: string; params?: unknown[] }
+
+afterEach(async () => {
+  vi.restoreAllMocks()
+  await cleanupDurablePushFixtures()
+})
+
+function traceDatabase(
+  database: PushDatabase,
+  calls: QueryCall[],
+  errors: unknown[]
+): PushDatabase {
+  return {
+    dialect: database.dialect,
+    query: async (sql, params) => {
+      calls.push({ sql, params })
+      try {
+        return await database.query(sql, params)
+      } catch (error) {
+        errors.push(error)
+        throw error
+      }
+    },
+    transaction: (run) => database.transaction((tx) => run(traceDatabase(tx, calls, errors))),
+    lockQuotaScope: (key) => database.lockQuotaScope(key),
+    tryLockScope: (key) => database.tryLockScope(key),
+    tryLockSharedScope: (key) => database.tryLockSharedScope(key),
+    close: () => database.close()
+  }
+}
+
+function payloadHash(value: unknown): string {
+  return createHash('sha256').update(JSON.stringify(value)).digest('hex')
+}
+
+it('parses each leased row once with exact complete payload, serialized key order and SQL sequence', async () => {
+  const { db, store, clock } = await fixture()
+  const input = {
+    ...notification(1),
+    body: 'Unicode: 🐋\ud800',
+    extra: { first: [null, false, 3], next: { z: 'last', a: 'first' } }
+  }
+  await store.accept('host', 'phone', input)
+  const [row] = await db.query('SELECT * FROM push_delivery_batches')
+  if (!row) {
+    throw new Error('Missing delivery row')
+  }
+  const payload = String(row.payload_json)
+  const calls: QueryCall[] = []
+  const errors: unknown[] = []
+  const owner = new DurablePushStore(traceDatabase(db, calls, errors), clock)
+  const parse = vi.spyOn(JSON, 'parse')
+  const delivery = await owner.claim()
+  expect(delivery).toEqual({
+    id: row.batch_id,
+    registrationId: 'phone',
+    hostFingerprint: 'host',
+    notification: input,
+    expiresAt: 1_300_000,
+    lease: expect.any(String),
+    attempts: 1
+  })
+  expect(JSON.stringify(delivery?.notification)).toBe(payload)
+  expect(payloadHash(delivery?.notification)).toBe(payloadHash(input))
+  if (!delivery) {
+    throw new Error('Missing delivery')
+  }
+  const published = buildPushDelivery(delivery)
+  const expected = buildPushDelivery({ ...delivery, notification: input })
+  expect(JSON.stringify(published)).toBe(JSON.stringify(expected))
+  expect(payloadHash(published)).toBe(payloadHash(expected))
+  expect(calls.map(({ sql }) => sql.replace(/\s+/g, ' ').trim())).toEqual([
+    `SELECT * FROM push_delivery_batches WHERE state = 'pending' AND lease_until <= ? AND expires_at > ? AND due_at <= ? AND due_at > ? AND NOT EXISTS (SELECT 1 FROM push_delivery_batches busy WHERE busy.registration_id = push_delivery_batches.registration_id AND busy.state = 'pending' AND busy.lease_until > 0 AND busy.lease_until > ?) ORDER BY due_at, created_at, batch_id LIMIT 1${db.dialect === 'postgres' ? ' FOR UPDATE SKIP LOCKED' : ''}`,
+    "SELECT (SELECT batch_id FROM push_delivery_batches WHERE registration_id = ? AND state = 'pending' AND expires_at > ? AND due_at > ? ORDER BY due_at, created_at, batch_id LIMIT 1) AS head, EXISTS (SELECT 1 FROM push_delivery_batches WHERE registration_id = ? AND state = 'pending' AND lease_until > 0 AND lease_until > ?) AS busy",
+    'SELECT notification_seq FROM push_dismissed_events WHERE host_fingerprint = ? AND notification_epoch = ? AND notification_id = ?',
+    'UPDATE push_delivery_batches SET lease_token = ?, lease_until = ?, attempts = attempts + 1 WHERE batch_id = ?'
+  ])
+  expect(calls[1]?.params).toEqual(['phone', clock(), clock() - 300_000, 'phone', clock()])
+  expect(calls[2]?.params).toEqual(['host', 'epoch', 'notification-1'])
+  expect(calls[3]?.params).toEqual([delivery?.lease, clock() + 30_000, row.batch_id])
+  expect(errors).toEqual([])
+  expect(parse.mock.calls.filter(([value]) => value === payload)).toHaveLength(1)
+})
+
+it('keeps concurrent device claims separate and returns fresh payload objects', async () => {
+  const { store } = await fixture()
+  const input = notification(1)
+  await store.accept('host', 'phone-a', input)
+  await store.accept('host', 'phone-b', input)
+  const payload = JSON.stringify(input)
+  const parse = vi.spyOn(JSON, 'parse')
+  const claims = await Promise.all(Array.from({ length: 4 }, () => store.claim()))
+  const delivered = claims.filter((claim) => claim !== null)
+  expect(delivered).toHaveLength(2)
+  expect(delivered.map((claim) => claim.registrationId).sort()).toEqual(['phone-a', 'phone-b'])
+  expect(delivered.every((claim) => JSON.stringify(claim.notification) === payload)).toBe(true)
+  expect(delivered[0]?.notification).not.toBe(delivered[1]?.notification)
+  expect(parse.mock.calls.filter(([value]) => value === payload)).toHaveLength(2)
+})
+
+it('reads changed retry bytes and a later writer update without carrying a parsed result across calls', async () => {
+  const { db, store, advance } = await fixture()
+  await store.accept('host', 'phone', notification(1))
+  const first = await store.claim()
+  if (!first) {
+    throw new Error('Missing first delivery')
+  }
+  first.notification.body = 'provider changed this retry'
+  await store.finish(first, 1000)
+  advance(1000)
+  const retriedPayload = JSON.stringify(first.notification)
+  const parse = vi.spyOn(JSON, 'parse')
+  const retry = await store.claim()
+  expect(retry).toEqual({ ...first, lease: expect.any(String), attempts: 2 })
+  expect(retry?.lease).not.toBe(first.lease)
+  expect(retry?.notification).not.toBe(first.notification)
+  expect(JSON.stringify(retry?.notification)).toBe(retriedPayload)
+  expect(payloadHash(retry?.notification)).toBe(payloadHash(first.notification))
+  const retryParses = parse.mock.calls.filter(([value]) => value === retriedPayload).length
+  if (!retry) {
+    throw new Error('Missing retry delivery')
+  }
+  await store.finish(retry, 1000)
+  const changed = { ...notification(1), body: 'fresh database row', title: 'Changed' }
+  const changedPayload = JSON.stringify(changed)
+  await db.query('UPDATE push_delivery_batches SET payload_json = ? WHERE batch_id = ?', [
+    changedPayload,
+    first.id
+  ])
+  advance(1000)
+  const fresh = await store.claim()
+  expect(fresh).toEqual({ ...retry, notification: changed, lease: expect.any(String), attempts: 3 })
+  expect(JSON.stringify(fresh?.notification)).toBe(changedPayload)
+  expect(payloadHash(fresh?.notification)).toBe(payloadHash(changed))
+  expect(retry.notification.body).toBe('provider changed this retry')
+  expect(retryParses).toBe(1)
+  expect(parse.mock.calls.filter(([value]) => value === changedPayload)).toHaveLength(1)
+})
+
+it('keeps dismissed alerts on the original single-parse delete path without leasing', async () => {
+  const { db, store, clock } = await fixture()
+  const input = notification(1)
+  await store.accept('host', 'phone', input)
+  await db.query(
+    'INSERT INTO push_dismissed_events(host_fingerprint, notification_epoch, notification_id, notification_seq, created_at) VALUES (?, ?, ?, ?, ?)',
+    ['host', 'epoch', input.notificationId, 1, clock()]
+  )
+  const calls: QueryCall[] = []
+  const parse = vi.spyOn(JSON, 'parse')
+  expect(await new DurablePushStore(traceDatabase(db, calls, []), clock).claim()).toBeNull()
+  expect(await store.pendingCount('phone')).toBe(0)
+  expect(calls.at(-1)?.sql).toBe('DELETE FROM push_delivery_batches WHERE batch_id = ?')
+  expect(calls.some(({ sql }) => sql.startsWith('UPDATE'))).toBe(false)
+  expect(parse.mock.calls.filter(([value]) => value === JSON.stringify(input))).toHaveLength(1)
+})
+
+it('preserves the existing trust boundary for an object missing notification fields', async () => {
+  const { db, store } = await fixture()
+  await store.accept('host', 'phone', notification(1))
+  await db.query('UPDATE push_delivery_batches SET payload_json = ?', ['{}'])
+  const parse = vi.spyOn(JSON, 'parse')
+  const delivery = await store.claim()
+  expect(delivery?.notification).toEqual({})
+  expect(JSON.stringify(delivery?.notification)).toBe('{}')
+  expect(parse.mock.calls.filter(([value]) => value === '{}')).toHaveLength(1)
+})
+
+it.each(['not JSON', 'undefined', 'null', '[]'])(
+  'preserves invalid payload rejection and rolls back the lease for %s',
+  async (payload) => {
+    const { db, store } = await fixture()
+    await store.accept('host', 'phone', notification(1))
+    await db.query('UPDATE push_delivery_batches SET payload_json = ?', [payload])
+    const [before] = await db.query('SELECT * FROM push_delivery_batches')
+    const parse = vi.spyOn(JSON, 'parse')
+    let caught: unknown
+    try {
+      await store.claim()
+    } catch (error) {
+      caught = error
+    }
+    expect(caught).toBeInstanceOf(Error)
+    const index = parse.mock.calls.findIndex(([value]) => value === payload)
+    expect(index).toBeGreaterThanOrEqual(0)
+    if (payload === 'not JSON' || payload === 'undefined') {
+      expect(caught).toBe(parse.mock.results[index]?.value)
+      expect(caught).toBeInstanceOf(SyntaxError)
+    } else {
+      expect(caught).toMatchObject({ message: 'invalid_push_delivery_payload' })
+    }
+    expect(await db.query('SELECT * FROM push_delivery_batches')).toEqual([before])
+    expect(parse.mock.calls.filter(([value]) => value === payload)).toHaveLength(1)
+  }
+)
+
+it('preserves the exact database UPDATE error and retries with a fresh payload after rollback', async () => {
+  const { db, store, clock } = await fixture()
+  await store.accept('host', 'phone', notification(1))
+  const [before] = await db.query('SELECT * FROM push_delivery_batches')
+  if (!before) {
+    throw new Error('Missing delivery row')
+  }
+  const originalQuery = db.query.bind(db)
+  const errors: unknown[] = []
+  // SQLite raises a native error in the real transaction; PostgreSQL uses its real constraint.
+  await originalQuery(
+    db.dialect === 'sqlite'
+      ? "CREATE TRIGGER deny_lease BEFORE UPDATE ON push_delivery_batches BEGIN SELECT RAISE(FAIL, 'deny_lease'); END"
+      : 'ALTER TABLE push_delivery_batches ADD CONSTRAINT deny_lease CHECK (lease_until = 0)'
+  )
+  const owner = new DurablePushStore(traceDatabase(db, [], errors), clock)
+  const parse = vi.spyOn(JSON, 'parse')
+  let caught: unknown
+  try {
+    await owner.claim()
+  } catch (error) {
+    caught = error
+  }
+  expect(errors).toHaveLength(1)
+  expect(caught).toBe(errors[0])
+  expect(await originalQuery('SELECT * FROM push_delivery_batches')).toEqual([before])
+  expect(parse.mock.calls.filter(([value]) => value === String(before.payload_json))).toHaveLength(
+    1
+  )
+  await originalQuery(
+    db.dialect === 'sqlite'
+      ? 'DROP TRIGGER deny_lease'
+      : 'ALTER TABLE push_delivery_batches DROP CONSTRAINT deny_lease'
+  )
+  const fresh = await owner.claim()
+  expect(fresh?.notification).toEqual(notification(1))
+  expect(fresh?.attempts).toBe(1)
+})

cloud/apps/push/src/durable-push-store.ts

@@ -153,15 +153,15 @@ export class DurablePushStore {
       'UPDATE push_delivery_batches SET lease_token = ?, lease_until = ?, attempts = attempts + 1 WHERE batch_id = ?',
       [lease, now + DELIVERY_LEASE_MS, row.batch_id]
     )
-    return this.delivery(row, lease)
+    return this.delivery(row, lease, notification)
   }
 
-  private delivery(row: SqlRow, lease: string): QueuedPushDelivery {
+  private delivery(row: SqlRow, lease: string, notification: PushNotification): QueuedPushDelivery {
     return {
       id: String(row.batch_id),
       registrationId: String(row.registration_id),
       hostFingerprint: String(row.host_fingerprint),
-      notification: parsePushDeliveryPayload(String(row.payload_json)),
+      notification,
       expiresAt: Number(row.expires_at),
       lease,
       attempts: Number(row.attempts) + 1

config/build-plugins/jsonc-parser-esm.ts

@@ -0,0 +1,6 @@
+import { resolve } from 'node:path'
+
+// UMD relative requires cannot survive a self-contained bundle.
+export const JSONC_PARSER_ESM_ALIAS = {
+  'jsonc-parser': resolve(import.meta.dirname, '../../node_modules/jsonc-parser/lib/esm/main.js')
+}

config/build-plugins/plain-node-entry-guard.ts

@@ -19,6 +19,7 @@ type OutputChunk = Rollup.OutputChunk
 // The CLI loads these paths after electron-vite replaces out/main.
 export const CLI_MAIN_ENTRY_NAMES = [
   'agent-hooks/managed-agent-hook-controls',
+  'gitlab/project-ref-parser',
   'orca-profiles/profile-index-store',
   'claude-accounts/keychain',
   ...[