Skip to content

Node-based terminal manager for AI coding agents — tmux-backed terminals and parallel agent sessions as draggable nodes on an infinite pan/zoom canvas. macOS, Linux, and a browser Server Edition.

24.2 KB
Raw Blame
import { describe, it, expect, beforeEach, afterEach } from 'vitest'
import { promises as fs } from 'fs'
import os from 'os'
import path from 'path'
import { initPlatform, resetPlatformForTests } from './platform'
import { fakePlatform } from './platform-fake'
import { WorkspaceStore } from './workspace-store'
import { ProjectTrustStore, hashTrustContent, localTrustKey } from './project-trust-store'
import { registerProjectLaunchInfoHandlers } from './project-launch-info-handlers'
import { projectTrustContent, type ProjectLaunchInfo } from '../shared/project-settings'
import type { Project, Workspace } from '../shared/types'

let userData: string
let projRoot: string
let fake: ReturnType<typeof fakePlatform>

const project = (over: Partial<Project> = {}): Project => ({
  id: 'p1', name: 'foo', color: '#7aa2f7', viewport: { x: 0, y: 0, zoom: 1 },
  nodes: [{ id: 'term-1', kind: 'terminal', position: { x: 0, y: 0 }, size: { width: 1, height: 1 }, title: 't', color: '#fff', group: null }],
  ...over
})
const ws = (projects: Project[], active = projects[0]?.id ?? ''): Workspace =>
  ({ version: 2, activeProjectId: active, projects })

beforeEach(async () => {
  userData = await fs.mkdtemp(path.join(os.tmpdir(), 'nt-ws-'))
  projRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'nt-proj-'))
  fake = fakePlatform({ userDataDir: userData })
  initPlatform(fake)
})
afterEach(async () => {
  resetPlatformForTests()
  await fs.rm(userData, { recursive: true, force: true })
  await fs.rm(projRoot, { recursive: true, force: true })
})

describe('project settings — local leg', () => {
  it('write → read round-trips through the store', async () => {
    const store = new WorkspaceStore()
    await store.save(ws([project({ cwd: projRoot })]))
    expect(await store.writeProjectSettings('p1', { terminal: { shell: '/bin/zsh' } })).toBe(true)
    const s = await store.readProjectSettings('p1')
    expect(s?.shared?.terminal?.shell).toBe('/bin/zsh')
    const onDisk = JSON.parse(await fs.readFile(path.join(projRoot, '.nodeterm', 'settings.json'), 'utf-8'))
    expect(onDisk.rev).toBe(1)
  })

  it('a cold store reads before writing, so the rev sequence continues instead of restarting', async () => {
    const store = new WorkspaceStore()
    await store.save(ws([project({ cwd: projRoot })]))
    await store.writeProjectSettings('p1', { terminal: { shell: '/bin/zsh' } }) // rev 1
    const file = path.join(projRoot, '.nodeterm', 'settings.json')
    expect(JSON.parse(await fs.readFile(file, 'utf-8')).rev).toBe(1)

    // A fresh process: nothing has been read this run, so the write must look at the file first.
    const store2 = new WorkspaceStore()
    await store2.load()
    expect(await store2.writeProjectSettings('p1', { terminal: { shell: '/bin/bash' } })).toBe(true)
    const onDisk = JSON.parse(await fs.readFile(file, 'utf-8'))
    expect(onDisk.rev).toBe(2)
    expect(onDisk.terminal.shell).toBe('/bin/bash')
  })

  it('re-saving identical content neither bumps rev nor rewrites the bytes', async () => {
    const store = new WorkspaceStore()
    await store.save(ws([project({ cwd: projRoot })]))
    await store.writeProjectSettings('p1', { terminal: { shell: '/bin/zsh' } })
    const file = path.join(projRoot, '.nodeterm', 'settings.json')
    await store.readProjectSettings('p1') // the panel always reads before it saves
    const before = await fs.readFile(file, 'utf-8')
    expect(await store.writeProjectSettings('p1', { terminal: { shell: '/bin/zsh' } })).toBe(true)
    // A no-op save must not churn a git-tracked file: same bytes, same rev.
    expect(await fs.readFile(file, 'utf-8')).toBe(before)
    expect(JSON.parse(before).rev).toBe(1)
  })

  it('re-reads before every write, so a file conflicted since the last read is left alone', async () => {
    const store = new WorkspaceStore()
    await store.save(ws([project({ cwd: projRoot })]))
    await store.writeProjectSettings('p1', { terminal: { shell: '/bin/zsh' } })
    await store.readProjectSettings('p1') // warms the rev source
    const file = path.join(projRoot, '.nodeterm', 'settings.json')
    // …and then a git pull leaves conflict markers behind our back.
    const conflicted = '<<<<<<< a\n{}\n=======\n{}\n>>>>>>> b\n'
    await fs.writeFile(file, conflicted, 'utf-8')
    expect(await store.writeProjectSettings('p1', { terminal: { shell: '/bin/bash' } })).toBe(false)
    expect(await fs.readFile(file, 'utf-8')).toBe(conflicted)
  })

  it('refuses to write over a git-conflicted settings.json, leaving the bytes untouched', async () => {
    const store = new WorkspaceStore()
    await store.save(ws([project({ cwd: projRoot })]))
    const file = path.join(projRoot, '.nodeterm', 'settings.json')
    const conflicted = '<<<<<<< a\n{}\n=======\n{}\n>>>>>>> b\n'
    await fs.mkdir(path.dirname(file), { recursive: true })
    await fs.writeFile(file, conflicted, 'utf-8')
    expect(await store.writeProjectSettings('p1', { terminal: { shell: '/bin/zsh' } })).toBe(false)
    expect(await fs.readFile(file, 'utf-8')).toBe(conflicted)
  })

  it('local overlay persists across store instances without a canvas save', async () => {
    const store = new WorkspaceStore()
    await store.save(ws([project({ cwd: projRoot })]))
    await store.updateLocalProjectSettings('p1', { ignoreShared: { setup: true } })
    const store2 = new WorkspaceStore()
    await store2.load()
    const s = await store2.readProjectSettings('p1')
    expect(s?.local).toEqual({ ignoreShared: { setup: true } })
  })

  it('a canvas save does not drop the overlay (survives splitWorkspace round trip)', async () => {
    const store = new WorkspaceStore()
    const w = ws([project({ cwd: projRoot })])
    await store.save(w)
    await store.updateLocalProjectSettings('p1', { terminal: { shell: '/bin/fish' } })
    await store.save(w) // canvas autosave rebuilds the index
    const idx = JSON.parse(await fs.readFile(path.join(userData, 'workspace.json'), 'utf-8'))
    expect(idx.entries[0].localSettings).toEqual({ terminal: { shell: '/bin/fish' } })
  })

  it('clearing the overlay removes it from the index', async () => {
    const store = new WorkspaceStore()
    await store.save(ws([project({ cwd: projRoot })]))
    const idxPath = path.join(userData, 'workspace.json')
    await store.updateLocalProjectSettings('p1', { terminal: { shell: '/bin/fish' } })
    const set = JSON.parse(await fs.readFile(idxPath, 'utf-8'))
    expect(set.entries[0].localSettings).toEqual({ terminal: { shell: '/bin/fish' } })
    await store.updateLocalProjectSettings('p1', undefined)
    const idx = JSON.parse(await fs.readFile(idxPath, 'utf-8'))
    expect(idx.entries[0].localSettings).toBeUndefined()
    const s = await store.readProjectSettings('p1')
    expect(s?.local).toBeUndefined()
  })

  it('a git-conflicted settings.json reads as conflict with shared null', async () => {
    const store = new WorkspaceStore()
    await store.save(ws([project({ cwd: projRoot })]))
    await fs.mkdir(path.join(projRoot, '.nodeterm'), { recursive: true })
    await fs.writeFile(path.join(projRoot, '.nodeterm', 'settings.json'),
      '<<<<<<< a\n{}\n=======\n{}\n>>>>>>> b\n', 'utf-8')
    const s = await store.readProjectSettings('p1')
    expect(s?.conflict).toBe(true)
    expect(s?.shared).toBeNull()
  })

  it('an inline (cwd-less) project has no shared doc and cannot be written to', async () => {
    const store = new WorkspaceStore()
    await store.save(ws([project({ id: 'inline1', name: 'inline' })]))
    await store.updateLocalProjectSettings('inline1', { terminal: { theme: 'dark' } })
    const s = await store.readProjectSettings('inline1')
    expect(s?.shared).toBeNull()
    expect(s?.local).toEqual({ terminal: { theme: 'dark' } })
    expect(await store.writeProjectSettings('inline1', { terminal: { shell: '/bin/zsh' } })).toBe(false)
  })

  it('returns null for an unknown project id', async () => {
    const store = new WorkspaceStore()
    await store.save(ws([project({ cwd: projRoot })]))
    expect(await store.readProjectSettings('nope')).toBeNull()
    expect(await store.writeProjectSettings('nope', {})).toBe(false)
    expect(await store.updateLocalProjectSettings('nope', {})).toBe(false)
  })

  it('a hostile localSettings shape in workspace.json is sanitized on load', async () => {
    const store = new WorkspaceStore()
    await store.save(ws([project({ cwd: projRoot })]))
    const idxPath = path.join(userData, 'workspace.json')
    const idx = JSON.parse(await fs.readFile(idxPath, 'utf-8'))
    // JSON.parse (not an object literal): only the parser creates `__proto__` as a real OWN
    // property — a literal would set the prototype and the key would never reach the file.
    idx.entries[0].localSettings = JSON.parse('{"agents":{"env":{"__proto__":"x","OK":"v"}},"bogus":1}')
    const rawIndex = JSON.stringify(idx)
    expect(rawIndex).toContain('__proto__') // the hostile key really is on disk
    await fs.writeFile(idxPath, rawIndex, 'utf-8')
    const store2 = new WorkspaceStore()
    await store2.load()
    const s = await store2.readProjectSettings('p1')
    expect(s?.local).toEqual({ agents: { env: { OK: 'v' } } })
  })

  it('a hostile settingsCache in workspace.json is rejected on load', async () => {
    const store = new WorkspaceStore()
    await store.save(ws([
      project({ id: 'ssh1', name: 'remote', ssh: { server: { host: 'h', user: 'u' }, remoteCwd: '~/x' } })
    ]))
    const idxPath = path.join(userData, 'workspace.json')
    const idx = JSON.parse(await fs.readFile(idxPath, 'utf-8'))
    idx.entries[0].settingsCache = { version: 2, rev: 'nope', terminal: { shell: '/bin/evil' } }
    await fs.writeFile(idxPath, JSON.stringify(idx), 'utf-8')
    const store2 = new WorkspaceStore()
    await store2.load()
    const s = await store2.readProjectSettings('ssh1')
    expect(s?.shared).toBeNull()
  })
})

const remoteFs = new Map<string, string>()
const fakeIO = {
  read: async () => ({ status: 'absent' as const }),
  write: async () => true,
  readSettings: async (_id: string, ssh: { remoteCwd: string }) => {
    const c = remoteFs.get(ssh.remoteCwd + '/.nodeterm/settings.json')
    return c === undefined ? { status: 'absent' as const } : { status: 'ok' as const, content: c }
  },
  writeSettings: async (_id: string, ssh: { remoteCwd: string }, content: string) => {
    remoteFs.set(ssh.remoteCwd + '/.nodeterm/settings.json', content); return true
  }
}
const sshProject = () => project({ id: 'ps1', cwd: undefined, ssh: { server: { host: 'h', user: 'u' }, remoteCwd: '/srv/app' } })

describe('project settings — ssh leg', () => {
  beforeEach(() => remoteFs.clear())
  it('write lands in the cache AND on the remote; read adopts the higher remote rev', async () => {
    const store = new WorkspaceStore(fakeIO)
    await store.save(ws([sshProject()]))
    expect(await store.writeProjectSettings('ps1', { setup: { setupScript: 'make' } })).toBe(true)
    expect(remoteFs.get('/srv/app/.nodeterm/settings.json')).toContain('make')
    remoteFs.set('/srv/app/.nodeterm/settings.json', JSON.stringify(
      { version: 1, rev: 9, savedAt: 't', setup: { setupScript: 'newer-remote' } }))
    const s = await store.readProjectSettings('ps1')
    expect(s?.shared?.setup?.setupScript).toBe('newer-remote')
  })
  it('remote read failure serves the cache (offline)', async () => {
    const store = new WorkspaceStore({ ...fakeIO, readSettings: async () => ({ status: 'error' as const }) })
    await store.save(ws([sshProject()]))
    await store.writeProjectSettings('ps1', { setup: { setupScript: 'cached' } })
    const s = await store.readProjectSettings('ps1')
    expect(s?.shared?.setup?.setupScript).toBe('cached')
  })
  it('an absent remote file is healed from the cache on read', async () => {
    const store = new WorkspaceStore(fakeIO)
    await store.save(ws([sshProject()]))
    await store.writeProjectSettings('ps1', { setup: { setupScript: 'mine' } })
    remoteFs.clear()
    await store.readProjectSettings('ps1')
    expect(remoteFs.get('/srv/app/.nodeterm/settings.json')).toContain('mine')
  })
  it('settings cache survives a store reload via the index entry', async () => {
    const store = new WorkspaceStore(fakeIO)
    await store.save(ws([sshProject()]))
    await store.writeProjectSettings('ps1', { setup: { setupScript: 'persisted' } })
    const store2 = new WorkspaceStore({ ...fakeIO, readSettings: async () => ({ status: 'error' as const }) })
    await store2.load()
    const s = await store2.readProjectSettings('ps1')
    expect(s?.shared?.setup?.setupScript).toBe('persisted')
  })

  it('an offline edit (cache newer than the remote) is pushed back and wins the read', async () => {
    const store = new WorkspaceStore(fakeIO)
    await store.save(ws([sshProject()]))
    await store.writeProjectSettings('ps1', { setup: { setupScript: 'a' } }) // rev 1
    await store.writeProjectSettings('ps1', { setup: { setupScript: 'offline-edit' } }) // rev 2
    remoteFs.set('/srv/app/.nodeterm/settings.json', JSON.stringify(
      { version: 1, rev: 1, savedAt: 't', setup: { setupScript: 'stale-remote' } }))
    const s = await store.readProjectSettings('ps1')
    expect(s?.shared?.setup?.setupScript).toBe('offline-edit')
    expect(remoteFs.get('/srv/app/.nodeterm/settings.json')).toContain('offline-edit')
  })

  // "Share with team": after the handover the server core owns the host's `.nodeterm/`, so this
  // desktop keeps its edit in the cache and never pushes it — neither on a write nor as a "heal" of
  // a host file that is absent or older on a read.
  it('a project handed to a hosted team never has its settings pushed to the host', async () => {
    let pushes = 0
    const store = new WorkspaceStore({
      ...fakeIO,
      writeSettings: async (id: string, ssh: { remoteCwd: string }, content: string) => {
        pushes++
        return fakeIO.writeSettings(id, ssh, content)
      }
    })
    await store.save(ws([{ ...sshProject(), handedOffTo: { hostId: 'h1', projectId: 'project-9', at: 1 } }]))
    expect(await store.writeProjectSettings('ps1', { setup: { setupScript: 'kept-local' } })).toBe(true)
    // The host file is absent and then older than the cache: both would be healed by a push.
    await store.readProjectSettings('ps1')
    remoteFs.set('/srv/app/.nodeterm/settings.json', JSON.stringify(
      { version: 1, rev: 0, savedAt: 't', setup: { setupScript: 'server-owned' } }))
    await store.readProjectSettings('ps1')
    expect(pushes).toBe(0)
    expect(remoteFs.get('/srv/app/.nodeterm/settings.json')).toContain('server-owned')
    const idx = JSON.parse(await fs.readFile(path.join(userData, 'workspace.json'), 'utf-8'))
    expect(idx.entries[0].settingsCache.setup.setupScript).toBe('kept-local')
  })

  it('a conflict-marked remote file is reported as such and never overwritten', async () => {
    const store = new WorkspaceStore(fakeIO)
    await store.save(ws([sshProject()]))
    const conflicted = '<<<<<<< a\n{}\n=======\n{}\n>>>>>>> b\n'
    remoteFs.set('/srv/app/.nodeterm/settings.json', conflicted)
    const s = await store.readProjectSettings('ps1')
    expect(s?.conflict).toBe(true)
    expect(s?.shared).toBeNull()
    expect(remoteFs.get('/srv/app/.nodeterm/settings.json')).toBe(conflicted)
  })

  it('a remote write failure still keeps the edit (cache-first) and reports success', async () => {
    const store = new WorkspaceStore({ ...fakeIO, writeSettings: async () => false })
    await store.save(ws([sshProject()]))
    expect(await store.writeProjectSettings('ps1', { setup: { setupScript: 'kept' } })).toBe(true)
    const idx = JSON.parse(await fs.readFile(path.join(userData, 'workspace.json'), 'utf-8'))
    expect(idx.entries[0].settingsCache.setup.setupScript).toBe('kept')
  })

  it('a write landing mid-read is not downgraded by the older doc that read was already fetching', async () => {
    let release!: () => void
    const gate = new Promise<void>((r) => { release = r })
    // The FIRST call is the cold write's own read-before-write (the host has no file yet); only the
    // read under test — the one racing the second write — waits on the gate.
    let coldPreflight = true
    const store = new WorkspaceStore({
      ...fakeIO,
      readSettings: async () => {
        if (coldPreflight) { coldPreflight = false; return { status: 'absent' as const } }
        await gate
        return { status: 'ok' as const, content: JSON.stringify(
          { version: 1, rev: 1, savedAt: 't', setup: { setupScript: 'remote-rev1' } }) }
      }
    })
    await store.save(ws([sshProject()]))
    await store.writeProjectSettings('ps1', { setup: { setupScript: 'v1' } }) // cache rev 1
    const reading = store.readProjectSettings('ps1') // in flight, host still answering rev 1
    await store.writeProjectSettings('ps1', { setup: { setupScript: 'v2' } }) // cache rev 2
    release()
    const s = await reading
    expect(s?.shared?.setup?.setupScript).toBe('v2') // NOT the rev-1 doc the read was carrying
    const idx = JSON.parse(await fs.readFile(path.join(userData, 'workspace.json'), 'utf-8'))
    expect(idx.entries[0].settingsCache.rev).toBe(2) // and no downgrade was persisted
  })

  it('refuses to write while the host file is conflict-marked, and resumes once it is resolved', async () => {
    const writes: string[] = []
    let remote = '<<<<<<< a\n{}\n=======\n{}\n>>>>>>> b\n'
    const store = new WorkspaceStore({
      ...fakeIO,
      readSettings: async () => ({ status: 'ok' as const, content: remote }),
      writeSettings: async (_id: string, _ssh: { remoteCwd: string }, content: string) => {
        writes.push(content); return true
      }
    })
    await store.save(ws([sshProject()]))
    expect((await store.readProjectSettings('ps1'))?.conflict).toBe(true)
    expect(await store.writeProjectSettings('ps1', { setup: { setupScript: 'nope' } })).toBe(false)
    expect(writes).toEqual([]) // nothing was pushed over the merge
    remote = JSON.stringify({ version: 1, rev: 3, savedAt: 't', setup: { setupScript: 'resolved' } })
    expect((await store.readProjectSettings('ps1'))?.shared?.setup?.setupScript).toBe('resolved')
    expect(await store.writeProjectSettings('ps1', { setup: { setupScript: 'after' } })).toBe(true)
    expect(writes.join('|')).toContain('after')
  })

  it('an adopted remote doc is persisted to the index and served after a reload', async () => {
    const store = new WorkspaceStore(fakeIO)
    await store.save(ws([sshProject()]))
    remoteFs.set('/srv/app/.nodeterm/settings.json', JSON.stringify(
      { version: 1, rev: 4, savedAt: 't', setup: { setupScript: 'from-host' } }))
    expect((await store.readProjectSettings('ps1'))?.shared?.setup?.setupScript).toBe('from-host')
    const store2 = new WorkspaceStore({ ...fakeIO, readSettings: async () => ({ status: 'error' as const }) })
    await store2.load()
    const s = await store2.readProjectSettings('ps1')
    expect(s?.shared?.setup?.setupScript).toBe('from-host')
    expect(s?.shared?.rev).toBe(4)
  })

  it('a cold store reads the host before its first ssh write, and refuses a conflict-marked file', async () => {
    const writes: string[] = []
    const conflicted = '<<<<<<< a\n{}\n=======\n{}\n>>>>>>> b\n'
    const store = new WorkspaceStore({
      ...fakeIO,
      readSettings: async () => ({ status: 'ok' as const, content: conflicted }),
      writeSettings: async (_id: string, _ssh: { remoteCwd: string }, content: string) => {
        writes.push(content); return true
      }
    })
    await store.save(ws([sshProject()]))
    // Nothing has been read this run, so the runtime conflict flag is cold — the write must look.
    expect(await store.writeProjectSettings('ps1', { setup: { setupScript: 'nope' } })).toBe(false)
    expect(writes).toEqual([])
  })

  it('an ssh project with no remote IO at all still reads and writes its cache', async () => {
    const store = new WorkspaceStore()
    await store.save(ws([sshProject()]))
    expect(await store.writeProjectSettings('ps1', { setup: { setupScript: 'no-io' } })).toBe(true)
    const s = await store.readProjectSettings('ps1')
    expect(s?.shared?.setup?.setupScript).toBe('no-io')
  })
})

describe('project settings IPC registration', () => {
  it('registers the three channels and round-trips through platform handlers', async () => {
    // fakePlatform's `handle` already records into `fake.handlers` (a plain object keyed by
    // channel) — no monkey-patching needed, just read handlers back off it.
    const store = new WorkspaceStore()
    store.registerIpc()
    await store.save(ws([project({ cwd: projRoot })]))
    const handlers = fake.handlers
    expect(await handlers['project-settings:write-shared']('p1', { terminal: { shell: '/bin/zsh' } })).toBe(true)
    const snap = (await handlers['project-settings:read']('p1')) as { shared: { terminal?: { shell?: string } } | null }
    expect(snap.shared?.terminal?.shell).toBe('/bin/zsh')
    expect(await handlers['project-settings:update-local']('p1', { ignoreShared: { setup: true } })).toBe(true)
    expect(await handlers['project-settings:read']('nope')).toBeNull()
  })
})

describe('project-settings:launch-info', () => {
  it('gates a shared launchCmd until recorded, and reports true for a family with nothing to gate', async () => {
    const store = new WorkspaceStore()
    const trust = new ProjectTrustStore()
    registerProjectLaunchInfoHandlers(fake, store, trust)
    await store.save(ws([project({ cwd: projRoot })]))
    await store.writeProjectSettings('p1', { agents: { launchCmd: 'npm run dev' } })

    const handler = fake.handlers['project-settings:launch-info']
    const before = (await handler('p1')) as ProjectLaunchInfo
    expect(before.resolved.agents.launchCmd).toEqual({ value: 'npm run dev', source: 'shared' })
    expect(before.trusted.agents).toBe(false) // shared content exists, not yet approved
    expect(before.trusted.shell).toBe(true) // no shared `terminal.shell` at all — nothing to gate

    const key = localTrustKey(projRoot)
    const content = projectTrustContent('agents', { agents: { launchCmd: 'npm run dev' } })!
    await trust.record(key, 'agents', hashTrustContent(content), '2026-08-19T00:00:00.000Z')

    const after = (await handler('p1')) as ProjectLaunchInfo
    expect(after.trusted.agents).toBe(true)
  })

  it('answers null for an unknown project id, same as project-settings:read', async () => {
    const store = new WorkspaceStore()
    const trust = new ProjectTrustStore()
    registerProjectLaunchInfoHandlers(fake, store, trust)
    await store.save(ws([project({ cwd: projRoot })]))
    expect(await fake.handlers['project-settings:launch-info']('nope')).toBeNull()
  })

  it('reports trusted.agents true when the SHARED doc has no launchCmd/env, even with a local agents overlay', async () => {
    const store = new WorkspaceStore()
    const trust = new ProjectTrustStore()
    registerProjectLaunchInfoHandlers(fake, store, trust)
    await store.save(ws([project({ cwd: projRoot })]))
    // A shared doc exists but never sets anything in the `agents` family — nothing executable to
    // gate — while this machine's own local overlay picks a launchCmd of its own (never gated: a
    // value the user typed locally is their own instruction, not hostile shared input).
    await store.writeProjectSettings('p1', { terminal: { shell: '/bin/zsh' } })
    await store.updateLocalProjectSettings('p1', { agents: { launchCmd: 'npm run dev' } })

    const info = (await fake.handlers['project-settings:launch-info']('p1')) as ProjectLaunchInfo
    expect(info.resolved.agents.launchCmd).toEqual({ value: 'npm run dev', source: 'local' })
    expect(info.trusted.agents).toBe(true)
  })

  it('a shared change invalidates the OLD approval — trusted flips back to false', async () => {
    const store = new WorkspaceStore()
    const trust = new ProjectTrustStore()
    registerProjectLaunchInfoHandlers(fake, store, trust)
    await store.save(ws([project({ cwd: projRoot })]))
    await store.writeProjectSettings('p1', { agents: { launchCmd: 'npm run dev' } })
    const key = localTrustKey(projRoot)
    const oldContent = projectTrustContent('agents', { agents: { launchCmd: 'npm run dev' } })!
    await trust.record(key, 'agents', hashTrustContent(oldContent), '2026-08-19T00:00:00.000Z')
    expect(((await fake.handlers['project-settings:launch-info']('p1')) as ProjectLaunchInfo).trusted.agents).toBe(true)

    await store.writeProjectSettings('p1', { agents: { launchCmd: 'npm run dev && rm -rf /' } })
    const after = (await fake.handlers['project-settings:launch-info']('p1')) as ProjectLaunchInfo
    expect(after.trusted.agents).toBe(false)
  })
})