mtech-ai-local-runner 0.1.82 → 0.1.85

package/README.md

@@ -291,12 +291,23 @@ reports `CODEX_HOOKS_JSON_INVALID`. `uninstall` removes both integrations, the s
 
 The Claude integration also installs the Work Room pane, the mod `ai-gateway-work-room@mtec-ai-gateway` (Work Item
 98da2635). A band above the prompt says how many Room shares and requests are waiting. Its button, or `/work-room`,
-opens a pane beside the conversation. The pane lists what waits for you and the Rooms you are in, and it opens Room
-threads. From the pane you can answer a request, reply in a thread, share an answer to a Room or mark messages read.
-Each of these is sent only after a confirm row that names who will see it. The pane calls the AI Gateway only through
-your own AI Gateway connector in Claude, and it never starts a model turn: its Open in chat button puts only ids in the
-conversation. Without the connector the pane says so. The Claude mobile app draws no input field, so there the pane
-reads, shares and marks read only.
+opens a pane beside the conversation. "Requests for me" shows each request, decision and review in its own box, with
+who asked first. "Rooms" shows each Room in its own box, with its threads and messages indented under it. From the
+pane you can answer a request, reply in a thread, share an answer to a Room or mark messages read. Each of these
+starts with Send (or the button that names it), then a confirm row that names who will see it, then Claude's
+permission dialog. Opening a Room shows its threads with unread messages first and every unread message in them, and
+Mark all read marks up to 100 of them at once.
+
+Ask Claude puts only ids and tool names in the conversation and asks Claude to read the full request and sum it up
+in one line; nothing is sent, and it is the only button that starts a model turn. Hide hides a request, decision or
+review on this Mac only, with no Gateway call: it stays open for the person who asked and on your other devices.
+"Hidden (N)" with Show lists them again, each with Unhide. The pane calls the AI Gateway only through your own AI
+Gateway connector in Claude; without the connector the pane says so. The Claude mobile app draws no input field, so
+there the pane reads, shares, marks read and offers Ask Claude.
+
+After a Gateway change to a tool's arguments, refresh the AI Gateway tools list in Claude (Settings, Connectors, AI
+Gateway) and start a new session: a session drops arguments its tools list does not declare. The pane says so when
+its Room reads lose their arguments.
 
 The pane calls the connector with no model turn, so a Claude session in auto mode would refuse every one of those
 calls. The mod therefore ships PreToolUse hooks that match any AI Gateway connector and apply to every caller in the

package/claude-mod/.claude-plugin/plugin.json

@@ -1 +1 @@
-{ "name": "ai-gateway-work-room", "version": "1.2.0", "description": "Work Room shares and requests from colleagues beside the conversation, installed by mtech-ai-local-runner (Work Item 98da2635).", "types": "./types/index.d.ts" }
+{ "name": "ai-gateway-work-room", "version": "1.4.0", "description": "Work Room shares and requests from colleagues beside the conversation, installed by mtech-ai-local-runner (Work Item 98da2635).", "types": "./types/index.d.ts" }

package/claude-mod/hooks/model.ts

@@ -1,4 +1,4 @@
-import type { Counts, InboxItem, RoomActivity, RoomInfo, RoomMessage } from '../types'
+import type { Counts, InboxItem, RoomActivity, RoomInfo, RoomMessage, RoomThread, ThreadRow } from '../types'
 
 /*
  * Pure helpers for the Work Room pane (Work Item 98da2635): they read Gateway tool results and build the text the
@@ -82,6 +82,20 @@ export function parseInbox(payload: Record<string, unknown> | undefined): InboxI
     .slice(0, 50)
 }
 
+/** `$.store` key prefix for a request, decision or review the person cleared on this Mac. */
+export const CLEARED = 'cleared:'
+
+/** The inbox's own page size: a shorter list is the whole inbox. */
+export const INBOX_LIMIT = 50
+
+export const clearedIds = (keys: string[]): string[] => keys.filter(key => key.startsWith(CLEARED)).map(key => key.slice(CLEARED.length))
+
+export const visibleInbox = (items: InboxItem[], cleared: string[]): InboxItem[] => {
+  const hidden = new Set(cleared)
+
+  return items.filter(item => !hidden.has(item.id))
+}
+
 export function parseMessages(payload: Record<string, unknown> | undefined): RoomMessage[] | undefined {
   if (!payload || !Array.isArray(payload.messages)) return undefined
 
@@ -107,6 +121,45 @@ export function parseMessages(payload: Record<string, unknown> | undefined): Roo
     })
 }
 
+/** One page of `threads`; `offset` numbers the rows so later pages sort after earlier ones. */
+export function parseThreads(payload: Record<string, unknown> | undefined, offset: number): { rows: ThreadRow[]; next: number | null } | undefined {
+  if (!payload || !Array.isArray(payload.threads)) return undefined
+  const rows = payload.threads
+    .map(record)
+    .filter((row): row is Record<string, unknown> => row !== undefined && typeof row.id === 'string')
+    .map((row, index) => ({ id: clean(row.id, 64), title: clean(row.title, 120), unread: num(row.unread_count), latest: num(row.latest_message_sequence), order: offset + index }))
+
+  return { rows, next: typeof payload.next_cursor === 'number' ? payload.next_cursor : null }
+}
+
+const newestFirst = (a: ThreadRow, b: ThreadRow): number => b.latest - a.latest || b.order - a.order
+
+/** Every thread with unread (at most 20), newest first, then the newest others until 10 threads are shown. */
+export function pickThreads(rows: ThreadRow[]): ThreadRow[] {
+  const unread = rows.filter(row => row.unread > 0).sort(newestFirst).slice(0, 20)
+  const rest = rows.filter(row => row.unread === 0).sort(newestFirst).slice(0, Math.max(0, 10 - unread.length))
+
+  return [...unread, ...rest]
+}
+
+export function mergeMessages(a: RoomMessage[], b: RoomMessage[]): RoomMessage[] {
+  const byId = new Map<string, RoomMessage>()
+  for (const message of [...a, ...b]) byId.set(message.id, message)
+
+  return [...byId.values()].sort((x, y) => x.sequence - y.sequence)
+}
+
+/** Unread ids the Gateway already records as presented, in display order, at most 100 (one receipt call). */
+export function markable(threads: RoomThread[]): string[] {
+  return threads
+    .flatMap(thread => {
+      const unread = new Set(thread.unreadIds)
+
+      return thread.messages.filter(m => unread.has(m.id) && m.presented && !m.acknowledged).map(m => m.id)
+    })
+    .slice(0, 100)
+}
+
 export function parseRoom(payload: Record<string, unknown> | undefined): RoomInfo | undefined {
   const room = record(payload?.room)
   if (!room || typeof room.id !== 'string') return undefined

package/claude-mod/hooks/register.tsx

@@ -1,9 +1,9 @@
 import { atom, read, update } from 'claude-code'
 import type { EngineInterface, Register } from 'claude-code'
 
-import type { Counts, InboxItem, OpenRoom, Pending, RoomActivity, Status } from '../types'
+import type { Counts, InboxItem, OpenRoom, Pending, RoomActivity, RoomMessage, Status, ThreadRow } from '../types'
 import { callGateway } from './gateway'
-import { bandText, chatPrompt, findPayload, parseActivity, parseInbox, parseMessages, parseRoom, writeKey } from './model'
+import { CLEARED, INBOX_LIMIT, bandText, chatPrompt, clearedIds, findPayload, 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
@@ -21,6 +21,10 @@ 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[])
@@ -28,6 +32,24 @@ const inbox = atom({ plugin: 'ai-gateway-work-room', key: 'inbox' } as const, []
 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)
+
+/** 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>()
@@ -41,6 +63,28 @@ async function fail($: EngineInterface, answer: { state: Status['state']; detail
   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> {
   const [roomAnswer, inboxAnswer] = await Promise.all([
@@ -48,31 +92,65 @@ export async function refreshCounts($: EngineInterface): Promise<void> {
     callGateway($, 'work_inbox', { direction: 'to_me' }),
   ])
   if (roomAnswer.ok) await update($, activity, () => parseActivity(findPayload(roomAnswer.payload, v => Array.isArray(v.rooms))) ?? [])
-  if (inboxAnswer.ok) await update($, inbox, () => parseInbox(findPayload(inboxAnswer.payload, v => Array.isArray(v.items))) ?? [])
-  const rows = await read($, activity)
-  const items = await read($, inbox)
-  await update($, counts, () => ({ shares: rows.reduce((sum, row) => sum + row.unread, 0), requests: items.length }))
+  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)
-  await update($, status, () => ({ state: 'ok', detail: '' }))
+  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 info, up to 10 threads and the latest 20 messages of each. */
+/** 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 listed = await callGateway($, 'work_room_read', { operation: 'threads', room_id: roomId, limit: 20 }, consent)
-  if (!listed.ok) return fail($, listed)
-  const threadRows = (findPayload(listed.payload, v => Array.isArray(v.threads))?.threads ?? []) as Array<Record<string, unknown>>
+  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 threadRows.slice(0, 10)) {
-    const id = String(row.id ?? '')
-    const latest = await callGateway($, 'work_room_read', { operation: 'messages', room_id: roomId, thread_id: id, limit: 20 }, consent)
+  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)
-    const messages = parseMessages(findPayload(latest.payload, v => Array.isArray(v.messages))) ?? []
-    threads.push({ id, title: String(row.title ?? '').slice(0, 120), messages })
+    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 } }))
 }
@@ -102,7 +180,9 @@ export async function reportPresented($: EngineInterface, roomId: string, ids: s
 /** 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 CONFIRM_LABEL: Record<NonNullable<Pending>['kind'], string> = { answer: 'Send', post: 'Post', answer_share: 'Share', acknowledge: 'Mark read' }
+const KIND_LABEL: Record<InboxItem['kind'], string> = { request: 'Request', decision: 'Decision', review: 'Review request' }
+const ASK_CLAUDE_HINT = 'Ask Claude: Claude reads the full request here and sums it up. Nothing is sent.'
+const HIDE_HINT = 'Hide: only on this Mac; it stays open for the person who asked.'
 
 async function stage($: EngineInterface, next: Pending): Promise<void> {
   await update($, pending, () => next)
@@ -178,11 +258,15 @@ export const register: Register = on => {
   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 Open in chat.
+    // 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 toReport: Array<[string, string[]]> = []
@@ -193,82 +277,120 @@ export const register: Register = on => {
         {job && (
           <Box>
             <Text color="yellow">{job.summary} </Text>
-            <Button key="confirm" label={CONFIRM_LABEL[job.kind]} onPress={() => quietly(confirm($))} />
+            <Button key="confirm" label="Confirm" onPress={() => quietly(confirm($))} />
             <Button key="cancel" label="Cancel" onPress={() => quietly(cancel($))} />
           </Box>
         )}
-        <Text bold>Requests for me</Text>
-        {asks.length === 0 && <Text dimColor>None.</Text>}
-        {asks.map(item => (
-          <Box flexDirection="column">
-            <Text>[{item.kind}] {item.title} — {item.askedBy}</Text>
-            {item.kind === 'request' && Input && (
-              <Input
-                key={`answer-${item.id}`}
-                placeholder="Answer this request"
-                rows={3}
-                submitLabel="review"
-                onSubmit={(text: string) => quietly(stage($, { kind: 'answer', target: item.id, text, summary: `Answer goes to ${item.askedBy} only.` }))}
-              />
-            )}
-            <Button key={`chat-${item.id}`} label="Open in chat" onPress={() => quietly($.prompt.submit({ text: chatPrompt(item) }))} />
-          </Box>
-        ))}
-        <Text bold>Room shares</Text>
-        {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">
-              <Box>
-                <Text>{row.name} ({row.unread} unread) </Text>
-                <Button
-                  key={`open-${row.roomId}`}
-                  label={room ? 'Refresh' : 'Open'}
-                  onPress={() => quietly(openRoom($, row.roomId, `The user pressed Open on Room ${row.name} in the Work Room pane.`))}
+        <Box flexDirection="column" gap="xs">
+          <Text bold>Requests for me ({visible.length})</Text>
+          {visible.length === 0 && <Text dimColor>None.</Text>}
+          {visible.map(item => (
+            <Box flexDirection="column" gap="xs" borderStyle="round" borderDimColor paddingX={1}>
+              <Text dimColor>{KIND_LABEL[item.kind]} from {item.askedBy}</Text>
+              <Text>{item.title}</Text>
+              {item.kind === 'request' && Input && (
+                <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 flexDirection="row" gap="xs">
+                <Button key={`chat-${item.id}`} label="Ask Claude" onPress={() => quietly($.prompt.submit({ text: chatPrompt(item) }))} />
+                <Button key={`hide-${item.id}`} label="Hide" onPress={() => quietly(clearItem($, item))} />
               </Box>
-              {room?.threads.map(thread => (
-                <Box flexDirection="column">
-                  <Text dimColor># {thread.title}</Text>
-                  {thread.messages.map(m => (
-                    <Box flexDirection="column">
-                      <Text>{m.author}: {m.body}</Text>
-                      {m.requestId !== undefined && (
+            </Box>
+          ))}
+          {visible.length > 0 && <Text dimColor>{ASK_CLAUDE_HINT}</Text>}
+          {visible.length > 0 && <Text dimColor>{HIDE_HINT}</Text>}
+          {clearedItems.length > 0 && (
+            <Box flexDirection="row" gap="xs" alignItems="center">
+              <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>
+        <Box flexDirection="column" gap="xs" marginTop={1}>
+          <Text bold>Rooms</Text>
+          {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" borderDimColor paddingX={1}>
+                <Box flexDirection="row" justifyContent="space-between" alignItems="center" gap="xs">
+                  <Text>{row.name} · {row.unread} unread</Text>
+                  <Box flexDirection="row" gap="xs">
+                    <Button
+                      key={`open-${row.roomId}`}
+                      label={room ? 'Refresh' : 'Open'}
+                      onPress={() => quietly(openRoom($, row.roomId, `The user pressed Open on Room ${row.name} in the Work Room pane.`))}
+                    />
+                    {room && markable(room.threads).length > 0 && (
+                      <Button
+                        key={`ack-room-${row.roomId}`}
+                        label="Mark all 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>
+                {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>
+                      {markable([thread]).length > 0 && (
                         <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.` }))}
+                          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>
-                  ))}
-                  {thread.messages.some(m => !m.acknowledged) && (
-                    <Button
-                      key={`ack-${thread.id}`}
-                      label="Mark read"
-                      onPress={() => {
-                        const ids = thread.messages.filter(m => !m.acknowledged).map(m => m.id)
-                        quietly(stage($, { kind: 'acknowledge', target: `${row.roomId}|${thread.id}`, text: ids.join(','), summary: `Mark ${ids.length} message${ids.length === 1 ? '' : 's'} read?` }))
-                      }}
-                    />
-                  )}
-                  {Input && (
-                    <Input
-                      key={`post-${thread.id}`}
-                      placeholder="Reply in this thread"
-                      rows={2}
-                      submitLabel="review"
-                      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.` }))}
-                    />
-                  )}
-                </Box>
-              ))}
-            </Box>
-          )
-        })}
+                    <Box flexDirection="column" gap="xs" paddingLeft={2}>
+                      {thread.messages.map(m => (
+                        <Box flexDirection="column">
+                          <Text>{m.author}: {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.` }))}
+                        />
+                      )}
+                    </Box>
+                  </Box>
+                ))}
+              </Box>
+            )
+          })}
+        </Box>
       </Box>
     )
     for (const [roomId, ids] of toReport) quietly(reportPresented($, roomId, ids))

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

@@ -2,10 +2,11 @@ export type RoomActivity = { roomId: string; name: string; unread: number; lates
 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 }
-export type RoomThread = { id: string; title: string; messages: RoomMessage[] }
+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'; detail: string }
+export type Status = { state: 'ok' | 'no-connector' | 'refused' | 'error' | 'loading' | 'stale'; detail: string }
 export type Counts = { shares: number; requests: number }
 
 declare module 'claude-code' {
@@ -17,6 +18,8 @@ declare module 'claude-code' {
       rooms: Record<string, OpenRoom>
       pending: Pending
       status: Status
+      cleared: string[]
+      showCleared: boolean
     }
   }
 }

package/dist/src/publication/git-snapshot.js

@@ -9,7 +9,8 @@ import { protocolHash } from './candidate.js';
 import { deflateObject, RawGitObjects } from './raw-git-objects.js';
 const execute = promisify(execFile), denied = () => Error('SNAPSHOT_REJECTED');
 const digest = (data) => createHash('sha256').update(data).digest('hex');
-const safe = (p) => p.length > 0 && !path.isAbsolute(p) && !p.includes('\\') && !p.includes('\0') && p.split('/').every(s => s !== '' && s !== '.' && s !== '..' && !/^(?:\.git|\.ssh|\.aws|\.codex|\.claude|\.env|\.netrc|\.npmrc|credentials(?:\..*)?)$/i.test(s));
+const structural = (p) => p.length > 0 && !path.isAbsolute(p) && !p.includes('\\') && !p.includes('\0') && p.split('/').every(s => s !== '' && s !== '.' && s !== '..' && !/^\.git$/i.test(s));
+const safe = (p) => structural(p) && p.split('/').every(s => !/^(?:\.ssh|\.aws|\.codex|\.claude|\.env|\.netrc|\.npmrc|credentials(?:\..*)?)$/i.test(s));
 /** P1 branch shape only. Authority still requires exact frozen-fence equality. */
 /** Whole-checkout memory bound for a snapshot, per file and in total. A snapshot reads every
  * file of the checkout, so callers bound candidate size on the changed files instead. */
@@ -89,8 +90,8 @@ export class GitSnapshotHost {
             throw denied();
         return result;
     }
-    async currentFile(relative) {
-        if (!safe(relative))
+    async currentFile(relative, protectedBase = false) {
+        if (!(protectedBase ? structural(relative) : safe(relative)))
             throw denied();
         const absolute = path.join(this.options.root, relative);
         let component = this.options.root;
@@ -148,7 +149,7 @@ export class GitSnapshotHost {
         const o = this.options;
         await this.head();
         const head = o.baseCommitSha, branch = o.workingBranch;
-        const base = new Map(), gitlinks = new Map(), baseListing = await this.git(['ls-tree', '-r', '-z', '--full-tree', o.baseCommitSha]);
+        const base = new Map(), gitlinks = new Map(), protectedNames = new Set(), baseListing = await this.git(['ls-tree', '-r', '-z', '--full-tree', o.baseCommitSha]);
         for (const line of baseListing.toString().split('\0').filter(Boolean)) {
             const link = /^160000 commit ([a-f0-9]{40})\t(.+)$/s.exec(line);
             if (link) {
@@ -158,16 +159,19 @@ export class GitSnapshotHost {
                 continue;
             }
             const match = /^(100644|100755) blob ([a-f0-9]{40})\t(.+)$/s.exec(line);
-            if (!match || !safe(match[3]))
+            if (!match || !structural(match[3]))
                 throw denied();
             base.set(match[3], { mode: parseInt(match[1], 8), blob: match[2] });
+            if (!safe(match[3]))
+                protectedNames.add(match[3]);
         }
+        // Protected names the base commit already tracks stay as exact base content; only a change to one is refused.
         // Gitlinks remain exact base-tree references. Never traverse or copy their source.
         // Staged replacement/deletion is refused rather than publishing hidden changes.
         const staged = new Map(), stagedListing = await this.git(['ls-files', '--stage', '-z']);
         for (const line of stagedListing.toString().split('\0').filter(Boolean)) {
             const entry = /^(100644|100755|160000) ([a-f0-9]{40}) 0\t(.+)$/s.exec(line);
-            if (!entry || !safe(entry[3]))
+            if (!entry || !structural(entry[3]))
                 throw denied();
             staged.set(entry[3], entry[1] + ' ' + entry[2]);
         }
@@ -184,7 +188,7 @@ export class GitSnapshotHost {
         for (const name of names) {
             if ([...gitlinks.keys()].some(p => name === p || name.startsWith(p + '/') || p.startsWith(name + '/')))
                 throw denied();
-            const current = await this.currentFile(name), prior = base.get(name);
+            const current = await this.currentFile(name, protectedNames.has(name)), prior = base.get(name);
             let before = null;
             if (prior) {
                 const blob = blobs.get(prior.blob);
@@ -199,11 +203,14 @@ export class GitSnapshotHost {
                 throw denied();
             if (current)
                 files.push(current);
-            if (!prior || !current || !before.equals(current.bytes) || prior.mode !== current.mode)
+            const changed = !prior || !current || !before.equals(current.bytes) || prior.mode !== current.mode;
+            if (changed && protectedNames.has(name))
+                throw denied();
+            if (changed)
                 changes.push({ path: name, status: !prior ? 'added' : !current ? 'deleted' : 'modified', before: before?.toString('base64') ?? null, after: current?.bytes.toString('base64') ?? null, before_mode: prior?.mode ?? null, after_mode: current?.mode ?? null });
         }
         const observation = { base_commit_sha: o.baseCommitSha, head_commit_sha: head, working_branch: branch, diff: JSON.stringify({ format: 'local-candidate-binary-diff-v1', changes }), changed_files: changes.map(({ path, status }) => ({ path, status })) };
-        const listing = { base: digest(baseListing), staged: digest(stagedListing), untracked: digest(untrackedListing), names };
+        const listing = { base: digest(baseListing), staged: digest(stagedListing), untracked: digest(untrackedListing), names, protectedNames };
         return { observation, files, listing, fingerprint: protocolHash({ observation, files: files.map(f => ({ path: f.path, mode: f.mode, sha256: digest(f.bytes) })) }) };
     }
     /** The checkout still equals a capture when HEAD, the branch, the three Git listings and every
@@ -217,7 +224,7 @@ export class GitSnapshotHost {
         const files = [];
         let total = 0;
         for (const name of listing.names) {
-            const current = await this.currentFile(name);
+            const current = await this.currentFile(name, listing.protectedNames.has(name));
             if (!current)
                 continue;
             total += current.bytes.length;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mtech-ai-local-runner",
-  "version": "0.1.82",
+  "version": "0.1.85",
   "private": false,
   "license": "UNLICENSED",
   "bin": {