mtech-ai-local-runner 0.1.81 → 0.1.84

package/README.md

@@ -293,6 +293,12 @@ The Claude integration also installs the Work Room pane, the mod `ai-gateway-wor
 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.
+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. Clear hides a request, decision or review on this Mac only, with no Gateway call; Show
+under "Cleared" lists them again with Restore.
+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.
 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

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.3.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: '' }))
 }
 
-/** Loads a Room the person opened: its info, up to 10 threads and the latest 20 messages of each. */
+/** Clear: hides the item 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: 'Clear 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: 'Restore 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 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 } }))
 }
@@ -183,6 +261,10 @@ export const register: Register = on => {
     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[]]> = []
@@ -198,8 +280,8 @@ export const register: Register = on => {
           </Box>
         )}
         <Text bold>Requests for me</Text>
-        {asks.length === 0 && <Text dimColor>None.</Text>}
-        {asks.map(item => (
+        {visible.length === 0 && <Text dimColor>None.</Text>}
+        {visible.map(item => (
           <Box flexDirection="column">
             <Text>[{item.kind}] {item.title} — {item.askedBy}</Text>
             {item.kind === 'request' && Input && (
@@ -212,6 +294,19 @@ export const register: Register = on => {
               />
             )}
             <Button key={`chat-${item.id}`} label="Open in chat" onPress={() => quietly($.prompt.submit({ text: chatPrompt(item) }))} />
+            <Button key={`clear-${item.id}`} label="Clear" onPress={() => quietly(clearItem($, item))} />
+          </Box>
+        ))}
+        {clearedItems.length > 0 && (
+          <Box>
+            <Text dimColor>Cleared ({clearedItems.length}) </Text>
+            <Button key="show-cleared" label={showHidden ? 'Hide' : 'Show'} onPress={() => quietly(update($, showCleared, shown => !shown))} />
+          </Box>
+        )}
+        {showHidden && clearedItems.map(item => (
+          <Box>
+            <Text dimColor>[{item.kind}] {item.title} — {item.askedBy} </Text>
+            <Button key={`restore-${item.id}`} label="Restore" onPress={() => quietly(restoreItem($, item.id))} />
           </Box>
         ))}
         <Text bold>Room shares</Text>
@@ -230,6 +325,16 @@ export const register: Register = on => {
                   onPress={() => quietly(openRoom($, row.roomId, `The user pressed Open on Room ${row.name} in the Work Room pane.`))}
                 />
               </Box>
+              {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?` }))
+                  }}
+                />
+              )}
               {room?.threads.map(thread => (
                 <Box flexDirection="column">
                   <Text dimColor># {thread.title}</Text>
@@ -245,12 +350,12 @@ export const register: Register = on => {
                       )}
                     </Box>
                   ))}
-                  {thread.messages.some(m => !m.acknowledged) && (
+                  {markable([thread]).length > 0 && (
                     <Button
                       key={`ack-${thread.id}`}
                       label="Mark read"
                       onPress={() => {
-                        const ids = thread.messages.filter(m => !m.acknowledged).map(m => m.id)
+                        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?` }))
                       }}
                     />

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/asks/messenger.js

@@ -1,9 +1,8 @@
-import { createHash } from "node:crypto";
 import { join } from "node:path";
 import { McpGatewayClient } from "../gateway-client.js";
 import { Daemon } from "../daemon/daemon.js";
 import { ProcessLock } from "../daemon/process-lock.js";
-import { runnerDisplayName } from "../daemon/runtime.js";
+import { runnerDeviceFingerprint, runnerDisplayName } from "../daemon/runtime.js";
 import { SessionOpener, sessionOpenAdvertisement } from "../daemon/session-opener.js";
 import { RunnerTransport } from "../transport/runner-transport.js";
 import { ReverbSocket } from "../transport/reverb-socket.js";
@@ -108,7 +107,7 @@ export async function buildMessengerDaemon(input) {
         const askInbox = await asks.advertisement();
         const guidance = await guide.advertisement();
         await gateway.heartbeatLocalRunner({
-            deviceFingerprint: createHash("sha256").update(`${process.getuid?.() ?? 0}|${runnerDisplayName()}|${input.gatewayMcpUrl}`).digest("hex"),
+            deviceFingerprint: runnerDeviceFingerprint(input.gatewayMcpUrl),
             displayName: runnerDisplayName(), packageVersion: packageVersion(), capabilities: [], mode: "messenger",
             // Without an integration, session_open still goes out (clients only): the Gateway keeps the last one it stored, and would keep long-polling for asks.
             ...(sessionOpen ? { sessionOpen: { ...sessionOpen, ...(askInbox ? { ask_inbox: askInbox } : {}) } } : {}),

package/dist/src/cli.js

@@ -25,8 +25,10 @@ import { createBrowserOpener } from "./auth/browser-opener.js";
 import { FileLocalConfigStore, runnerMode } from "./registration/local-config.js";
 import { LaunchdService } from "./platform/macos/launchd.js";
 import { installStableRelease } from "./platform/macos/stable-release.js";
-import { buildDaemon, runnerDisplayName } from "./daemon/runtime.js";
-import { createHash } from "node:crypto";
+import { packageVersion } from "./package-version.js";
+import { reportRefusal } from "./registration/refusal-report.js";
+import { selfChecksReport } from "./safety/self-checks.js";
+import { buildDaemon, runnerDeviceFingerprint, runnerDisplayName } from "./daemon/runtime.js";
 import { discoverEmployeeAdapters, hasUsableAdapter, adapterDiagnosticsWithRemedies } from "./adapters/discovery.js";
 import { verifyPackagedHook } from "./safety/hook-command.js";
 import { access, mkdir, rm } from "node:fs/promises";
@@ -259,6 +261,8 @@ export async function main(argv, env, io = {}) {
                     const hook = await hookSelfTest(config.workspaceRoot);
                     if (!hook.enforcing) {
                         stdout(JSON.stringify({ ok: false, configured: false, hook: hookReport(hook), action: hookAction(hook) }));
+                        await reportRefusal({ stateRoot: config.stateRoot, env, fetchFn, report: selfChecksReport({ source: "setup", packageVersion: packageVersion(),
+                                checkedAt: Math.floor(Date.now() / 1000), tools: null, hook, refusalCode: "hook_not_enforcing" }) });
                         throw new Error(`The PreToolUse hook did not deny the probe call (hook_not_enforcing: ${hook.reason})`);
                     }
                     // A full runner whose job file tools cannot read here would take jobs and stop executor_blocked on every one
@@ -268,6 +272,8 @@ export async function main(argv, env, io = {}) {
                     if (tools.status !== "passed") {
                         const report = localToolsReport(tools);
                         stdout(JSON.stringify({ ok: false, configured: false, local_tools: report, action: report.action }));
+                        await reportRefusal({ stateRoot: config.stateRoot, env, fetchFn, report: selfChecksReport({ source: "setup", packageVersion: packageVersion(),
+                                checkedAt: Math.floor(Date.now() / 1000), tools, hook, refusalCode: "local_tools_failed" }) });
                         throw new Error(`The job file tools failed on this Mac (local_tools_failed: ${tools.tool ?? "setup"}: ${tools.detail ?? "unknown"})`);
                     }
                 }
@@ -285,8 +291,8 @@ export async function main(argv, env, io = {}) {
                     throw new Error("No usable authenticated runtime adapter is available. Run doctor for adapter diagnostics.");
                 }
                 const registered = await gateway.registerLocalRunner({
-                    deviceFingerprint: createHash("sha256").update(`${process.getuid?.() ?? 0}|${runnerDisplayName()}|${config.gatewayMcpUrl}`).digest("hex"),
-                    displayName: runnerDisplayName(), packageVersion: "0.1.11",
+                    deviceFingerprint: runnerDeviceFingerprint(config.gatewayMcpUrl),
+                    displayName: runnerDisplayName(), packageVersion: packageVersion(),
                     capabilities: mode === "full" ? adapters.map(probe => ({ adapter: probe.id, version: probe.version, capabilities: probe.capabilities, ...adapterStatus(probe) })) : [],
                     mode,
                 });
@@ -418,6 +424,8 @@ export async function main(argv, env, io = {}) {
                 if (!hook.enforcing) {
                     stderr(JSON.stringify({ event: "hook_not_enforcing", reason: hook.reason,
                         ...(hook.exitCode === null ? {} : { exit_code: hook.exitCode }), ...(hook.detail ? { detail: hook.detail } : {}) }));
+                    await reportRefusal({ stateRoot: config.stateRoot, env, fetchFn, report: selfChecksReport({ source: "daemon_start", packageVersion: packageVersion(),
+                            checkedAt: Math.floor(Date.now() / 1000), tools: null, hook, refusalCode: "hook_not_enforcing" }) });
                     return 1;
                 }
             }

package/dist/src/daemon/runtime.js

@@ -30,7 +30,9 @@ import { PendingClosureAcks, createSyncDispatcher } from "../transport/sync-disp
 import { abortableDelay } from "../transport/abortable-delay.js";
 import { sideLoops } from "../transport/side-loops.js";
 import { buildTerminalEvidenceCollector } from "../safety/terminal-evidence.js";
-import { packagedHookCommandParts } from "../safety/hook-command.js";
+import { packagedHookCommandParts, verifyPackagedHook } from "../safety/hook-command.js";
+import { localToolSelfTest } from "../safety/local-tool-self-test.js";
+import { SelfCheckMonitor } from "./self-check-monitor.js";
 import { composeReviewedP1Host } from '../verification/p1-host-composition.js';
 import { AskRuntime, withAsks } from '../asks/runtime.js';
 import { GuideRuntime, withGuide } from '../guide/runtime.js';
@@ -196,6 +198,15 @@ export async function buildDaemon(input) {
         // Until now the heartbeat said this runner takes no jobs; tell the Gateway at once, and ask whether one waits.
         onArmed: () => { void heartbeats.tick(); transport?.requestSync("start"); },
     });
+    // Work Item 2549b1b0: the file tools and hook checked with this daemon's node, sent in every heartbeat.
+    const selfChecks = new SelfCheckMonitor({
+        workspaceRoot: input.workspaceRoot,
+        localTools: input.selfChecks?.localTools ?? localToolSelfTest,
+        hook: input.selfChecks?.hook ?? verifyPackagedHook,
+        packageVersion: () => packageVersion(),
+        changed: () => { void heartbeats.tick(); },
+        ...(input.selfChecks?.intervalMs ? { intervalMs: input.selfChecks.intervalMs } : {}),
+    });
     const heartbeats = new HeartbeatScheduler({
         intervalMs: 30_000,
         snapshot: async () => {
@@ -259,13 +270,14 @@ export async function buildDaemon(input) {
             const askInbox = await asks.advertisement();
             const guidance = await guide.advertisement();
             return {
-                deviceFingerprint: createHash("sha256").update(`${process.getuid?.() ?? 0}|${runnerDisplayName()}|${input.gatewayMcpUrl}`).digest("hex"),
+                deviceFingerprint: runnerDeviceFingerprint(input.gatewayMcpUrl),
                 displayName: runnerDisplayName(), packageVersion: packageVersion(),
                 capabilities: acceptingJobs(localRunnerCapabilities(probes, !!localFixHost, localFixHost?.verificationModes ?? localFixHost?.verificationMode), poller.accepting),
                 mode: "full",
                 ...(sessionOpen ? { sessionOpen: { ...sessionOpen, ...(askInbox ? { ask_inbox: askInbox } : {}) } } : {}),
                 ...(guidance ? { guidance } : {}),
                 localFix: localFixReport(),
+                ...(selfChecks.report() ? { selfChecks: selfChecks.report() } : {}),
             };
         },
         send: async (payload) => { await gateway.heartbeatLocalRunner(payload); },
@@ -340,6 +352,7 @@ export async function buildDaemon(input) {
     });
     transport = pushTransport;
     const sessionOpens = sideLoops({ heartbeat: heartbeats, transport: pushTransport, onStop: () => stopping.abort() });
+    selfChecks.start();
     const daemon = new Daemon({
         lock: new ProcessLock(join(input.stateRoot, "daemon.lock")), state,
         reconcile: async (stored) => {
@@ -358,6 +371,7 @@ export async function buildDaemon(input) {
     // Model tools have no Gateway relay. Each adapter owns and closes its job endpoint.
     // The Claude host always closes; a failing Claude close never masks a Codex close failure.
     return { daemon, close: async () => {
+            selfChecks.stop();
             daemon.stop();
             try {
                 await production?.close();
@@ -370,6 +384,10 @@ export async function buildDaemon(input) {
         } };
 }
 export function runnerDisplayName() { return `${hostname()} local AI`; }
+/** The fingerprint setup registers and every heartbeat repeats; a refusal report must match it too (Work Item 2549b1b0). */
+export function runnerDeviceFingerprint(gatewayMcpUrl) {
+    return createHash("sha256").update(`${process.getuid?.() ?? 0}|${runnerDisplayName()}|${gatewayMcpUrl}`).digest("hex");
+}
 /** The execution blocker a full runner reports for every adapter while it takes no jobs. */
 export const RUNNER_NOT_ACCEPTING_JOBS = "RUNNER_NOT_ACCEPTING_JOBS";
 /*

package/dist/src/daemon/self-check-monitor.js

@@ -0,0 +1,43 @@
+import { selfChecksReport } from "../safety/self-checks.js";
+export const SELF_CHECK_INTERVAL_MS = 6 * 60 * 60 * 1000;
+/**
+ * Runs the job file tool and hook self-checks with this daemon's own node (Work Item 2549b1b0): the node every job uses,
+ * which doctor's terminal node may not be. A check that throws counts as failed; nothing here stops job claims.
+ */
+export class SelfCheckMonitor {
+    deps;
+    latest;
+    timer;
+    stopped = false;
+    constructor(deps) {
+        this.deps = deps;
+    }
+    report() { return this.latest; }
+    start() {
+        const loop = () => {
+            if (this.stopped)
+                return;
+            void this.check().finally(() => {
+                if (!this.stopped)
+                    this.timer = setTimeout(loop, this.deps.intervalMs ?? SELF_CHECK_INTERVAL_MS);
+            });
+        };
+        loop();
+    }
+    stop() {
+        this.stopped = true;
+        if (this.timer)
+            clearTimeout(this.timer);
+    }
+    async check() {
+        const [tools, hook] = await Promise.all([
+            this.deps.localTools(this.deps.workspaceRoot).catch(() => ({ status: "failed", node: process.execPath })),
+            this.deps.hook(this.deps.workspaceRoot).catch(() => ({ enforcing: false, reason: "failed", exitCode: null })),
+        ]);
+        if (this.stopped)
+            return;
+        this.latest = selfChecksReport({ source: "daemon", packageVersion: this.deps.packageVersion(),
+            checkedAt: Math.floor((this.deps.now?.() ?? Date.now()) / 1000), tools, hook });
+        this.deps.changed();
+    }
+}

package/dist/src/gateway-client.js

@@ -568,9 +568,18 @@ export class McpGatewayClient {
                 ...(input.sessionOpen ? { session_open: input.sessionOpen } : {}),
                 ...(input.guidance ? { guidance: input.guidance } : {}),
                 ...(input.localFix !== undefined ? { local_fix: input.localFix } : {}),
+                ...(input.selfChecks ? { self_checks: input.selfChecks } : {}),
             },
         }, signal);
     }
+    /** A refused setup or daemon start, reported once before the process exits (Work Item 2549b1b0). */
+    async reportRunnerChecks(input, signal) {
+        return this.callTool("local_agent_runner_check_report", {
+            runner_id: this.runnerId,
+            device_fingerprint: input.deviceFingerprint,
+            self_checks: input.selfChecks,
+        }, signal);
+    }
     async waitForSessionOpens(waitSeconds = 25, signal) {
         const result = await this.callTool("local_agent_session_opens_wait", {
             runner_id: this.runnerId,

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/dist/src/registration/refusal-report.js

@@ -0,0 +1,27 @@
+import { FileOAuthCredentialStore } from "../auth/credential-store.js";
+import { OAuthClient } from "../auth/oauth-client.js";
+import { OAuthTokenProvider } from "../auth/token-provider.js";
+import { McpGatewayClient } from "../gateway-client.js";
+import { FileLocalConfigStore } from "./local-config.js";
+import { runnerDeviceFingerprint } from "../daemon/runtime.js";
+const REPORT_TIMEOUT_MS = 5000;
+/**
+ * Tell the Gateway once that setup or the daemon start refused (Work Item 2549b1b0), with the identity and login an
+ * earlier setup saved. A first install has neither, so it reports nothing. Advisory: it never throws and never waits
+ * more than 5 seconds, so the refusal's message and exit code stay as they were.
+ */
+export async function reportRefusal(input) {
+    try {
+        const local = await new FileLocalConfigStore(input.stateRoot).load();
+        if (!local)
+            return;
+        const tokenProvider = new OAuthTokenProvider({ store: new FileOAuthCredentialStore(input.stateRoot),
+            oauthClient: new OAuthClient({ resource: local.gatewayMcpUrl, fetchFn: input.fetchFn }), resource: local.gatewayMcpUrl,
+            tokenOverride: input.env.AI_GATEWAY_LOCAL_RUNNER_TOKEN, clock: () => Date.now() });
+        const gateway = new McpGatewayClient({ mcpUrl: local.gatewayMcpUrl, tokenProvider, runnerId: local.runnerId, fetchFn: input.fetchFn });
+        await gateway.reportRunnerChecks({ deviceFingerprint: runnerDeviceFingerprint(local.gatewayMcpUrl), selfChecks: input.report }, AbortSignal.timeout(REPORT_TIMEOUT_MS));
+    }
+    catch {
+        // The refusal itself is what the employee must act on; the report is only for the owner.
+    }
+}

package/dist/src/safety/self-checks.js

@@ -0,0 +1,31 @@
+/** A hint for the reader; local_tools.status is the signal. */
+export function nodeKind(execPath) {
+    if (execPath.includes("/opt/homebrew/") || execPath.includes("/Cellar/"))
+        return "homebrew";
+    if (execPath.includes("/.nvm/"))
+        return "nvm";
+    if (execPath === "/usr/local/bin/node")
+        return "official";
+    return "other";
+}
+export function selfChecksReport(input) {
+    const tools = input.tools;
+    return {
+        version: 1,
+        source: input.source,
+        package_version: input.packageVersion,
+        checked_at: input.checkedAt,
+        local_tools: tools === null ? null : {
+            status: tools.status,
+            ...(tools.status === "failed" && tools.tool ? { tool: tools.tool } : {}),
+            ...(tools.sandbox?.reason ? { sandbox_reason: tools.sandbox.reason } : {}),
+            node_kind: nodeKind(tools.node),
+            node_version: input.nodeVersion ?? process.version,
+        },
+        hook: input.hook === null ? null : {
+            status: input.hook.enforcing ? "enforcing" : "hook_not_enforcing",
+            ...(input.hook.enforcing ? {} : { reason: input.hook.reason }),
+        },
+        ...(input.refusalCode ? { refusal_code: input.refusalCode } : {}),
+    };
+}

package/package.json

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