@clawpump/claw-agent 0.1.4 → 0.1.6

package/agent/apps/desktop/src/lib/todos.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect, it } from 'vitest'
 
-import { parseTodos } from './todos'
+import { latestSessionTodos, parseTodos } from './todos'
 
 describe('parseTodos', () => {
   it('parses todo arrays with valid ids, content, and statuses', () => {
@@ -33,3 +33,48 @@ describe('parseTodos', () => {
     expect(parseTodos({ message: 'no todos here' })).toBeNull()
   })
 })
+
+describe('latestSessionTodos', () => {
+  const todoPart = (todos: unknown, extra: Record<string, unknown> = {}) => ({
+    type: 'tool-call',
+    toolCallId: 't1',
+    toolName: 'todo',
+    args: { todos },
+    ...extra
+  })
+
+  it('returns the last todo list across the transcript (result beats args)', () => {
+    const messages = [
+      { parts: [todoPart([{ content: 'Old', id: 'a', status: 'pending' }])] },
+      { parts: [{ type: 'text', text: 'hi' }] },
+      {
+        parts: [
+          todoPart([{ content: 'Stale', id: 'a', status: 'pending' }], {
+            result: { todos: [{ content: 'Fresh', id: 'a', status: 'completed' }] }
+          })
+        ]
+      }
+    ]
+
+    expect(latestSessionTodos(messages)).toEqual([{ content: 'Fresh', id: 'a', status: 'completed' }])
+  })
+
+  it('prefers the live carried `todos` field over args', () => {
+    const messages = [
+      {
+        parts: [
+          todoPart([{ content: 'Args', id: 'a', status: 'pending' }], {
+            todos: [{ content: 'Live', id: 'a', status: 'in_progress' }]
+          })
+        ]
+      }
+    ]
+
+    expect(latestSessionTodos(messages)).toEqual([{ content: 'Live', id: 'a', status: 'in_progress' }])
+  })
+
+  it('returns null when no todo tool calls exist', () => {
+    expect(latestSessionTodos([{ parts: [{ type: 'text', text: 'hi' }] }])).toBeNull()
+    expect(latestSessionTodos([])).toBeNull()
+  })
+})

package/agent/apps/desktop/src/lib/todos.ts

@@ -49,3 +49,40 @@ function parse(value: unknown, depth: number): null | TodoItem[] {
 }
 
 export const parseTodos = (value: unknown): null | TodoItem[] => parse(value, 0)
+
+/** Latest parseable todo list from one message's aui content parts (tool-call
+ *  parts named `todo`; live parts carry `todos`, hydrated ones args/result). */
+export function todosFromMessageContent(content: unknown): null | TodoItem[] {
+  if (!Array.isArray(content)) {
+    return null
+  }
+
+  let latest: null | TodoItem[] = null
+
+  for (const part of content) {
+    if (!isRecord(part) || part.type !== 'tool-call' || part.toolName !== 'todo') {
+      continue
+    }
+
+    const parsed = parseTodos(part.todos) ?? parseTodos(part.result) ?? parseTodos(part.args)
+
+    if (parsed !== null) {
+      latest = parsed
+    }
+  }
+
+  return latest
+}
+
+/** Current todo state for a whole transcript — the last list wins. */
+export function latestSessionTodos(messages: readonly { parts?: unknown }[]): null | TodoItem[] {
+  for (let i = messages.length - 1; i >= 0; i -= 1) {
+    const todos = todosFromMessageContent(messages[i]?.parts)
+
+    if (todos !== null) {
+      return todos
+    }
+  }
+
+  return null
+}

package/agent/apps/desktop/src/lib/tool-result-summary.ts

@@ -20,7 +20,11 @@ const PRIORITY_KEYS = [
 ] as const
 
 const ERROR_KEYS = ['error', 'errors', 'failure', 'exception'] as const
-const ERROR_MSG_KEYS = ['message', 'reason', 'detail', 'stderr'] as const
+// 'stderr' deliberately excluded: many CLIs emit informational lines on
+// stderr (npm progress, git's hint:, gcc's `In file included from`) that
+// aren't errors. Treating those as error signal flipped tool cards into
+// destructive styling for healthy commands.
+const ERROR_MSG_KEYS = ['message', 'reason', 'detail'] as const
 const NON_ERROR_TEXT = new Set(['', '0', 'false', 'none', 'null', 'nil', 'ok', 'success', 'n/a', 'na'])
 
 type Json = Record<string, unknown>

package/agent/apps/desktop/src/lib/update-copy.test.ts

@@ -0,0 +1,38 @@
+import { describe, expect, it } from 'vitest'
+
+import { resolveUpdateCopy } from './update-copy'
+
+const copy = {
+  availableTitle: 'New update available',
+  availableBody: 'A new version of Hermes is ready to install.',
+  availableTitleBackend: 'Backend update available',
+  availableBodyBackend: 'A newer version of the connected Hermes backend is ready to install.',
+  availableBodyNoChangelog: 'A newer version is ready. Release notes aren’t available for this install type.'
+}
+
+describe('resolveUpdateCopy', () => {
+  it('client target with commits: client title + client body', () => {
+    const r = resolveUpdateCopy({ target: 'client', shownItems: 5, copy })
+    expect(r.title).toBe('New update available')
+    expect(r.body).toBe('A new version of Hermes is ready to install.')
+  })
+
+  it('backend target with commits: names the backend in title and body', () => {
+    const r = resolveUpdateCopy({ target: 'backend', shownItems: 5, copy })
+    expect(r.title).toBe('Backend update available')
+    expect(r.body).toContain('backend')
+  })
+
+  it('no changelog (pip/non-git backend): degrades honestly, still names backend target in title', () => {
+    const r = resolveUpdateCopy({ target: 'backend', shownItems: 0, copy })
+    expect(r.title).toBe('Backend update available')
+    // Body must NOT pretend there are notes — it states they're unavailable.
+    expect(r.body).toBe(copy.availableBodyNoChangelog)
+  })
+
+  it('no changelog on client: same honest degrade', () => {
+    const r = resolveUpdateCopy({ target: 'client', shownItems: 0, copy })
+    expect(r.title).toBe('New update available')
+    expect(r.body).toBe(copy.availableBodyNoChangelog)
+  })
+})

package/agent/apps/desktop/src/lib/update-copy.ts

@@ -0,0 +1,44 @@
+/**
+ * Pure copy-selection for the updates overlay's "available" state.
+ *
+ * Names the update target (client vs the connected backend in remote mode) and
+ * degrades honestly when there's no commit changelog to show (e.g. a pip /
+ * non-git backend where `git log` yields nothing) instead of generic filler.
+ *
+ * Extracted from updates-overlay.tsx so the wording logic is unit-testable.
+ */
+
+export type UpdateTarget = 'client' | 'backend'
+
+export interface UpdateCopyStrings {
+  availableTitle: string
+  availableBody: string
+  availableTitleBackend: string
+  availableBodyBackend: string
+  availableBodyNoChangelog: string
+}
+
+export interface ResolveUpdateCopyInput {
+  target: UpdateTarget
+  /** Number of commit rows actually shown in the changelog. 0 → no notes. */
+  shownItems: number
+  copy: UpdateCopyStrings
+}
+
+export interface UpdateCopyResult {
+  title: string
+  body: string
+}
+
+export function resolveUpdateCopy({ target, shownItems, copy }: ResolveUpdateCopyInput): UpdateCopyResult {
+  const title = target === 'backend' ? copy.availableTitleBackend : copy.availableTitle
+
+  const body =
+    shownItems === 0
+      ? copy.availableBodyNoChangelog
+      : target === 'backend'
+        ? copy.availableBodyBackend
+        : copy.availableBody
+
+  return { title, body }
+}

package/agent/apps/desktop/src/lib/use-enter-animation.ts

@@ -81,10 +81,10 @@ export function useEnterAnimation(enabled: boolean, animationKey?: string): (el:
 
     el.animate(
       [
-        { opacity: 0, transform: 'translateY(0.5rem)' },
+        { opacity: 0, transform: 'translateY(0.375rem)' },
         { opacity: 1, transform: 'translateY(0)' }
       ],
-      { duration: 220, easing: 'linear', fill: 'both' }
+      { duration: 180, easing: 'cubic-bezier(0.16, 1, 0.3, 1)', fill: 'both' }
     )
 
     if (key) {

package/agent/apps/desktop/src/lib/yolo-session.ts

@@ -0,0 +1,50 @@
+import { setYoloActive } from '@/store/session'
+
+export type GatewayRequester = <T = unknown>(method: string, params?: Record<string, unknown>) => Promise<T>
+
+/**
+ * Toggle per-session YOLO (approval bypass) via gateway `config.set` — the same
+ * session-scoped flag as the TUI's Shift+Tab. It does NOT touch the global
+ * `approvals.mode` config, so CLI / TUI / cron behavior is unaffected.
+ */
+export async function setSessionYolo(
+  requestGateway: GatewayRequester,
+  sessionId: string,
+  enabled: boolean
+): Promise<boolean> {
+  const result = await requestGateway<{ value?: string }>('config.set', {
+    key: 'yolo',
+    session_id: sessionId,
+    value: enabled ? '1' : '0'
+  })
+
+  const active = result?.value === '1'
+
+  setYoloActive(active)
+
+  return active
+}
+
+/**
+ * Toggle GLOBAL YOLO (approval bypass) via gateway `config.set` with
+ * `scope: 'global'`. This flips the persistent `approvals.mode` in config.yaml
+ * between `off` (bypass on) and `manual` (bypass off), affecting every session,
+ * the CLI, the TUI, and cron — and it survives restarts. Triggered by
+ * Shift+clicking the status-bar zap.
+ */
+export async function setGlobalYolo(
+  requestGateway: GatewayRequester,
+  enabled: boolean
+): Promise<boolean> {
+  const result = await requestGateway<{ value?: string }>('config.set', {
+    key: 'yolo',
+    scope: 'global',
+    value: enabled ? '1' : '0'
+  })
+
+  const active = result?.value === '1'
+
+  setYoloActive(active)
+
+  return active
+}

package/agent/apps/desktop/src/main.tsx

@@ -1,13 +1,18 @@
 import './styles.css'
+// Side-effect: applies the persisted window translucency on load.
+import './store/translucency'
 
-import { QueryClient, QueryClientProvider } from '@tanstack/react-query'
+import { QueryClientProvider } from '@tanstack/react-query'
 import { StrictMode } from 'react'
 import { createRoot } from 'react-dom/client'
 import { HashRouter } from 'react-router-dom'
 
 import App from './app'
+import { ErrorBoundary } from './components/error-boundary'
 import { HapticsProvider } from './components/haptics-provider'
+import { I18nProvider } from './i18n'
 import { installClipboardShim } from './lib/clipboard'
+import { queryClient } from './lib/query-client'
 import { ThemeProvider } from './themes/context'
 
 installClipboardShim()
@@ -21,25 +26,20 @@ if (import.meta.env.MODE !== 'production') {
   import('./app/chat/perf-probe')
 }
 
-const queryClient = new QueryClient({
-  defaultOptions: {
-    queries: {
-      refetchOnWindowFocus: false,
-      staleTime: 60_000
-    }
-  }
-})
-
 createRoot(document.getElementById('root')!).render(
   <StrictMode>
-    <QueryClientProvider client={queryClient}>
-      <ThemeProvider>
-        <HapticsProvider>
-          <HashRouter>
-            <App />
-          </HashRouter>
-        </HapticsProvider>
-      </ThemeProvider>
-    </QueryClientProvider>
+    <ErrorBoundary label="root">
+      <QueryClientProvider client={queryClient}>
+        <I18nProvider>
+          <ThemeProvider>
+            <HapticsProvider>
+              <HashRouter>
+                <App />
+              </HashRouter>
+            </HapticsProvider>
+          </ThemeProvider>
+        </I18nProvider>
+      </QueryClientProvider>
+    </ErrorBoundary>
   </StrictMode>
 )

package/agent/apps/desktop/src/store/boot.ts

@@ -1,6 +1,7 @@
 import { atom } from 'nanostores'
 
 import type { DesktopBootProgress } from '@/global'
+import { translateNow } from '@/i18n'
 
 export interface DesktopBootState extends DesktopBootProgress {
   visible: boolean
@@ -9,7 +10,7 @@ export interface DesktopBootState extends DesktopBootProgress {
 const INITIAL_BOOT_STATE: DesktopBootState = {
   error: null,
   fakeMode: false,
-  message: 'Starting Hermes Desktop…',
+  message: translateNow('boot.steps.startingHermesDesktop'),
   phase: 'renderer.init',
   progress: 2,
   running: true,
@@ -61,7 +62,7 @@ export function setDesktopBootStep(step: {
   })
 }
 
-export function completeDesktopBoot(message = 'Hermes Desktop is ready') {
+export function completeDesktopBoot(message = translateNow('boot.ready')) {
   const current = $desktopBoot.get()
   $desktopBoot.set({
     ...current,
@@ -80,7 +81,7 @@ export function failDesktopBoot(message: string) {
   $desktopBoot.set({
     ...current,
     error: message,
-    message: `Desktop boot failed: ${message}`,
+    message: translateNow('boot.desktopBootFailedWithMessage', message),
     phase: 'renderer.error',
     progress: clampProgress(current.progress),
     running: false,

package/agent/apps/desktop/src/store/clarify.test.ts

@@ -0,0 +1,81 @@
+import { afterEach, beforeEach, describe, expect, it } from 'vitest'
+
+import {
+  $clarifyRequest,
+  $clarifyRequests,
+  type ClarifyRequest,
+  clearClarifyRequest,
+  setClarifyRequest
+} from './clarify'
+import { $activeSessionId } from './session'
+
+function clarify(sessionId: string | null, requestId: string): ClarifyRequest {
+  return {
+    requestId,
+    question: `question-${requestId}`,
+    choices: null,
+    sessionId
+  }
+}
+
+describe('clarify store', () => {
+  beforeEach(() => {
+    $clarifyRequests.set({})
+    $activeSessionId.set(null)
+  })
+
+  afterEach(() => {
+    $clarifyRequests.set({})
+    $activeSessionId.set(null)
+  })
+
+  it('keeps clarify requests from concurrent sessions independent', () => {
+    setClarifyRequest(clarify('session-a', 'req-a'))
+    setClarifyRequest(clarify('session-b', 'req-b'))
+
+    expect($clarifyRequests.get()['session-a']?.requestId).toBe('req-a')
+    expect($clarifyRequests.get()['session-b']?.requestId).toBe('req-b')
+  })
+
+  it('exposes only the active session via the focus-scoped view', () => {
+    setClarifyRequest(clarify('session-a', 'req-a'))
+    setClarifyRequest(clarify('session-b', 'req-b'))
+
+    $activeSessionId.set('session-a')
+    expect($clarifyRequest.get()?.requestId).toBe('req-a')
+
+    $activeSessionId.set('session-b')
+    expect($clarifyRequest.get()?.requestId).toBe('req-b')
+
+    $activeSessionId.set('session-c')
+    expect($clarifyRequest.get()).toBeNull()
+  })
+
+  it('clears only the targeted session, leaving the other pending', () => {
+    setClarifyRequest(clarify('session-a', 'req-a'))
+    setClarifyRequest(clarify('session-b', 'req-b'))
+
+    clearClarifyRequest('req-a', 'session-a')
+
+    expect($clarifyRequests.get()['session-a']).toBeUndefined()
+    expect($clarifyRequests.get()['session-b']?.requestId).toBe('req-b')
+  })
+
+  it('ignores a stale clear whose request id no longer matches', () => {
+    setClarifyRequest(clarify('session-a', 'req-a2'))
+
+    clearClarifyRequest('req-a1', 'session-a')
+
+    expect($clarifyRequests.get()['session-a']?.requestId).toBe('req-a2')
+  })
+
+  it('clears by request id across sessions when no session hint is given', () => {
+    setClarifyRequest(clarify('session-a', 'shared'))
+    setClarifyRequest(clarify('session-b', 'other'))
+
+    clearClarifyRequest('shared')
+
+    expect($clarifyRequests.get()['session-a']).toBeUndefined()
+    expect($clarifyRequests.get()['session-b']?.requestId).toBe('other')
+  })
+})

package/agent/apps/desktop/src/store/clarify.ts

@@ -1,4 +1,6 @@
-import { atom } from 'nanostores'
+import { atom, computed } from 'nanostores'
+
+import { $activeSessionId } from './session'
 
 export interface ClarifyRequest {
   requestId: string
@@ -7,26 +9,61 @@ export interface ClarifyRequest {
   sessionId: string | null
 }
 
-// Holds the request_id (and metadata) for the most recent in-flight
-// clarify call. The inline ClarifyTool component (rendered inside the
-// assistant message stream) reads this to know which request_id to send
-// back over `clarify.respond`.
-export const $clarifyRequest = atom<ClarifyRequest | null>(null)
+// Pending clarify requests keyed by the runtime session id that raised them.
+// Storing per-session (instead of one shared slot) lets a *background* session
+// park its clarify request while the user is looking at a different chat, then
+// resolve it once they switch over — without a second concurrent clarify
+// clobbering the first. A request with no session id lands under the empty key.
+const keyFor = (sessionId: string | null | undefined): string => sessionId ?? ''
+
+export const $clarifyRequests = atom<Record<string, ClarifyRequest>>({})
+
+// The clarify request for the currently-viewed session. The inline ClarifyTool
+// only ever mounts inside the active session's transcript, so it reads this
+// focus-scoped view rather than reaching into the whole map.
+export const $clarifyRequest = computed(
+  [$clarifyRequests, $activeSessionId],
+  (requests, activeId) => requests[keyFor(activeId)] ?? null
+)
 
 export function setClarifyRequest(request: ClarifyRequest): void {
-  $clarifyRequest.set(request)
+  $clarifyRequests.set({ ...$clarifyRequests.get(), [keyFor(request.sessionId)]: request })
 }
 
-export function clearClarifyRequest(requestId?: string): void {
-  const current = $clarifyRequest.get()
+export function clearClarifyRequest(requestId?: string, sessionId?: string | null): void {
+  const requests = $clarifyRequests.get()
+
+  // Targeted clear when the caller knows the session (the common path from the
+  // inline ClarifyTool answering its own request).
+  if (sessionId !== undefined) {
+    const key = keyFor(sessionId)
+    const current = requests[key]
+
+    if (!current || (requestId && current.requestId !== requestId)) {
+      return
+    }
+
+    const next = { ...requests }
+    delete next[key]
+    $clarifyRequests.set(next)
 
-  if (!current) {
     return
   }
 
-  if (requestId && current.requestId !== requestId) {
-    return
+  // Fallback with no session hint: drop every entry matching the request id
+  // (or clear all when none is given).
+  const next: Record<string, ClarifyRequest> = {}
+  let changed = false
+
+  for (const [key, value] of Object.entries(requests)) {
+    if (requestId && value.requestId !== requestId) {
+      next[key] = value
+    } else {
+      changed = true
+    }
   }
 
-  $clarifyRequest.set(null)
+  if (changed) {
+    $clarifyRequests.set(next)
+  }
 }

package/agent/apps/desktop/src/store/command-palette.ts

@@ -0,0 +1,20 @@
+import { atom } from 'nanostores'
+
+/** Whether the global command palette (Cmd/Ctrl+K) is currently open. */
+export const $commandPaletteOpen = atom(false)
+
+export function openCommandPalette(): void {
+  $commandPaletteOpen.set(true)
+}
+
+export function closeCommandPalette(): void {
+  $commandPaletteOpen.set(false)
+}
+
+export function setCommandPaletteOpen(open: boolean): void {
+  $commandPaletteOpen.set(open)
+}
+
+export function toggleCommandPalette(): void {
+  $commandPaletteOpen.set(!$commandPaletteOpen.get())
+}

package/agent/apps/desktop/src/store/compaction.test.ts

@@ -0,0 +1,53 @@
+import { afterEach, beforeEach, describe, expect, it } from 'vitest'
+
+import { $compactingSessions, $compactionActive, setSessionCompacting } from './compaction'
+import { $activeSessionId } from './session'
+
+describe('compaction store', () => {
+  beforeEach(() => {
+    $compactingSessions.set({})
+    $activeSessionId.set(null)
+  })
+
+  afterEach(() => {
+    $compactingSessions.set({})
+    $activeSessionId.set(null)
+  })
+
+  it('tracks compaction per session independently', () => {
+    setSessionCompacting('session-a', true)
+    setSessionCompacting('session-b', true)
+
+    expect($compactingSessions.get()).toEqual({ 'session-a': true, 'session-b': true })
+  })
+
+  it('exposes only the active session via the focus-scoped view', () => {
+    setSessionCompacting('session-a', true)
+
+    expect($compactionActive.get()).toBe(false)
+
+    $activeSessionId.set('session-a')
+    expect($compactionActive.get()).toBe(true)
+
+    $activeSessionId.set('session-b')
+    expect($compactionActive.get()).toBe(false)
+  })
+
+  it('clears a session without disturbing the others', () => {
+    setSessionCompacting('session-a', true)
+    setSessionCompacting('session-b', true)
+
+    setSessionCompacting('session-a', false)
+
+    expect($compactingSessions.get()).toEqual({ 'session-b': true })
+  })
+
+  it('is a no-op when clearing an unknown session', () => {
+    setSessionCompacting('session-a', true)
+    const before = $compactingSessions.get()
+
+    setSessionCompacting('session-missing', false)
+
+    expect($compactingSessions.get()).toBe(before)
+  })
+})

package/agent/apps/desktop/src/store/compaction.ts

@@ -0,0 +1,38 @@
+import { atom, computed } from 'nanostores'
+
+import { $activeSessionId } from './session'
+
+// Per-session flag while auto-compaction runs mid-turn. Without it the
+// transcript looks like it reset; per-session so a background chat can't
+// clobber the foreground view.
+const keyFor = (sessionId: string | null | undefined): string => sessionId ?? ''
+
+export const $compactingSessions = atom<Record<string, true>>({})
+
+export const $compactionActive = computed(
+  [$compactingSessions, $activeSessionId],
+  (sessions, activeId) => keyFor(activeId) in sessions
+)
+
+export function setSessionCompacting(sessionId: string | null | undefined, active: boolean): void {
+  const key = keyFor(sessionId)
+  const sessions = $compactingSessions.get()
+
+  if (active) {
+    if (key in sessions) {
+      return
+    }
+
+    $compactingSessions.set({ ...sessions, [key]: true })
+
+    return
+  }
+
+  if (!(key in sessions)) {
+    return
+  }
+
+  const next = { ...sessions }
+  delete next[key]
+  $compactingSessions.set(next)
+}

package/agent/apps/desktop/src/store/completion-sound.ts

@@ -0,0 +1,32 @@
+import { atom } from 'nanostores'
+
+import { persistString, storedString } from '@/lib/storage'
+
+const STORAGE_KEY = 'hermes.desktop.completionSoundVariantId'
+
+export const DEFAULT_COMPLETION_SOUND_VARIANT_ID = 1
+
+// Range mirrors COMPLETION_SOUND_VARIANTS in lib/completion-sound.ts. Validating
+// by range (not membership) keeps this store free of a dependency on the lib,
+// which imports the atom back — a membership check would close that cycle.
+const VARIANT_COUNT = 14
+
+export function resolveCompletionSoundVariantId(variantId: number): number {
+  return Number.isInteger(variantId) && variantId >= 1 && variantId <= VARIANT_COUNT
+    ? variantId
+    : DEFAULT_COMPLETION_SOUND_VARIANT_ID
+}
+
+function load(): number {
+  const stored = storedString(STORAGE_KEY)
+
+  return stored ? resolveCompletionSoundVariantId(Number.parseInt(stored, 10)) : DEFAULT_COMPLETION_SOUND_VARIANT_ID
+}
+
+export const $completionSoundVariantId = atom(load())
+
+$completionSoundVariantId.subscribe(id => persistString(STORAGE_KEY, String(id)))
+
+export function setCompletionSoundVariantId(variantId: number) {
+  $completionSoundVariantId.set(resolveCompletionSoundVariantId(variantId))
+}