@astrale-os/cli 1.0.0-beta.32 → 1.0.0-beta.43

package/studio/server/lifecycle.ts

@@ -34,7 +34,7 @@ export async function bootDomain(handle: DomainHandle): Promise<BootedDomain> {
         root: bundle?.schemaMode === 'canonical-admitted' ? (bundle.schemaRoot ?? null) : null,
         revision: bundle?.schemaRevision ?? null,
       },
-      hashAnatomyFiles(handle.root, handle.schemaDirName),
+      hashAnatomyFiles(handle.root, handle.schemaDirName, handle.applicationFile),
     )
   const stop = watchDomain(handle)
   return {

package/studio/server/state/baseline.test.ts

@@ -62,6 +62,20 @@ test('hashes current Application and vertical authoring files', () => {
   ])
 })
 
+test('hashes a config-selected nested Application explicitly', () => {
+  const root = mkdtempSync(join(tmpdir(), 'studio-nested-application-baseline-'))
+  roots.push(root)
+  mkdirSync(join(root, 'domain/schema'), { recursive: true })
+  const application = join(root, 'domain/application.ts')
+  writeFileSync(application, 'nested Application\n')
+  writeFileSync(join(root, 'domain/schema/index.ts'), 'selected Schema\n')
+
+  expect(hashAnatomyFiles(root, 'domain/schema', application)).toMatchObject({
+    'domain/application.ts': expect.any(String),
+    'domain/schema/index.ts': expect.any(String),
+  })
+})
+
 const schema = (domain: string): SchemaIR => ({
   format: 'astrale.dsl',
   version: 'v1',

package/studio/server/state/baseline.ts

@@ -104,7 +104,11 @@ function walkFiles(dir: string, out: string[]): void {
  * Hash (sha256) every file in the anatomy + schema fileset. Keys are paths
  * relative to `root`, forward-slashed. Missing dirs/files are silently skipped.
  */
-export function hashAnatomyFiles(root: string, schemaDirName: string): Record<string, string> {
+export function hashAnatomyFiles(
+  root: string,
+  schemaDirName: string,
+  applicationFile?: string,
+): Record<string, string> {
   const r = resolve(root)
   const absFiles: string[] = []
 
@@ -135,8 +139,18 @@ export function hashAnatomyFiles(root: string, schemaDirName: string): Record<st
     }
   }
 
+  // A config-selected Application may live below the domain root. It is the
+  // composition source of truth and must participate in cache/change identity.
+  if (applicationFile && existsSync(applicationFile)) {
+    try {
+      if (statSync(applicationFile).isFile()) absFiles.push(applicationFile)
+    } catch {
+      /* skip */
+    }
+  }
+
   const hashes: Record<string, string> = {}
-  for (const abs of absFiles) {
+  for (const abs of new Set(absFiles)) {
     let buf: Buffer
     try {
       buf = readFileSync(abs)

package/studio/server/watch.test.ts

@@ -24,7 +24,8 @@ test('watches current Application, Runtime, and vertical authoring roots', () =>
   expect(ANATOMY_PATHS).toContain('queries')
   expect(ANATOMY_PATHS).toContain('workflows')
   expect(DOMAIN_SET_TRIGGER_FILES.has('application.ts')).toBe(true)
-  expect(DOMAIN_SET_TRIGGER_FILES.has('schema.ts')).toBe(true)
+  expect(DOMAIN_SET_TRIGGER_FILES.has('astrale.config.ts')).toBe(true)
+  expect(DOMAIN_SET_TRIGGER_FILES.has('schema.ts')).toBe(false)
 })
 
 test('Application, Runtime, Action, and Workflow changes invalidate the schema bundle', () => {

package/studio/server/watch.ts

@@ -1,6 +1,6 @@
 /**
  * watch.ts — two debounced watch channels per domain:
- *   schema/**         → re-introspect → schema-diff (+ compile-error)
+ *   Application + selected Schema sources → re-introspect → schema-diff (+ compile-error)
  *   anatomy fileset   → anatomy-diff
  * The studio is read-only, so this only ever pushes; the client refetches.
  */
@@ -50,7 +50,10 @@ export function affectsBundle(handle: DomainHandle, path: string): boolean {
 }
 
 export function watchDomain(handle: DomainHandle): () => void {
-  const schemaW = chokidar.watch(handle.schemaDir, { ignoreInitial: true, ignored })
+  const schemaW = chokidar.watch([handle.applicationFile, handle.schemaDir], {
+    ignoreInitial: true,
+    ignored,
+  })
   const anatomyW = chokidar.watch(
     ANATOMY_PATHS.map((p) => join(handle.root, p)),
     { ignoreInitial: true, ignored },

package/studio/server/workspace/create.ts

@@ -15,10 +15,10 @@ import { existsSync, readFileSync, writeFileSync } from 'node:fs'
 import { join } from 'node:path'
 
 import { getBundle } from '../cache'
-import { isDomainDir, registerDomain } from '../domain'
+import { registerDomain } from '../domain'
 import { findSchemaDefinition } from '../introspect/anatomy-extras'
 import { bootDomain } from '../lifecycle'
-import { stoppers, workspaceRoot, workspaceSchemaDirName } from '../workspace-state'
+import { stoppers, workspaceRoot } from '../workspace-state'
 
 /** Mirrors create-astrale-domain's `isValidSlug`: lowercase letters, digits, dots, dashes;
  *  must start/end alphanumeric. Also guards the filesystem target (no `/`, no `..`, no leading dot). */
@@ -88,18 +88,19 @@ export async function createDomain(
     ...(instance ? ['--instance', instance] : []),
   ]
   const scaffold = await run('npx', scaffoldArgs, root)
-  const schemaDirName = workspaceSchemaDirName()
-  if (!isDomainDir(dir, schemaDirName)) {
+  const scaffolded = registerDomain(dir)
+  if (!scaffolded) {
     return {
       ok: false,
-      error: 'Scaffolding did not produce a domain. See the log.',
+      error:
+        'Scaffolding did not produce a domain with an Application schema binding. See the log.',
       output: scaffold.output.slice(-6000),
     }
   }
 
   // 1b. Flag the placeholder origin for the agent (we ask for the name only, so the
   //     origin is `<name>.example.dev` until someone — or the agent — sets the real one).
-  annotateOrigin(dir, schemaDirName)
+  annotateOrigin(dir, scaffolded.schemaDirName)
 
   // 2. Install deps so the domain is fully introspectable + deployable. Best-effort:
   //    a scaffolded-but-uninstalled domain still loads (static fallback), so a failed
@@ -108,11 +109,11 @@ export async function createDomain(
 
   // 3. Register + boot with deps present. The live watcher may have already booted a
   //    deps-less fallback for this dir mid-install — stop it and boot fresh.
-  const handle = registerDomain(dir, schemaDirName)
+  const handle = registerDomain(dir)
   if (!handle) {
     return {
       ok: false,
-      error: 'Scaffold incomplete — config, composition entry, or schema index is missing.',
+      error: 'Scaffold incomplete — config or Application schema binding is missing.',
       output: combine(scaffold, install),
     }
   }

package/studio/server/workspace-state.ts

@@ -2,25 +2,23 @@
  * workspace-state.ts — process-global workspace context shared by the entrypoint
  * (index.ts), the live watcher (workspace-watch.ts), and the create-domain
  * endpoint (workspace/create.ts): the scanned ROOT (where new domains are
- * scaffolded), the schema-dir name, and the `domainId → file-watcher stop` map.
+ * scaffolded) and the `domainId → file-watcher stop` map.
  *
  * It exists so the create endpoint can scaffold into the same root the studio
  * watches — and re-boot the freshly-created domain — without index.ts having to
  * thread those values through the API signature.
  */
 
-const state = { root: '', schemaDirName: 'schema' }
+const state = { root: '' }
 
 /** domainId → stop its file watcher. The startup scan + the live watcher + the
  *  create endpoint all share this one map so "what domains are live" stays single-sourced. */
 export const stoppers = new Map<string, () => void>()
 
-/** Called once at boot with the resolved workspace root + schema-dir name. */
-export function initWorkspaceState(root: string, schemaDirName: string): void {
+/** Called once at boot with the resolved workspace root. */
+export function initWorkspaceState(root: string): void {
   state.root = root
-  state.schemaDirName = schemaDirName
 }
 
 /** The directory the studio scans for domains — where `create new` scaffolds a sibling. */
 export const workspaceRoot = (): string => state.root
-export const workspaceSchemaDirName = (): string => state.schemaDirName

package/studio/server/workspace-watch.ts

@@ -1,14 +1,15 @@
 /**
  * workspace-watch.ts — keeps the domain registry in sync with the workspace while
- * the studio is running. A domain dropped in (or one whose astrale.config.ts +
- * composition entry + schema/index.ts triple just completed) is registered, booted, and
- * announced over SSE; one whose triple vanished is unregistered. It reuses
+ * the studio is running. A domain dropped in (or one whose config + Application
+ * schema binding just became complete) is registered, booted, and announced over
+ * SSE; one whose composition vanished is unregistered. It reuses
  * `scanWorkspace` (detection) + `bootDomain` (lifecycle), so there is no second
  * source of truth for "what is a domain" or "how a domain comes online".
  */
 import chokidar from 'chokidar'
 import { basename } from 'node:path'
 
+import { invalidate } from './cache'
 import { scanWorkspace } from './detect'
 import { allDomains, isDomainDir, unregisterDomain } from './domain'
 import { bootDomain } from './lifecycle'
@@ -17,41 +18,43 @@ import { broadcast } from './sse'
 const IGNORED =
   /(^|[/\\])(node_modules|\.git|\.astrale|\.domain-studio|dist|\.dist|\.next|\.cache|\.turbo|\.vercel|coverage)([/\\]|$)/
 // only these file changes can change the domain SET (vs. ordinary in-domain edits)
-export const DOMAIN_SET_TRIGGER_FILES = new Set([
-  'astrale.config.ts',
-  'application.ts',
-  'schema.ts',
-  'index.ts',
-])
+export const DOMAIN_SET_TRIGGER_FILES = new Set(['astrale.config.ts', 'application.ts'])
+const AUTHORED_SOURCE = /\.[cm]?[jt]sx?$/u
 
 /**
  * Watch `root` for domains appearing/disappearing.
  * @param stoppers shared `domainId → file-watcher stop` map. The startup scan seeds
  *   it (via bootDomain); this watcher keeps it in sync as domains come and go.
  */
-export function watchWorkspace(
-  root: string,
-  schemaDirName: string,
-  stoppers: Map<string, () => void>,
-): () => void {
+export function watchWorkspace(root: string, stoppers: Map<string, () => void>): () => void {
   let timer: ReturnType<typeof setTimeout> | undefined
   let running = false
   let queued = false
 
   const reconcile = async () => {
-    const before = new Set(allDomains().map((d) => d.id))
+    const previous = new Map(allDomains().map((domain) => [domain.id, domain]))
+    const before = new Set(previous.keys())
+    let refreshed = false
 
-    // 1. drop domains whose triple vanished (dir deleted, or a trigger file removed)
+    // 1. drop domains whose Application composition vanished.
     for (const h of allDomains()) {
-      if (isDomainDir(h.root, h.schemaDirName)) continue
+      if (isDomainDir(h.root)) continue
       stoppers.get(h.id)?.()
       stoppers.delete(h.id)
       unregisterDomain(h.id)
       console.log(`  Domain Studio — domain removed: ${h.id}`)
     }
 
-    // 2. register + boot any new ones (scanWorkspace registers; bootDomain initializes + watches)
-    for (const h of scanWorkspace(root, schemaDirName)) {
+    // 2. Register + boot new domains. If Application now selects another Schema
+    //    module, replace the old per-domain watcher and invalidate its cached bundle.
+    for (const h of scanWorkspace(root)) {
+      const prior = previous.get(h.id)
+      if (prior && prior !== h) {
+        stoppers.get(h.id)?.()
+        stoppers.delete(h.id)
+        invalidate(h.id, 'all')
+        refreshed = true
+      }
       if (stoppers.has(h.id)) continue
       const { origin, stop } = await bootDomain(h)
       stoppers.set(h.id, stop)
@@ -60,7 +63,7 @@ export function watchWorkspace(
 
     // 3. announce if the set changed → clients refetch /api/workspace
     const after = new Set(allDomains().map((d) => d.id))
-    if (before.size !== after.size || [...after].some((id) => !before.has(id))) {
+    if (refreshed || before.size !== after.size || [...after].some((id) => !before.has(id))) {
       broadcast({ type: 'workspace', domains: [...after] })
     }
   }
@@ -88,16 +91,24 @@ export function watchWorkspace(
     clearTimeout(timer)
     timer = setTimeout(() => void run(), 400)
   }
-  const onFile = (p: string) => {
+  const onCompositionChange = (p: string) => {
     if (DOMAIN_SET_TRIGGER_FILES.has(basename(p))) schedule()
   }
+  const onSourceAddedOrRemoved = (p: string) => {
+    if (DOMAIN_SET_TRIGGER_FILES.has(basename(p)) || AUTHORED_SOURCE.test(p)) schedule()
+  }
 
   const watcher = chokidar.watch(root, {
     ignoreInitial: true,
     depth: 4,
     ignored: (p: string) => IGNORED.test(p),
   })
-  watcher.on('addDir', schedule).on('unlinkDir', schedule).on('add', onFile).on('unlink', onFile)
+  watcher
+    .on('addDir', schedule)
+    .on('unlinkDir', schedule)
+    .on('add', onSourceAddedOrRemoved)
+    .on('unlink', onSourceAddedOrRemoved)
+    .on('change', onCompositionChange)
 
   return () => {
     clearTimeout(timer)

package/studio/shared/contracts/agent.ts

@@ -86,6 +86,9 @@ export interface AgentRun {
   resumed?: boolean
   /** short human label of what this turn was asked to do */
   summary: string
+  /** the instruction as typed, verbatim — what the chat shows as your message.
+   *  Absent when the turn was started from open threads rather than a message. */
+  instruction?: string
   /** comment ids this turn was started to answer */
   targetCommentIds: string[]
   events: AgentEvent[]