npm - @astrale-os/cli - Versions diffs - 0.7.0-alpha.0 → 0.8.1-alpha.0 - Mend

@astrale-os/cli 0.7.0-alpha.0 → 0.8.1-alpha.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (111) hide show

package/README.md +7 -3
package/dist/astrale.js +128 -98
package/package.json +11 -5
package/src/commands/studio.ts +13 -0
package/src/lib/__tests__/view-assets.test.ts +114 -0
package/src/lib/instance.ts +0 -11
package/src/lib/login-flow.ts +4 -41
package/src/lib/view/assets.ts +64 -0
package/src/lib/view/server.ts +4 -37
package/studio/client/dist/assets/elk-api-DVw5WDTH.js +1 -0
package/studio/client/dist/assets/elk-worker.min-C9JGDOE-.js +6312 -0
package/studio/client/dist/assets/index-BQnJ5sgd.css +1 -0
package/studio/client/dist/assets/index-CTbkDp3z.js +81 -0
package/studio/client/dist/assets/index-ChOr3yP0.css +1 -0
package/studio/client/dist/assets/index-Dl709Ra1.js +8 -0
package/studio/client/dist/index.html +2 -2
package/studio/server/agent/ask.test.ts +74 -0
package/studio/server/agent/ask.ts +20 -22
package/studio/server/agent/bridge/client.test.ts +49 -0
package/studio/server/agent/bridge/client.ts +37 -0
package/studio/server/agent/bridge/grant.test.ts +62 -0
package/studio/server/agent/bridge/grant.ts +84 -0
package/studio/server/agent/bridge/routes.test.ts +151 -0
package/studio/server/agent/bridge/routes.ts +148 -0
package/studio/server/agent/{bridge-mcp.ts → bridge/stdio.ts} +27 -21
package/studio/server/agent/conversation.test.ts +84 -0
package/studio/server/agent/conversation.ts +110 -0
package/studio/server/agent/{types.ts → harness/adapter.ts} +63 -12
package/studio/server/agent/harness/claude/adapter.test.ts +338 -0
package/studio/server/agent/harness/claude/adapter.ts +71 -0
package/studio/server/agent/harness/claude/ask.ts +114 -0
package/studio/server/agent/harness/claude/capabilities.ts +27 -0
package/studio/server/agent/harness/claude/command.ts +63 -0
package/studio/server/agent/harness/claude/events.ts +215 -0
package/studio/server/agent/harness/claude/loadout.ts +132 -0
package/studio/server/agent/harness/claude/mcp.test.ts +36 -0
package/studio/server/agent/harness/claude/mcp.ts +41 -0
package/studio/server/agent/harness/claude/skills.ts +43 -0
package/studio/server/agent/harness/codex/adapter.test.ts +269 -0
package/studio/server/agent/harness/codex/adapter.ts +116 -0
package/studio/server/agent/harness/codex/ask.test.ts +176 -0
package/studio/server/agent/harness/codex/ask.ts +181 -0
package/studio/server/agent/harness/codex/command.test.ts +69 -0
package/studio/server/agent/harness/codex/command.ts +43 -0
package/studio/server/agent/harness/codex/events.test.ts +94 -0
package/studio/server/agent/harness/codex/events.ts +132 -0
package/studio/server/agent/harness/codex/exec.ts +113 -0
package/studio/server/agent/harness/codex/loadout.ts +63 -0
package/studio/server/agent/harness/codex/mcp.test.ts +32 -0
package/studio/server/agent/harness/codex/mcp.ts +27 -0
package/studio/server/agent/harness/codex/models.test.ts +167 -0
package/studio/server/agent/harness/codex/models.ts +211 -0
package/studio/server/agent/harness/codex/skills.ts +33 -0
package/studio/server/agent/harness/gateway/config.test.ts +98 -0
package/studio/server/{state/harness-gateway.ts → agent/harness/gateway/config.ts} +30 -8
package/studio/server/agent/harness/gateway/token.test.ts +133 -0
package/studio/server/agent/harness/gateway/token.ts +166 -0
package/studio/server/agent/harness/mock/adapter.ts +190 -0
package/studio/server/agent/harness/mock/domain-edit.ts +41 -0
package/studio/server/agent/harness/process.test.ts +46 -0
package/studio/server/agent/harness/process.ts +104 -0
package/studio/server/agent/harness/registry.ts +37 -0
package/studio/server/agent/harness/selection.test.ts +75 -0
package/studio/server/agent/harness/selection.ts +77 -0
package/studio/server/agent/harness/skills.test.ts +95 -0
package/studio/server/agent/harness/skills.ts +100 -0
package/studio/server/agent/layout.test.ts +95 -0
package/studio/server/agent/notify.ts +12 -0
package/studio/server/agent/{schema-map.ts → prompts/anchors.ts} +2 -2
package/studio/server/agent/prompts/ask.ts +34 -0
package/studio/server/agent/{prompt.ts → prompts/system.ts} +3 -107
package/studio/server/agent/prompts/turn.ts +57 -0
package/studio/server/agent/routes.test.ts +176 -0
package/studio/server/agent/routes.ts +214 -0
package/studio/server/agent/run/completion.ts +193 -0
package/studio/server/agent/run/coordinator.test.ts +337 -0
package/studio/server/agent/run/coordinator.ts +104 -0
package/studio/server/agent/run/live-state.ts +73 -0
package/studio/server/agent/run/preparation.ts +162 -0
package/studio/server/agent/run/transcript.test.ts +47 -0
package/studio/server/agent/run/transcript.ts +30 -0
package/studio/server/agent/run/usage.test.ts +46 -0
package/studio/server/{state → agent/run}/usage.ts +4 -4
package/studio/server/agent/stream.ts +37 -0
package/studio/server/agent/{session-id.ts → telemetry.ts} +1 -1
package/studio/server/api-agent-loadout.test.ts +69 -0
package/studio/server/api.ts +3 -155
package/studio/server/index.ts +6 -5
package/studio/server/state/comments.test.ts +29 -0
package/studio/server/state/comments.ts +3 -3
package/studio/server/state/settings.test.ts +78 -0
package/studio/server/state/settings.ts +28 -1
package/studio/shared/agent-effort.test.ts +12 -0
package/studio/shared/agent-effort.ts +15 -0
package/studio/shared/agent-models.test.ts +9 -0
package/studio/shared/agent-models.ts +14 -0
package/studio/shared/settings-values.test.ts +18 -0
package/studio/shared/settings-values.ts +20 -0
package/studio/shared/types.ts +58 -7
package/studio/tsconfig.json +23 -0
package/viewer/tsconfig.json +13 -0
package/src/connect-core.test.ts +0 -42
package/src/connect-core.ts +0 -53
package/studio/client/dist/assets/index-DAC1a9vW.js +0 -109
package/studio/client/dist/assets/index-huaFafBC.css +0 -1
package/studio/server/agent/bridge.ts +0 -188
package/studio/server/agent/claude.ts +0 -678
package/studio/server/agent/mock.ts +0 -186
package/studio/server/agent/registry.ts +0 -29
package/studio/server/agent/runner.ts +0 -487
package/studio/server/state/harness-token.ts +0 -0

package/studio/client/dist/index.html CHANGED Viewed

@@ -4,8 +4,8 @@
     <meta charset="UTF-8" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <title>Domain Studio</title>
-    <script type="module" crossorigin src="/assets/index-DAC1a9vW.js"></script>
-    <link rel="stylesheet" crossorigin href="/assets/index-huaFafBC.css">
+    <script type="module" crossorigin src="/assets/index-CTbkDp3z.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-BQnJ5sgd.css">
   </head>
   <body>
     <div id="root"></div>

package/studio/server/agent/ask.test.ts ADDED Viewed

@@ -0,0 +1,74 @@
+import { afterEach, expect, test } from 'bun:test'
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { registerDomain, unregisterDomain } from '../domain'
+import { updateSettings } from '../state/settings'
+import { runAsk } from './ask'
+import { saveConversation } from './conversation'
+const roots: string[] = []
+const domainIds: string[] = []
+const envBefore = {
+  harness: process.env.DOMAIN_STUDIO_HARNESS,
+  model: process.env.DOMAIN_STUDIO_MOCK_EXPECT_MODEL,
+  session: process.env.DOMAIN_STUDIO_MOCK_EXPECT_SESSION,
+}
+function restore(name: keyof typeof envBefore, variable: string): void {
+  const value = envBefore[name]
+  if (value === undefined) delete process.env[variable]
+  else process.env[variable] = value
+}
+afterEach(() => {
+  restore('harness', 'DOMAIN_STUDIO_HARNESS')
+  restore('model', 'DOMAIN_STUDIO_MOCK_EXPECT_MODEL')
+  restore('session', 'DOMAIN_STUDIO_MOCK_EXPECT_SESSION')
+  while (domainIds.length) unregisterDomain(domainIds.pop()!)
+  while (roots.length) rmSync(roots.pop()!, { recursive: true, force: true })
+})
+test('Ask uses the active harness model and matching per-harness conversation', async () => {
+  const root = mkdtempSync(join(tmpdir(), 'studio-ask-model-'))
+  roots.push(root)
+  mkdirSync(join(root, 'schema'))
+  writeFileSync(join(root, 'astrale.config.ts'), 'export default {}\n')
+  writeFileSync(join(root, 'domain.ts'), 'export default {}\n')
+  writeFileSync(join(root, 'schema/index.ts'), 'export const Test = {}\n')
+  const handle = registerDomain(root)!
+  domainIds.push(handle.id)
+  process.env.DOMAIN_STUDIO_HARNESS = 'mock'
+  process.env.DOMAIN_STUDIO_MOCK_EXPECT_MODEL = 'mock-selected-model'
+  process.env.DOMAIN_STUDIO_MOCK_EXPECT_SESSION = 'mock-parent-session'
+  updateSettings(root, {
+    agentModels: {
+      mock: 'mock-selected-model',
+      claude: 'claude-other-model',
+    },
+  })
+  saveConversation(root, 'mock', {
+    sessionId: 'mock-parent-session',
+    turns: 2,
+    updatedAt: 'now',
+  })
+  saveConversation(root, 'claude', {
+    sessionId: 'claude-other-session',
+    turns: 4,
+    updatedAt: 'now',
+  })
+  const deltas: string[] = []
+  const result = await runAsk(
+    handle,
+    { question: 'Which context is active?' },
+    new AbortController().signal,
+    (delta) => deltas.push(delta),
+  )
+  expect(result.isError).toBe(false)
+  expect(result.text).toStartWith('(forked from mock-par…)')
+  expect(deltas.join('')).toBe(result.text)
+})

package/studio/server/agent/ask.ts CHANGED Viewed

@@ -10,15 +10,13 @@
  */
 import type { AnchorRef } from '../../shared/types'
 import type { DomainHandle } from '../domain'
-import type { AskResult } from './types'
+import type { AskResult } from './harness/adapter'
 import { getBundle } from '../cache'
-import { resolveHarnessEnv } from '../state/harness-gateway'
-import { readSettings } from '../state/settings'
-import { buildAskPrompt, buildAskSystemPrompt } from './prompt'
-import { getHarness } from './registry'
-import { forkableSession } from './runner'
-import { studioSessionId } from './session-id'
+import { readConversation } from './conversation'
+import { resolveHarnessConfiguration } from './harness/selection'
+import { buildAskPrompt, buildAskSystemPrompt } from './prompts/ask'
+import { studioSessionId } from './telemetry'
 export interface AskRequest {
   anchor?: AnchorRef
@@ -32,15 +30,22 @@ export async function runAsk(
   signal: AbortSignal,
   onDelta: (text: string) => void,
 ): Promise<AskResult> {
-  const harness = getHarness()
+  const question = String(body?.question ?? '').trim()
+  if (!question) return { text: '', isError: true, errorMessage: 'question is required' }
+  const resolved = await resolveHarnessConfiguration(handle.root)
+  if (!resolved.ok)
+    return {
+      text: '',
+      isError: true,
+      errorMessage: `model gateway auth failed — ${resolved.error}`,
+    }
+  const { harness, model, effort, env } = resolved.configuration
   if (!harness.ask)
     return {
       text: '',
       isError: true,
       errorMessage: `${harness.label} does not support side questions`,
     }
-  const question = String(body?.question ?? '').trim()
-  if (!question) return { text: '', isError: true, errorMessage: 'question is required' }
   const ref = body.anchor?.ref ?? '(no target)'
   const bundle = await getBundle(handle.id)
@@ -51,22 +56,15 @@ export async function runAsk(
     ir: bundle?.ir ?? null,
     overlay: bundle?.overlay,
   })
-  const settings = readSettings(handle.root)
-  const envResult = await resolveHarnessEnv(handle.root)
-  if (!envResult.ok)
-    return {
-      text: '',
-      isError: true,
-      errorMessage: `model gateway auth failed — ${envResult.error}`,
-    }
   return harness.ask({
     root: handle.root,
     prompt,
     appendSystemPrompt: buildAskSystemPrompt(),
-    sessionId: forkableSession(handle.id), // fork the live conversation (undefined ⇒ fresh)
-    effort: settings.agentEffort,
-    env: { ...envResult.env, ASTRALE_SESSION: studioSessionId(handle.id) },
+    sessionId: readConversation(handle.root, harness.id).sessionId,
+    model,
+    effort,
+    access: resolved.configuration.settings.agentAccess,
+    env: { ...env, ASTRALE_SESSION: studioSessionId(handle.id) },
     signal,
     onDelta,
   })

package/studio/server/agent/bridge/client.test.ts ADDED Viewed

@@ -0,0 +1,49 @@
+import { expect, test } from 'bun:test'
+import { forwardBridgeTool } from './client'
+test('marks HTTP and transport failures as MCP tool errors', async () => {
+  const denied = await forwardBridgeTool(
+    'http://studio.test',
+    'token',
+    'reply',
+    {},
+    async () => new Response('denied', { status: 401 }),
+  )
+  expect(denied).toEqual({
+    content: [{ type: 'text', text: 'bridge error 401: denied' }],
+    isError: true,
+  })
+  const unavailable = await forwardBridgeTool(
+    'http://studio.test',
+    'token',
+    'reply',
+    {},
+    async () => {
+      throw new Error('offline')
+    },
+  )
+  expect(unavailable).toEqual({
+    content: [{ type: 'text', text: 'bridge call failed: offline' }],
+    isError: true,
+  })
+})
+test('keeps the scoped bearer authoritative and returns successful content', async () => {
+  let sent: any
+  const response = await forwardBridgeTool(
+    'http://studio.test',
+    'scoped',
+    'threads',
+    { token: 'forged' },
+    async (_url, init) => {
+      sent = JSON.parse(String(init?.body))
+      return new Response('{"threads":[]}')
+    },
+  )
+  expect(sent).toEqual({ token: 'scoped' })
+  expect(response).toEqual({
+    content: [{ type: 'text', text: '{"threads":[]}' }],
+  })
+})

package/studio/server/agent/bridge/client.ts ADDED Viewed

@@ -0,0 +1,37 @@
+export interface BridgeToolResult {
+  content: [{ type: 'text'; text: string }]
+  isError?: true
+}
+type FetchBridge = (input: string | URL | Request, init?: RequestInit) => Promise<Response>
+function result(text: string, isError = false): BridgeToolResult {
+  return {
+    content: [{ type: 'text', text }],
+    ...(isError ? { isError: true as const } : {}),
+  }
+}
+/** Forward one stdio MCP tool call to the authenticated Studio bridge. */
+export async function forwardBridgeTool(
+  base: string,
+  token: string,
+  route: string,
+  args: Record<string, unknown>,
+  fetchBridge: FetchBridge = fetch,
+): Promise<BridgeToolResult> {
+  if (!base || !token) return result('bridge not configured', true)
+  try {
+    const response = await fetchBridge(`${base}/${route}`, {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({ ...args, token }),
+    })
+    const text = await response.text()
+    return response.ok
+      ? result(text || 'ok')
+      : result(`bridge error ${response.status}: ${text}`, true)
+  } catch (error: any) {
+    return result(`bridge call failed: ${error?.message ?? error}`, true)
+  }
+}

package/studio/server/agent/bridge/grant.test.ts ADDED Viewed

@@ -0,0 +1,62 @@
+import { afterEach, expect, test } from 'bun:test'
+import { existsSync, mkdtempSync, readFileSync, rmSync, statSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import type { DomainHandle } from '../../domain'
+import { startBridge } from './grant'
+const roots: string[] = []
+afterEach(() => {
+  while (roots.length) rmSync(roots.pop()!, { recursive: true, force: true })
+})
+function domain(root: string, id: string): DomainHandle {
+  return {
+    id,
+    root,
+    configFile: join(root, 'astrale.config.ts'),
+    domainFile: join(root, 'domain.ts'),
+    schemaDirName: 'schema',
+    schemaDir: join(root, 'schema'),
+    schemaIndex: join(root, 'schema/index.ts'),
+  }
+}
+test('keeps its bearer out of the harness command line', () => {
+  const root = mkdtempSync(join(tmpdir(), 'studio-bridge-'))
+  roots.push(root)
+  const bridge = startBridge(domain(root, 'test-domain'), () => {})
+  const server = bridge.mcpServers[0]!
+  const configPath = server.args?.at(-1)
+  expect(server.name).toBe('domain-studio')
+  expect(server.approvalMode).toBe('approve')
+  expect(configPath).toBeTruthy()
+  const config = JSON.parse(readFileSync(configPath!, 'utf8')) as {
+    base: string
+    token: string
+  }
+  expect(server.args?.join(' ')).not.toContain(config.token)
+  expect(config.base).toContain('/api/domain/test-domain/agent/bridge')
+  expect(existsSync(configPath!)).toBe(true)
+  expect(statSync(configPath!).mode & 0o777).toBe(0o600)
+  bridge.dispose()
+  expect(existsSync(configPath!)).toBe(false)
+})
+test('does not let an in-process tool replace its scoped bearer', async () => {
+  const root = mkdtempSync(join(tmpdir(), 'studio-bridge-invoke-'))
+  roots.push(root)
+  const bridge = startBridge(domain(root, 'test-domain'), () => {})
+  const server = bridge.mcpServers[0]!
+  await expect(server.invoke?.('list_open_threads', { token: 'forged' })).resolves.toEqual({
+    threads: [],
+  })
+  bridge.dispose()
+})

package/studio/server/agent/bridge/grant.ts ADDED Viewed

@@ -0,0 +1,84 @@
+import { randomUUID } from 'node:crypto'
+import { chmodSync } from 'node:fs'
+import { join } from 'node:path'
+import type { StudioEvent } from '../../../shared/types'
+import type { DomainHandle } from '../../domain'
+import type { HarnessMcpServer } from '../harness/adapter'
+import { removeState, statePath, writeJson } from '../../state/store'
+import { openBridgeSession } from './routes'
+export interface Bridge {
+  enabled: boolean
+  mcpServers: HarnessMcpServer[]
+  onReply(callback: (commentId: string, text: string) => void): void
+  onProgress(callback: (text: string) => void): void
+  dispose(): void
+}
+const TOOL_ROUTES: Record<string, string> = {
+  list_open_threads: 'threads',
+  reply_to_thread: 'reply',
+  resolve_thread: 'resolve',
+  post_progress: 'progress',
+  raise_question: 'raise_question',
+}
+let studioPort = Number(process.env.PORT) || 4319
+export function setBridgePort(port: number): void {
+  studioPort = port
+}
+const MCP_SERVER = join(import.meta.dir, 'stdio.ts')
+const BIN = process.env.DOMAIN_STUDIO_BRIDGE_BUN || process.execPath
+/** Mint the run-scoped MCP grant and its secret-bearing configuration file. */
+export function startBridge(handle: DomainHandle, notify: (event: StudioEvent) => void): Bridge {
+  const token = randomUUID()
+  const fileId = randomUUID()
+  const session = openBridgeSession(handle, token, notify)
+  const base = `http://127.0.0.1:${studioPort}/api/domain/${encodeURIComponent(handle.id)}/agent/bridge`
+  const bridgeRel = `.cache/agent/bridge-${fileId}.json`
+  writeJson(handle.root, bridgeRel, { base, token })
+  const bridgeConfigPath = statePath(handle.root, bridgeRel)
+  chmodSync(bridgeConfigPath, 0o600)
+  const server: HarnessMcpServer = {
+    name: 'domain-studio',
+    command: BIN,
+    args: [MCP_SERVER, '--config', bridgeConfigPath],
+    required: true,
+    approvalMode: 'approve',
+    enabledTools: Object.keys(TOOL_ROUTES),
+    invoke: async (tool, args) => {
+      const route = TOOL_ROUTES[tool]
+      if (!route) throw new Error(`unknown bridge tool: ${tool}`)
+      const response = await session.invoke(route, args)
+      const result = await response.json()
+      if (!response.ok)
+        throw new Error(
+          typeof result?.error === 'string'
+            ? result.error
+            : `bridge call failed: ${response.status}`,
+        )
+      return result
+    },
+  }
+  return {
+    enabled: true,
+    mcpServers: [server],
+    onReply: session.onReply,
+    onProgress: session.onProgress,
+    dispose: () => {
+      session.dispose()
+      try {
+        removeState(handle.root, bridgeRel)
+      } catch {
+        /* best-effort */
+      }
+    },
+  }
+}

package/studio/server/agent/bridge/routes.test.ts ADDED Viewed

@@ -0,0 +1,151 @@
+import { afterEach, expect, test } from 'bun:test'
+import { mkdtempSync, readFileSync, rmSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import type { DomainHandle } from '../../domain'
+import { readComments, upsertComment } from '../../state/comments'
+import { startBridge } from './grant'
+import { handleBridge } from './routes'
+const roots: string[] = []
+afterEach(() => {
+  while (roots.length) rmSync(roots.pop()!, { recursive: true, force: true })
+})
+function domain(root: string, id: string): DomainHandle {
+  return {
+    id,
+    root,
+    configFile: join(root, 'astrale.config.ts'),
+    domainFile: join(root, 'domain.ts'),
+    schemaDirName: 'schema',
+    schemaDir: join(root, 'schema'),
+    schemaIndex: join(root, 'schema/index.ts'),
+  }
+}
+test('authorizes one domain and applies live thread mutations', async () => {
+  const rootA = mkdtempSync(join(tmpdir(), 'studio-bridge-a-'))
+  const rootB = mkdtempSync(join(tmpdir(), 'studio-bridge-b-'))
+  roots.push(rootA, rootB)
+  const domainA = domain(rootA, 'domain-a')
+  const domainB = domain(rootB, 'domain-b')
+  const awaiting = upsertComment(rootA, {
+    anchors: ['Test'],
+    anchorRefs: [{ ref: 'class.Test', kind: 'schema' }],
+    text: 'please answer',
+  })
+  upsertComment(rootA, {
+    anchors: ['Agent question'],
+    anchorRefs: [{ ref: 'class.Test', kind: 'schema' }],
+    text: 'already answered by author',
+    firstRole: 'author',
+  })
+  const notifications: string[] = []
+  const bridge = startBridge(domainA, (event) =>
+    notifications.push(`${event.type}:${'domainId' in event ? event.domainId : ''}`),
+  )
+  const configPath = bridge.mcpServers[0]!.args!.at(-1)!
+  const { token } = JSON.parse(readFileSync(configPath, 'utf8')) as { token: string }
+  const replies: string[] = []
+  const progress: string[] = []
+  bridge.onReply((id, text) => replies.push(`${id}:${text}`))
+  bridge.onProgress((text) => progress.push(text))
+  const request = new Request('http://studio.test')
+  const invalid = await handleBridge(domainA, 'reply', request, {
+    token: 'wrong',
+    commentId: awaiting.id,
+    text: 'forged',
+  })
+  const crossDomain = await handleBridge(domainB, 'reply', request, {
+    token,
+    commentId: awaiting.id,
+    text: 'forged',
+  })
+  expect([invalid.status, crossDomain.status]).toEqual([401, 401])
+  expect(readComments(rootA).comments[0]!.thread).toHaveLength(1)
+  const listed = await handleBridge(domainA, 'threads', request, { token })
+  expect(await listed.json()).toEqual({
+    threads: [
+      {
+        id: awaiting.id,
+        kind: 'comment',
+        anchor: 'class.Test',
+        file: null,
+        latest: 'please answer',
+      },
+    ],
+  })
+  const replied = await handleBridge(domainA, 'reply', request, {
+    token,
+    commentId: awaiting.id,
+    text: 'done',
+    resolve: true,
+    closeNote: 'complete',
+  })
+  await handleBridge(domainA, 'progress', request, { token, text: 'working' })
+  const raised = await handleBridge(domainA, 'raise_question', request, {
+    token,
+    ref: 'class.Test.property.value',
+    text: 'Which value?',
+    options: ['A', 'B'],
+  })
+  expect(await replied.json()).toEqual({ ok: true, resolved: true })
+  expect(await raised.json()).toMatchObject({ ok: true })
+  const comments = readComments(rootA).comments
+  expect(comments[0]).toMatchObject({
+    id: awaiting.id,
+    status: 'closed',
+    closeNote: 'complete',
+  })
+  expect(comments[0]!.thread.at(-1)).toMatchObject({ role: 'author', text: 'done' })
+  expect(comments.at(-1)).toMatchObject({
+    kind: 'question',
+    status: 'open',
+    thread: [{ role: 'author', type: 'choice', text: 'Which value?', options: ['A', 'B'] }],
+  })
+  expect(replies).toEqual([`${awaiting.id}:done`])
+  expect(progress).toEqual(['working'])
+  expect(notifications).toEqual(['comments:domain-a', 'comments:domain-a'])
+  bridge.dispose()
+  const expired = await handleBridge(domainA, 'threads', request, { token })
+  expect(expired.status).toBe(401)
+})
+test('returns committed success when UI notification delivery fails', async () => {
+  const root = mkdtempSync(join(tmpdir(), 'studio-bridge-notify-'))
+  roots.push(root)
+  const handle = domain(root, 'domain-notify')
+  const comment = upsertComment(root, {
+    anchors: ['Test'],
+    anchorRefs: [{ ref: 'class.Test', kind: 'schema' }],
+    text: 'reply once',
+  })
+  const bridge = startBridge(handle, () => {
+    throw new Error('listener failed')
+  })
+  const configPath = bridge.mcpServers[0]!.args!.at(-1)!
+  const { token } = JSON.parse(readFileSync(configPath, 'utf8')) as { token: string }
+  const response = await handleBridge(handle, 'reply', new Request('http://studio.test'), {
+    token,
+    commentId: comment.id,
+    text: 'committed',
+  })
+  expect(response.status).toBe(200)
+  expect(readComments(root).comments[0]!.thread.map((entry) => entry.text)).toEqual([
+    'reply once',
+    'committed',
+  ])
+  bridge.dispose()
+})