@astrale-os/cli 1.0.0-beta.8 → 1.0.0-npm-deprecated.0

package/studio/server/agent/prompts/anchors.test.ts

@@ -1,70 +0,0 @@
-import { describe, expect, test } from 'bun:test'
-
-import type { SchemaIR } from '../../../shared/types'
-
-import { describeAnchor } from './anchors'
-
-const importedKey = 'directory.example.dev:class.Named' as const
-const ir: SchemaIR = {
-  format: 'astrale.dsl',
-  version: 'v1',
-  domain: 'example.dev',
-  classes: {
-    Item: {
-      type: 'node',
-      name: 'Item',
-      origin: 'example.dev',
-      ref: { origin: 'example.dev', kind: 'class', name: 'Item' },
-      properties: { count: { type: 'integer' } },
-      required: ['count'],
-      methods: {},
-    },
-  },
-  importsByKey: {
-    [importedKey]: {
-      origin: 'directory.example.dev',
-      key: importedKey,
-      ref: { origin: 'directory.example.dev', kind: 'class', name: 'Named' },
-    },
-  },
-  importedClassesByKey: {
-    [importedKey]: {
-      type: 'node',
-      name: 'Named',
-      origin: 'directory.example.dev',
-      ref: { origin: 'directory.example.dev', kind: 'class', name: 'Named' },
-      properties: { label: { type: 'string' } },
-      required: [],
-      methods: {},
-    },
-  },
-  functions: {
-    inspect: {
-      name: 'inspect',
-      input: { type: 'object', properties: { cursor: { type: 'string' } }, required: [] },
-      output: { mode: 'stream', item: { type: 'integer' } },
-      auth: 'authenticated',
-    },
-  },
-  views: {},
-  policies: {},
-  dependencies: [],
-  core: {},
-}
-
-describe('anchor descriptions', () => {
-  test('describes local and exact imported Class properties', () => {
-    expect(describeAnchor('class.Item.property.count', ir, undefined)).toContain(
-      '**Item.count** : int',
-    )
-    expect(describeAnchor(`class.${importedKey}.property.label`, ir, undefined)).toContain(
-      '**Named.label** : string?',
-    )
-  })
-
-  test('describes standalone Functions with output mode and authentication', () => {
-    expect(describeAnchor('function.inspect', ir, undefined)).toContain(
-      'stream<int> [authenticated]',
-    )
-  })
-})

package/studio/server/agent/prompts/anchors.ts

@@ -1,153 +0,0 @@
-/**
- * prompts/anchors.ts — focused anchor descriptions for turn and Ask prompts.
- * The whole-domain schema map is intentionally not embedded in agent turns; the
- * agent reads schema/ directly when it needs broader context.
- */
-import type {
-  Comment,
-  IrClass,
-  IrClassKey,
-  IrFunction,
-  IrMethod,
-  JsonSchema,
-  SchemaIR,
-  SchemaOverlay,
-} from '../../../shared/types'
-
-/** Terse JSON-Schema type label (mirrors the client's format.tsx describe/typeLabel). */
-function propType(s: JsonSchema | undefined, optionalOverride?: boolean): string {
-  if (!s) return 'any'
-  const t = s.type
-  const optional = optionalOverride ?? (Array.isArray(t) ? t.includes('null') : false)
-  const base = Array.isArray(t) ? t.find((x) => x !== 'null') : t
-  let label: string
-  if (s.enum) label = `enum(${s.enum.map(String).join('|')})`
-  else if (s.$nodeRef) label = '→node'
-  else if (s.$dataRef) label = '→data'
-  else if (base === 'array') label = `${propType(s.items)}[]`
-  else if (base === 'object') label = `{${Object.keys(s.properties ?? {}).join(',')}}`
-  else if (base === 'integer') label = 'int'
-  else if (typeof base === 'string') label = base
-  else label = 'any'
-  return label + (optional ? '?' : '')
-}
-
-function methodSig(name: string, m: IrMethod | IrFunction): string {
-  const required = new Set(m.input.required ?? [])
-  const params = Object.entries(m.input.properties ?? {})
-    .map(([p, s]) => `${p}:${propType(s, !required.has(p))}`)
-    .join(', ')
-  const output =
-    m.output.mode === 'stream'
-      ? `stream<${propType(m.output.item)}>`
-      : m.output.mode === 'binary'
-        ? 'binary'
-        : propType(m.output.schema)
-  const tags = [
-    'static' in m && m.static ? 'static' : '',
-    'inheritance' in m && m.inheritance === 'abstract' ? 'abstract' : '',
-    m.auth ?? '',
-  ].filter(Boolean)
-  return `${name}(${params})→${output}${tags.length ? ` [${tags.join(',')}]` : ''}`
-}
-
-function classByToken(ir: SchemaIR, token: string): IrClass | undefined {
-  const exact = /^(.+):class\.([A-Za-z_$][\w$]*)$/.exec(token)
-  if (!exact) return ir.classes[token]
-  const [, origin, name] = exact
-  if (origin === ir.domain) return ir.classes[name]
-  return ir.importedClassesByKey[`${origin}:class.${name}` as IrClassKey]
-}
-
-/**
- * A focused, compact description of ONE anchor target — the element the user is
- * asking about. Used to inject context into an Ask side-question prompt. Returns
- * a short block (signature + file:line + doc) or just the location for non-code
- * anchors. Empty string when nothing can be resolved.
- */
-export function describeAnchor(
-  ref: string,
-  ir: SchemaIR | null,
-  overlay: SchemaOverlay | undefined,
-): string {
-  const span = overlay?.sourceSpans[ref]
-  const loc = span ? `${span.file}:${span.startLine}` : ''
-  const doc = span?.doc ? ` — ${span.doc.replace(/\s+/g, ' ').trim().slice(0, 160)}` : ''
-
-  // class.X.property.y / class.X.method.m
-  const member = ref.match(/^class\.(.+)\.(property|method)\.([^.]+)$/)
-  if (member && ir) {
-    const [, cls, kind, name] = member
-    const c = classByToken(ir, cls)
-    if (c && kind === 'property' && c.properties?.[name])
-      return `**${c.name}.${name}** : ${propType(c.properties[name], c.required ? !c.required.includes(name) : undefined)}${loc ? `  (${loc})` : ''}${doc}`
-    if (c && kind === 'method' && c.methods?.[name])
-      return `**${c.name}.${name}** — ${methodSig(name, c.methods[name])}${loc ? `  (${loc})` : ''}${doc}`
-  }
-
-  // class.X / edge.X (edges live in ir.classes too)
-  const cm = ref.match(/^(?:class|edge)\.(.+)$/)
-  if (cm && ir) {
-    const c = classByToken(ir, cm[1])
-    if (c) {
-      const L = [`**${c.name}** (${c.type})${loc ? `  (${loc})` : ''}${doc}`]
-      const props = Object.entries(c.properties ?? {})
-      if (props.length)
-        L.push(
-          `  props: ${props
-            .map(
-              ([p, s]) => `${p}:${propType(s, c.required ? !c.required.includes(p) : undefined)}`,
-            )
-            .join(' · ')}`,
-        )
-      const ms = Object.entries(c.methods ?? {})
-      if (ms.length) L.push(`  methods: ${ms.map(([n, m]) => methodSig(n, m)).join(' · ')}`)
-      if (c.type === 'edge' && c.endpoints?.length)
-        L.push(
-          `  endpoints: ${c.endpoints
-            .map(
-              (e) =>
-                e.refs
-                  ?.map((target) => `${target.origin}:${target.kind}.${target.name}`)
-                  .join('|') ||
-                e.types?.join('|') ||
-                e.name,
-            )
-            .join(' → ')}`,
-        )
-      return L.join('\n')
-    }
-  }
-
-  // Standalone canonical Function.
-  const fm = ref.match(/^function\.([A-Za-z_$][\w$]*)$/)
-  if (fm && ir) {
-    const fn = ir.functions?.[fm[1]]
-    if (fn)
-      return `**${fn.name}** (function) — ${methodSig(fn.name, fn)}${loc ? `  (${loc})` : ''}${doc}`
-  }
-
-  // module / section / file / free — not a specific code element
-  if (loc) return `\`${ref}\` (${loc})${doc}`
-  return ''
-}
-
-/** For each thread, resolve its anchor to a concrete code location + the element's own doc. */
-export function resolveThreadAnchors(
-  threads: Comment[],
-  overlay: SchemaOverlay | undefined,
-): string {
-  const lines: string[] = []
-  threads.forEach((c, i) => {
-    const a = c.anchorRefs?.[0]
-    if (!a) return
-    const span = overlay?.sourceSpans[a.ref]
-    const loc = span
-      ? `${span.file}:${span.startLine}${span.doc ? ` — ${span.doc.replace(/\s+/g, ' ').trim().slice(0, 100)}` : ''}`
-      : a.file
-        ? a.file
-        : '(section / free-text anchor — not a specific code element)'
-    lines.push(`  ${i + 1}. \`${a.ref}\` → ${loc}`)
-  })
-  return lines.length ? `## Where the open threads point\n${lines.join('\n')}` : ''
-}

package/studio/server/agent/prompts/ask.ts

@@ -1,34 +0,0 @@
-import type { SchemaIR, SchemaOverlay } from '../../../shared/types'
-
-import { describeAnchor } from './anchors'
-
-export function buildAskSystemPrompt(): string {
-  return [
-    'You are answering a QUICK side question from inside Domain Studio about ONE element',
-    'of an Astrale domain. This is an ephemeral aside, shown in a small popover and then',
-    'discarded — it is NOT part of the main build conversation.',
-    '- Answer directly and concisely (usually 1–4 sentences). Lead with the answer.',
-    '- You have the same local tool surface and permission mode as the main agent. You may',
-    '  inspect files, run commands, use web/search tools if available, and edit files when',
-    '  the user explicitly asks for a change. Keep any edits tightly scoped and say what changed.',
-    '- No preamble, no machine-state/JSON block, no thread protocol — just the answer.',
-  ].join('\n')
-}
-
-export interface AskParts {
-  anchorRef: string
-  excerpt: string
-  question: string
-  ir: SchemaIR | null
-  overlay?: SchemaOverlay
-}
-
-/** Build one focused side-question prompt. */
-export function buildAskPrompt(parts: AskParts): string {
-  const target = describeAnchor(parts.anchorRef, parts.ir, parts.overlay)
-  const named = parts.excerpt && parts.excerpt !== parts.anchorRef ? ` (${parts.excerpt})` : ''
-  const lines = [`Quick question about \`${parts.anchorRef}\`${named} in this domain.`]
-  if (target) lines.push('', 'Target:', target)
-  lines.push('', `Question: ${parts.question.trim()}`)
-  return lines.join('\n')
-}

package/studio/server/agent/prompts/system.test.ts

@@ -1,13 +0,0 @@
-import { expect, test } from 'bun:test'
-
-import { buildSystemPrompt } from './system'
-
-test('embedded agents receive the current SDK layout contract', () => {
-  const prompt = buildSystemPrompt({ bridge: false })
-
-  expect(prompt).toContain('modular Actions and Workflows')
-  expect(prompt).toContain('pre-Kernel-V2 APIs or layouts')
-  expect(prompt).toContain('Runtime/Application entries')
-  expect(prompt).toContain('do not restore defineDomain or Interface-era layouts')
-  expect(prompt).not.toContain('schema/ runtime/ views/')
-})

package/studio/server/agent/prompts/system.ts

@@ -1,99 +0,0 @@
-/** Build the durable Studio protocol appended to a harness system prompt. */
-export function buildSystemPrompt(options: { bridge: boolean }): string {
-  const lines: string[] = [
-    'You are the build agent for an Astrale domain, driven from **Domain Studio** — a local',
-    'GUI where the user pins comment threads onto schema classes, methods, views, data, etc.',
-    'Each thread is a conversation. Your working directory IS the domain repo root.',
-    '',
-    'FIRST, read each open thread and judge what it actually wants — editing code is ONE possible',
-    'response, not the default. Match the intent:',
-    '- A REQUEST to change something ("add a status enum", "rename X", "implement reservations")',
-    '  → make the smallest correct change in code, then reply with what you did.',
-    '- A QUESTION or open discussion ("what could we add here?", "should we split this?",',
-    '  "is X better than Y?", "thoughts?", "why is …?") → DO NOT touch code. Reply with your',
-    '  analysis. When there are a few concrete directions, offer them as OPTIONS (below) so the',
-    '  user can choose, then WAIT for their answer before implementing anything.',
-    '- AMBIGUOUS, or several reasonable approaches → ask before acting: reply with options rather',
-    '  than guessing and editing. Answering now and implementing on a later turn is always fine.',
-    'A comment that asks a question wants a conversation, not a commit. When in doubt, reply first.',
-    '',
-    'OFFERING OPTIONS (multiple-choice): when a decision is the user’s to make, give a short menu',
-    'instead of a wall of prose. Pass an `options` array (2–5 short, concrete choices) to',
-    'reply_to_thread (to answer their thread) or raise_question (to open a new one). The user picks',
-    'one or types their own; you see their choice next turn. Keep the surrounding text to one framing line.',
-    '',
-    'Operating rules (when a thread genuinely calls for a code change):',
-    '- Read the skills under `.agents/skills/` FIRST and follow them: **astrale-domain**',
-    '  (schema modeling, handlers, views, deploy/install) before editing schema/handlers,',
-    '  and **astrale-cli** when you run the `astrale` CLI. Treat those current skills and',
-    '  the project itself as authoritative; do not restore pre-Kernel-V2 APIs or layouts.',
-    '- Prefer the project’s existing semantic modules over inventing new structure. Current',
-    '  SDK projects author Schema definitions, modular Actions and Workflows, a Runtime,',
-    '  and an Application. Wire modules through their semantic SDK facades and explicit',
-    '  Runtime/Application entries; do not restore defineDomain or Interface-era layouts.',
-    '- The studio re-renders automatically as you save files — never start, build, or refresh',
-    '  anything for the UI to update.',
-    '- Sanity-check schema/handler edits with `pnpm typecheck` (or `tsgo --noEmit`).',
-    '- You ARE allowed to run the shell. When a thread asks you to **deploy or install**, do',
-    '  it yourself: `pnpm prod` (managed deploy + install) or the `astrale` CLI. The user is',
-    '  already authenticated (`astrale auth`). After deploying, VERIFY:',
-    '  `curl <svc-url>/.well-known/astrale/domain.json` must publish this domain origin, and a',
-    '  live smoke call (create a node, call a method) should work',
-    '  — report the URL and what you verified. Long-running commands are fine.',
-    '- SINGLE HEADLESS TURN — you are not a resident session: there is NO background loop and NO',
-    '  wake-on-completion. A shell started with run_in_background (or any “notify me when it',
-    '  finishes” task) is KILLED a few seconds after this turn ends, and you will NOT be re-invoked',
-    '  when it completes. So whenever you must WAIT — a deploy to finish, a service to come up, a',
-    '  long build, or polling an endpoint until it is ready — do it SYNCHRONOUSLY in the FOREGROUND',
-    '  in THIS turn: block on the command, or run a foreground `until …; do sleep N; done` loop',
-    '  (with a sane overall timeout), then act on the result. Never background a wait-and-react task',
-    '  and end your turn expecting to be woken — you won’t be.',
-    '- Do NOT hand-edit anything under .domain-studio/ (that is the studio’s own state).',
-    '',
-    'RAISE DX ISSUES — Astrale runs an in-graph issue tracker (the primary feedback channel). If',
-    'working in this domain costs YOU friction — a confusing or missing Astrale API/error, stale',
-    'docs or skills, or a bug that forced a workaround — FILE a DX issue as part of the task, per',
-    'the **astrale-cli** skill’s “Reporting DX Issues” section: dedup against open issues first, then',
-    '`astrale call /:issues.astrale.ai:class.Issue:create -i admin parent=/issues status=open title=… body=… initialTags=\'["<bug|friction|feature>","<area>"]\'`.',
-    'It is best-effort and non-blocking — never let filing one derail the user’s task — and mention',
-    'the returned issue path in your reply when you file one.',
-    '',
-    'REPLY PROTOCOL — this is how the user sees your answers (they are NOT watching your terminal):',
-    '- For EVERY open thread, append exactly one concise {role:"author"} reply: what you changed,',
-    '  your answer (with `options` when it is a decision), or a clarifying question.',
-    '- If you fully addressed a thread, also set "status":"closed" and add a short "closeNote".',
-    '- You MUST end your final message with a fenced ```json``` machine-state block of the SAME',
-    '  shape you were given: { "schemaVersion", "comments":[ { "id", "anchors", "status",',
-    '  "thread":[ ...every existing entry PLUS your new author entries... ] } ] }. Merge is by id;',
-    '  a thread whose last entry is not yours is resent next turn, so always answer every thread.',
-  ]
-  if (options.bridge) {
-    lines.push(
-      '',
-      'PREFERRED CHANNEL — the **domain-studio** MCP tools are connected. Use them as your',
-      'PRIMARY way to reply, so the user sees answers appear live in the threads:',
-      '  • list_open_threads — see what to address (ids + anchors).',
-      '  • reply_to_thread { commentId, text, resolve?, closeNote?, options? } — answer one thread.',
-      '    Pass `options` (2–5 short strings) to offer a multiple-choice decision. Set resolve=true',
-      '    ONLY when fully handled — never resolve a question you just asked; wait for the answer.',
-      '  • raise_question { ref, text, options? } — open a NEW question thread, optionally with choices.',
-      '  • resolve_thread / post_progress — close or narrate.',
-      'When you reply through these tools you do NOT need the final json block — it is only a',
-      'fallback for if a tool call fails. Still answer EVERY open thread one way or the other.',
-    )
-  }
-  lines.push(
-    '',
-    'WRITING / VOICE — your reader is usually a BUSINESS user, not an engineer. Write the way',
-    'you would brief a smart colleague who does not code:',
-    '- Lead with the outcome in plain language — what now works, what it means for them — not',
-    '  the mechanism. Keep sentences short and concrete; one idea per sentence.',
-    '- Default to business framing over technical detail. Skip jargon,',
-    '  file paths and code unless they are the point. If a technical term is unavoidable, gloss it',
-    '  in a few plain words.',
-    '- Only go technical when the user does first — match their level. Even then, stay crisp:',
-    '  precise and direct, never vague, hand-wavy or padded. No filler, no hedging, no buzzwords.',
-    'Keep prose short. The substance goes in the thread replies and the code.',
-  )
-  return lines.join('\n')
-}

package/studio/server/agent/prompts/turn.ts

@@ -1,66 +0,0 @@
-import type {
-  Comment,
-  ContextItem,
-  DocMeta,
-  SchemaIR,
-  SchemaOverlay,
-  SchemaRevision,
-} from '../../../shared/types'
-
-import { buildCopyMarkdown } from '../../handoff/copy'
-import { resolveThreadAnchors } from './anchors'
-
-export interface TurnParts {
-  origin: string
-  root: string
-  renderFingerprint: string
-  schemaRevision?: SchemaRevision
-  awaitingThreads: Comment[]
-  userContext: ContextItem[]
-  autoContext: ContextItem[]
-  documents: DocMeta[]
-  firstTurn: boolean
-  message?: string
-  ir: SchemaIR | null
-  overlay?: SchemaOverlay
-}
-
-/** Build the handoff payload for one new or follow-up turn. */
-export function buildTurnPrompt(parts: TurnParts): string {
-  const body = buildCopyMarkdown({
-    origin: parts.origin,
-    root: parts.root,
-    renderFingerprint: parts.renderFingerprint,
-    schemaRevision: parts.schemaRevision,
-    openComments: parts.awaitingThreads,
-    userContext: parts.userContext,
-    autoContext: parts.autoContext,
-    documents: parts.documents,
-  })
-  const hasThreads = parts.awaitingThreads.length > 0
-  const header = parts.firstTurn
-    ? hasThreads
-      ? '> New session. The thread pointers and context below are your orientation — implement the open threads and reply by id.'
-      : '> New session. Follow the direct instruction below; use the context below and read schema/ when needed.'
-    : hasThreads
-      ? '> Follow-up turn in the SAME session. The schema files are current (incl. your prior edits); the threads below were added or updated since your last reply — implement and answer them.'
-      : '> Follow-up turn in the SAME session. The schema files are current (incl. your prior edits). Follow the direct instruction below.'
-  const anchors = resolveThreadAnchors(parts.awaitingThreads, parts.overlay)
-  const message = parts.message?.trim()
-  const instruction = message ? ['', '## Direct instruction', '', message] : []
-  return [header, ...instruction, '', anchors, '', body]
-    .filter((part) => part !== undefined)
-    .join('\n')
-}
-
-/** Build the minimal nudge for a surviving interrupted conversation. */
-export function buildResumePrompt(): string {
-  return [
-    '> Resuming the SAME session. Your previous turn was cut off when Domain Studio',
-    '> restarted — nothing else has changed. Pick up exactly where you left off.',
-    '',
-    'Continue and finish what you were doing, then make sure every open thread gets an',
-    'answer through the usual channel (the domain-studio MCP tools, or the final',
-    'machine-state ```json``` block). Keep going from where you stopped — do not restart.',
-  ].join('\n')
-}

package/studio/server/agent/routes.test.ts

@@ -1,176 +0,0 @@
-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 type { AskResult } from './harness/adapter'
-
-import { registerDomain, unregisterDomain } from '../domain'
-import { getHarnessById } from './harness/registry'
-import { handleAgentRoute } from './routes'
-import { NdjsonChannel } from './stream'
-
-const roots: string[] = []
-const domainIds: string[] = []
-const previousHarness = process.env.DOMAIN_STUDIO_HARNESS
-
-afterEach(() => {
-  if (previousHarness === undefined) delete process.env.DOMAIN_STUDIO_HARNESS
-  else process.env.DOMAIN_STUDIO_HARNESS = previousHarness
-  while (domainIds.length) unregisterDomain(domainIds.pop()!)
-  while (roots.length) rmSync(roots.pop()!, { recursive: true, force: true })
-})
-
-function fixture() {
-  const root = mkdtempSync(join(tmpdir(), 'studio-agent-routes-'))
-  roots.push(root)
-  mkdirSync(join(root, 'schema'))
-  writeFileSync(join(root, 'astrale.config.ts'), 'export default {}\n')
-  writeFileSync(join(root, 'application.ts'), 'export default {}\n')
-  writeFileSync(join(root, 'schema/index.ts'), 'export const Test = {}\n')
-  const handle = registerDomain(root)!
-  domainIds.push(handle.id)
-  return handle
-}
-
-async function route(rest: string, method = 'GET', body: any = {}, search = '') {
-  const handle = fixture()
-  const url = new URL(`http://127.0.0.1/api/domain/${handle.id}${rest}${search}`)
-  const req = new Request(url, {
-    method,
-    ...(method === 'POST'
-      ? {
-          headers: { 'content-type': 'application/json' },
-          body: JSON.stringify(body),
-        }
-      : {}),
-  })
-  return handleAgentRoute({ req, url, rest, body, handle, notify: () => {} })
-}
-
-test('owns harness status and prompt routes behind one agent boundary', async () => {
-  process.env.DOMAIN_STUDIO_HARNESS = 'mock'
-
-  const harness = await route('/agent/harness')
-  expect(harness?.status).toBe(200)
-  expect(await harness?.json()).toMatchObject({
-    id: 'mock',
-    label: 'Mock agent (free)',
-    ok: true,
-    locked: true,
-    source: 'environment',
-  })
-
-  const prompt = await route('/agent/prompt/system')
-  expect(await prompt?.json()).toMatchObject({
-    bridge: true,
-  })
-})
-
-test('ignores non-agent routes and rejects unknown agent routes', async () => {
-  process.env.DOMAIN_STUDIO_HARNESS = 'mock'
-  expect(await route('/context')).toBeNull()
-  expect((await route('/agent/unknown'))?.status).toBe(404)
-})
-
-test('rejects stale session ownership and invalid gateway writes at the route boundary', async () => {
-  process.env.DOMAIN_STUDIO_HARNESS = 'mock'
-
-  const staleSession = await route('/agent/session', 'POST', {
-    harness: 'codex',
-    sessionId: 'wrong-owner',
-  })
-  expect(staleSession?.status).toBe(400)
-  expect(await staleSession?.json()).toEqual({
-    error: 'selected harness changed from codex to mock',
-  })
-
-  const invalidGateway = await route('/agent/harness-gateway', 'POST', {
-    action: 'set',
-    scope: 'domain',
-    config: { enabled: true, baseUrl: '', auth: { mode: 'mint' } },
-  })
-  expect(invalidGateway?.status).toBe(400)
-  expect(await invalidGateway?.json()).toEqual({
-    error: 'gateway base URL is required while enabled',
-  })
-})
-
-test('threads an explicit loadout refresh through to the selected harness', async () => {
-  process.env.DOMAIN_STUDIO_HARNESS = 'claude'
-  const harness = getHarnessById('claude')
-  const originalLoadout = harness.loadout
-  let refresh: boolean | undefined
-  harness.loadout = async (_root, options) => {
-    refresh = options?.refresh
-    return {
-      ok: true,
-      tools: [],
-      mcpServers: [],
-      skills: [],
-      agents: [],
-      builtinCommandCount: 0,
-      probedAt: Date.now(),
-    }
-  }
-
-  try {
-    const response = await route('/agent/loadout', 'GET', {}, '?refresh=1')
-    expect(response?.status).toBe(200)
-    expect(refresh).toBe(true)
-  } finally {
-    harness.loadout = originalLoadout
-  }
-})
-
-test('cancels an Ask stream without enqueueing after the client closes it', async () => {
-  process.env.DOMAIN_STUDIO_HARNESS = 'mock'
-  const harness = getHarnessById('mock')
-  const originalAsk = harness.ask
-  let finishAsk!: () => void
-  const askFinished = new Promise<void>((resolve) => (finishAsk = resolve))
-  let receivedAbort = false
-  harness.ask = async (input): Promise<AskResult> => {
-    input.onDelta('first')
-    await new Promise<void>((resolve) => {
-      input.signal.addEventListener(
-        'abort',
-        () => {
-          receivedAbort = true
-          resolve()
-        },
-        { once: true },
-      )
-    })
-    input.onDelta('late')
-    finishAsk()
-    return { text: 'firstlate', isError: false }
-  }
-
-  try {
-    const response = await route('/agent/ask', 'POST', { question: 'stream briefly' })
-    const reader = response!.body!.getReader()
-    expect(new TextDecoder().decode((await reader.read()).value)).toContain('"delta":"first"')
-    await reader.cancel()
-    await askFinished
-    expect(receivedAbort).toBe(true)
-  } finally {
-    harness.ask = originalAsk
-  }
-})
-
-test('an NDJSON channel never enqueues after cancellation', () => {
-  const abortController = new AbortController()
-  const chunks: Uint8Array[] = []
-  const target = {
-    enqueue: (chunk: Uint8Array) => chunks.push(chunk),
-    close: () => {},
-  } as unknown as ReadableStreamDefaultController<Uint8Array>
-  const channel = new NdjsonChannel(target, abortController)
-
-  expect(channel.send({ delta: 'first' })).toBe(true)
-  channel.cancel()
-  expect(abortController.signal.aborted).toBe(true)
-  expect(channel.send({ delta: 'late' })).toBe(false)
-  expect(chunks).toHaveLength(1)
-})