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

package/studio/server/handoff/copy.ts

@@ -1,171 +0,0 @@
-/**
- * Pure copy-payload projection for a Studio handoff (no IO). It turns studio
- * state into a single Markdown handoff payload that an author agent can paste
- * into its own session. The payload ends with a fenced ```json``` machine-state
- * block in the annotate shape so the author can reply by appending
- * {role:'author'} thread entries and merging back by id.
- */
-import type { Comment, ContextItem, DocMeta, SchemaRevision, ThreadEntry } from '../../shared/types'
-
-interface CopyParts {
-  origin: string
-  root: string
-  /** Studio render fingerprint retained by the handoff machine-state. */
-  renderFingerprint: string
-  schemaRevision?: SchemaRevision
-  openComments: Comment[]
-  userContext: ContextItem[]
-  autoContext: ContextItem[]
-  documents?: DocMeta[]
-}
-
-function primaryAnchor(comment: Comment): { ref: string; file?: string } | null {
-  const ref = comment.anchorRefs?.[0]
-  if (!ref) return null
-  return { ref: ref.ref, file: ref.file }
-}
-
-function latestThreadEntry(comment: Comment): ThreadEntry | null {
-  const thread = comment.thread ?? []
-  return thread.length > 0 ? thread[thread.length - 1] : null
-}
-
-function formatBytes(n: number): string {
-  if (!Number.isFinite(n) || n < 0) return 'unknown size'
-  if (n < 1024) return `${n} B`
-  if (n < 1024 * 1024) return `${Math.round(n / 1024)} KB`
-  return `${(n / 1024 / 1024).toFixed(1)} MB`
-}
-
-/** annotate machine-state projection of a comment: {id, anchors, status, thread}. */
-function toMachineState(comment: Comment): {
-  id: string
-  anchors: string[]
-  status: 'open' | 'closed'
-  thread: ThreadEntry[]
-} {
-  return {
-    id: comment.id,
-    anchors: comment.anchors ?? [],
-    status: comment.status,
-    thread: (comment.thread ?? []).map((t) => {
-      const entry: ThreadEntry = {
-        id: t.id,
-        role: t.role,
-        type: t.type,
-        text: t.text,
-      }
-      if (t.options !== undefined) entry.options = t.options
-      if (t.answer !== undefined) entry.answer = t.answer
-      return entry
-    }),
-  }
-}
-
-export function buildCopyMarkdown(parts: CopyParts): string {
-  const {
-    origin,
-    root,
-    renderFingerprint,
-    schemaRevision,
-    openComments,
-    userContext,
-    autoContext,
-    documents = [],
-  } = parts
-  const lines: string[] = []
-
-  // ── Header ──
-  lines.push(`# Domain handoff — ${origin}`)
-  lines.push('')
-  lines.push(`- **Origin:** \`${origin}\``)
-  lines.push(`- **Repo root:** \`${root}\``)
-  if (schemaRevision) lines.push(`- **Schema revision:** \`${schemaRevision}\``)
-  lines.push(`- **Render fingerprint:** \`${renderFingerprint}\``)
-  lines.push('')
-  lines.push(
-    'Load the **astrale-domain** skill, use the context/threads below, ' +
-      'read any listed context documents if relevant, edit code on disk, and reply by appending one `{role:"author"}` entry per open thread ' +
-      '(merge by `id`). Resolve a thread by adding a closing note plus `"status":"closed"`; ' +
-      'a thread whose last entry is not yours will be resent.',
-  )
-  lines.push('')
-
-  // ── Context documents (paths only; contents stay on disk for the agent to read on demand) ──
-  if (documents.length > 0) {
-    lines.push('## Context documents')
-    lines.push('')
-    for (const doc of documents) {
-      const type = doc.type || 'application/octet-stream'
-      lines.push(
-        `- \`.domain-studio/${doc.stored}\` — ${doc.name} (${type}, ${formatBytes(doc.size)})`,
-      )
-    }
-    lines.push('')
-  }
-
-  // ── Saved context notes ──
-  if (userContext.length > 0) {
-    lines.push('## Saved context notes')
-    lines.push('')
-    for (const item of userContext) {
-      lines.push(`### ${item.title}`)
-      lines.push('')
-      lines.push(item.body)
-      lines.push('')
-    }
-  }
-
-  // ── Context (auto) — optional, caller already filtered ──
-  if (autoContext.length > 0) {
-    lines.push('## Auto context')
-    lines.push('')
-    for (const item of autoContext) {
-      lines.push(`### ${item.title}`)
-      lines.push('')
-      lines.push(item.body)
-      lines.push('')
-    }
-  }
-
-  // ── Open comments & questions ──
-  lines.push('## Open comments & questions')
-  lines.push('')
-  if (openComments.length === 0) {
-    lines.push('_none_')
-    lines.push('')
-  } else {
-    openComments.forEach((comment, i) => {
-      const anchor = primaryAnchor(comment)
-      const latest = latestThreadEntry(comment)
-      const head = `${i + 1}. **${comment.kind}**`
-      const where = anchor ? ` — \`${anchor.ref}\`${anchor.file ? ` (${anchor.file})` : ''}` : ''
-      lines.push(`${head}${where}`)
-      if (latest) {
-        lines.push(`   - ${latest.role}: ${latest.text}`)
-        if (latest.type === 'choice') {
-          if (latest.options && latest.options.length > 0) {
-            lines.push(`   - options: ${latest.options.join(', ')}`)
-          }
-          lines.push(`   - answer: ${latest.answer ?? '(unanswered)'}`)
-        }
-      }
-      lines.push('')
-    })
-  }
-
-  // ── Trailing machine-state block ──
-  // `schemaVersion` is the established annotate wire key. Its value remains the
-  // render fingerprint because it detects anchor/layout drift, not installation
-  // compatibility.
-  const machineState = {
-    schemaVersion: renderFingerprint,
-    comments: openComments.map(toMachineState),
-  }
-  lines.push('```json')
-  lines.push(JSON.stringify(machineState, null, 2))
-  lines.push('```')
-  lines.push('')
-
-  return lines.join('\n')
-}

package/studio/server/handoff/service.test.ts

@@ -1,22 +0,0 @@
-import { expect, test } from 'bun:test'
-
-import type { ChangeSet } from '../../shared/types'
-
-import { changeText } from './service'
-
-test('labels schema changes as indicative structure rather than Runtime compatibility', () => {
-  const changes: ChangeSet = {
-    source: 'baseline',
-    hasGit: false,
-    hasBaseline: true,
-    schemaChanges: [{ kind: 'class-removed', target: 'Legacy' }],
-    fileChanges: [],
-    structuralStatus: 'changed',
-  }
-
-  const text = changeText(changes)
-  expect(text).toContain('Indicative source/structure diff only')
-  expect(text).toContain('~ class-removed Legacy')
-  expect(text).not.toContain('BREAKING')
-  expect(text).not.toContain('additive')
-})

package/studio/server/handoff/service.ts

@@ -1,62 +0,0 @@
-/**
- * Handoff service that turns live domain state into the "what changed
- * + what to read" material both the Copy payload (api.ts) and the live agent
- * runner depend on. Extracted so there is ONE definition of the change text and
- * the auto-context refresh.
- */
-import type { ChangeSet } from '../../shared/types'
-import type { DomainHandle } from '../domain'
-
-import { getBundle } from '../cache'
-import { computeChanges, hashAnatomyFiles } from '../state/baseline'
-import { readComments } from '../state/comments'
-import { materializeAuto } from '../state/context'
-import { detectGit, gitDiff } from '../workspace/git'
-
-/** Current changes vs the review baseline (schema IR diff + anatomy file diff). */
-export async function changeSet(handle: DomainHandle): Promise<ChangeSet> {
-  const bundle = await getBundle(handle.id)
-  const files = hashAnatomyFiles(handle.root, handle.schemaDirName)
-  const { hasGit } = detectGit(handle.root)
-  const diffText = hasGit ? gitDiff(handle.root, handle.schemaDirName) : null
-  return computeChanges(handle.root, bundle?.ir ?? null, files, {
-    currentRevision: bundle?.schemaRevision ?? null,
-    git: {
-      hasGit,
-      ...(diffText === null ? {} : { diffText }),
-    },
-  })
-}
-
-/** A human-readable "current changes" blob for the handoff payload. */
-export function changeText(cs: ChangeSet): string {
-  const notice =
-    'Indicative source/structure diff only; the Kernel Runtime has not assessed installation or data migration.'
-  if (cs.schemaDiffText && cs.schemaDiffText.trim()) return `${notice}\n${cs.schemaDiffText.trim()}`
-  const lines: string[] = []
-  for (const c of cs.schemaChanges)
-    lines.push(`~ ${c.kind} ${c.target}${c.detail ? ` (${c.detail})` : ''}`)
-  for (const f of cs.fileChanges) lines.push(`~ ${f.status} ${f.file}`)
-  return lines.length > 0 ? `${notice}\n${lines.join('\n')}` : ''
-}
-
-/** Refresh the on-disk context/auto digests so an external agent can read them. */
-export async function refreshAuto(handle: DomainHandle): Promise<void> {
-  const cs = await changeSet(handle)
-  const store = readComments(handle.root)
-  const open = store.comments.filter((c) => c.status === 'open')
-  const commentsDigest = open
-    .map(
-      (c, i) =>
-        `${i + 1}. [${c.kind} ${c.id}] ${c.anchorRefs[0]?.ref ?? ''} — ${c.thread.at(-1)?.text ?? ''}`,
-    )
-    .join('\n')
-  const schemaSummary = cs.schemaChanges.map((c) => `STRUCTURAL ${c.kind} ${c.target}`).join('\n')
-  materializeAuto(handle.root, {
-    changes: changeText(cs) || 'no tracked changes',
-    schemaChange: schemaSummary
-      ? `Indicative only; Runtime compatibility was not assessed.\n${schemaSummary}`
-      : 'no schema changes since baseline',
-    comments: commentsDigest || 'no open comments',
-  })
-}

package/studio/server/index.ts

@@ -1,148 +0,0 @@
-#!/usr/bin/env bun
-/**
- * index.ts — the Domain Studio server entrypoint.
- *
- *   bun server/index.ts [path | --workspace dir] [--port n] [--schema-dir schema] [--open]
- *
- * `path` may be an astrale.config.ts, a domain dir, or a workspace to scan.
- * Boots a Bun HTTP server: serves the built SPA, the JSON API, and the SSE
- * stream; watches each domain's files for live re-render.
- */
-import { existsSync, statSync } from 'node:fs'
-import { dirname, join, resolve } from 'node:path'
-
-import { setBridgePort } from './agent/bridge/grant'
-import { handleApi } from './api'
-import { resolveTarget } from './detect'
-import { allDomains } from './domain'
-import { bootDomain } from './lifecycle'
-import { broadcast, sseResponse } from './sse'
-import { initWorkspaceState, stoppers } from './workspace-state'
-import { watchWorkspace } from './workspace-watch'
-
-const argv = process.argv.slice(2)
-let target = ''
-let port = Number(process.env.PORT) || 4319
-let schemaDir = 'schema'
-// Default OFF — printing the URL is enough; popping a browser is invasive. The CLI
-// owns browser-opening (its own --open), and always passes --no-open here.
-let open = false
-for (let i = 0; i < argv.length; i++) {
-  const a = argv[i]
-  if (a === '--port') port = Number(argv[++i])
-  else if (a === '--schema-dir') schemaDir = argv[++i]
-  else if (a === '--open') open = true
-  else if (a === '--no-open') open = false
-  else if (a === '--workspace') target = argv[++i]
-  else if (!a.startsWith('--')) target = a
-}
-if (!target) target = process.cwd()
-
-const domains = resolveTarget(target, schemaDir)
-if (!domains.length) {
-  console.error(`\n  ✗ No Astrale domains found at ${target}`)
-  console.error(
-    `    (looking for: astrale.config.ts + application.ts + schema.ts or ${schemaDir}/index.ts)\n`,
-  )
-  process.exit(1)
-}
-
-console.log(`\n  Domain Studio — indexing ${domains.length} domain(s):`)
-for (const h of domains) {
-  const { origin, depsInstalled, stop } = await bootDomain(h)
-  stoppers.set(h.id, stop)
-  console.log(`    • ${origin}${depsInstalled ? '' : ' [deps not installed — static fallback]'}`)
-}
-
-// keep the registry in sync with the workspace — pick up domains added/removed at runtime
-const watchRoot = target.endsWith('astrale.config.ts') ? dirname(resolve(target)) : resolve(target)
-initWorkspaceState(watchRoot, schemaDir) // where `create new` scaffolds + the create endpoint reads
-if (existsSync(watchRoot) && statSync(watchRoot).isDirectory())
-  watchWorkspace(watchRoot, schemaDir, stoppers)
-
-const DIST = process.env.DOMAIN_STUDIO_DIST || join(import.meta.dir, '..', 'client', 'dist')
-const DEV = process.env.DOMAIN_STUDIO_DEV === '1'
-const VITE = process.env.VITE_URL || 'http://localhost:5173'
-
-function serveStatic(pathname: string): Response {
-  const rel = pathname === '/' ? 'index.html' : pathname.replace(/^\//, '')
-  const file = join(DIST, rel)
-  if (existsSync(file) && !file.endsWith('/') && rel !== 'index.html') {
-    // Vite emits content-hashed asset names (index-<hash>.js), so a given URL is
-    // immutable — cache it forever. A rebuild produces a NEW name, and the
-    // never-cached shell below points the browser at it.
-    return new Response(Bun.file(file), {
-      headers: { 'cache-control': 'public, max-age=31536000, immutable' },
-    })
-  }
-  const index = join(DIST, 'index.html')
-  if (existsSync(index))
-    // NEVER cache the HTML shell: it references the CURRENT hashed bundle. A stale
-    // shell would point at an asset a later build deleted → 404 → the app never
-    // boots and the page "loads forever". no-store guarantees every load is fresh.
-    return new Response(Bun.file(index), {
-      headers: { 'content-type': 'text/html', 'cache-control': 'no-store' },
-    })
-  return new Response(
-    'client not built — run `vite build` (or set DOMAIN_STUDIO_DEV=1 for the Vite dev server)',
-    { status: 500 },
-  )
-}
-
-// Bind to loopback by default. Studio can trigger a LOCAL harness that edits code
-// and runs commands with the configured access level — exposing the trigger on
-// 0.0.0.0 would be RCE on the LAN. Power users behind a trusted tunnel can opt in
-// via DOMAIN_STUDIO_HOST.
-const HOST = process.env.DOMAIN_STUDIO_HOST || '127.0.0.1'
-const LOOPBACK = HOST === '127.0.0.1' || HOST === 'localhost' || HOST === '::1'
-
-const server = Bun.serve({
-  port,
-  hostname: HOST,
-  // SSE + long agent turns hold connections open; Bun's 10s default would drop
-  // them (and the live UI). 255s is Bun's max; the SSE hub also sends keepalives.
-  idleTimeout: 255,
-  async fetch(req) {
-    const url = new URL(req.url)
-    if (url.pathname === '/api/events') return sseResponse(allDomains().map((d) => d.id))
-    const apiRes = await handleApi(req, url, broadcast)
-    if (apiRes) return apiRes
-    if (DEV) {
-      return fetch(VITE + url.pathname + url.search, {
-        headers: req.headers,
-        method: req.method,
-      }).catch(() => new Response('Vite dev server not reachable', { status: 502 }))
-    }
-    return serveStatic(url.pathname)
-  },
-})
-
-let shuttingDown = false
-async function shutdown(signal: NodeJS.Signals): Promise<void> {
-  if (shuttingDown) return
-  shuttingDown = true
-  for (const stop of stoppers.values()) stop()
-  server.stop(true)
-  process.exit(signal === 'SIGINT' ? 130 : 143)
-}
-process.once('SIGINT', () => void shutdown('SIGINT'))
-process.once('SIGTERM', () => void shutdown('SIGTERM'))
-
-setBridgePort(server.port ?? port)
-const urlStr = `http://localhost:${server.port}`
-console.log(`\n  ▸ ${urlStr}${DEV ? '  (dev proxy → Vite)' : ''}\n`)
-if (!LOOPBACK) {
-  console.warn(
-    `  ⚠ SECURITY: bound to ${HOST} (not loopback). The Submit-to-agent trigger is the\n` +
-      `    only thing standing between the network and an agent that edits code + runs shell\n` +
-      `    with its configured access. Anyone who can reach this port can trigger it. Use only behind\n` +
-      `    a trusted tunnel; unset DOMAIN_STUDIO_HOST to bind 127.0.0.1.\n`,
-  )
-}
-if (open) {
-  try {
-    Bun.spawn(['open', urlStr])
-  } catch {
-    /* headless ok */
-  }
-}

package/studio/server/instances/active.ts

@@ -1,72 +0,0 @@
-import type { InstanceInfo, InstancesState } from '../../shared/types'
-
-import { decodeJsonObject, runStudioCliJson, runStudioCliText } from '../cli'
-
-async function astraleJson(args: string[]): Promise<Record<string, unknown> | null> {
-  const result = await runStudioCliJson(args, decodeJsonObject)
-  return result.ok ? result.data : null
-}
-
-function records(value: unknown): Record<string, unknown>[] {
-  return Array.isArray(value) ? value.map(decodeJsonObject).filter((item) => item !== null) : []
-}
-
-async function activeName(): Promise<string | null> {
-  const active = await astraleJson(['instance', 'active', '--json'])
-  return typeof active?.name === 'string' ? active.name : null
-}
-
-/** The CLI-owned global active instance. */
-export const activeInstanceName = activeName
-
-export async function listInstances(): Promise<InstancesState> {
-  const local = await astraleJson(['instance', 'list', '--bookmarked', '--json'])
-  const active = typeof local?.active === 'string' ? local.active : await activeName()
-  const instances: InstanceInfo[] = []
-  for (const bookmark of records(local?.bookmarks)) {
-    if (typeof bookmark.name !== 'string') continue
-    instances.push({
-      name: bookmark.name,
-      url: typeof bookmark.url === 'string' ? bookmark.url : '',
-      active: bookmark.active === true || bookmark.name === active,
-      kind: 'bookmark',
-    })
-  }
-  const managed = await astraleJson(['instance', 'list', '--admin-only', '--json'])
-  for (const item of records(managed?.instances)) {
-    if (
-      typeof item.slug !== 'string' ||
-      instances.some((instance) => instance.name === item.slug)
-    ) {
-      continue
-    }
-    instances.push({
-      name: item.slug,
-      url: typeof item.url === 'string' ? item.url : '',
-      active: item.slug === active,
-      kind: 'managed',
-    })
-  }
-  if (active && !instances.some((instance) => instance.name === active)) {
-    instances.unshift({ name: active, url: '', active: true, kind: 'bookmark' })
-  }
-  return { active, instances }
-}
-
-export async function setActiveInstance(
-  name: string,
-): Promise<{ ok: boolean; active: string | null; output: string }> {
-  const result = await runStudioCliText([
-    'instance',
-    'use',
-    name,
-    '--adopt-default',
-    '--skip-jwks-check',
-  ])
-  const combined = `${result.stdout}\n${result.stderr}`.trim()
-  return {
-    ok: result.ok,
-    active: await activeName(),
-    output: (combined || result.detail).slice(-1000),
-  }
-}

package/studio/server/instances/deploy-record.test.ts

@@ -1,31 +0,0 @@
-import { afterEach, expect, test } from 'bun:test'
-import { mkdtempSync, rmSync } from 'node:fs'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-
-import { writeJson } from '../state/store'
-import { lastDeploy } from './deploy-record'
-
-const roots: string[] = []
-
-afterEach(() => {
-  while (roots.length > 0) rmSync(roots.pop()!, { recursive: true, force: true })
-})
-
-test('reads the previous deploy fingerprint key but exposes only the current name', () => {
-  const root = mkdtempSync(join(tmpdir(), 'studio-deploy-record-'))
-  roots.push(root)
-  writeJson(root, 'deploy.json', {
-    at: '2026-08-20T00:00:00.000Z',
-    schemaHash: 'sha-legacy',
-    ok: true,
-    url: 'https://notes.svc.example.astrale.ai',
-  })
-
-  expect(lastDeploy(root)).toEqual({
-    at: '2026-08-20T00:00:00.000Z',
-    renderFingerprint: 'sha-legacy',
-    ok: true,
-    url: 'https://notes.svc.example.astrale.ai',
-  })
-})

package/studio/server/instances/deploy-record.ts

@@ -1,37 +0,0 @@
-import type { DeployRecord } from '../../shared/types'
-
-import { asJsonRecord, asString } from '../json'
-import { readJson, writeJson } from '../state/store'
-
-const DEPLOY_RECORD_FILE = 'deploy.json'
-
-function decodeDeployRecord(value: unknown): DeployRecord | undefined {
-  const stored = asJsonRecord(value)
-  const at = asString(stored?.at)
-  if (!at || stored?.ok !== true) return undefined
-  const renderFingerprint = asString(stored.renderFingerprint) ?? asString(stored.schemaHash) ?? ''
-  const url = asString(stored.url)
-  return {
-    at,
-    renderFingerprint,
-    ok: true,
-    ...(url === undefined ? {} : { url }),
-  }
-}
-
-export function lastDeploy(root: string): DeployRecord | null {
-  return readJson(root, DEPLOY_RECORD_FILE, decodeDeployRecord, null)
-}
-
-export function recordSuccessfulDeploy(
-  root: string,
-  renderFingerprint: string | null,
-  url: string | null,
-): void {
-  writeJson(root, DEPLOY_RECORD_FILE, {
-    at: new Date().toISOString(),
-    renderFingerprint: renderFingerprint ?? '',
-    ok: true,
-    url: url ?? undefined,
-  } satisfies DeployRecord)
-}

package/studio/server/instances/deploy.ts

@@ -1,56 +0,0 @@
-import { readFileSync } from 'node:fs'
-import { join } from 'node:path'
-
-import type { DeployResult } from '../../shared/types'
-import type { DomainHandle } from '../domain'
-
-import { recordSuccessfulDeploy } from './deploy-record'
-
-export function hasProdScript(root: string): boolean {
-  try {
-    const pkg = JSON.parse(readFileSync(join(root, 'package.json'), 'utf8'))
-    return typeof pkg?.scripts?.prod === 'string'
-  } catch {
-    return false
-  }
-}
-
-const SVC_URL = /https:\/\/[\w-]+\.svc\.[\w.-]+\.astrale\.ai\b/
-
-/** Run `pnpm prod` only after an explicit outward-facing deploy request. */
-export async function runDeploy(
-  handle: DomainHandle,
-  renderFingerprint: string | null,
-): Promise<DeployResult> {
-  if (!hasProdScript(handle.root)) {
-    return {
-      ok: false,
-      url: null,
-      output:
-        'This domain has no "prod" script in package.json — it is not deployable via `pnpm prod`.',
-    }
-  }
-  let out = ''
-  let err = ''
-  let code = 1
-  try {
-    const proc = Bun.spawn(['pnpm', 'prod'], {
-      cwd: handle.root,
-      stdout: 'pipe',
-      stderr: 'pipe',
-    })
-    ;[out, err] = await Promise.all([
-      new Response(proc.stdout).text(),
-      new Response(proc.stderr).text(),
-    ])
-    code = await proc.exited
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error)
-    return { ok: false, url: null, output: `failed to start pnpm: ${message}` }
-  }
-  const combined = `${out}\n${err}`.trim()
-  const url = combined.match(SVC_URL)?.[0] ?? null
-  const ok = code === 0
-  if (ok) recordSuccessfulDeploy(handle.root, renderFingerprint, url)
-  return { ok, url, output: combined.slice(-6000) }
-}

package/studio/server/instances/probe.test.ts

@@ -1,67 +0,0 @@
-import { describe, expect, test } from 'bun:test'
-
-import { installedDomainCommand, installedDomainProbeResult } from './probe'
-
-describe('installed Domain introspection', () => {
-  test('uses the public bundle introspection command for the selected instance', () => {
-    const descriptor = JSON.stringify({
-      version: 1,
-      executable: '/usr/local/bin/bun',
-      args: ['/workspace/cli/bin/astrale.ts'],
-    })
-    expect(installedDomainCommand('issues.astrale.ai', 'staging', descriptor)).toEqual([
-      '/usr/local/bin/bun',
-      '/workspace/cli/bin/astrale.ts',
-      'introspect',
-      'issues.astrale.ai',
-      '--bundle',
-      '--json',
-      '-i',
-      'staging',
-    ])
-  })
-
-  test('retains the complete installed Bundle for installed SDK admission', () => {
-    const root = {
-      version: 'v1',
-      domain: 'issues.astrale.ai',
-      classes: { Issue: { properties: { title: { type: 'string' } } } },
-    }
-    expect(
-      installedDomainProbeResult(
-        JSON.stringify({
-          state: 'ready',
-          bundle: { format: 'astrale.dsl.bundle', version: 'v1', root, closure: [] },
-        }),
-        '',
-        0,
-      ),
-    ).toEqual({
-      state: 'installed',
-      bundle: { format: 'astrale.dsl.bundle', version: 'v1', root, closure: [] },
-    })
-  })
-
-  test('does not mistake the removed Domain Node shape for installation introspection', () => {
-    expect(
-      installedDomainProbeResult(
-        JSON.stringify({ path: '/issues.astrale.ai', props: { schema: '{"domain":"old"}' } }),
-        '',
-        0,
-      ),
-    ).toEqual({ state: 'unknown', bundle: null })
-  })
-
-  test('recognizes the current CLI not-installed diagnostic', () => {
-    expect(
-      installedDomainProbeResult(
-        '',
-        JSON.stringify({
-          error: 'DOMAIN_NOT_INSTALLED',
-          message: 'Domain issues.astrale.ai is not installed on this Kernel.',
-        }),
-        1,
-      ),
-    ).toEqual({ state: 'not-installed', bundle: null })
-  })
-})