@astrale-os/cli 1.0.0-beta.3 → 1.0.0-beta.30

package/studio/server/cache.ts

@@ -16,17 +16,16 @@ import { buildAnatomy } from './introspect/anatomy'
 import { buildBundle } from './introspect/bundle'
 import { isCanonicalDomainSchemaV1 } from './introspect/canonical-schema'
 import { buildCore } from './introspect/core'
-import { decodeIrInterfaceRecord, decodeSchemaIR } from './introspect/schema-ir-json'
-import { asBoolean, asFiniteNumber, asJsonRecord, asString, asStringArray } from './json'
+import { decodeSchemaIR } from './introspect/schema-ir-json'
+import { asBoolean, asFiniteNumber, asJsonRecord, asString } from './json'
 import { hashAnatomyFiles } from './state/baseline'
 import { readJson, writeJson } from './state/store'
 
 const bundles = new Map<string, StudioSchemaBundle>()
 const anatomies = new Map<string, Promise<DomainAnatomy>>()
-const cores = new Map<string, StudioCore>()
 
 const BUNDLE_CACHE_FILE = '.cache/schema-bundle.json'
-const BUNDLE_CACHE_VERSION = 4
+const BUNDLE_CACHE_VERSION = 6
 const LOCKFILES = ['bun.lock', 'pnpm-lock.yaml', 'package-lock.json', 'yarn.lock']
 const TOOL_INPUTS = [
   'cache.ts',
@@ -37,7 +36,6 @@ const TOOL_INPUTS = [
   'introspect/canonical-schema.ts',
   'introspect/overlay.ts',
   'introspect/overlay-tsmorph.ts',
-  'introspect/source-overlay/annotations.ts',
   'introspect/source-overlay/handlers.ts',
   'introspect/source-overlay/kernel-calls.ts',
   'introspect/source-overlay/project.ts',
@@ -53,20 +51,12 @@ interface BundleCacheEntry {
   bundle: StudioSchemaBundle
 }
 
-function isCrossDomainImport(value: unknown): boolean {
-  const record = asJsonRecord(value)
-  return (
-    typeof record?.name === 'string' &&
-    typeof record.origin === 'string' &&
-    (record.definition === 'class' || record.definition === 'interface')
-  )
-}
-
 function isHandlerLink(value: unknown): boolean {
   const record = asJsonRecord(value)
   return (
     typeof record?.owner === 'string' &&
-    ['class', 'interface', 'function'].includes(String(record.ownerKind)) &&
+    ['class', 'function'].includes(String(record.ownerKind)) &&
+    ['action', 'workflow'].includes(String(record.kind)) &&
     typeof record.method === 'string' &&
     typeof record.static === 'boolean' &&
     typeof record.implemented === 'boolean'
@@ -83,37 +73,15 @@ function isSourceSpan(value: unknown): boolean {
   )
 }
 
-function isAnnotation(value: unknown): boolean {
-  const record = asJsonRecord(value)
-  return (
-    typeof record?.target === 'string' &&
-    (record.severity === 'warn' || record.severity === 'info') &&
-    (record.code === 'COMPILE_ERROR' || record.code === 'EDGE_PROP_TYPE_MISSING') &&
-    typeof record.message === 'string'
-  )
-}
-
 function decodeOverlay(value: unknown): SchemaOverlay | undefined {
   const record = asJsonRecord(value)
-  const requires = asStringArray(record?.requires)
-  const crossDomainImports = record?.crossDomainImports
-  const mixins = record?.mixins
   const handlerLinks = record?.handlerLinks
   const sourceSpans = asJsonRecord(record?.sourceSpans)
-  const annotations = record?.annotations
   if (
-    typeof record?.origin !== 'string' ||
-    !requires ||
-    !Array.isArray(crossDomainImports) ||
-    !crossDomainImports.every(isCrossDomainImport) ||
-    !Array.isArray(mixins) ||
-    !mixins.every(isCrossDomainImport) ||
     !Array.isArray(handlerLinks) ||
     !handlerLinks.every(isHandlerLink) ||
     !sourceSpans ||
-    !Object.values(sourceSpans).every(isSourceSpan) ||
-    !Array.isArray(annotations) ||
-    !annotations.every(isAnnotation)
+    !Object.values(sourceSpans).every(isSourceSpan)
   ) {
     return undefined
   }
@@ -125,9 +93,9 @@ function decodeBundle(value: unknown): StudioSchemaBundle | undefined {
   if (!record) return undefined
   const domainId = asString(record.domainId)
   const renderFingerprint = asString(record.renderFingerprint)
-  const schemaMode = (
-    ['canonical-admitted', 'canonical-preview', 'legacy', 'unavailable'] as const
-  ).find((candidate) => candidate === record.schemaMode)
+  const schemaMode = (['canonical-admitted', 'canonical-preview', 'unavailable'] as const).find(
+    (candidate) => candidate === record.schemaMode,
+  )
   const extractedBy = record.extractedBy
   const depsInstalled = asBoolean(record.depsInstalled)
   const ir = record.ir === null ? null : decodeSchemaIR(record.ir)
@@ -153,11 +121,6 @@ function decodeBundle(value: unknown): StudioSchemaBundle | undefined {
   ) {
     return undefined
   }
-  const importedInterfaces =
-    record.importedInterfaces === undefined
-      ? undefined
-      : decodeIrInterfaceRecord(record.importedInterfaces)
-  if (record.importedInterfaces !== undefined && importedInterfaces === undefined) return undefined
   const errorRecord = record.error === null ? null : asJsonRecord(record.error)
   const errorMessage = asString(errorRecord?.message)
   if (record.error !== undefined && record.error !== null && errorMessage === undefined) {
@@ -173,7 +136,6 @@ function decodeBundle(value: unknown): StudioSchemaBundle | undefined {
     ir,
     ...(record.schemaRoot === undefined ? {} : { schemaRoot: record.schemaRoot }),
     overlay,
-    ...(importedInterfaces === undefined ? {} : { importedInterfaces }),
     ...(record.error === undefined
       ? {}
       : record.error === null
@@ -287,10 +249,7 @@ export async function getAnatomy(id: string, rebuild = false): Promise<DomainAna
 export async function getCore(id: string, rebuild = false): Promise<StudioCore | null> {
   const h = getDomain(id)
   if (!h) return null
-  if (!rebuild && cores.has(id)) return cores.get(id)!
-  const c = await buildCore(h)
-  cores.set(id, c)
-  return c
+  return buildCore(h, await getBundle(id, rebuild))
 }
 
 export function invalidate(id: string, what: 'schema' | 'anatomy' | 'all'): void {
@@ -300,7 +259,4 @@ export function invalidate(id: string, what: 'schema' | 'anatomy' | 'all'): void
     const domain = getDomain(id)
     if (domain) invalidateClientPackage(domain.root)
   }
-  // Core is derived from the canonical schema (or the legacy composition entry),
-  // both of which belong to the anatomy invalidation set.
-  if (what !== 'schema') cores.delete(id)
 }

package/studio/server/cli-consumers.test.ts

@@ -3,7 +3,7 @@ import { existsSync, mkdtempSync, readFileSync, realpathSync, rmSync, writeFileS
 import { tmpdir } from 'node:os'
 import { join } from 'node:path'
 
-import type { StudioSchemaBundle, ViewInfo } from '../shared/types'
+import type { StaleReport, StudioSchemaBundle, ViewInfo } from '../shared/types'
 
 import { STUDIO_CLI_DESCRIPTOR_ENV } from './cli'
 import { activeInstanceName, listInstances, setActiveInstance } from './instances/active'
@@ -209,6 +209,7 @@ describe('workspace update CLI orchestration', () => {
                 latest: '0.8.0',
                 channel: 'latest',
               },
+              skills: { status: 'update-available' },
               sdk: {
                 stale: true,
                 inProject: true,
@@ -235,6 +236,7 @@ describe('workspace update CLI orchestration', () => {
         latest: '0.8.0',
         channel: 'latest',
       },
+      skills: { status: 'update-available' },
       sdk: {
         stale: true,
         inProject: true,
@@ -251,6 +253,31 @@ describe('workspace update CLI orchestration', () => {
     ])
   })
 
+  test('accepts an older CLI report without a skills axis during binary replacement', async () => {
+    const checkArgs = ['update', '--check', '--json']
+    const fake = installFakeCli([
+      {
+        args: checkArgs,
+        responses: [
+          {
+            stdout: {
+              stale: false,
+              cli: { stale: false, managed: true },
+              sdk: { stale: false, inProject: false, outdated: [] },
+            },
+          },
+        ],
+      },
+    ])
+
+    expect(await getUpdates(fake.root)).toEqual({
+      stale: false,
+      cli: { stale: false, managed: true },
+      skills: { status: 'current' },
+      sdk: { stale: false, inProject: false, outdated: [] },
+    })
+  })
+
   test('hides the badge when check output is malformed or fails', async () => {
     const checkArgs = ['update', '--check', '--json']
     const fake = installFakeCli([
@@ -262,6 +289,7 @@ describe('workspace update CLI orchestration', () => {
             stdout: {
               stale: true,
               cli: { stale: true, managed: true },
+              skills: { status: 'current' },
               sdk: {
                 stale: true,
                 inProject: true,
@@ -274,9 +302,10 @@ describe('workspace update CLI orchestration', () => {
         ],
       },
     ])
-    const expected = {
+    const expected: StaleReport = {
       stale: false,
       cli: { stale: false, managed: true },
+      skills: { status: 'current' },
       sdk: { stale: false, inProject: false, outdated: [] },
     }
 
@@ -301,7 +330,6 @@ const bundle = {
     views: {
       'issue-detail': {
         name: 'issue-detail',
-        auth: 'required',
         target: {
           kind: 'definition',
           definitions: [{ origin: 'issues.example.dev', kind: 'class', name: 'Issue' }],

package/studio/server/domain.test.ts

@@ -1,14 +1,14 @@
-import { afterEach, expect, test } from 'bun:test'
+import { afterEach, describe, expect, test } from 'bun:test'
 import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs'
 import { tmpdir } from 'node:os'
 import { basename, join } from 'node:path'
 
-import { resolveTarget } from './detect'
 import {
   depsInstalled,
   isDomainDir,
   registerDomain,
-  resolveDomainEntry,
+  resolveApplicationEntry,
+  resolveSchemaEntry,
   unregisterDomain,
 } from './domain'
 
@@ -20,76 +20,58 @@ afterEach(() => {
   while (roots.length) rmSync(roots.pop()!, { recursive: true, force: true })
 })
 
-function fixture(entry: 'implementation.ts' | 'domain.ts', parent = tmpdir()): string {
-  const root = mkdtempSync(join(parent, 'studio-domain-layout-'))
+function fixture(nested = false): string {
+  const root = mkdtempSync(join(tmpdir(), 'studio-application-layout-'))
   roots.push(root)
-  mkdirSync(join(root, 'schema'), { recursive: true })
-  writeFileSync(join(root, 'astrale.config.ts'), 'export default {}\n')
-  writeFileSync(join(root, entry), 'export const domain = {}\n')
-  writeFileSync(join(root, 'schema/index.ts'), 'export const schema = {}\n')
+  const owner = nested ? join(root, 'domain') : root
+  mkdirSync(join(owner, 'schema'), { recursive: true })
+  writeFileSync(
+    join(root, 'astrale.config.ts'),
+    nested
+      ? "import application from './domain/application.js'\nexport default { application }\n"
+      : 'export default {}\n',
+  )
+  writeFileSync(join(owner, 'application.ts'), 'export default {}\n')
+  writeFileSync(join(owner, 'schema/index.ts'), 'export const schema = {}\n')
   return root
 }
 
-test('detects the current implementation.ts layout and requires its SDK dependency', () => {
-  const root = fixture('implementation.ts')
-
-  expect(isDomainDir(root)).toBe(true)
-  expect(basename(resolveDomainEntry(root)!)).toBe('implementation.ts')
-  expect(depsInstalled(root)).toBe(false)
-
-  mkdirSync(join(root, 'node_modules', '@astrale-os', 'kernel-core'), { recursive: true })
-  expect(depsInstalled(root)).toBe(false)
-  mkdirSync(join(root, 'node_modules', '@astrale-os', 'sdk'), { recursive: true })
-  expect(depsInstalled(root)).toBe(true)
-
-  const handle = registerDomain(root)!
-  domainIds.push(handle.id)
-  expect(basename(handle.domainFile)).toBe('implementation.ts')
-  expect(resolveTarget(root).map((domain) => domain.root)).toEqual([root])
-})
-
-test('preserves domain.ts and kernel-core as the legacy fallback', () => {
-  const root = fixture('domain.ts')
-  mkdirSync(join(root, 'node_modules', '@astrale-os', 'kernel-core'), { recursive: true })
-
-  expect(isDomainDir(root)).toBe(true)
-  expect(depsInstalled(root)).toBe(true)
-  const handle = registerDomain(root)!
-  domainIds.push(handle.id)
-  expect(basename(handle.domainFile)).toBe('domain.ts')
-})
-
-test('prefers implementation.ts when both composition entries exist', () => {
-  const root = fixture('domain.ts')
-  writeFileSync(join(root, 'implementation.ts'), 'export const domain = {}\n')
-
-  expect(basename(resolveDomainEntry(root)!)).toBe('implementation.ts')
-})
+describe('SDK V1 project discovery', () => {
+  test('discovers conventional root Application and Schema entries', () => {
+    const root = fixture()
+    expect(isDomainDir(root)).toBe(true)
+    expect(basename(resolveApplicationEntry(root)!)).toBe('application.ts')
+    expect(basename(resolveSchemaEntry(root, resolveApplicationEntry(root)!)!)).toBe('index.ts')
+    const handle = registerDomain(root)!
+    domainIds.push(handle.id)
+    expect(basename(handle.applicationFile)).toBe('application.ts')
+    expect(handle.schemaDirName).toBe('schema')
+  })
 
-test('recognizes only an SDK that resolves from the Domain through an autonomous hoist', () => {
-  const isolatedWorkspace = mkdtempSync(join(tmpdir(), 'studio-domain-no-hoist-'))
-  roots.push(isolatedWorkspace)
-  mkdirSync(join(isolatedWorkspace, 'packages'))
-  const isolatedRoot = fixture('implementation.ts', join(isolatedWorkspace, 'packages'))
-  expect(depsInstalled(isolatedRoot)).toBe(false)
+  test('follows a config-imported nested Application and adjacent Schema', () => {
+    const root = fixture(true)
+    const application = resolveApplicationEntry(root)!
+    expect(application).toBe(join(root, 'domain/application.ts'))
+    expect(resolveSchemaEntry(root, application)).toBe(join(root, 'domain/schema/index.ts'))
+  })
 
-  const hoistedWorkspace = mkdtempSync(join(tmpdir(), 'studio-domain-hoist-'))
-  roots.push(hoistedWorkspace)
-  mkdirSync(join(hoistedWorkspace, 'packages'))
-  mkdirSync(join(hoistedWorkspace, 'node_modules', '@astrale-os', 'sdk'), { recursive: true })
-  writeFileSync(
-    join(hoistedWorkspace, 'node_modules', '@astrale-os', 'sdk', 'package.json'),
-    JSON.stringify({
-      name: '@astrale-os/sdk',
-      type: 'module',
-      exports: { './schema': './schema.js' },
-    }),
-  )
-  writeFileSync(
-    join(hoistedWorkspace, 'node_modules', '@astrale-os', 'sdk', 'schema.js'),
-    'export const schema = {}\n',
-  )
-  const hoistedRoot = fixture('implementation.ts', join(hoistedWorkspace, 'packages'))
+  test('requires the semantic SDK dependency, not Kernel implementation packages', () => {
+    const root = fixture()
+    expect(depsInstalled(root)).toBe(false)
+    mkdirSync(join(root, 'node_modules', '@astrale-os', 'kernel-core'), { recursive: true })
+    expect(depsInstalled(root)).toBe(false)
+    mkdirSync(join(root, 'node_modules', '@astrale-os', 'sdk'), { recursive: true })
+    expect(depsInstalled(root)).toBe(true)
+  })
 
-  expect(depsInstalled(hoistedRoot)).toBe(true)
+  test('rejects implementation.ts and domain.ts compatibility layouts', () => {
+    const root = mkdtempSync(join(tmpdir(), 'studio-legacy-layout-'))
+    roots.push(root)
+    mkdirSync(join(root, 'schema'))
+    writeFileSync(join(root, 'astrale.config.ts'), 'export default {}\n')
+    writeFileSync(join(root, 'implementation.ts'), 'export default {}\n')
+    writeFileSync(join(root, 'domain.ts'), 'export default {}\n')
+    writeFileSync(join(root, 'schema/index.ts'), 'export const schema = {}\n')
+    expect(isDomainDir(root)).toBe(false)
+  })
 })

package/studio/server/domain.ts

@@ -1,74 +1,95 @@
-/**
- * domain.ts — DomainHandle resolution + the in-process registry. A "domain" is
- * confirmed by astrale.config.ts + a composition entry + <schemaDir>/index.ts.
- * Current SDK projects use implementation.ts; domain.ts remains the legacy
- * fallback. The schema dir is configurable (default 'schema') and threaded
- * everywhere.
- */
-import { existsSync } from 'node:fs'
-import { basename, join, resolve } from 'node:path'
+/** SDK V1 project discovery and the in-process Studio registry. */
+import { existsSync, readFileSync } from 'node:fs'
+import { basename, dirname, extname, join, relative, resolve } from 'node:path'
 
 export interface DomainHandle {
-  id: string
-  root: string
-  configFile: string
-  /** Active composition entry (implementation.ts when present, otherwise legacy domain.ts). */
-  domainFile: string
-  schemaDirName: string
-  schemaDir: string
-  schemaIndex: string
+  readonly id: string
+  readonly root: string
+  readonly configFile: string
+  readonly applicationFile: string
+  readonly schemaDirName: string
+  readonly schemaDir: string
+  readonly schemaIndex: string
   origin?: string
 }
 
 const registry = new Map<string, DomainHandle>()
 
-export const DOMAIN_ENTRY_FILES = ['implementation.ts', 'domain.ts'] as const
-
 export function makeId(root: string): string {
   return basename(resolve(root)).replace(/[^a-zA-Z0-9_-]/g, '-') || 'domain'
 }
 
-/** Resolve the current composition entry, preferring the SDK layout. */
-export function resolveDomainEntry(root: string): string | null {
-  const r = resolve(root)
-  for (const file of DOMAIN_ENTRY_FILES) {
-    const candidate = join(r, file)
-    if (existsSync(candidate)) return candidate
+/** Resolve the Application imported by config, with root application.ts as convention. */
+export function resolveApplicationEntry(root: string): string | null {
+  const project = resolve(root)
+  const conventional = join(project, 'application.ts')
+  if (existsSync(conventional)) return conventional
+  const config = join(project, 'astrale.config.ts')
+  if (!existsSync(config)) return null
+  let source: string
+  try {
+    source = readFileSync(config, 'utf8')
+  } catch {
+    return null
+  }
+  for (const match of source.matchAll(/\bfrom\s+['"]([^'"]+)['"]/gu)) {
+    const specifier = match[1]
+    if (
+      !specifier?.startsWith('.') ||
+      basename(specifier).replace(/\.[^.]+$/u, '') !== 'application'
+    ) {
+      continue
+    }
+    const selected = resolveSourceFile(project, specifier)
+    if (selected !== null) return selected
   }
   return null
 }
 
-/** The single definition of "is this dir an Astrale domain": the triple must all exist. */
+/** Resolve schema.ts or schema/index.ts beside the Application, then at project root. */
+export function resolveSchemaEntry(
+  root: string,
+  applicationFile: string,
+  schemaDirName = 'schema',
+): string | null {
+  const project = resolve(root)
+  const applicationDir = dirname(applicationFile)
+  const candidates = [
+    join(applicationDir, 'schema.ts'),
+    join(applicationDir, schemaDirName, 'index.ts'),
+    join(project, 'schema.ts'),
+    join(project, schemaDirName, 'index.ts'),
+  ]
+  return [...new Set(candidates)].find(existsSync) ?? null
+}
+
 export function isDomainDir(root: string, schemaDirName = 'schema'): boolean {
-  const r = resolve(root)
-  return (
-    existsSync(join(r, 'astrale.config.ts')) &&
-    resolveDomainEntry(r) !== null &&
-    existsSync(join(r, schemaDirName, 'index.ts'))
-  )
+  const project = resolve(root)
+  if (!existsSync(join(project, 'astrale.config.ts'))) return false
+  const application = resolveApplicationEntry(project)
+  return application !== null && resolveSchemaEntry(project, application, schemaDirName) !== null
 }
 
-/** Confirm + register a domain rooted at `root`. Returns null if the triple is incomplete. */
 export function registerDomain(root: string, schemaDirName = 'schema'): DomainHandle | null {
-  const r = resolve(root)
-  if (!isDomainDir(r, schemaDirName)) return null
-  const domainFile = resolveDomainEntry(r)
-  if (!domainFile) return null
-  const schemaDir = join(r, schemaDirName)
+  const project = resolve(root)
+  const applicationFile = resolveApplicationEntry(project)
+  if (applicationFile === null || !existsSync(join(project, 'astrale.config.ts'))) return null
+  const schemaIndex = resolveSchemaEntry(project, applicationFile, schemaDirName)
+  if (schemaIndex === null) return null
+  const schemaDir = dirname(schemaIndex)
   const handle: DomainHandle = {
-    id: makeId(r),
-    root: r,
-    configFile: join(r, 'astrale.config.ts'),
-    domainFile,
-    schemaDirName,
+    id: makeId(project),
+    root: project,
+    configFile: join(project, 'astrale.config.ts'),
+    applicationFile,
+    schemaDirName: relative(project, schemaDir).replaceAll('\\', '/') || '.',
     schemaDir,
-    schemaIndex: join(schemaDir, 'index.ts'),
+    schemaIndex,
   }
   registry.set(handle.id, handle)
   return handle
 }
 
-/** Drop a domain from the registry (its dir/triple is gone). */
 export function unregisterDomain(id: string): void {
   registry.delete(id)
 }
@@ -81,25 +102,23 @@ export function allDomains(): DomainHandle[] {
   return [...registry.values()]
 }
 
-/** Does the domain have the dependency cohort required by its project layout installed? */
+/** Studio's current project model always requires the semantic SDK Schema facade. */
 export function depsInstalled(root: string): boolean {
-  const installed = (packageDir: string, specifier: string): boolean => {
-    if (existsSync(join(root, 'node_modules', '@astrale-os', packageDir))) return true
-    try {
-      Bun.resolveSync(specifier, root)
-      return true
-    } catch {
-      return false
-    }
+  if (existsSync(join(root, 'node_modules', '@astrale-os', 'sdk'))) return true
+  try {
+    Bun.resolveSync('@astrale-os/sdk/schema', root)
+    return true
+  } catch {
+    return false
   }
+}
 
-  // A workspace may hoist the package above the Domain root. Check both the
-  // conventional local link and Bun's real resolver from the Domain boundary.
-  const sdk = installed('sdk', '@astrale-os/sdk/schema')
-  const entry = resolveDomainEntry(root)
-
-  // implementation.ts is an SDK boundary by contract. Legacy domain.ts
-  // projects may predate the SDK facade and depend on kernel-core directly.
-  if (entry?.endsWith('implementation.ts')) return sdk
-  return sdk || installed('kernel-core', '@astrale-os/kernel-core')
+function resolveSourceFile(root: string, specifier: string): string | null {
+  const absolute = resolve(root, specifier)
+  const extension = extname(absolute)
+  const candidates =
+    extension === ''
+      ? [`${absolute}.ts`, join(absolute, 'index.ts')]
+      : [absolute, `${absolute.slice(0, -extension.length)}.ts`]
+  return candidates.find(existsSync) ?? null
 }

package/studio/server/handoff/copy.ts

@@ -10,7 +10,7 @@ import type { Comment, ContextItem, DocMeta, SchemaRevision, ThreadEntry } from
 interface CopyParts {
   origin: string
   root: string
-  /** Studio render fingerprint retained by the legacy annotate machine-state. */
+  /** Studio render fingerprint retained by the handoff machine-state. */
   renderFingerprint: string
   schemaRevision?: SchemaRevision
   openComments: Comment[]
@@ -84,7 +84,7 @@ export function buildCopyMarkdown(parts: CopyParts): string {
   lines.push(`- **Render fingerprint:** \`${renderFingerprint}\``)
   lines.push('')
   lines.push(
-    'Load the **astrale-domain** skill, use the context/threads below, ' +
+    'Load the **astrale-domain** skill and, for UI work, **astrale-frontend-design**. 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.',

package/studio/server/index.ts

@@ -42,7 +42,7 @@ const domains = resolveTarget(target, schemaDir)
 if (!domains.length) {
   console.error(`\n  ✗ No Astrale domains found at ${target}`)
   console.error(
-    `    (looking for: astrale.config.ts + implementation.ts (or legacy domain.ts) + ${schemaDir}/index.ts)\n`,
+    `    (looking for: astrale.config.ts + application.ts + schema.ts or ${schemaDir}/index.ts)\n`,
   )
   process.exit(1)
 }

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

@@ -21,7 +21,7 @@ describe('installed Domain introspection', () => {
     ])
   })
 
-  test('retains the complete installed Bundle for cohort SDK admission', () => {
+  test('retains the complete installed Bundle for installed SDK admission', () => {
     const root = {
       version: 'v1',
       domain: 'issues.astrale.ai',