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

package/studio/server/agent/harness/registry.ts

@@ -0,0 +1,37 @@
+import type { AgentHarness } from './adapter'
+
+/**
+ * Register the concrete local harness adapters and reuse their process-level
+ * caches across domains.
+ */
+import { ClaudeCodeHarness } from './claude/adapter'
+import { CodexHarness } from './codex/adapter'
+import { MockHarness } from './mock/adapter'
+
+const harnesses: Record<string, () => AgentHarness> = {
+  claude: () => new ClaudeCodeHarness(),
+  codex: () => new CodexHarness(),
+  mock: () => new MockHarness(),
+}
+
+const instances = new Map<string, AgentHarness>()
+
+export function hasHarness(id: string): boolean {
+  return !!harnesses[id]
+}
+
+export function getHarnessById(id: string): AgentHarness {
+  let harness = instances.get(id)
+  if (!harness) {
+    harness = (harnesses[id] ?? harnesses.claude)()
+    instances.set(id, harness)
+  }
+  return harness
+}
+
+/** All registered harnesses (id + label) — for the (currently locked) UI selector. */
+export function listHarnesses(selected?: string): { id: string; label: string }[] {
+  return Object.entries(harnesses)
+    .filter(([id]) => id !== 'mock' || id === selected)
+    .map(([id, make]) => ({ id, label: make().label }))
+}

package/studio/server/agent/harness/selection.test.ts

@@ -0,0 +1,75 @@
+import { afterEach, expect, test } from 'bun:test'
+import { mkdtempSync, rmSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+
+import { updateSettings } from '../../state/settings'
+import {
+  getHarness,
+  getHarnessSelection,
+  resolveHarnessConfiguration,
+  setHarnessSelection,
+} from './selection'
+
+const roots: string[] = []
+const previous = process.env.DOMAIN_STUDIO_HARNESS
+
+afterEach(() => {
+  if (previous === undefined) delete process.env.DOMAIN_STUDIO_HARNESS
+  else process.env.DOMAIN_STUDIO_HARNESS = previous
+  while (roots.length) rmSync(roots.pop()!, { recursive: true, force: true })
+})
+
+test('persists a per-domain Codex selection', () => {
+  delete process.env.DOMAIN_STUDIO_HARNESS
+  const rootA = mkdtempSync(join(tmpdir(), 'studio-harness-a-'))
+  const rootB = mkdtempSync(join(tmpdir(), 'studio-harness-b-'))
+  roots.push(rootA, rootB)
+  expect(getHarnessSelection(rootA)).toMatchObject({ id: 'claude', source: 'default' })
+  expect(getHarnessSelection(rootB)).toMatchObject({ id: 'claude', source: 'default' })
+
+  setHarnessSelection(rootA, 'codex')
+  expect(getHarnessSelection(rootA)).toEqual({
+    id: 'codex',
+    locked: false,
+    source: 'domain',
+  })
+  expect(getHarness(rootA).id).toBe('codex')
+  expect(getHarnessSelection(rootB)).toEqual({
+    id: 'claude',
+    locked: false,
+    source: 'default',
+  })
+  expect(getHarness(rootB).id).toBe('claude')
+})
+
+test('environment selection locks the GUI override', () => {
+  const root = mkdtempSync(join(tmpdir(), 'studio-harness-'))
+  roots.push(root)
+  process.env.DOMAIN_STUDIO_HARNESS = 'codex'
+  expect(getHarnessSelection(root)).toEqual({
+    id: 'codex',
+    locked: true,
+    source: 'environment',
+  })
+  expect(() => setHarnessSelection(root, 'claude')).toThrow('locked to codex')
+})
+
+test('resolves persisted Claude max and Ultracode effort modes', async () => {
+  delete process.env.DOMAIN_STUDIO_HARNESS
+  const root = mkdtempSync(join(tmpdir(), 'studio-harness-effort-'))
+  roots.push(root)
+  updateSettings(root, { agentEffort: 'max' })
+
+  const resolved = await resolveHarnessConfiguration(root)
+  expect(resolved.ok).toBe(true)
+  if (!resolved.ok) return
+  expect(resolved.configuration.harness.id).toBe('claude')
+  expect(resolved.configuration.effort).toBe('max')
+
+  updateSettings(root, { agentEffort: 'ultracode' })
+  const ultracode = await resolveHarnessConfiguration(root)
+  expect(ultracode.ok).toBe(true)
+  if (!ultracode.ok) return
+  expect(ultracode.configuration.effort).toBe('ultracode')
+})

package/studio/server/agent/harness/selection.ts

@@ -0,0 +1,77 @@
+import type { AgentEffort, StudioSettings } from '../../../shared/types'
+import type { AgentHarness } from './adapter'
+
+import { effectiveAgentEffort } from '../../../shared/agent-effort'
+import { readSettings } from '../../state/settings'
+import { readJson, writeJson } from '../../state/store'
+import { resolveHarnessEnv } from './gateway/config'
+import { getHarnessById, hasHarness } from './registry'
+
+const SELECTION_FILE = '.cache/agent/harness.json'
+
+export interface HarnessSelection {
+  id: string
+  locked: boolean
+  source: 'environment' | 'domain' | 'default'
+}
+
+export interface HarnessConfiguration {
+  harness: AgentHarness
+  settings: StudioSettings
+  model?: string
+  effort?: AgentEffort
+  env: Record<string, string>
+}
+
+export type HarnessConfigurationResult =
+  | { ok: true; configuration: HarnessConfiguration }
+  | { ok: false; error: string }
+
+export function getHarnessSelection(root: string): HarnessSelection {
+  const environment = process.env.DOMAIN_STUDIO_HARNESS?.trim().toLowerCase()
+  if (environment && hasHarness(environment))
+    return { id: environment, locked: true, source: 'environment' }
+  const stored = readJson<{ id?: string }>(root, SELECTION_FILE, {})
+  const id = stored.id?.toLowerCase()
+  if (id && hasHarness(id)) return { id, locked: false, source: 'domain' }
+  return { id: 'claude', locked: false, source: 'default' }
+}
+
+export function setHarnessSelection(root: string, id: string): HarnessSelection {
+  const normalized = id.trim().toLowerCase()
+  if (!hasHarness(normalized) || normalized === 'mock') throw new Error(`unknown harness: ${id}`)
+  const current = getHarnessSelection(root)
+  if (current.locked)
+    throw new Error(`the harness is locked to ${current.id} by DOMAIN_STUDIO_HARNESS / --harness`)
+  writeJson(root, SELECTION_FILE, { id: normalized })
+  return { id: normalized, locked: false, source: 'domain' }
+}
+
+export function getHarness(root: string): AgentHarness {
+  return getHarnessById(getHarnessSelection(root).id)
+}
+
+/** Resolve the selected adapter and every per-domain option used to invoke it. */
+export async function resolveHarnessConfiguration(
+  root: string,
+  harness = getHarness(root),
+): Promise<HarnessConfigurationResult> {
+  const settings = readSettings(root)
+  const model = settings.agentModels[harness.id]?.trim() || undefined
+  const effort = effectiveAgentEffort(harness.capabilities.effortLevels, settings.agentEffort)
+  const environment =
+    harness.capabilities.gateway === 'anthropic'
+      ? await resolveHarnessEnv(root)
+      : { ok: true as const, env: {} }
+  if (!environment.ok) return { ok: false, error: environment.error }
+  return {
+    ok: true,
+    configuration: {
+      harness,
+      settings,
+      model,
+      effort,
+      env: environment.env,
+    },
+  }
+}

package/studio/server/agent/harness/skills.test.ts

@@ -0,0 +1,95 @@
+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 { scanClaudeSkills } from './claude/skills'
+import { scanCodexSkills } from './codex/skills'
+import { readSkillContent } from './skills'
+
+const roots: string[] = []
+
+afterEach(() => {
+  while (roots.length) rmSync(roots.pop()!, { recursive: true, force: true })
+})
+
+function skill(dir: string, command: string, frontmatter: string): string {
+  const target = join(dir, command)
+  mkdirSync(target, { recursive: true })
+  const path = join(target, 'SKILL.md')
+  writeFileSync(path, `---\n${frontmatter}\n---\n\nInstructions for ${command}.\n`)
+  return path
+}
+
+test('Codex skill discovery prefers the nearest project skill and preserves disabled plugins', () => {
+  const parent = mkdtempSync(join(tmpdir(), 'studio-skills-'))
+  roots.push(parent)
+  const root = join(parent, 'domain')
+  mkdirSync(root)
+  const parentSkill = skill(
+    join(parent, '.agents', 'skills'),
+    'project-check',
+    'name: Parent\ndescription: parent',
+  )
+  const nearestSkill = skill(
+    join(root, '.agents', 'skills'),
+    'project-check',
+    `name: Nearest
+description: >
+  First line of a folded description.
+  Second line stays visible.`,
+  )
+  const pluginRoot = join(parent, 'plugin')
+  const pluginSkill = skill(
+    join(pluginRoot, 'skills'),
+    'review',
+    'name: Review\ndescription: Disabled review tool',
+  )
+
+  const found = scanCodexSkills(root, [{ name: 'demo', path: pluginRoot, enabled: false }])
+  const project = found.find((item) => item.command === 'project-check')!
+  const plugin = found.find((item) => item.command === 'demo:review')!
+
+  expect(project).toMatchObject({
+    name: 'Nearest',
+    description: 'First line of a folded description. Second line stays visible.',
+    source: 'project',
+    loaded: true,
+    path: nearestSkill,
+  })
+  expect(plugin).toMatchObject({
+    name: 'Review',
+    source: 'plugin',
+    plugin: 'demo',
+    loaded: false,
+    path: pluginSkill,
+  })
+  expect(readSkillContent(found, 'demo:review')).toEqual({
+    command: 'demo:review',
+    content: `---\nname: Review\ndescription: Disabled review tool\n---\n\nInstructions for review.\n`,
+    path: pluginSkill,
+  })
+})
+
+test('Claude skill discovery owns Claude project precedence without leaking Codex policy', () => {
+  const parent = mkdtempSync(join(tmpdir(), 'studio-claude-skills-'))
+  roots.push(parent)
+  const root = join(parent, 'domain')
+  mkdirSync(root)
+  skill(join(root, '.agents', 'skills'), 'review', 'name: Shared\ndescription: shared fallback')
+  const claudeSkill = skill(
+    join(root, '.claude', 'skills'),
+    'review',
+    'name: Claude Review\ndescription: Claude-native project skill',
+  )
+
+  const reviews = scanClaudeSkills(root).filter((item) => item.command === 'review')
+  expect(reviews).toEqual([
+    expect.objectContaining({
+      name: 'Claude Review',
+      source: 'project',
+      loaded: true,
+      path: claudeSkill,
+    }),
+  ])
+})

package/studio/server/agent/harness/skills.ts

@@ -0,0 +1,100 @@
+import { existsSync, readdirSync, readFileSync } from 'node:fs'
+import { homedir } from 'node:os'
+import { dirname, join } from 'node:path'
+import { parse as parseYaml } from 'yaml'
+
+import type { LoadoutSkill } from '../../../shared/types'
+
+function readSkillMeta(skillMd: string): { name?: string; description?: string } {
+  let text: string
+  try {
+    text = readFileSync(skillMd, 'utf8')
+  } catch {
+    return {}
+  }
+  if (!text.startsWith('---')) return {}
+  const end = text.indexOf('\n---', 3)
+  const fm = end >= 0 ? text.slice(3, end) : text.slice(3)
+  try {
+    const meta = parseYaml(fm) as { name?: unknown; description?: unknown } | null
+    return {
+      name: typeof meta?.name === 'string' ? meta.name : undefined,
+      description: typeof meta?.description === 'string' ? meta.description.trim() : undefined,
+    }
+  } catch {
+    return {}
+  }
+}
+
+export function scanSkillDir(
+  dir: string,
+  source: LoadoutSkill['source'],
+  plugin: string | undefined,
+  commandPrefix: string,
+  loaded: boolean,
+  out: LoadoutSkill[],
+  seen: Set<string>,
+): void {
+  if (!existsSync(dir)) return
+  let entries: string[]
+  try {
+    entries = readdirSync(dir)
+  } catch {
+    return
+  }
+  for (const entry of entries) {
+    const skillMd = join(dir, entry, 'SKILL.md')
+    if (!existsSync(skillMd)) continue
+    const command = commandPrefix + entry
+    if (seen.has(command)) continue
+    seen.add(command)
+    const meta = readSkillMeta(skillMd)
+    out.push({
+      command,
+      name: meta.name || entry,
+      description: meta.description,
+      source,
+      plugin,
+      loaded,
+      path: skillMd,
+    })
+  }
+}
+
+export function scanAncestors(
+  root: string,
+  dirs: string[],
+  out: LoadoutSkill[],
+  seen: Set<string>,
+): void {
+  const home = homedir()
+  let current = root
+  for (let i = 0; i < 12 && current !== home; i++) {
+    for (const dir of dirs)
+      scanSkillDir(join(current, dir), 'project', undefined, '', true, out, seen)
+    const parent = dirname(current)
+    if (parent === current) break
+    current = parent
+  }
+}
+
+export function readSkillContent(
+  skills: LoadoutSkill[],
+  command: string,
+): { command: string; content: string; path: string } | null {
+  const skill = skills.find((candidate) => candidate.command === command)
+  if (!skill?.path) return null
+  try {
+    return { command, content: readFileSync(skill.path, 'utf8'), path: skill.path }
+  } catch {
+    return null
+  }
+}
+
+export function reconcileLoadedSkills(
+  installed: LoadoutSkill[],
+  loadedCommands: string[],
+): LoadoutSkill[] {
+  const loaded = new Set(loadedCommands)
+  return installed.map((skill) => ({ ...skill, loaded: loaded.has(skill.command) }))
+}

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

@@ -0,0 +1,95 @@
+import { expect, test } from 'bun:test'
+import { readdirSync, readFileSync, statSync } from 'node:fs'
+import { dirname, join, relative, resolve } from 'node:path'
+
+const ROOT = resolve(import.meta.dir)
+
+function sourceFiles(dir = ROOT): string[] {
+  return readdirSync(dir)
+    .flatMap((entry) => {
+      const path = join(dir, entry)
+      if (statSync(path).isDirectory()) return sourceFiles(path)
+      return path.endsWith('.ts') && !path.endsWith('.test.ts') ? [path] : []
+    })
+    .sort()
+}
+
+function imports(file: string): string[] {
+  const source = readFileSync(file, 'utf8')
+  const found: string[] = []
+  const pattern = /(?:from\s+|import\s*\()\s*['"]([^'"]+)['"]/g
+  for (const match of source.matchAll(pattern)) {
+    const specifier = match[1]
+    if (!specifier.startsWith('.')) continue
+    const target = resolve(dirname(file), specifier)
+    const candidate = target.endsWith('.ts') ? target : `${target}.ts`
+    if (candidate.startsWith(ROOT)) found.push(candidate)
+  }
+  return found
+}
+
+function agentPath(file: string): string {
+  return relative(ROOT, file).replaceAll('\\', '/')
+}
+
+test('agent concepts form an acyclic dependency graph', () => {
+  const graph = new Map(sourceFiles().map((file) => [file, imports(file)]))
+  const visiting = new Set<string>()
+  const visited = new Set<string>()
+  const stack: string[] = []
+  const cycles: string[][] = []
+
+  const visit = (file: string) => {
+    if (visiting.has(file)) {
+      const start = stack.indexOf(file)
+      cycles.push([...stack.slice(start), file].map(agentPath))
+      return
+    }
+    if (visited.has(file)) return
+    visiting.add(file)
+    stack.push(file)
+    for (const dependency of graph.get(file) ?? []) if (graph.has(dependency)) visit(dependency)
+    stack.pop()
+    visiting.delete(file)
+    visited.add(file)
+  }
+
+  for (const file of graph.keys()) visit(file)
+  expect(cycles).toEqual([])
+})
+
+test('leaf concepts do not depend on orchestration or HTTP ownership', () => {
+  const violations: string[] = []
+  for (const file of sourceFiles()) {
+    const source = agentPath(file)
+    for (const dependency of imports(file).map(agentPath)) {
+      if (
+        source.startsWith('harness/') &&
+        (dependency.startsWith('run/') ||
+          dependency.startsWith('bridge/') ||
+          dependency.startsWith('prompts/') ||
+          dependency === 'routes.ts')
+      )
+        violations.push(`${source} -> ${dependency}`)
+      if (
+        source.startsWith('prompts/') &&
+        (dependency.startsWith('run/') ||
+          dependency.startsWith('bridge/') ||
+          dependency.startsWith('harness/') ||
+          dependency === 'routes.ts')
+      )
+        violations.push(`${source} -> ${dependency}`)
+      if (
+        source.startsWith('bridge/') &&
+        (dependency.startsWith('run/') ||
+          dependency.startsWith('prompts/') ||
+          dependency.startsWith('harness/claude/') ||
+          dependency.startsWith('harness/codex/') ||
+          dependency.startsWith('harness/mock/') ||
+          dependency === 'routes.ts')
+      )
+        violations.push(`${source} -> ${dependency}`)
+    }
+  }
+  expect(violations).toEqual([])
+})

package/studio/server/agent/notify.ts

@@ -0,0 +1,12 @@
+import type { StudioEvent } from '../../shared/types'
+
+export type Notify = (event: StudioEvent) => void
+
+/** Keep optional UI delivery failures from corrupting committed agent state. */
+export function emitStudioEvent(notify: Notify, event: StudioEvent): void {
+  try {
+    notify(event)
+  } catch {
+    /* the persisted state remains authoritative; clients can refetch */
+  }
+}

package/studio/server/agent/{schema-map.ts → prompts/anchors.ts}

@@ -1,9 +1,9 @@
 /**
- * agent/schema-map.ts — focused anchor descriptions for thread and Ask prompts.
+ * 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, IrMethod, JsonSchema, SchemaIR, SchemaOverlay } from '../../shared/types'
+import type { Comment, 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): string {

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

@@ -0,0 +1,34 @@
+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/{prompt.ts → prompts/system.ts}

@@ -1,18 +1,5 @@
-/**
- * agent/prompt.ts — the scaffolding that tells a harness-agnostic agent who it
- * is and exactly how to answer. Two pieces:
- *   - the SYSTEM prompt (appended to the harness default) = the durable protocol.
- *   - the TURN prompt = the handoff data (context + changes + the threads
- *     awaiting a reply + the machine-state block). Reuses buildCopyMarkdown so
- *     the live loop and the copy/paste flow stay byte-for-byte consistent.
- */
-import type { Comment, ContextItem, DocMeta, SchemaIR, SchemaOverlay } from '../../shared/types'
-
-import { buildCopyMarkdown } from '../state/copy'
-import { describeAnchor, resolveThreadAnchors } from './schema-map'
-
-/** The reply protocol — appended to the harness's own system prompt. */
-export function buildSystemPrompt(opts: { bridge: boolean }): string {
+/** 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.',
@@ -79,7 +66,7 @@ export function buildSystemPrompt(opts: { bridge: boolean }): string {
     '  "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 (opts.bridge) {
+  if (options.bridge) {
     lines.push(
       '',
       'PREFERRED CHANNEL — the **domain-studio** MCP tools are connected. Use them as your',
@@ -109,94 +96,3 @@ export function buildSystemPrompt(opts: { bridge: boolean }): string {
   )
   return lines.join('\n')
 }
-
-export interface TurnParts {
-  origin: string
-  root: string
-  schemaHash: string
-  /** only the threads awaiting an author reply (open, last entry not author) */
-  awaitingThreads: Comment[]
-  userContext: ContextItem[]
-  autoContext: ContextItem[]
-  documents: DocMeta[]
-  firstTurn: boolean
-  /** optional free-text instruction the user typed in the Context composer */
-  message?: string
-  /** current schema IR (null when deps aren't installed → static fallback) */
-  ir: SchemaIR | null
-  overlay?: SchemaOverlay
-}
-
-/** The per-turn message piped to the harness. */
-export function buildTurnPrompt(parts: TurnParts): string {
-  const body = buildCopyMarkdown({
-    origin: parts.origin,
-    root: parts.root,
-    schemaHash: parts.schemaHash,
-    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.'
-  // Inject only precise thread-anchor pointers. The schema overview is not embedded;
-  // the system prompt tells the agent to read/edit schema/ directly when needed.
-  const anchors = resolveThreadAnchors(parts.awaitingThreads, parts.overlay)
-  const msg = parts.message?.trim()
-  const instruction = msg ? ['', '## Direct instruction', '', msg] : []
-  return [header, ...instruction, '', anchors, '', body].filter((s) => s !== undefined).join('\n')
-}
-
-/** A bare "pick up where you left off" nudge for resuming an interrupted turn.
- *  Deliberately empty of handoff data: the resumed session already holds the
- *  threads, context and prior edits, so re-sending them would be pure noise — the
- *  point of Resume is a seamless continue, not a fresh briefing. */
-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')
-}
-
-/** The system prompt for a quick Ask side-question — capable, concise, ephemeral. */
-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
-}
-
-/** Compose the Ask turn: a friendly prefix + the injected target context + the question. */
-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')
-}