mtech-ai-local-runner 0.1.111 → 0.1.113

package/claude-mod/hooks/register.tsx

@@ -1,460 +0,0 @@
-import { atom, read, update } from 'claude-code'
-import type { EngineInterface, Register } from 'claude-code'
-
-import type { Counts, InboxItem, OpenRoom, Pending, RoomActivity, RoomMessage, Status, ThreadRow } from '../types'
-import { callGateway } from './gateway'
-import { CLEARED, INBOX_LIMIT, bandText, authorName, chatPrompt, clearedIds, detailLine, findPayload, groupInbox, markable, mergeMessages, parseActivity, parseInbox, parseMessages, parseRoom, parseThreads, pickThreads, visibleInbox, writeKey } from './model'
-
-/*
- * The Work Room pane (Work Item 98da2635, spec 2026-10-30): Room shares and requests from colleagues beside the
- * conversation, read and answered through the person's own AI Gateway connector with no model turn. The band above
- * the prompt says what waits; the pane opens only from the band or /work-room, never at session start.
- *
- * Auto mode refuses every call the pane makes, since none comes from a request of the person's in the conversation, and
- * a mod's own module hooks cannot approve its own calls. So hooks/hooks.json carries PreToolUse hooks for every caller
- * (owner decisions 2026-10-31): they allow the reads (work_room_read, work_inbox) and the presented receipt, and they
- * put each write (answer, post, share, mark read) to the person in Claude's own permission dialog, after the pane's
- * confirm press.
- */
-
-export const PANE = 'work-room'
-const TITLE = 'Work Room'
-const REFRESH_MS = 60_000
-const NO_CONNECTOR = 'This session has no AI Gateway Work Room tools. Connect AI Gateway in Claude, reconnect it with /mcp, or start a new session.'
-// A session keeps the tools list its connector had when it started, and a call drops arguments that list does not
-// declare. With a list from before unread_only and latest (Gateway a8df571a), a Room opens with its oldest messages.
-const STALE = 'Refresh the AI Gateway tools list in Claude (Settings, Connectors, AI Gateway), then start a new session, so Rooms show their newest and unread messages.'
-const NIL = '00000000-0000-4000-8000-000000000000'
-
-const counts = atom({ plugin: 'ai-gateway-work-room', key: 'counts' } as const, { shares: 0, requests: 0 } as Counts)
-const activity = atom({ plugin: 'ai-gateway-work-room', key: 'activity' } as const, [] as RoomActivity[])
-const inbox = atom({ plugin: 'ai-gateway-work-room', key: 'inbox' } as const, [] as InboxItem[])
-const rooms = atom({ plugin: 'ai-gateway-work-room', key: 'rooms' } as const, {} as Record<string, OpenRoom>)
-const pending = atom({ plugin: 'ai-gateway-work-room', key: 'pending' } as const, null as Pending)
-const status = atom({ plugin: 'ai-gateway-work-room', key: 'status' } as const, { state: 'ok', detail: '' } as Status)
-const cleared = atom({ plugin: 'ai-gateway-work-room', key: 'cleared' } as const, [] as string[])
-const showCleared = atom({ plugin: 'ai-gateway-work-room', key: 'showCleared' } as const, false as boolean)
-const tab = atom({ plugin: 'ai-gateway-work-room', key: 'tab' } as const, 'requests' as 'requests' | 'rooms')
-// The request group the person opened; null opens the newest one.
-const openGroup = atom({ plugin: 'ai-gateway-work-room', key: 'openGroup' } as const, null as string | null)
-const nowMs = atom({ plugin: 'ai-gateway-work-room', key: 'nowMs' } as const, 0 as number)
-
-/** Whether this session's calls carry unread_only and latest to the Gateway; asked once per run. */
-let readOptions: boolean | undefined
-
-/**
- * The Gateway refuses unread_only with latest before it looks up the Room. A call that loses both arguments on the
- * way gets "Work Room is unavailable." instead. Undefined when the answer says neither (a refusal, no connector).
- */
-async function readOptionsReach($: EngineInterface): Promise<boolean | undefined> {
-  if (readOptions !== undefined) return readOptions
-  const probe = await callGateway($, 'work_room_read', { operation: 'messages', room_id: NIL, thread_id: NIL, unread_only: true, latest: true, limit: 1 })
-  if (probe.ok || probe.state !== 'error') return undefined
-  readOptions = probe.detail.includes('not both')
-
-  return readOptions
-}
-
-/** Messages already sent for presented in this run, so a redraw before the update lands does not report them twice. */
-const presentedSent = new Set<string>()
-
-/** Background work the person did not wait for: a failure is already shown through status, never thrown. */
-function quietly(work: Promise<unknown>): void {
-  work.catch(() => undefined)
-}
-
-async function fail($: EngineInterface, answer: { state: Status['state']; detail: string }): Promise<void> {
-  await update($, status, () => ({ state: answer.state, detail: answer.state === 'no-connector' ? NO_CONNECTOR : answer.detail }))
-}
-
-/** The band's counts from what this session holds: Room unread, and requests not cleared on this Mac. */
-async function recount($: EngineInterface): Promise<void> {
-  const rows = await read($, activity)
-  const items = visibleInbox(await read($, inbox), await read($, cleared))
-  await update($, counts, () => ({ shares: rows.reduce((sum, row) => sum + row.unread, 0), requests: items.length }))
-}
-
-/** Reads the cleared ids from the store. A complete inbox read drops ids it no longer lists (answered, decided or expired). */
-async function syncCleared($: EngineInterface, items: InboxItem[] | undefined): Promise<void> {
-  try {
-    let ids = clearedIds(await $.store.keys())
-    if (items !== undefined && items.length < INBOX_LIMIT) {
-      const open = new Set(items.map(item => item.id))
-      for (const id of ids.filter(id => !open.has(id))) await $.store.delete(`${CLEARED}${id}`)
-      ids = ids.filter(id => open.has(id))
-    }
-    await update($, cleared, () => ids)
-  } catch {
-    // An unreadable store keeps the ids this session already holds; the counts still show.
-  }
-}
-
-/** Counts only: Room activity and open inbox items, never message bodies. Each half shows even when the other fails. */
-export async function refreshCounts($: EngineInterface): Promise<void> {
-  // Ages are a nicety: a host without a clock shows rows without them.
-  const now = await $.clock.now().catch(() => 0)
-  await update($, nowMs, () => now)
-  const [roomAnswer, inboxAnswer] = await Promise.all([
-    callGateway($, 'work_room_read', { operation: 'activity', limit: 100 }),
-    callGateway($, 'work_inbox', { direction: 'to_me' }),
-  ])
-  if (roomAnswer.ok) await update($, activity, () => parseActivity(findPayload(roomAnswer.payload, v => Array.isArray(v.rooms))) ?? [])
-  const listed = inboxAnswer.ok ? parseInbox(findPayload(inboxAnswer.payload, v => Array.isArray(v.items))) : undefined
-  if (inboxAnswer.ok) await update($, inbox, () => listed ?? [])
-  await syncCleared($, listed)
-  await recount($)
-  if (!roomAnswer.ok) return fail($, roomAnswer)
-  if (!inboxAnswer.ok) return fail($, inboxAnswer)
-  const current = await readOptionsReach($)
-  await update($, status, () => (current === false ? { state: 'stale', detail: STALE } : { state: 'ok', detail: '' }))
-}
-
-/** Hide (stored as cleared): on this Mac only. No Gateway call; the item stays open there and on other Macs. */
-export async function clearItem($: EngineInterface, item: InboxItem): Promise<void> {
-  try {
-    await $.store.set(`${CLEARED}${item.id}`, item.kind)
-  } catch {
-    return fail($, { state: 'error', detail: 'Hide could not be saved on this Mac.' })
-  }
-  await update($, cleared, ids => (ids.includes(item.id) ? ids : [...ids, item.id]))
-  await recount($)
-}
-
-export async function restoreItem($: EngineInterface, id: string): Promise<void> {
-  try {
-    await $.store.delete(`${CLEARED}${id}`)
-  } catch {
-    return fail($, { state: 'error', detail: 'Unhide could not be saved on this Mac.' })
-  }
-  await update($, cleared, ids => ids.filter(other => other !== id))
-  await recount($)
-}
-
-/** Loads a Room the person opened: its threads with unread first, then the newest; per thread the newest 20 messages and every unread one (up to 100). */
-export async function openRoom($: EngineInterface, roomId: string, consent: string): Promise<void> {
-  const shown = await callGateway($, 'work_room_read', { operation: 'show', room_id: roomId }, consent)
-  if (!shown.ok) return fail($, shown)
-  const info = parseRoom(findPayload(shown.payload, v => v.room !== undefined))
-  if (!info) return fail($, { state: 'error', detail: 'The Room is unavailable.' })
-  const rows: ThreadRow[] = []
-  let cursor: number | null = 0
-  for (let page = 0; page < 5 && cursor !== null; page++) {
-    const listed = await callGateway($, 'work_room_read', { operation: 'threads', room_id: roomId, after_sequence: cursor, limit: 100 }, consent)
-    if (!listed.ok) return fail($, listed)
-    const parsed = parseThreads(findPayload(listed.payload, v => Array.isArray(v.threads)), rows.length)
-    if (!parsed) break
-    rows.push(...parsed.rows)
-    cursor = parsed.next
-  }
-  const threads: OpenRoom['threads'] = []
-  for (const row of pickThreads(rows)) {
-    const latest = await callGateway($, 'work_room_read', { operation: 'messages', room_id: roomId, thread_id: row.id, latest: true, limit: 20 }, consent)
-    if (!latest.ok) return fail($, latest)
-    let unread: RoomMessage[] = []
-    if (row.unread > 0) {
-      const page = await callGateway($, 'work_room_read', { operation: 'messages', room_id: roomId, thread_id: row.id, unread_only: true, limit: 100 }, consent)
-      if (!page.ok) return fail($, page)
-      unread = parseMessages(findPayload(page.payload, v => Array.isArray(v.messages))) ?? []
-    }
-    const newest = parseMessages(findPayload(latest.payload, v => Array.isArray(v.messages))) ?? []
-    threads.push({ id: row.id, title: row.title, messages: mergeMessages(newest, unread), unreadIds: unread.map(m => m.id) })
-  }
-  await update($, rooms, all => ({ ...all, [roomId]: { info, threads } }))
-}
-
-/** Closes a Room on this Mac only; opening it again loads its newest messages. */
-async function closeRoom($: EngineInterface, roomId: string): Promise<void> {
-  await update($, rooms, all => {
-    const { [roomId]: _closed, ...rest } = all
-
-    return rest
-  })
-}
-
-/** Reports presented once for messages the pane has drawn that the Gateway does not yet record as presented. */
-export async function reportPresented($: EngineInterface, roomId: string, ids: string[]): Promise<void> {
-  const fresh = ids.filter(id => !presentedSent.has(id)).slice(0, 100)
-  if (fresh.length === 0) return
-  for (const id of fresh) presentedSent.add(id)
-  const name = (await read($, rooms))[roomId]?.info.name ?? 'a Room'
-  // The person's press on Open is what showed these messages, so the receipt carries it as consent.
-  const consent = `The user opened Room ${name} in the Work Room pane, which showed them ${fresh.length} message${fresh.length === 1 ? '' : 's'}.`
-  const sent = await callGateway($, 'work_room_receipt_report', { room_id: roomId, message_ids: fresh, state: 'presented' }, consent)
-  if (!sent.ok) {
-    for (const id of fresh) presentedSent.delete(id)
-    return fail($, sent)
-  }
-  const done = new Set(fresh)
-  await update($, rooms, all => {
-    const room = all[roomId]
-    if (!room) return all
-
-    return { ...all, [roomId]: { ...room, threads: room.threads.map(thread => ({ ...thread, messages: thread.messages.map(m => (done.has(m.id) ? { ...m, presented: true } : m)) })) } }
-  })
-}
-
-/** Writes already confirmed in this run, by write key, so a second press of the same text sends once. */
-const sent = new Set<string>()
-
-const KIND_LABEL: Record<InboxItem['kind'], string> = { request: 'Request', decision: 'Decision', review: 'Review request' }
-const ITEM_HINT = 'Ask Claude sums the request up here and sends nothing. Hide is only on this Mac; it stays open for the person who asked.'
-
-async function stage($: EngineInterface, next: Pending): Promise<void> {
-  await update($, pending, () => next)
-}
-
-async function cancel($: EngineInterface): Promise<void> {
-  await update($, pending, () => null)
-}
-
-/** Moving away from where a write was staged (another tab, a closed card or Room) drops it unsent. */
-async function leave($: EngineInterface, move: () => Promise<unknown>): Promise<void> {
-  await cancel($)
-  await move()
-}
-
-/** Sends the staged write. The person pressed confirm on its summary, which the call carries as consent. */
-async function confirm($: EngineInterface): Promise<void> {
-  const job = await read($, pending)
-  if (!job) return
-  await update($, pending, () => null)
-  const key = writeKey(`${job.kind}:${job.target}`, job.text)
-  if (sent.has(key)) return
-  sent.add(key)
-  const consent = `The user confirmed "${job.summary}" in the Work Room pane.`
-  const [roomId = '', threadId = '', revision = '0', requestId = ''] = job.target.split('|')
-  const answer = job.kind === 'answer'
-    ? await callGateway($, 'work_request_answer', { request_id: job.target, body: job.text }, consent)
-    : job.kind === 'post'
-      ? await callGateway($, 'work_room_write', { operation: 'post', room_id: roomId, thread_id: threadId, body: job.text, membership_revision: Number(revision), idempotency_key: key }, consent)
-      : job.kind === 'answer_share'
-        ? await callGateway($, 'work_room_write', { operation: 'answer_share', room_id: roomId, thread_id: threadId, request_id: requestId, membership_revision: Number(revision), idempotency_key: key }, consent)
-        : await callGateway($, 'work_room_receipt_report', { room_id: roomId, message_ids: job.text.split(',').slice(0, 100), state: 'user_acknowledged', human_confirmed: true }, consent)
-  if (!answer.ok) {
-    sent.delete(key)
-    return fail($, answer)
-  }
-  if (job.kind !== 'answer') await openRoom($, roomId, consent)
-  await refreshCounts($)
-}
-
-export const register: Register = on => {
-  on('session.start', async ($, e, next) => {
-    const started = await next(e)
-    await $.command.register({ name: 'work-room', description: 'Show Work Room shares and requests from colleagues' })
-    $.clock.every(REFRESH_MS, () => {
-      quietly(refreshCounts($))
-    })
-    quietly(refreshCounts($))
-
-    return started
-  })
-
-  on('turn.complete', async ($, e, next) => {
-    if (e.agentId === undefined) quietly(refreshCounts($))
-
-    return next(e)
-  })
-
-  on('command.run', { command: 'work-room' }, async $ => {
-    await $.ui.open({ id: PANE, title: TITLE })
-    quietly(refreshCounts($))
-
-    return { text: 'Work Room pane opened.' }
-  })
-
-  on('ui.render', { component: 'AbovePrompt' }, async ($, e, next) => {
-    const text = bandText(await read($, counts))
-    if (text === null) return next(e)
-    const { Box, Button, Text } = $.ui.resolve(e)
-
-    return (
-      <Box>
-        <Text>{text} </Text>
-        <Button key="work-room-open" label="Open" onPress={() => quietly($.ui.open({ id: PANE, title: TITLE }))} />
-      </Box>
-    )
-  })
-
-  on('ui.render', { component: 'Pane', requestId: PANE }, async ($, e) => {
-    const table = $.ui.resolve(e)
-    const { Box, Button, Text } = table
-    // The mobile app draws no field yet: there the pane reads, shares and marks read, and answers go through Ask Claude.
-    const Input = 'Input' in table ? table.Input : undefined
-    const state = await read($, status)
-    const job = await read($, pending)
-    const asks = await read($, inbox)
-    const hidden = await read($, cleared)
-    const showHidden = await read($, showCleared)
-    const visible = visibleInbox(asks, hidden)
-    const clearedItems = asks.filter(item => hidden.includes(item.id))
-    const rows = await read($, activity)
-    const open = await read($, rooms)
-    const current = await read($, tab)
-    const now = await read($, nowMs)
-    const groups = groupInbox(visible)
-    const chosen = await read($, openGroup)
-    // Nothing chosen opens the newest group; '' is a group the person closed.
-    const openKey = typeof chosen === 'string' ? chosen : groups[0]?.key
-    const unreadTotal = rows.reduce((sum, row) => sum + row.unread, 0)
-    // The confirm row stands under the field or button that staged it; leaving that place drops the staged write.
-    const [jobRoom = '', jobThread = ''] = job && job.kind !== 'answer' ? job.target.split('|') : []
-    const answerOpen = job?.kind === 'answer' && current === 'requests' && groups.some(group => group.key === openKey && group.items[0]?.id === job.target)
-    const roomOpen = job !== null && job.kind !== 'answer' && current === 'rooms' && open[jobRoom] !== undefined
-    const inlinePlace = answerOpen ? `item:${job?.target}` : roomOpen ? (jobThread && job?.kind !== 'acknowledge' ? `thread:${jobThread}` : `room:${jobRoom}`) : null
-    const confirmRow = job && (
-      <Box flexDirection="row" flexWrap="wrap" gap="xs" alignItems="center">
-        <Text color="yellow">{job.summary}</Text>
-        <Box flexDirection="row" gap="xs">
-          <Button key="confirm" variant="primary" label="Confirm" onPress={() => quietly(confirm($))} />
-          <Button key="cancel" label="Cancel" onPress={() => quietly(cancel($))} />
-        </Box>
-      </Box>
-    )
-    const toReport: Array<[string, string[]]> = []
-
-    const view = (
-      <Box flexDirection="column">
-        {state.state !== 'ok' && <Text color="yellow">{state.detail}</Text>}
-        <Box flexDirection="row" gap="xs" marginBottom={1}>
-          <Button key="tab-requests" variant={current === 'requests' ? 'primary' : 'secondary'} label={`Requests · ${groups.length}`} onPress={() => quietly(leave($, () => update($, tab, () => 'requests')))} />
-          <Button key="tab-rooms" variant={current === 'rooms' ? 'primary' : 'secondary'} label={`Rooms · ${unreadTotal} unread`} onPress={() => quietly(leave($, () => update($, tab, () => 'rooms')))} />
-        </Box>
-        {current === 'requests' && (
-          <Box flexDirection="column" gap="xs">
-            {groups.length === 0 && <Text dimColor>No requests waiting for you.</Text>}
-            {groups.map(group => {
-              const item = group.items[0]!
-              const isOpen = group.key === openKey
-
-              return (
-                <Box flexDirection="column" gap="xs" borderStyle="round" borderColor={isOpen ? 'suggestion' : 'promptBorder'} paddingX={1}>
-                  <Button key={`item-${item.id}`} onPress={() => quietly(leave($, () => update($, openGroup, () => (isOpen ? '' : group.key))))}>
-                    <Text bold={isOpen} wrap={isOpen ? 'wrap' : 'truncate'}>{isOpen ? '▼ ' : '► '}{group.title}</Text>
-                  </Button>
-                  <Box paddingLeft={2}>
-                    <Text dimColor size="footnote" wrap="truncate">{detailLine(item, group.items.length - 1, now)}</Text>
-                  </Box>
-                  {isOpen && item.kind === 'request' && Input && (
-                    <Box flexDirection="column" paddingLeft={2} width="100%" flexGrow={1}>
-                      <Input
-                        key={`answer-${item.id}`}
-                        placeholder="Answer this request"
-                        rows={3}
-                        submitLabel="Send"
-                        onSubmit={(text: string) => quietly(stage($, { kind: 'answer', target: item.id, text, summary: `Answer goes to ${item.askedBy} only.` }))}
-                      />
-                    </Box>
-                  )}
-                  {inlinePlace === `item:${item.id}` && <Box paddingLeft={2}>{confirmRow}</Box>}
-                  {isOpen && (
-                    <Box flexDirection="row" gap="xs" paddingLeft={2}>
-                      <Button key={`chat-${item.id}`} label="Ask Claude" onPress={() => quietly($.prompt.submit({ text: chatPrompt(item) }))} />
-                      <Button key={`hide-${item.id}`} label="Hide" onPress={() => quietly(Promise.all(group.items.map(each => clearItem($, each))))} />
-                    </Box>
-                  )}
-                  {isOpen && (
-                    <Box paddingLeft={2}>
-                      <Text dimColor size="footnote">{ITEM_HINT}</Text>
-                    </Box>
-                  )}
-                </Box>
-              )
-            })}
-            {clearedItems.length > 0 && (
-              <Box flexDirection="row" gap="xs" alignItems="center" marginTop={1}>
-                <Text dimColor>Hidden ({clearedItems.length})</Text>
-                <Button key="show-hidden" label={showHidden ? 'Close' : 'Show'} onPress={() => quietly(update($, showCleared, shown => !shown))} />
-              </Box>
-            )}
-            {showHidden && clearedItems.map(item => (
-              <Box flexDirection="row" gap="xs" alignItems="center">
-                <Text dimColor>{KIND_LABEL[item.kind]} from {item.askedBy}: {item.title}</Text>
-                <Button key={`unhide-${item.id}`} label="Unhide" onPress={() => quietly(restoreItem($, item.id))} />
-              </Box>
-            ))}
-          </Box>
-        )}
-        {current === 'rooms' && (
-        <Box flexDirection="column" gap="xs">
-          {rows.length === 0 && <Text dimColor>No Rooms.</Text>}
-          {rows.map(row => {
-            const room = open[row.roomId]
-            if (room) toReport.push([row.roomId, room.threads.flatMap(thread => thread.messages.filter(m => !m.presented).map(m => m.id))])
-
-            return (
-              <Box flexDirection="column" gap="xs" borderStyle="round" borderColor={room ? 'suggestion' : 'promptBorder'} paddingX={1}>
-                <Box flexDirection="row" justifyContent="space-between" alignItems="center" gap="xs">
-                  <Button
-                    key={`open-${row.roomId}`}
-                    onPress={() => quietly(room ? leave($, () => closeRoom($, row.roomId)) : openRoom($, row.roomId, `The user pressed Open on Room ${row.name} in the Work Room pane.`))}
-                  >
-                    <Text bold={room !== undefined}>{room ? '▼ ' : '► '}{row.name} · {row.unread} unread</Text>
-                  </Button>
-                  <Box flexDirection="row" gap="xs">
-                    {room && markable(room.threads).length > 0 && (
-                      <Button
-                        key={`ack-room-${row.roomId}`}
-                        label="Mark read"
-                        onPress={() => {
-                          const ids = markable(room.threads)
-                          quietly(stage($, { kind: 'acknowledge', target: `${row.roomId}|`, text: ids.join(','), summary: `Mark ${ids.length} message${ids.length === 1 ? '' : 's'} read?` }))
-                        }}
-                      />
-                    )}
-                  </Box>
-                </Box>
-                {inlinePlace === `room:${row.roomId}` && confirmRow}
-                {room?.threads.map(thread => (
-                  <Box flexDirection="column" gap="xs" paddingLeft={2}>
-                    <Box flexDirection="row" justifyContent="space-between" alignItems="center" gap="xs">
-                      <Text bold dimColor># {thread.title}</Text>
-                      {room.threads.length > 1 && markable([thread]).length > 0 && (
-                        <Button
-                          key={`ack-${thread.id}`}
-                          label="Mark read"
-                          onPress={() => {
-                            const ids = markable([thread])
-                            quietly(stage($, { kind: 'acknowledge', target: `${row.roomId}|${thread.id}`, text: ids.join(','), summary: `Mark ${ids.length} message${ids.length === 1 ? '' : 's'} read?` }))
-                          }}
-                        />
-                      )}
-                    </Box>
-                    <Box flexDirection="column" gap="xs" paddingLeft={2}>
-                      {thread.messages.map(m => (
-                        <Box flexDirection="column">
-                          <Text><Text bold>{authorName(room.info, m.author)}</Text>: {m.body}</Text>
-                          {m.requestId !== undefined && (
-                            <Button
-                              key={`share-${m.id}`}
-                              label="Share answer to Room"
-                              onPress={() => quietly(stage($, { kind: 'answer_share', target: `${row.roomId}|${thread.id}|${room.info.membershipRevision}|${m.requestId}`, text: m.requestId ?? '', summary: `Shares your answer to ${room.info.name} for ${room.info.memberCount} members.` }))}
-                            />
-                          )}
-                        </Box>
-                      ))}
-                      {Input && (
-                        <Input
-                          key={`post-${thread.id}`}
-                          placeholder="Reply in this thread"
-                          rows={2}
-                          submitLabel="Send"
-                          onSubmit={(text: string) => quietly(stage($, { kind: 'post', target: `${row.roomId}|${thread.id}|${room.info.membershipRevision}`, text, summary: `Posts to ${room.info.name} for ${room.info.memberCount} members.` }))}
-                        />
-                      )}
-                      {inlinePlace === `thread:${thread.id}` && confirmRow}
-                    </Box>
-                  </Box>
-                ))}
-              </Box>
-            )
-          })}
-        </Box>
-        )}
-      </Box>
-    )
-    for (const [roomId, ids] of toReport) quietly(reportPresented($, roomId, ids))
-
-    return view
-  })
-}

package/claude-mod/tsconfig.json

@@ -1,3 +0,0 @@
-{
-  "extends": "./.claude-plugin/types/tsconfig.json"
-}

package/claude-mod/types/index.d.ts

@@ -1,28 +0,0 @@
-export type RoomActivity = { roomId: string; name: string; unread: number; latest: number }
-export type InboxItem = { kind: 'request' | 'decision' | 'review'; id: string; workItemId: string; askedBy: string; title: string; status: string; changedAt: number }
-export type RoomMessage = { id: string; threadId: string; sequence: number; author: string; kind: string; body: string; createdAt: number; presented: boolean; acknowledged: boolean; requestId?: string }
-export type RoomInfo = { id: string; name: string; membershipRevision: number; memberCount: number; names: Record<string, string> }
-export type ThreadRow = { id: string; title: string; unread: number; latest: number; order: number }
-export type RoomThread = { id: string; title: string; messages: RoomMessage[]; unreadIds: string[] }
-export type OpenRoom = { info: RoomInfo; threads: RoomThread[] }
-export type Pending = { kind: 'answer' | 'post' | 'answer_share' | 'acknowledge'; target: string; text: string; summary: string } | null
-export type Status = { state: 'ok' | 'no-connector' | 'refused' | 'error' | 'loading' | 'stale'; detail: string }
-export type Counts = { shares: number; requests: number }
-
-declare module 'claude-code' {
-  interface PluginState {
-    'ai-gateway-work-room': {
-      counts: Counts
-      activity: RoomActivity[]
-      inbox: InboxItem[]
-      rooms: Record<string, OpenRoom>
-      pending: Pending
-      status: Status
-      cleared: string[]
-      showCleared: boolean
-      tab: 'requests' | 'rooms'
-      openGroup: string | null
-      nowMs: number
-    }
-  }
-}