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

package/src/commands/call.ts

@@ -4,8 +4,8 @@ import type { ConnectionContext, KernelCommandOpts } from '../connection'
 import type { CommandDefinition } from '../program/index'
 
 import { createPathCall, expandSelfInCall, runKernelCommand, withSelfHint } from '../connection'
-import { presentBinary } from '../lib/binary'
-import { failClosed, log } from '../lib/log'
+import { presentBinary, readBinaryBody } from '../lib/binary'
+import { failInput, log } from '../lib/log'
 import { output, present } from '../lib/output'
 
 type CallOpts = KernelCommandOpts & {
@@ -15,8 +15,20 @@ type CallOpts = KernelCommandOpts & {
 }
 
 type CallResult = Awaited<ReturnType<ConnectionContext['session']['dispatch']>>
+type BinaryCallResult = Extract<CallResult, { readonly kind: 'binary' }>
+type BinaryCallInput = Omit<BinaryCallResult, 'value'> & {
+  readonly value: Omit<BinaryCallResult['value'], 'body' | 'status'> & {
+    readonly body: Uint8Array | AsyncIterable<Uint8Array>
+    readonly status?: number
+  }
+}
+type CallResultInput = Exclude<CallResult, { readonly kind: 'binary' }> | BinaryCallInput
+type MaterializedBinaryCallResult = Omit<BinaryCallResult, 'value'> & {
+  readonly value: Omit<BinaryCallInput['value'], 'body'> & { readonly body: Uint8Array }
+}
 type MaterializedCallResult =
-  | Exclude<CallResult, { readonly kind: 'stream' }>
+  | Exclude<CallResult, { readonly kind: 'binary' | 'stream' }>
+  | MaterializedBinaryCallResult
   | { readonly kind: 'stream'; readonly values: readonly unknown[] }
 
 export async function callCommand(
@@ -24,64 +36,60 @@ export async function callCommand(
   rawParams: string[],
   opts: CallOpts,
 ): Promise<void> {
-  // Expand @self before describe/execute through authenticated Identity.whoami.
-  let expanded: Awaited<ReturnType<typeof expandSelfInCall>>
-  try {
-    expanded = await expandSelfInCall(path, rawParams, opts)
-  } catch (error) {
-    failClosed(error, opts)
-  }
-  const expandedPath = expanded.path
-  try {
-    Path.parse(expandedPath)
-  } catch (error) {
-    failClosed(error, opts)
-  }
-
-  // ── Parse params ────────────────────────────────────────
   let params: Record<string, unknown>
   try {
-    params = await parseParams([...expanded.parameters], opts.data)
-  } catch (e) {
-    failClosed(e, opts)
-  }
-
-  // ── Dry-run: show what would be sent ─────────────────────
-  if (opts.dryRun) {
-    output({ method: expandedPath, params }, opts)
-    return
+    Path.parse(path)
+    params = await parseParams(rawParams, opts.data)
+  } catch (error) {
+    failInput(error, opts)
   }
 
-  // ── Execute ────────────────────────────────────────────
-  await runKernelCommand<MaterializedCallResult>({
-    opts,
-    label: expandedPath,
-    fn: (ctx) =>
-      withSelfHint(
-        async () =>
-          materializeCallResult(await ctx.session.dispatch(createPathCall(expandedPath, params))),
-        expanded.meta,
-      ),
-    format: async (result, fmtOpts) => {
-      switch (result.kind) {
-        case 'value':
-          present(result.value, fmtOpts)
-          return
-        case 'binary':
-          await presentBinary(result.value, fmtOpts, { outFile: opts.output })
-          return
-        case 'stream':
-          output(result.values, fmtOpts)
-          return
-        case 'redirect':
-          throw new Error('Client Session returned an unresolved redirect.')
-      }
+  await runKernelCommand<MaterializedCallResult | { readonly kind: 'dry'; readonly call: unknown }>(
+    {
+      opts,
+      label: path,
+      fn: async (ctx) => {
+        const expanded = await expandSelfInCall(path, params, ctx)
+        const request = createPathCall(expanded.path, expanded.parameters)
+        if (opts.dryRun) return { kind: 'dry', call: request }
+        return withSelfHint(
+          async () => materializeCallResult(await ctx.session.dispatch(request)),
+          expanded.meta,
+        )
+      },
+      format: async (result, fmtOpts) => {
+        switch (result.kind) {
+          case 'dry':
+            output(result.call, fmtOpts)
+            return
+          case 'value':
+            present(result.value, fmtOpts)
+            return
+          case 'binary':
+            await presentBinary(result.value, fmtOpts, { outFile: opts.output })
+            return
+          case 'stream':
+            output(result.values, fmtOpts)
+            return
+          case 'redirect':
+            throw new Error('Client Session returned an unresolved redirect.')
+        }
+      },
     },
-  })
+  )
 }
 
 /** Drain a session-backed stream before the command-scoped Client Session closes. */
-export async function materializeCallResult(result: CallResult): Promise<MaterializedCallResult> {
+export async function materializeCallResult(
+  result: CallResultInput,
+): Promise<MaterializedCallResult> {
+  if (result.kind === 'binary') {
+    const body = await readBinaryBody(result.value.body)
+    return Object.freeze({
+      ...result,
+      value: Object.freeze({ ...result.value, body }),
+    })
+  }
   if (result.kind !== 'stream') return result
   const values: unknown[] = []
   for await (const value of result.stream) values.push(value)
@@ -101,7 +109,7 @@ export async function parseParams(
     try {
       return JSON.parse(dataFlag)
     } catch {
-      throw new Error(`Invalid JSON in --data: ${dataFlag}`)
+      throw new TypeError(`Invalid JSON in --data: ${dataFlag}`)
     }
   }
 
@@ -114,7 +122,7 @@ export async function parseParams(
     try {
       return JSON.parse(stdin)
     } catch {
-      throw new Error('Invalid JSON from stdin')
+      throw new TypeError('Invalid JSON from stdin')
     }
   }
 
@@ -142,7 +150,7 @@ export function parseKeyValue(pairs: string[]): Record<string, unknown> {
   for (const pair of pairs) {
     const eqIdx = pair.indexOf('=')
     if (eqIdx === -1) {
-      throw new Error(`Invalid param "${pair}" — expected key=value format`)
+      throw new TypeError(`Invalid param "${pair}" — expected key=value format`)
     }
     const key = pair.slice(0, eqIdx)
     const raw = pair.slice(eqIdx + 1)
@@ -150,7 +158,7 @@ export function parseKeyValue(pairs: string[]): Record<string, unknown> {
       const hint = key.endsWith(':')
         ? ` (looks like httpie's "key:=value" syntax — Astrale CLI doesn't support it; use --data '{"${key.slice(0, -1)}":<value>}' for nested values)`
         : ` (keys must be identifier-shaped: letters, digits, underscore, hyphen)`
-      throw new Error(`Invalid param key "${key}" in "${pair}"${hint}`)
+      throw new TypeError(`Invalid param key "${key}" in "${pair}"${hint}`)
     }
     result[key] = coerceValue(raw)
   }
@@ -184,6 +192,10 @@ Behavior:
   input without executing. Remote-bound functions auto-mint a
   worker-scoped credential; --creds overrides it.
 
+  Streaming binary bodies are consumed while the Client session remains live,
+  then presented through the same --output, --raw, and --json paths as buffered
+  binary. JSON retains the application HTTP status and text/base64 body.
+
 Self-reference:
   @self expands to your nodeId on the active instance (path head or
   bare param value, e.g. node=@self). --data and stdin payloads are
@@ -194,7 +206,7 @@ Self-reference:
   Callable input/output lives on astrale introspect <path>.
 
 Examples:
-  $ astrale introspect /:host.astrale.ai:class.Manager:createInstance
+  $ astrale introspect /:kernel.astrale.ai:class.Identity:whois
   $ astrale call /:blog.acme.com:class.Author:list limit=10
   $ astrale call '@self::deactivate'
   $ astrale call /:kernel.astrale.ai:function.journal --data '{"limit":5}' --json
@@ -203,7 +215,7 @@ Examples:
     {
       name: 'path',
       description:
-        'Operation path (e.g., /:host.astrale.ai:class.Manager:createInstance or /node::method)',
+        'Operation path (e.g., /:kernel.astrale.ai:class.Identity:whois or /node::method)',
     },
     { name: 'params...', description: 'Params as key=value pairs', required: false },
   ],

package/src/commands/domain/install.ts

@@ -1,11 +1,11 @@
-import { Path } from '@astrale-os/sdk/graph/path'
-import { syscalls } from '@astrale-os/sdk/schema/kernel'
+import type { InstallRequest, InstallResult, OperationId } from '@astrale-os/sdk/client/schema'
+
 import chalk from 'chalk'
 
 import type { KernelCommandOpts } from '../../connection'
 import type { CommandDefinition } from '../../program/index'
 
-import { createPathCall, runKernelCommand, withAdminClientSession } from '../../connection'
+import { runKernelCommand, withAdminClientSession } from '../../connection'
 import { formatKernelError } from '../../connection/errors'
 import { AstraleError } from '../../errors'
 import {
@@ -23,35 +23,61 @@ import { confirmWithInput, promptText, selectFrom } from '../../lib/prompt'
 import { isHttpUrl } from '../../lib/validation'
 
 /** Public Kernel install syscall input for one remote URL. */
-export function directInstallCallInput(url: string, operation: string, token?: string) {
+export function directInstallCallInput(
+  url: string,
+  operation: string,
+  token?: string,
+): InstallRequest {
+  const domain = Object.freeze({
+    publication: Object.freeze({
+      url,
+      ...(token === undefined ? {} : { token }),
+    }),
+  })
   return Object.freeze({
-    operation,
-    domains: [
-      Object.freeze({
-        source: Object.freeze({
-          kind: 'remote' as const,
-          url,
-          ...(token === undefined ? {} : { token }),
-        }),
-      }),
-    ],
+    operation: acceptOperationId(operation),
+    domains: Object.freeze([domain] as const),
   })
 }
 
-type DirectInstallResult = {
+export interface DirectInstallPresentation {
   readonly operation: string
-  readonly transitions: readonly {
-    readonly intent: {
-      readonly origin: string
-      readonly target?: { readonly schemaRevision?: string } | null
+  readonly origin: string
+  readonly revision: string
+  readonly status: 'installed' | 'already current'
+}
+
+/** Stable CLI presentation derived from the canonical binary install result. */
+export function directInstallPresentation(
+  result: InstallResult,
+  requestedOperation: string,
+): DirectInstallPresentation {
+  if (result.changed) {
+    const installed = result.receipt.transitions[0]?.intent
+    if (!installed) throw new Error('Kernel install returned no committed Domain transition.')
+    if (!installed.generation) {
+      throw new Error('Kernel install returned a committed transition without a Domain generation.')
     }
-  }[]
+    return Object.freeze({
+      operation: result.receipt.operation,
+      origin: installed.origin,
+      revision: installed.generation.revision,
+      status: 'installed' as const,
+    })
+  }
+  const installed = result.domains[0]
+  return Object.freeze({
+    operation: requestedOperation,
+    origin: installed.origin,
+    revision: installed.revision,
+    status: 'already current' as const,
+  })
 }
 
 const OPERATION_ID_PATTERN =
   /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/u
 
-function acceptOperationId(input: unknown): string {
+function acceptOperationId(input: unknown): OperationId {
   if (typeof input !== 'string' || !OPERATION_ID_PATTERN.test(input)) {
     throw new AstraleError(
       'INVALID_FLAG',
@@ -59,10 +85,10 @@ function acceptOperationId(input: unknown): string {
       'Omit --operation for a fresh install; use it only with the exact UUID printed for recovery.',
     )
   }
-  return input
+  return input as OperationId
 }
 
-function createOperationId(): string {
+function createOperationId(): OperationId {
   return acceptOperationId(globalThis.crypto.randomUUID())
 }
 
@@ -400,6 +426,7 @@ export async function installDirect(
       target,
       host,
       opts.allowIdentityOverride ?? false,
+      isMachine(opts),
     )
   } catch (e) {
     fatal(e, opts)
@@ -407,36 +434,31 @@ export async function installDirect(
   const url = target as string
   const retry = directInstallRetry(url, operation, opts)
 
-  await direct.runKernelCommand<DirectInstallResult>({
+  await direct.runKernelCommand<InstallResult>({
     opts,
     label: `Installing domain from ${url} (operation ${operation})`,
     recovery: { operation, retry },
     fn: async ({ session }) =>
-      (await session.call(
-        createPathCall(
-          Path.project(syscalls.install.ref).raw,
-          directInstallCallInput(url, operation, opts.token),
-        ),
-      )) as DirectInstallResult,
+      session.schema.install(directInstallCallInput(url, operation, opts.token)),
     format: (result, fmtOpts, isRaw) => {
       if (isRaw) {
         output(result, fmtOpts)
         return
       }
-      const installed = result.transitions[0]?.intent
-      if (!installed) throw new Error('Kernel install returned no committed Domain transition.')
-      const revision = installed.target?.schemaRevision ?? result.operation
-      log.success(`Domain installed: ${installed.origin}@${revision}`)
-      log.dim(`  operation:   ${result.operation}`)
+      const installed = directInstallPresentation(result, operation)
+      log.success(`Domain ${installed.status}: ${installed.origin}@${installed.revision}`)
+      log.dim(`  operation:   ${installed.operation}`)
       // Belt-and-braces: the kernel-confirmed origin is authoritative. If it
       // aliases the host and the pre-install gate never consented to THAT
       // origin (lying or unavailable Publication), say so loudly after the fact.
       if (isIdentityOverride(installed.origin, host) && installed.origin !== consentedOrigin) {
-        log.warn(
-          `Installed origin "${installed.origin}" differs from the serving host "${host}" ` +
-            `and was not confirmed before install (the worker Publication was unavailable). ` +
-            `Every ${installed.origin}/* call on this instance now routes to ${host}.`,
-        )
+        if (!isMachine(fmtOpts)) {
+          log.warn(
+            `Installed origin "${installed.origin}" differs from the serving host "${host}" ` +
+              `and was not confirmed before install (the worker Publication was unavailable). ` +
+              `Every ${installed.origin}/* call on this instance now routes to ${host}.`,
+          )
+        }
       }
     },
   })
@@ -493,20 +515,25 @@ async function ensureIdentityOverrideConsent(
   url: string,
   host: string,
   allow: boolean,
+  machine: boolean,
 ): Promise<string | undefined> {
   const origin = await probeDeclaredOrigin(url)
   if (origin === undefined) {
-    log.warn(
-      `Could not read a declared origin from ` +
-        `${new URL('/.well-known/astrale/domain.json', url).href} — ` +
-        `skipping the pre-install identity check (the installed origin is verified after install).`,
-    )
+    if (!machine) {
+      log.warn(
+        `Could not read a declared origin from ` +
+          `${new URL('/.well-known/astrale/domain.json', url).href} — ` +
+          `skipping the pre-install identity check (the installed origin is verified after install).`,
+      )
+    }
     return undefined
   }
   if (!isIdentityOverride(origin, host)) return undefined
 
   if (allow) {
-    log.warn(`Identity override consented via --allow-identity-override: ${origin} ← ${host}`)
+    if (!machine) {
+      log.warn(`Identity override consented via --allow-identity-override: ${origin} ← ${host}`)
+    }
     return origin
   }
 

package/src/commands/domain/list.ts

@@ -73,7 +73,7 @@ Behavior:
   or with --json/--raw (agent-friendly — full DomainInfo objects). -q prints
   one install URL per line (pipeable into \`domain install\`); --count prints
   only the number. --default-only keeps the install-by-default entries (what
-  every new instance gets via alphaCreate). --check probes each published URL's
+  every new instance receives during Admin-managed provisioning). --check probes each published URL's
   canonical Publication and adds a live/unreachable STATUS column
   (+ reachable/schemaRevision in machine output).
 

package/src/commands/domain/publish.ts

@@ -3,9 +3,11 @@ import chalk from 'chalk'
 import type { KernelCommandOpts } from '../../connection'
 import type { CommandDefinition } from '../../program/index'
 
+import { formatKernelError } from '../../connection/errors'
 import { publishAdminDomain } from '../../lib/admin-domain'
 import { ADMIN_TARGET_OPTIONS, type AdminTargetCommandOpts } from '../../lib/admin-target'
-import { fatal, withSpinner } from '../../lib/log'
+import { domainPublicationUrl } from '../../lib/domain-publication'
+import { withSpinner } from '../../lib/log'
 import { isMachine, output } from '../../lib/output'
 import { promptText } from '../../lib/prompt'
 import { isHttpUrl, validateName, validateUrl } from '../../lib/validation'
@@ -48,9 +50,9 @@ Behavior:
 
   Publishing only makes the domain INSTALLABLE. Mount it on an instance with
   \`astrale domain install <url>\` (or rely on the admin's install-by-default
-  policy). This is usually invoked for you by \`astrale-domain publish\` (which
-  registers the already-deployed URL — it does NOT deploy) or by
-  \`astrale-domain deploy --publish\` (deploy AND register in one step).
+  policy). Deployment and catalog publication are separate owners: run the
+  project's \`astrale-domain deploy <environment>\`, then publish its observed
+  public URL with this command.
 
   Run in a terminal with flags omitted and it PROMPTS for origin / name /
   public-url (origin defaults to the URL host, name to the origin's first
@@ -68,17 +70,16 @@ Examples:
     { flags: '--description <text>', description: 'Optional human description for the catalog' },
     {
       flags: '--install-by-default',
-      description: 'Mark the domain for install on every new instance (alphaCreate)',
+      description: 'Mark the domain for install on every new instance',
     },
   ],
   // No positional arguments → Commander passes (opts, command); `opts` is first.
   action: async (opts: PublishOpts) => {
     try {
       // Interactive fill (TTY only): a human running this by hand is prompted for
-      // any missing field. The primary caller — `astrale-domain publish` — always
-      // passes every flag, so it never prompts. No TTY / --ci / --no-prompt / CI
-      // env → no prompt: fall straight through to the required-flag error below,
-      // so a piped / agent / LLM run fails fast instead of hanging on a read.
+      // any missing field. Automation passes every flag. No TTY / --ci /
+      // --no-prompt / CI env means no prompt: fall straight through to the
+      // required-flag error below so a piped or agent run fails fast.
       const interactive = !!process.stdin.isTTY && !(opts.ci || opts.noPrompt || process.env.CI)
       let { origin, name, publicUrl } = opts
       if (interactive) {
@@ -102,6 +103,7 @@ Examples:
       validateName(origin, 'origin')
       validateName(name, 'domain')
       validateUrl(publicUrl)
+      const discoveryUrl = domainPublicationUrl(publicUrl).href
 
       const result = await withSpinner(
         `Publishing ${name} → ${publicUrl}`,
@@ -110,7 +112,7 @@ Examples:
           publishAdminDomain(opts, {
             origin,
             name,
-            url: publicUrl,
+            url: discoveryUrl,
             ...(opts.description ? { description: opts.description } : {}),
             ...(opts.installByDefault ? { installByDefault: true } : {}),
           }),
@@ -127,7 +129,8 @@ Examples:
         return
       }
     } catch (e) {
-      fatal(e)
+      await formatKernelError(e, isMachine(opts), undefined, opts.debug)
+      process.exit(1)
     }
   },
 } satisfies CommandDefinition

package/src/commands/domain/uninstall.ts

@@ -1,5 +1,5 @@
 import { Path } from '@astrale-os/sdk/graph/path'
-import { syscalls } from '@astrale-os/sdk/schema/kernel'
+import { K } from '@astrale-os/sdk/schema'
 import chalk from 'chalk'
 
 import type { KernelCommandOpts } from '../../connection'
@@ -77,7 +77,7 @@ Examples:
       label: `Uninstalling domain ${origin}`,
       fn: async ({ session }) =>
         (await session.call(
-          createPathCall(Path.project(syscalls.uninstall.ref).raw, uninstallCallInput(origin)),
+          createPathCall(Path.project(K.functions.uninstall.ref).raw, uninstallCallInput(origin)),
         )) as UninstallResult,
       format: (result, formatOpts, machine) => {
         if (machine) {

package/src/commands/get.ts

@@ -4,40 +4,39 @@ import type { KernelCommandOpts } from '../connection'
 import type { CommandDefinition } from '../program/index'
 
 import { expandSelfInPath, runKernelCommand, withSelfHint } from '../connection'
-import { formatKernelError } from '../connection/errors'
 import { AstraleError } from '../errors'
-import { denoise, isMachine, output } from '../lib/output'
+import { failInput, fatal } from '../lib/log'
+import { denoise, output } from '../lib/output'
 
 type GetOpts = KernelCommandOpts & { schema?: boolean }
 
 /** Read one exact canonical Node. The caller's Path is not fabricated into the Node value. */
 export async function getCommand(target: string, opts: GetOpts): Promise<void> {
-  let path: string
-  let meta
   let parsed
   try {
-    ;({ path, meta } = await expandSelfInPath(target, opts))
-    parsed = Path.parse(path)
+    parsed = Path.parse(target)
   } catch (error) {
-    await formatKernelError(error, isMachine(opts), undefined, opts.debug)
-    process.exit(1)
+    failInput(error, opts)
   }
 
   const last = parsed.ast.steps.at(-1)
   if (last?.kind === 'method') {
     const error = new AstraleError(
       'NOT_A_NODE',
-      `${path} is a callable Path, not a Node.`,
-      `Use \`astrale call ${path}\` or \`astrale introspect ${path}\`.`,
+      `${target} is a callable Path, not a Node.`,
+      `Use \`astrale call ${target}\` or \`astrale introspect ${target}\`.`,
     )
-    await formatKernelError(error, isMachine(opts), undefined, opts.debug)
-    process.exit(1)
+    fatal(error, opts)
   }
 
   await runKernelCommand({
     opts,
-    label: `Node ${path}`,
-    fn: ({ graph }) => withSelfHint(() => graph.getOrThrow(parsed), meta),
+    label: `Node ${target}`,
+    fn: async (context) => {
+      const { path, meta } = await expandSelfInPath(target, context)
+      const resolved = meta === undefined ? parsed : Path.parse(path)
+      return withSelfHint(() => context.graph.getOrThrow(resolved), meta)
+    },
     format: (node, format) => output(opts.schema === true ? node : denoise(node), format),
   })
 }
@@ -47,7 +46,7 @@ export default {
   description: 'Get one canonical node by Path or ID',
   afterHelpText: `
 Behavior:
-  Resolves one exact Kernel V2 Path and prints the canonical Node
+  Resolves one exact Kernel Path and prints the canonical Node
   { id, class, props }. Missing and authorization-masked nodes remain
   intentionally indistinguishable. @self is expanded before dispatch.
 
@@ -60,7 +59,7 @@ Examples:
   $ astrale get /:notes.example.dev:class.Note
   $ astrale get @abc123 --json
   $ astrale get @self
-  $ astrale get /:host.astrale.ai --schema
+  $ astrale get /:kernel.astrale.ai --schema
 `,
   arguments: [{ name: 'target', description: 'Canonical Node Path or @id' }],
   options: [{ flags: '--schema', description: 'Include schema-valued properties' }],

package/src/commands/identity/__tests__/register.test.ts

@@ -1,9 +1,9 @@
 import { issuer, jwk, provision } from '@astrale-os/sdk/auth'
-import { ClassPath } from '@astrale-os/sdk/graph/class'
 import { normalizeProperties } from '@astrale-os/sdk/graph/properties'
 import { expect, mock, test } from 'bun:test'
 import { exportJWK, generateKeyPair, jwtVerify } from 'jose'
 
+import { classKey } from '../../../graph'
 import { formatIdentityRegistration, prepareIdentityProvision } from '../register'
 
 /** @evidence TEST-CLI-IDENTITY-REGISTER-JSON-EXACT */
@@ -46,7 +46,7 @@ test('builds one exact Mutation V3 identity birth bound to a self proof', async
     kid: 'alice-key',
   })
   const kernelIssuer = issuer.accept('https://kernel.example')
-  const classPath = ClassPath.parse('/:accounts.example:class.User')
+  const classPath = classKey('/:accounts.example:class.User', '--class')
   const properties = normalizeProperties({
     'accounts.example:class.User.property.name': 'Alice',
   })
@@ -70,7 +70,7 @@ test('builds one exact Mutation V3 identity birth bound to a self proof', async
       {
         op: 'node.create',
         as: 'identity',
-        class: '/:accounts.example:class.User',
+        class: 'accounts.example:class.User',
         props: { 'accounts.example:class.User.property.name': 'Alice' },
       },
     ],

package/src/commands/identity/register.ts

@@ -1,9 +1,9 @@
 import type { IssuerId, JsonWebKey, ProvisionRequest } from '@astrale-os/sdk/auth'
+import type { ClassKey as ClassKeyValue } from '@astrale-os/sdk/graph/class'
 import type { JWK } from 'jose'
 
 import { provision, jwk } from '@astrale-os/sdk/auth'
-import { ClassPath } from '@astrale-os/sdk/graph/class'
-import { LocalBinding } from '@astrale-os/sdk/graph/model'
+import { LocalBinding } from '@astrale-os/sdk/graph'
 import { normalizeProperties } from '@astrale-os/sdk/graph/properties'
 import { MutationAST } from '@astrale-os/sdk/mutation'
 import { importJWK, SignJWT } from 'jose'
@@ -14,6 +14,7 @@ import type { IdentityRegistrationResult } from '../../identity/index'
 import type { CommandDefinition } from '../../program/index'
 
 import { registrationKeyForTarget, runKernelCommand } from '../../connection'
+import { classKey } from '../../graph'
 import { getIdentity, setRegistration, submitIdentityProvision } from '../../identity/index'
 import { fileExists, keypairPaths } from '../../keys/index'
 import { fatal, log } from '../../lib/log'
@@ -44,10 +45,9 @@ Behavior:
   its result and stores the same target-bound registration. The callable owns
   authorization; the CLI never receives installed Domain authority.
 
-  Kernel V2 Nodes have opaque identity and no caller-assigned storage path, so
-  the historical --path option no longer exists. The CLI binds the key proof
-  to the exact provision fingerprint and target Kernel audience, then caches
-  the returned (issuer, subject) for subsequent calls.
+  The Kernel assigns each Node ID; callers do not choose a storage path. The
+  CLI binds the key proof to the exact provision fingerprint and target Kernel
+  audience, then caches the returned (issuer, subject) for subsequent calls.
 
 Example:
   $ astrale identity register alice --class /:accounts.example:class.User \
@@ -83,7 +83,7 @@ Example:
 
       const privateKey = await readJwk(privatePath)
       const publicKey = jwk.acceptPublic(await readJwk(publicPath))
-      const classPath = ClassPath.parse(opts.class)
+      const classPath = classKey(opts.class, '--class')
       const properties = normalizeProperties(opts.props ? JSON.parse(opts.props) : {})
 
       await runKernelCommand<IdentityRegistrationResult>({
@@ -142,7 +142,7 @@ export function formatIdentityRegistration(
 /** Build and self-prove one exact canonical provision request for the target Kernel. */
 export async function prepareIdentityProvision(input: {
   readonly name: string
-  readonly classPath: ReturnType<typeof ClassPath.parse>
+  readonly classPath: ClassKeyValue
   readonly properties: ReturnType<typeof normalizeProperties>
   readonly privateKey: JWK
   readonly publicKey: JsonWebKey