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

package/studio/server/agent/{types.ts → harness/adapter.ts}

@@ -1,5 +1,6 @@
 /**
- * agent/types.ts — the harness-agnostic contract for "run one agent turn".
+ * harness/adapter.ts — the executable boundary implemented by each local agent
+ * harness.
  *
  * A *harness* is whatever local AI agent does the edits (Claude Code, Codex, …).
  * The studio never talks to a model API directly; it shells out to the harness
@@ -7,7 +8,13 @@
  * harness maps its native streaming output onto `AgentStreamEvent`s and returns
  * a final text blob (which carries the machine-state reply block).
  */
-import type { AgentEffort, AgentEventKind, HarnessLoadout } from '../../shared/types'
+import type {
+  AgentAccess,
+  AgentEffort,
+  AgentEventKind,
+  HarnessCapabilities,
+  HarnessLoadout,
+} from '../../../shared/types'
 
 /** A single normalized activity event emitted while the harness runs. */
 export interface AgentStreamEvent {
@@ -17,6 +24,21 @@ export interface AgentStreamEvent {
   target?: string
 }
 
+/** Harness-neutral description of one stdio MCP server. Each harness is
+ * responsible for expressing this in its native CLI/config shape. */
+export interface HarnessMcpServer {
+  name: string
+  command: string
+  args?: string[]
+  env?: Record<string, string>
+  required?: boolean
+  /** Studio's run-scoped write-back tools are user-authorized by the submit. */
+  approvalMode?: 'auto' | 'prompt' | 'writes' | 'approve'
+  enabledTools?: string[]
+  /** In-process harnesses may invoke the same grant without spawning stdio. */
+  invoke?: (tool: string, args: Record<string, unknown>) => Promise<unknown>
+}
+
 export interface AgentTurnInput {
   /** the domain repo root — the agent's working directory */
   root: string
@@ -26,13 +48,16 @@ export interface AgentTurnInput {
   appendSystemPrompt?: string
   /** prior harness session id → resume the same conversation */
   sessionId?: string
+  /** explicit model override; absent preserves the harness's native config/default */
+  model?: string
   /** harness reasoning effort for this turn */
   effort?: AgentEffort
-  /** path to a generated MCP config exposing the studio write-back bridge */
-  mcpConfigPath?: string
-  /** extra env merged into the harness CHILD process only (e.g. ANTHROPIC_BASE_URL
-   *  / ANTHROPIC_AUTH_TOKEN to route through a custom model gateway). Never touches
-   *  the studio's own env or the user's shell / global `claude`. */
+  /** authority granted to the local harness */
+  access?: AgentAccess
+  /** generated MCP servers exposing Studio write-back */
+  mcpServers?: HarnessMcpServer[]
+  /** extra env merged into the harness CHILD process only. Never touches the
+   *  studio's own env or the user's shell/global harness process. */
   env?: Record<string, string>
   /** abort the turn (user pressed Cancel) */
   signal: AbortSignal
@@ -47,7 +72,7 @@ export interface AgentTurnResult {
   finalText: string
   costUsd?: number
   numTurns?: number
-  /** total tokens processed (input + output + cache) */
+  /** total token usage reported by the harness */
   tokens?: number
   isError: boolean
   errorMessage?: string
@@ -68,9 +93,13 @@ export interface AskInput {
   appendSystemPrompt?: string
   /** the domain's live conversation session id to FORK from (undefined ⇒ fresh, no fork) */
   sessionId?: string
+  /** explicit model override; absent preserves the harness's native config/default */
+  model?: string
   /** harness reasoning effort for this side question */
   effort?: AgentEffort
-  /** extra env merged into the harness child only (custom model gateway) — see AgentTurnInput.env */
+  /** authority granted to the local harness */
+  access?: AgentAccess
+  /** extra env merged into the harness child only — see AgentTurnInput.env */
   env?: Record<string, string>
   signal: AbortSignal
   /** called with each chunk of the answer as it streams in */
@@ -93,16 +122,26 @@ export interface HarnessHealth {
   detail?: string
 }
 
+export interface HarnessLoadoutOptions {
+  /** Child-only environment overrides used while probing the harness. */
+  env?: Record<string, string>
+  /** Studio's per-domain override for the selected harness. */
+  model?: string
+  /** Bypass the adapter's short-lived probe cache for an explicit user re-probe. */
+  refresh?: boolean
+}
+
 export interface AgentHarness {
   /** stable id, e.g. 'claude' | 'mock' | 'codex' */
   id: string
   /** human label for the UI */
   label: string
+  capabilities: HarnessCapabilities
   /** is the underlying CLI/binary actually invokable here? */
-  isAvailable(): Promise<boolean>
+  isAvailable(signal?: AbortSignal): Promise<boolean>
   /** optional: a richer install probe for the UI (version + reason). Harnesses that
    *  omit it fall back to isAvailable(). */
-  health?(): Promise<HarnessHealth>
+  health?(signal?: AbortSignal): Promise<HarnessHealth>
   run(input: AgentTurnInput): Promise<AgentTurnResult>
   /** optional: answer a quick forked side question (Ask). Harnesses without a
    *  fork concept simply omit this; the studio falls back gracefully. */
@@ -111,10 +150,22 @@ export interface AgentHarness {
    *  tools, agents) — a read-only window into the agent for the Settings page.
    *  Harnesses without an introspectable loadout omit it. `env` (e.g. a custom
    *  model gateway) is merged into the probe child so the reported model reflects it. */
-  loadout?(root: string, env?: Record<string, string>): Promise<HarnessLoadout>
+  loadout?(root: string, options?: HarnessLoadoutOptions): Promise<HarnessLoadout>
   /** optional: the raw SKILL.md for a skill command, so the UI can show it. */
   skillContent?(
     root: string,
     command: string,
   ): Promise<{ command: string; content: string; path: string } | null>
 }
+
+/** Normalize optional rich health probes into one route-facing result. */
+export async function inspectHarnessHealth(
+  harness: AgentHarness,
+  signal?: AbortSignal,
+): Promise<HarnessHealth> {
+  if (harness.health) return harness.health(signal)
+  return {
+    ok: await harness.isAvailable(signal),
+    bin: harness.id,
+  }
+}

package/studio/server/agent/harness/claude/adapter.test.ts

@@ -0,0 +1,338 @@
+import { afterEach, expect, test } from 'bun:test'
+import { chmodSync, existsSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+
+import { ClaudeCodeHarness } from './adapter'
+
+const roots: string[] = []
+
+afterEach(() => {
+  while (roots.length) rmSync(roots.pop()!, { recursive: true, force: true })
+})
+
+function fakeClaude(root: string): string {
+  const file = join(root, 'fake-claude')
+  writeFileSync(
+    file,
+    `#!/usr/bin/env bun
+const fs = require('node:fs')
+const { spawn } = require('node:child_process')
+const args = process.argv.slice(2)
+if (args[0] === '--version') {
+  console.log('2.1.test')
+  process.exit(0)
+}
+if (process.env.FAKE_CLAUDE_LOG) {
+  fs.appendFileSync(process.env.FAKE_CLAUDE_LOG, JSON.stringify({ args }) + '\\n')
+}
+const modelAt = args.indexOf('--model')
+const model = modelAt >= 0 ? args[modelAt + 1] + '-resolved' : 'native-default'
+const resumedAt = args.indexOf('--resume')
+const session = resumedAt >= 0 ? args[resumedAt + 1] : 'fresh-session'
+const send = (event) => process.stdout.write(JSON.stringify(event) + '\\n')
+send({
+  type: 'system',
+  subtype: 'init',
+  session_id: session,
+  model,
+  permissionMode: 'bypassPermissions',
+  apiKeySource: 'none',
+  cwd: process.cwd(),
+  tools: ['Read', 'Edit'],
+  mcp_servers: [],
+  slash_commands: [],
+  agents: [],
+})
+let prompt = ''
+process.stdin.setEncoding('utf8')
+process.stdin.on('data', (chunk) => { prompt += chunk })
+process.stdin.on('end', () => {
+  if (prompt === '.') return setInterval(() => {}, 1000)
+  if (process.env.FAKE_CLAUDE_MODE === 'no-result') process.exit(0)
+  send({ type: 'assistant', message: { content: [{ type: 'text', text: 'answer' }] } })
+  if (process.env.FAKE_CLAUDE_MODE === 'text-then-crash') {
+    console.error('crashed after text')
+    process.exit(7)
+  }
+  if (process.env.FAKE_CLAUDE_MODE === 'result-error') {
+    send({ type: 'result', subtype: 'error_during_execution', is_error: true, result: 'failed' })
+    return
+  }
+  if (process.env.FAKE_CLAUDE_MODE === 'hang-ignore-term') {
+    process.on('SIGTERM', () => {})
+    const child = spawn(process.execPath, ['-e', "process.on('SIGTERM',()=>{});setInterval(()=>{},1000)"], {
+      stdio: 'ignore',
+    })
+    fs.writeFileSync(
+      process.env.FAKE_CLAUDE_PID_LOG,
+      JSON.stringify({ parent: process.pid, child: child.pid }),
+    )
+    return setInterval(() => {}, 1000)
+  }
+  send({
+    type: 'result',
+    subtype: 'success',
+    result: 'done',
+    session_id: session,
+    num_turns: 1,
+    usage: { input_tokens: 2, output_tokens: 3 },
+  })
+})
+`,
+  )
+  chmodSync(file, 0o755)
+  return file
+}
+
+function invocations(log: string): { args: string[] }[] {
+  return readFileSync(log, 'utf8')
+    .trim()
+    .split('\n')
+    .map((line) => JSON.parse(line))
+}
+
+async function waitFor(predicate: () => boolean, timeoutMs = 3_000): Promise<void> {
+  const deadline = Date.now() + timeoutMs
+  while (!predicate()) {
+    if (Date.now() >= deadline) throw new Error('condition did not become true before timeout')
+    await Bun.sleep(20)
+  }
+}
+
+function processExists(pid: number): boolean {
+  try {
+    process.kill(pid, 0)
+    return true
+  } catch {
+    return false
+  }
+}
+
+test('Claude loadout probing reports and passes the Studio model override', async () => {
+  const root = mkdtempSync(join(tmpdir(), 'studio-claude-model-probe-'))
+  roots.push(root)
+  const log = join(root, 'claude.jsonl')
+  const harness = new ClaudeCodeHarness(fakeClaude(root))
+
+  const loadout = await harness.loadout(root, {
+    model: 'sonnet',
+    env: { FAKE_CLAUDE_LOG: log },
+  })
+
+  expect(loadout).toMatchObject({
+    ok: true,
+    model: 'sonnet-resolved',
+    modelSource: 'studio',
+  })
+  const args = invocations(log)[0].args
+  const modelAt = args.indexOf('--model')
+  expect(args.slice(modelAt, modelAt + 2)).toEqual(['--model', 'sonnet'])
+
+  await harness.loadout(root, {
+    model: 'sonnet',
+    env: { FAKE_CLAUDE_LOG: log },
+  })
+  expect(invocations(log)).toHaveLength(1)
+  await harness.loadout(root, {
+    model: 'sonnet',
+    env: { FAKE_CLAUDE_LOG: log },
+    refresh: true,
+  })
+  expect(invocations(log)).toHaveLength(2)
+})
+
+test('Claude turns and Ask calls carry selected models and native effort modes', async () => {
+  const root = mkdtempSync(join(tmpdir(), 'studio-claude-model-turns-'))
+  roots.push(root)
+  const log = join(root, 'claude.jsonl')
+  const harness = new ClaudeCodeHarness(fakeClaude(root))
+  const signal = new AbortController().signal
+
+  const normal = await harness.run({
+    root,
+    prompt: 'normal turn',
+    model: 'sonnet',
+    effort: 'ultracode',
+    access: 'full',
+    env: { FAKE_CLAUDE_LOG: log },
+    signal,
+    onEvent: () => {},
+  })
+  expect(normal).toMatchObject({
+    sessionId: 'fresh-session',
+    finalText: 'done',
+    isError: false,
+  })
+
+  const resumed = await harness.run({
+    root,
+    prompt: 'resumed turn',
+    sessionId: 'parent-session',
+    model: 'opus',
+    effort: 'max',
+    access: 'full',
+    env: { FAKE_CLAUDE_LOG: log },
+    signal,
+    onEvent: () => {},
+  })
+  expect(resumed).toMatchObject({
+    sessionId: 'parent-session',
+    finalText: 'done',
+    isError: false,
+  })
+
+  const fresh = await harness.ask({
+    root,
+    prompt: 'fresh ask',
+    model: 'fable',
+    effort: 'max',
+    access: 'workspace',
+    env: { FAKE_CLAUDE_LOG: log },
+    signal,
+    onDelta: () => {},
+  })
+  const forked = await harness.ask({
+    root,
+    prompt: 'forked ask',
+    sessionId: 'parent-session',
+    model: 'sonnet',
+    effort: 'max',
+    access: 'workspace',
+    env: { FAKE_CLAUDE_LOG: log },
+    signal,
+    onDelta: () => {},
+  })
+  expect(fresh).toEqual({ text: 'done', isError: false })
+  expect(forked).toEqual({ text: 'done', isError: false })
+
+  const [normalArgs, resumedArgs, freshArgs, forkArgs] = invocations(log).map((entry) => entry.args)
+  expect(normalArgs).not.toContain('--resume')
+  expect(
+    normalArgs.slice(normalArgs.indexOf('--model'), normalArgs.indexOf('--model') + 2),
+  ).toEqual(['--model', 'sonnet'])
+  expect(
+    resumedArgs.slice(resumedArgs.indexOf('--resume'), resumedArgs.indexOf('--resume') + 2),
+  ).toEqual(['--resume', 'parent-session'])
+  expect(
+    resumedArgs.slice(resumedArgs.indexOf('--model'), resumedArgs.indexOf('--model') + 2),
+  ).toEqual(['--model', 'opus'])
+  expect(freshArgs.slice(freshArgs.indexOf('--model'), freshArgs.indexOf('--model') + 2)).toEqual([
+    '--model',
+    'fable',
+  ])
+  expect(freshArgs).not.toContain('--resume')
+  expect(forkArgs.slice(forkArgs.indexOf('--model'), forkArgs.indexOf('--model') + 2)).toEqual([
+    '--model',
+    'sonnet',
+  ])
+  expect(forkArgs.slice(forkArgs.indexOf('--resume'), forkArgs.indexOf('--resume') + 3)).toEqual([
+    '--resume',
+    'parent-session',
+    '--fork-session',
+  ])
+  const normalEffortAt = normalArgs.indexOf('--effort')
+  expect(normalArgs.slice(normalEffortAt, normalEffortAt + 2)).toEqual(['--effort', 'xhigh'])
+  const settingsAt = normalArgs.indexOf('--settings')
+  expect(normalArgs.slice(settingsAt, settingsAt + 2)).toEqual(['--settings', '{"ultracode":true}'])
+  expect(normalArgs).not.toContain('ultracode')
+
+  for (const args of [resumedArgs, freshArgs, forkArgs]) {
+    const effortAt = args.indexOf('--effort')
+    expect(args.slice(effortAt, effortAt + 2)).toEqual(['--effort', 'max'])
+  }
+})
+
+test('Claude turns and Ask reject incomplete terminal protocols', async () => {
+  const root = mkdtempSync(join(tmpdir(), 'studio-claude-terminal-'))
+  roots.push(root)
+  const harness = new ClaudeCodeHarness(fakeClaude(root))
+  const input = {
+    root,
+    prompt: 'work',
+    signal: new AbortController().signal,
+    onEvent: () => {},
+  }
+
+  const noResult = await harness.run({
+    ...input,
+    env: { FAKE_CLAUDE_MODE: 'no-result' },
+  })
+  expect(noResult).toMatchObject({
+    isError: true,
+    errorMessage: 'claude exited without a result event',
+  })
+
+  const crashed = await harness.run({
+    ...input,
+    env: { FAKE_CLAUDE_MODE: 'text-then-crash' },
+  })
+  expect(crashed).toMatchObject({
+    isError: true,
+    errorMessage: expect.stringContaining('claude exited 7'),
+  })
+
+  const askInput = {
+    root,
+    prompt: 'question',
+    signal: new AbortController().signal,
+    onDelta: () => {},
+  }
+  const askNoResult = await harness.ask({
+    ...askInput,
+    env: { FAKE_CLAUDE_MODE: 'no-result' },
+  })
+  expect(askNoResult).toMatchObject({
+    isError: true,
+    errorMessage: 'claude exited without a result event',
+  })
+
+  const askCrashed = await harness.ask({
+    ...askInput,
+    env: { FAKE_CLAUDE_MODE: 'text-then-crash' },
+  })
+  expect(askCrashed).toMatchObject({
+    isError: true,
+    errorMessage: expect.stringContaining('claude exited 7'),
+  })
+
+  const askTerminalError = await harness.ask({
+    ...askInput,
+    env: { FAKE_CLAUDE_MODE: 'result-error' },
+  })
+  expect(askTerminalError).toEqual({
+    text: 'failed',
+    isError: true,
+    errorMessage: 'error_during_execution',
+  })
+})
+
+test('Claude Ask cancellation kills the entire stubborn subprocess group', async () => {
+  const root = mkdtempSync(join(tmpdir(), 'studio-claude-ask-cancel-'))
+  roots.push(root)
+  const pidLog = join(root, 'pids.json')
+  const controller = new AbortController()
+  const resultPromise = new ClaudeCodeHarness(fakeClaude(root)).ask({
+    root,
+    prompt: 'question',
+    env: {
+      FAKE_CLAUDE_MODE: 'hang-ignore-term',
+      FAKE_CLAUDE_PID_LOG: pidLog,
+    },
+    signal: controller.signal,
+    onDelta: () => {},
+  })
+
+  await waitFor(() => existsSync(pidLog))
+  const pids = JSON.parse(readFileSync(pidLog, 'utf8')) as { parent: number; child: number }
+  expect(processExists(pids.parent)).toBe(true)
+  expect(processExists(pids.child)).toBe(true)
+  controller.abort()
+
+  expect(await resultPromise).toEqual({
+    text: '',
+    isError: true,
+    errorMessage: 'canceled',
+  })
+  await waitFor(() => !processExists(pids.parent) && !processExists(pids.child))
+})

package/studio/server/agent/harness/claude/adapter.ts

@@ -0,0 +1,71 @@
+import type { HarnessLoadout } from '../../../../shared/types'
+import type {
+  AgentHarness,
+  AgentTurnInput,
+  AgentTurnResult,
+  AskInput,
+  HarnessHealth,
+  HarnessLoadoutOptions,
+} from '../adapter'
+
+import { readSkillContent } from '../skills'
+import { runClaudeAsk } from './ask'
+import { CLAUDE_CAPABILITIES } from './capabilities'
+import { runClaudeTurn } from './events'
+import { loadClaudeConfiguration, probeClaudeHealth } from './loadout'
+import { scanClaudeSkills } from './skills'
+
+const DEFAULT_BIN = process.env.DOMAIN_STUDIO_CLAUDE_BIN || 'claude'
+
+export class ClaudeCodeHarness implements AgentHarness {
+  id = 'claude'
+  label = 'Claude Code (local)'
+  capabilities = CLAUDE_CAPABILITIES
+
+  private availCache?: { at: number; health: HarnessHealth }
+  private loadoutCache?: { at: number; key: string; data: HarnessLoadout }
+
+  constructor(private readonly bin = DEFAULT_BIN) {}
+
+  async health(signal?: AbortSignal): Promise<HarnessHealth> {
+    const now = Date.now()
+    if (this.availCache && now - this.availCache.at < 30_000) return this.availCache.health
+    const health = await probeClaudeHealth(this.bin, signal)
+    if (!signal?.aborted) this.availCache = { at: now, health }
+    return health
+  }
+
+  async isAvailable(signal?: AbortSignal): Promise<boolean> {
+    return (await this.health(signal)).ok
+  }
+
+  async loadout(root: string, options?: HarnessLoadoutOptions): Promise<HarnessLoadout> {
+    const now = Date.now()
+    const key = `${root}\u0000${options?.model ?? ''}\u0000${JSON.stringify(options?.env ?? {})}`
+    if (
+      !options?.refresh &&
+      this.loadoutCache &&
+      this.loadoutCache.key === key &&
+      now - this.loadoutCache.at < 60_000
+    )
+      return this.loadoutCache.data
+    const data = await loadClaudeConfiguration(this.bin, root, options)
+    this.loadoutCache = { at: now, key, data }
+    return data
+  }
+
+  async skillContent(
+    root: string,
+    command: string,
+  ): Promise<{ command: string; content: string; path: string } | null> {
+    return readSkillContent(scanClaudeSkills(root), command)
+  }
+
+  run(input: AgentTurnInput): Promise<AgentTurnResult> {
+    return runClaudeTurn(this.bin, input)
+  }
+
+  ask(input: AskInput) {
+    return runClaudeAsk(this.bin, input)
+  }
+}

package/studio/server/agent/harness/claude/ask.ts

@@ -0,0 +1,114 @@
+import { spawn } from 'node:child_process'
+
+import type { AskInput, AskResult } from '../adapter'
+
+import { childEnvironment, terminateProcessTree } from '../process'
+import { buildClaudeAskArgs } from './command'
+
+/** Execute one ephemeral Claude side-question stream. */
+export function runClaudeAsk(bin: string, input: AskInput): Promise<AskResult> {
+  return new Promise((resolve) => {
+    let finalText = ''
+    let stderr = ''
+    let isError = false
+    let errorMessage: string | undefined
+    let sawResult = false
+    let settled = false
+    let forceKillTimer: ReturnType<typeof setTimeout> | undefined
+    let onAbort = () => {}
+    const finish = (result: AskResult) => {
+      if (settled) return
+      settled = true
+      if (forceKillTimer) clearTimeout(forceKillTimer)
+      input.signal.removeEventListener('abort', onAbort)
+      resolve(result)
+    }
+
+    let child: ReturnType<typeof spawn>
+    try {
+      child = spawn(bin, buildClaudeAskArgs(input), {
+        cwd: input.root,
+        stdio: ['pipe', 'pipe', 'pipe'],
+        env: childEnvironment(input.env),
+        detached: process.platform !== 'win32',
+      })
+    } catch (error) {
+      finish({
+        text: finalText,
+        isError: true,
+        errorMessage: `failed to spawn ${bin}: ${String(error)}`,
+      })
+      return
+    }
+    onAbort = () => {
+      terminateProcessTree(child)
+      forceKillTimer = setTimeout(() => terminateProcessTree(child, 'SIGKILL'), 2_000)
+      forceKillTimer.unref?.()
+    }
+    if (input.signal.aborted) onAbort()
+    else input.signal.addEventListener('abort', onAbort, { once: true })
+    child.stdin?.write(input.prompt)
+    child.stdin?.end()
+
+    const handleLine = (line: string) => {
+      let event: any
+      try {
+        event = JSON.parse(line)
+      } catch {
+        return
+      }
+      if (event.type === 'assistant' && Array.isArray(event.message?.content)) {
+        for (const block of event.message.content)
+          if (block.type === 'text' && block.text) input.onDelta(block.text)
+      } else if (event.type === 'result') {
+        sawResult = true
+        if (typeof event.result === 'string') finalText = event.result
+        if (
+          event.is_error ||
+          event.subtype === 'error_during_execution' ||
+          event.subtype === 'error_max_turns'
+        ) {
+          isError = true
+          errorMessage = event.subtype || 'ask error'
+        }
+      }
+    }
+    let buffer = ''
+    child.stdout?.setEncoding('utf8')
+    child.stdout?.on('data', (chunk: string) => {
+      buffer += chunk
+      let newline: number
+      while ((newline = buffer.indexOf('\n')) >= 0) {
+        const line = buffer.slice(0, newline).trim()
+        buffer = buffer.slice(newline + 1)
+        if (line) handleLine(line)
+      }
+    })
+    child.stderr?.setEncoding('utf8')
+    child.stderr?.on('data', (chunk: string) => {
+      stderr += chunk
+    })
+    child.on('error', (error) =>
+      finish({
+        text: finalText,
+        isError: true,
+        errorMessage: `failed to spawn ${bin}: ${error.message}`,
+      }),
+    )
+    child.on('close', (code) => {
+      const trailing = buffer.trim()
+      if (trailing) handleLine(trailing)
+      if (input.signal.aborted)
+        return finish({ text: finalText, isError: true, errorMessage: 'canceled' })
+      if (code !== 0) {
+        isError = true
+        errorMessage =
+          errorMessage || `claude exited ${code}${stderr ? `: ${stderr.slice(-300)}` : ''}`
+      } else if (!sawResult) {
+        isError = true
+        errorMessage = 'claude exited without a result event'
+      }
+      finish({ text: finalText, isError, errorMessage })
+    })
+  })
+}

package/studio/server/agent/harness/claude/capabilities.ts

@@ -0,0 +1,27 @@
+import type { HarnessCapabilities } from '../../../../shared/types'
+
+/** Stable model aliases plus the effort modes supported by current Claude Code. */
+export const CLAUDE_CAPABILITIES = {
+  effortLevels: ['low', 'medium', 'high', 'xhigh', 'max', 'ultracode'],
+  accessLevels: ['workspace', 'full'],
+  modelOptions: [
+    {
+      id: 'fable',
+      label: 'Fable',
+      description: 'Claude Code alias for the latest available Fable model.',
+    },
+    {
+      id: 'sonnet',
+      label: 'Sonnet',
+      description: 'Claude Code alias for the latest available Sonnet model.',
+    },
+    {
+      id: 'opus',
+      label: 'Opus',
+      description: 'Claude Code alias for the latest available Opus model.',
+    },
+  ],
+  ask: true,
+  loadout: true,
+  gateway: 'anthropic',
+} as const satisfies HarnessCapabilities