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

package/studio/server/views/target.ts

@@ -61,7 +61,7 @@ export async function listViewTargets(
 
   const queried = await Promise.all(
     bindings.map(async (binding) => {
-      const definition = targetDefinition(binding.className, binding.classOrigin, binding.kind)
+      const definition = targetDefinition(binding.className, binding.classOrigin)
       const result = await runAstraleJson<RawQueryResult>(
         [
           'query',
@@ -116,21 +116,17 @@ export async function listViewTargets(
   }
 }
 
-export function targetDefinition(
-  className: string,
-  classOrigin: string,
-  kind: 'class' | 'interface' = 'class',
-): string {
-  return `/:${assertOrigin(classOrigin)}:${kind}.${assertSchemaName(className)}`
+export function targetDefinition(className: string, classOrigin: string): string {
+  return `/:${assertOrigin(classOrigin)}:class.${assertSchemaName(className)}`
 }
 
 export interface ViewDefinitionBinding {
   className: string
   classOrigin: string
-  kind: 'class' | 'interface'
+  kind: 'class'
 }
 
-/** Preserve exact canonical View target coordinates; short-name anatomy is legacy-only. */
+/** Preserve exact canonical View target coordinates. */
 export function viewDefinitionBindings(
   origin: string,
   view: ViewInfo,
@@ -140,16 +136,17 @@ export function viewDefinitionBindings(
   if (target) {
     if (target.kind === 'domain') return []
     return uniqueViewBindings(
-      target.definitions
-        .filter(
-          (definition): definition is typeof definition & { kind: 'class' | 'interface' } =>
-            definition.kind === 'class' || definition.kind === 'interface',
-        )
-        .map((definition) => ({
-          className: definition.name,
-          classOrigin: definition.origin,
-          kind: definition.kind,
-        })),
+      target.definitions.flatMap((definition) =>
+        definition.kind === 'class'
+          ? [
+              {
+                className: definition.name,
+                classOrigin: definition.origin,
+                kind: 'class' as const,
+              },
+            ]
+          : [],
+      ),
     )
   }
 
@@ -165,7 +162,6 @@ export function viewDefinitionBindings(
     names.flatMap((className) => {
       const local: ViewDefinitionBinding[] = []
       const localClass = ir.classes[className]
-      const localInterface = ir.interfaces[className]
       if (localClass) {
         local.push({
           className,
@@ -173,33 +169,11 @@ export function viewDefinitionBindings(
           kind: 'class',
         })
       }
-      if (localInterface) {
-        local.push({
-          className,
-          classOrigin: localInterface.ref?.origin ?? localInterface.origin ?? ir.domain ?? origin,
-          kind: 'interface',
-        })
-      }
-
-      if (ir.importsByKey !== undefined) {
-        const imported = Object.keys(ir.importsByKey).flatMap((key) => {
-          const binding = viewBindingFromDefinitionKey(key)
-          return binding?.className === className ? [binding] : []
-        })
-        return [...local, ...imported]
-      }
-
-      const legacy = ir.imports[className]
-      if (legacy) {
-        return [
-          ...local,
-          {
-            className,
-            classOrigin: legacy.origin,
-            kind: legacy.definition,
-          } satisfies ViewDefinitionBinding,
-        ]
-      }
+      const imported = Object.keys(ir.importsByKey).flatMap((key) => {
+        const binding = viewBindingFromDefinitionKey(key)
+        return binding?.className === className ? [binding] : []
+      })
+      if (imported.length > 0) return [...local, ...imported]
 
       return local.length > 0 ? local : [{ className, classOrigin: origin, kind: 'class' }]
     }),
@@ -211,12 +185,12 @@ function viewBindingFromDefinitionKey(key: string): ViewDefinitionBinding | null
   if (separator <= 0) return null
   const classOrigin = key.slice(0, separator)
   const ref = key.slice(separator + 1)
-  const match = /^(class|interface)\.([A-Za-z_$][\w$]*)$/.exec(ref)
+  const match = /^class\.([A-Za-z_$][\w$]*)$/.exec(ref)
   if (!match) return null
   return {
-    className: match[2]!,
+    className: match[1]!,
     classOrigin,
-    kind: match[1] as ViewDefinitionBinding['kind'],
+    kind: 'class',
   }
 }
 

package/studio/server/watch.test.ts

@@ -10,27 +10,27 @@ const handle: DomainHandle = {
   id: 'current',
   root: '/workspace/current',
   configFile: '/workspace/current/astrale.config.ts',
-  domainFile: '/workspace/current/implementation.ts',
+  applicationFile: '/workspace/current/application.ts',
   schemaDirName: 'schema',
   schemaDir: '/workspace/current/schema',
   schemaIndex: '/workspace/current/schema/index.ts',
 }
 
-test('watches current layout roots and reconciles either composition entry', () => {
-  expect(ANATOMY_PATHS).toContain('implementation.ts')
+test('watches current Application, Runtime, and vertical authoring roots', () => {
+  expect(ANATOMY_PATHS).toContain('application.ts')
+  expect(ANATOMY_PATHS).toContain('runtime.ts')
   expect(ANATOMY_PATHS).toContain('ui')
-  expect(ANATOMY_PATHS).toContain('handlers')
+  expect(ANATOMY_PATHS).toContain('providers')
   expect(ANATOMY_PATHS).toContain('queries')
   expect(ANATOMY_PATHS).toContain('workflows')
-  expect(DOMAIN_SET_TRIGGER_FILES.has('implementation.ts')).toBe(true)
-  expect(DOMAIN_SET_TRIGGER_FILES.has('domain.ts')).toBe(true)
+  expect(DOMAIN_SET_TRIGGER_FILES.has('application.ts')).toBe(true)
+  expect(DOMAIN_SET_TRIGGER_FILES.has('schema.ts')).toBe(true)
 })
 
-test('composition and handler source changes invalidate the schema bundle', () => {
-  expect(affectsBundle(handle, join(handle.root, 'implementation.ts'))).toBe(true)
-  expect(affectsBundle(handle, join(handle.root, 'domain.ts'))).toBe(true)
+test('Application, Runtime, Action, and Workflow changes invalidate the schema bundle', () => {
+  expect(affectsBundle(handle, join(handle.root, 'application.ts'))).toBe(true)
+  expect(affectsBundle(handle, join(handle.root, 'runtime.ts'))).toBe(true)
   expect(affectsBundle(handle, join(handle.root, 'actions', 'risk', 'create.ts'))).toBe(true)
-  expect(affectsBundle(handle, join(handle.root, 'functions', 'user', 'ensure.ts'))).toBe(true)
-  expect(affectsBundle(handle, join(handle.root, 'handlers', 'create.ts'))).toBe(true)
+  expect(affectsBundle(handle, join(handle.root, 'workflows', 'user', 'ensure.ts'))).toBe(true)
   expect(affectsBundle(handle, join(handle.root, 'views', 'routes.ts'))).toBe(false)
 })

package/studio/server/watch.ts

@@ -19,10 +19,9 @@ export const ANATOMY_PATHS = [...ANATOMY_GLOBS.files, ...ANATOMY_GLOBS.dirs]
 // part of the schema bundle cache even though they are outside schema/ itself.
 const BUNDLE_SOURCE_DIRS = new Set([
   'actions',
-  'capabilities',
-  'functions',
-  'handlers',
+  'integrations',
   'mutations',
+  'providers',
   'queries',
   'rules',
   'runtime',
@@ -42,7 +41,12 @@ function ignored(p: string): boolean {
 export function affectsBundle(handle: DomainHandle, path: string): boolean {
   const rel = relative(handle.root, path).split('\\').join('/')
   const topLevel = rel.split('/')[0]
-  return rel === 'implementation.ts' || rel === 'domain.ts' || BUNDLE_SOURCE_DIRS.has(topLevel)
+  return (
+    path === handle.applicationFile ||
+    rel === 'runtime.ts' ||
+    rel.endsWith('/runtime.ts') ||
+    BUNDLE_SOURCE_DIRS.has(topLevel)
+  )
 }
 
 export function watchDomain(handle: DomainHandle): () => void {

package/studio/server/workspace/updates.ts

@@ -3,7 +3,7 @@
  *
  * We don't reimplement staleness: the `astrale` CLI owns it. `astrale update
  * --check --json`, run in the DOMAIN ROOT (so its @astrale-os/* SDK-dep axis sees
- * THIS project), emits a unified `{ stale, cli, sdk }` report. We run it with
+ * THIS project), emits a unified `{ stale, cli, skills, sdk }` report. We run it with
  * stdout piped and read it regardless of exit code — a stale result exits 10 by
  * design, which is not an error here. Best-effort: anything unexpected (no
  * bad output) collapses to "nothing stale" so the badge stays
@@ -16,6 +16,7 @@ import { decodeJsonObject, runStudioCliJson, runStudioCliText } from '../cli'
 const NOT_STALE: StaleReport = {
   stale: false,
   cli: { stale: false, managed: true },
+  skills: { status: 'current' },
   sdk: { stale: false, inProject: false, outdated: [] },
 }
 
@@ -30,6 +31,7 @@ export async function getUpdates(root: string): Promise<StaleReport> {
 function decodeStaleReport(value: unknown): StaleReport | null {
   const report = decodeJsonObject(value)
   const cli = decodeJsonObject(report?.cli)
+  const skills = decodeJsonObject(report?.skills)
   const sdk = decodeJsonObject(report?.sdk)
   if (
     typeof report?.stale !== 'boolean' ||
@@ -50,6 +52,22 @@ function decodeStaleReport(value: unknown): StaleReport | null {
       : []
   })
   if (outdated.length !== sdk.outdated.length) return null
+  const skillStatuses = new Set([
+    'current',
+    'update-available',
+    'repair-needed',
+    'unavailable',
+    'skipped',
+  ])
+  // Additive compatibility: Studio can briefly run a newer server against an
+  // older CLI report while a binary update is being applied.
+  const skillStatus =
+    skills === null || skills === undefined
+      ? 'current'
+      : typeof skills.status === 'string' && skillStatuses.has(skills.status)
+        ? (skills.status as StaleReport['skills']['status'])
+        : null
+  if (skillStatus === null) return null
   return {
     stale: report.stale,
     cli: {
@@ -59,6 +77,10 @@ function decodeStaleReport(value: unknown): StaleReport | null {
       ...(typeof cli.latest === 'string' ? { latest: cli.latest } : {}),
       ...(typeof cli.channel === 'string' ? { channel: cli.channel } : {}),
     },
+    skills: {
+      status: skillStatus,
+      ...(typeof skills?.error === 'string' ? { error: skills.error } : {}),
+    },
     sdk: { stale: sdk.stale, inProject: sdk.inProject, outdated },
   }
 }

package/studio/server/workspace-watch.ts

@@ -19,8 +19,8 @@ const IGNORED =
 // 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',
-  'implementation.ts',
-  'domain.ts',
+  'application.ts',
+  'schema.ts',
   'index.ts',
 ])
 

package/studio/shared/contracts/runtime.ts

@@ -42,6 +42,10 @@ export interface StudioSettings {
 export interface StaleReport {
   stale: boolean
   cli: { stale: boolean; managed: boolean; current?: string; latest?: string; channel?: string }
+  skills: {
+    status: 'current' | 'update-available' | 'repair-needed' | 'unavailable' | 'skipped'
+    error?: string
+  }
   sdk: {
     stale: boolean
     inProject: boolean

package/studio/shared/contracts/schema.ts

@@ -5,7 +5,7 @@
  * is owned by `../schema/identity`; SDK admission owns schema semantics.
  */
 
-import type { IrDefinitionKey, IrDefinitionRef, IrSchemaRef } from '../schema/identity'
+import type { IrClassKey, IrClassRef, IrSchemaRef } from '../schema/identity'
 
 export interface JsonSchema {
   type?: string | string[]
@@ -18,11 +18,17 @@ export interface JsonSchema {
   maximum?: number
   format?: string
   description?: string
-  $nodeRef?: unknown
-  $dataRef?: unknown
+  $ref?: string
   [k: string]: unknown
 }
 
+const NODE_PATH_SCHEMA_ID = 'https://schemas.astrale.ai/graph/1/node-path'
+
+/** Structural form emitted by the V1 DSL for a graph Node path. */
+export function isNodePathSchema(schema: JsonSchema): boolean {
+  return schema.$ref === NODE_PATH_SCHEMA_ID && Object.hasOwn(schema, 'x-astrale-path')
+}
+
 export type MethodInheritance = 'default' | 'abstract' | 'sealed'
 
 /** Portable form of the DSL-owned canonical schema revision. */
@@ -37,7 +43,7 @@ export function isSchemaRevision(value: unknown): value is SchemaRevision {
  * Version of Studio's lossy canonical-schema -> render-IR projection. Persisted
  * baselines must match this value before their IR can be compared.
  */
-export const STUDIO_SCHEMA_PROJECTION_VERSION = 1
+export const STUDIO_SCHEMA_PROJECTION_VERSION = 3
 
 export type IrCallableAuth = 'anonymous' | 'authenticated' | 'authorized'
 
@@ -46,67 +52,27 @@ export type IrCallableOutput =
   | { mode: 'stream'; item: JsonSchema }
   | { mode: 'binary' }
 
-export interface IrMethod {
-  name: string
-  /** Canonical callable input. Legacy projections expose only `params`. */
-  input?: JsonSchema
-  params: Record<string, JsonSchema>
-  /** Names required by canonical `input.required`; absent on legacy Methods. */
-  requiredParams?: string[]
-  /** Canonical discriminated output. Legacy projections expose only `returns`. */
-  output?: IrCallableOutput
-  returns: JsonSchema
-  static: boolean
-  inheritance: MethodInheritance
-  description?: string
-  auth?: IrCallableAuth
-  policy?: unknown
-}
-
-/** Standalone Domain Function projected into the Studio's callable vocabulary. */
-export interface IrFunction {
+export interface IrCallable {
   name: string
   input: JsonSchema
-  params: Record<string, JsonSchema>
-  /** Names required by canonical `input.required`. */
-  requiredParams?: string[]
   output: IrCallableOutput
-  returns: JsonSchema
-  /** Standalone Functions have no receiver; these legacy-compatible fields let
-   * existing callable renderers consume them alongside static Methods. */
-  static: true
-  inheritance: 'default'
   description?: string
   auth?: IrCallableAuth
   policy?: unknown
 }
 
-export interface IrInterface {
-  type: 'interface'
-  name: string
-  /** Canonical declaration owner/family; absent on legacy projections. */
-  origin?: string
-  family?: 'node' | 'edge' | 'both'
-  ref?: IrSchemaRef
-  extends?: string[]
-  extendsRefs?: IrSchemaRef[]
-  properties: Record<string, JsonSchema>
-  /** Canonical `properties.required`; absence, unlike null, encodes optionality. */
-  required?: string[]
-  methods: Record<string, IrMethod>
-  endpoints?: IrEndpoint[]
-  orientation?: 'directed' | 'undirected'
-  constraints?: { noSelf?: true; acyclic?: true }
-  description?: string
-  propertyMetadata?: Record<string, unknown>
-  /** Canonical data declaration; `mediaType` is required and extensions stay lossless. */
-  data?: { mediaType: string; [key: string]: unknown }
+export interface IrMethod extends IrCallable {
+  static: boolean
+  inheritance: MethodInheritance
 }
 
+/** Standalone DSL callable projected without inventing a receiver. */
+export interface IrFunction extends IrCallable {}
+
 export interface IrEndpoint {
   name: string
   types: string[]
-  /** Exact accepted Definition coordinates. `types` remains for existing UI consumers. */
+  /** Exact accepted Definition coordinates. `types` is the local display projection. */
   refs?: IrSchemaRef[]
   /** declared multiplicity for this end; max:null = unbounded ("many"). Absent ⇒ unconstrained. */
   cardinality?: { min: number; max: number | null }
@@ -115,11 +81,10 @@ export interface IrEndpoint {
 export interface IrClass {
   type: 'node' | 'edge'
   name: string
-  /** Canonical declaration owner/ref; absent on legacy projections. */
-  origin?: string
-  ref?: IrSchemaRef
-  implements?: string[]
-  implementsRefs?: IrSchemaRef[]
+  origin: string
+  ref: IrClassRef
+  extends?: string[]
+  extendsRefs?: IrClassRef[]
   /** edges only: the two (source,target) endpoints with role names + allowed types */
   endpoints?: IrEndpoint[]
   orientation?: 'directed' | 'undirected'
@@ -139,10 +104,8 @@ export interface IrClass {
 
 export interface IrImportDescriptor {
   origin: string
-  definition: 'interface' | 'class'
-  ref?: IrDefinitionRef
-  /** Canonical qualified identity; absent on legacy import descriptors. */
-  key?: IrDefinitionKey
+  ref: IrClassRef
+  key: IrClassKey
 }
 
 export type IrViewTarget = { kind: 'domain' } | { kind: 'definition'; definitions: IrSchemaRef[] }
@@ -150,41 +113,30 @@ export type IrViewTarget = { kind: 'domain' } | { kind: 'definition'; definition
 export interface IrView {
   name: string
   target: IrViewTarget
-  auth: 'required' | 'optional' | 'public'
   description?: string
 }
 
 export interface SchemaIR {
+  format: 'astrale.dsl'
   version: string
   domain: string
-  /** Canonical document format; absent on legacy projections. */
-  format?: 'astrale.dsl'
-  types: Record<string, JsonSchema>
-  interfaces: Record<string, IrInterface>
   classes: Record<string, IrClass>
-  imports: Record<string, IrImportDescriptor>
-  /**
-   * Canonical authoritative import index, keyed by `origin:kind.name`.
-   * `imports` remains the unambiguous short-name compatibility index.
-   */
-  importsByKey?: Record<IrDefinitionKey, IrImportDescriptor>
-  /** Exact imported Interface bodies under the same collision-free identity. */
-  importedInterfacesByKey?: Record<IrDefinitionKey, IrInterface>
-  /** Canonical V1 members absent from the legacy serializer projection. */
+  importsByKey: Record<IrClassKey, IrImportDescriptor>
+  importedClassesByKey: Record<IrClassKey, IrClass>
   functions: Record<string, IrFunction>
-  views?: Record<string, IrView>
-  policies?: Record<string, unknown>
-  dependencies?: Array<{ origin: string; revision: string }>
-  /** Exact canonical genesis declaration; absent on legacy projections. */
-  core?: unknown
+  views: Record<string, IrView>
+  policies: Record<string, unknown>
+  dependencies: Array<{ origin: string; revision: string }>
+  core: unknown
 }
 
 export interface HandlerLink {
   owner: string
-  ownerKind: 'class' | 'interface' | 'function'
+  ownerKind: 'class' | 'function'
+  kind: 'action' | 'workflow'
   method: string
   static: boolean
-  /** the legacy runtime registry or current implementation.ts wiring site */
+  /** The Runtime registry or one modular Action/Workflow file. */
   wiringFile?: string
   wiringLine?: number
   /** the resolved handler file (followed from the `execute` import) */
@@ -192,14 +144,6 @@ export interface HandlerLink {
   handlerLine?: number
   /** kernel ops detected in the handler (::update, ::link, createNode, …) */
   kernelCalls?: string[]
-  /** declared auth policy on the runtime config; absent ⇒ defaults to 'required'. */
-  auth?: 'public' | 'optional' | 'required'
-  /** Canonical V1 callable auth, when the handler comes from implementation.ts. */
-  callableAuth?: IrCallableAuth
-  /** authorize hook shape: 'absent' (none), 'noop' (allow-all), 'custom' (real check). */
-  authorize?: 'absent' | 'noop' | 'custom'
-  /** raw source of the authorize hook (for the hover preview). */
-  authorizeSnippet?: string
   /** false ⇒ a todo()/NotImplemented stub → "contract-only" badge */
   implemented: boolean
   /** true ⇒ resolver could not link a file → "unlinked" badge */
@@ -213,33 +157,10 @@ export interface SourceSpan {
   doc?: string
 }
 
-export interface SchemaAnnotation {
-  /** anchor ref key, e.g. 'class.Monitor.property.status' */
-  target: string
-  severity: 'warn' | 'info'
-  code: 'COMPILE_ERROR' | 'EDGE_PROP_TYPE_MISSING'
-  message: string
-}
-
-export interface CrossDomainImport {
-  name: string
-  origin: string
-  definition: 'interface' | 'class'
-}
-
 export interface SchemaOverlay {
-  origin: string
-  /** defineDomain({ requires }) — runtime domain dependencies */
-  requires: string[]
-  /** non-kernel ir.imports → true cross-domain imports */
-  crossDomainImports: CrossDomainImport[]
-  /** kernel-origin ir.imports → mixin interfaces (collapsed chip) */
-  mixins: CrossDomainImport[]
-  postInstall?: string
   handlerLinks: HandlerLink[]
-  /** keyed by anchor ref (class.X / class.X.property.y / class.X.method.m / edge.e / interface.I…) */
+  /** Keyed by Class, Property, Method, Function, Policy, View, or Core anchor. */
   sourceSpans: Record<string, SourceSpan>
-  annotations: SchemaAnnotation[]
 }
 
 export interface BundleError {
@@ -251,25 +172,19 @@ export interface StudioSchemaBundle {
   domainId: string
   /** UI/cache identity only. This is not the DSL schema revision. */
   renderFingerprint: string
-  schemaMode: 'canonical-admitted' | 'canonical-preview' | 'legacy' | 'unavailable'
-  /** DSL-owned revision, present only after cohort SDK admission. */
+  schemaMode: 'canonical-admitted' | 'canonical-preview' | 'unavailable'
+  /** DSL-owned revision, present only after installed SDK admission. */
   schemaRevision?: SchemaRevision
   extractedBy: 'runtime-bun' | 'static-tsmorph-fallback'
   depsInstalled: boolean
   ir: SchemaIR | null
   /**
    * Portable canonical V1 document emitted by the domain. `schemaMode` records
-   * whether the cohort SDK admitted it or Studio is rendering it as a structural
-   * preview. Kept separate from the lossy render IR; absent for legacy domains.
+   * whether the installed SDK admitted it or Studio is rendering it as a structural
+   * preview. Kept separate from the lossy render IR.
    */
   schemaRoot?: unknown
   overlay: SchemaOverlay
-  /**
-   * Unambiguous short-name aliases for imported Interface bodies, retained for
-   * legacy renderers. Canonical consumers use `ir.importedInterfacesByKey`, whose
-   * `origin:interface.Name` keys cannot collide. Empty when deps aren't installed.
-   */
-  importedInterfaces?: Record<string, IrInterface>
   /** present when the runtime import failed to compile (render state, not a crash) */
   error?: BundleError | null
   extractedAt: string
@@ -277,12 +192,11 @@ export interface StudioSchemaBundle {
 
 export interface DomainOverview {
   origin: string
-  /** Active SDK composition entry; `domain.ts` is retained for legacy projects. */
-  compositionFile?: 'implementation.ts' | 'domain.ts'
+  /** Active SDK Application entry relative to the project root. */
+  applicationFile?: string
   adapter: 'astrale' | 'cloudflare' | 'unknown'
   prodTarget?: string
   devSecrets?: string
-  postInstall?: string
   requires: string[]
   packageName?: string
   packageVersion?: string
@@ -294,7 +208,6 @@ export interface DomainOverview {
 export interface ViewInfo {
   slug: string
   kind: 'inline-html' | 'spa' | 'unknown'
-  auth?: string
   mount?: string
   url?: string
   /** the class(es) this view binds to via `viewFor: selfOf(Class)` (DSL allows an array);
@@ -427,9 +340,9 @@ export interface StudioCoreNode {
 
 /** One materialized edge instance wiring two core nodes. */
 export interface StudioCoreEdge {
-  /** source Core path, owning Domain path, or a legacy meta-node endpoint */
+  /** source Core path or owning Domain path */
   from: string
-  /** target Core path, owning Domain path, or a legacy meta-node endpoint */
+  /** target Core path or owning Domain path */
   to: string
   /** the IR edge class name (keys into StudioSchemaBundle.ir.classes, type:'edge') */
   edgeName: string
@@ -459,4 +372,4 @@ export type TypeDescriptor =
       required: string[]
       optional: boolean
     }
-  | { kind: 'ref'; target: string; refKind: 'node' | 'data'; optional: boolean }
+  | { kind: 'ref'; target: 'node'; optional: boolean }