@astrale-os/cli 0.8.1-alpha.2 → 0.8.1-alpha.4

package/src/commands/__tests__/logs.test.ts

@@ -66,4 +66,27 @@ describe('acceptJournalPage', () => {
     expect(() => acceptJournalPage({ records: [{}] })).toThrow('record 0')
     expect(() => acceptJournalPage({ records: [], cursor: 7 })).toThrow('cursor')
   })
+
+  test('admits journal v2 records that use occurredAt instead of timestamp', () => {
+    const page = acceptJournalPage({
+      records: [
+        {
+          sequence: 10241,
+          topic: 'function.invoke',
+          occurredAt: '2026-08-19T16:51:10.049Z',
+          committedAt: '2026-08-19T16:51:10.070Z',
+          payload: { outcome: 'rejected' },
+          correlation: { invocationId: 'cf862a64-3aa1-4343-ba86-f9b516c4ff95' },
+        },
+      ],
+    })
+    expect(page.records[0]).toMatchObject({
+      sequence: 10241,
+      topic: 'function.invoke',
+      timestamp: '2026-08-19T16:51:10.049Z',
+      occurredAt: '2026-08-19T16:51:10.049Z',
+      committedAt: '2026-08-19T16:51:10.070Z',
+      correlationId: 'cf862a64-3aa1-4343-ba86-f9b516c4ff95',
+    })
+  })
 })

package/src/commands/__tests__/read-commands.test.ts

@@ -218,18 +218,6 @@ describe('get command', () => {
   })
 })
 
-describe('ls command', () => {
-  /** @evidence TEST-CLI-LS-REQUIRES-EXACT-EDGE-BEFORE-CONNECTION */
-  test('rejects a generic child listing before opening the command connection', async () => {
-    const { lsCommand } = await import('../ls')
-
-    await expect(lsCommand('@node', { json: true })).rejects.toEqual(new ExitError(1))
-
-    expect(runKernelCommandMock).not.toHaveBeenCalled()
-    expect(errors.join('\n')).toContain('Kernel V2 has no universal child relation')
-  })
-})
-
 describe('mutate command', () => {
   /** @evidence TEST-CLI-MUTATE-DISPATCHES-CANONICAL-V3 */
   test('admits authoring input and dispatches one canonical Mutation V3 document', async () => {

package/src/commands/call-describe.ts

@@ -0,0 +1,131 @@
+import type { Path } from '@astrale-os/sdk/graph/path'
+
+import { AstraleError } from '../errors'
+
+type JsonRecord = Record<string, unknown>
+
+export interface CallableDescription {
+  readonly path: string
+  readonly origin: string
+  readonly method?: string
+  readonly function?: string
+  readonly class?: string
+  readonly dispatch?: 'static' | 'instance'
+  readonly description?: string
+  readonly auth?: unknown
+  readonly input?: unknown
+  readonly output?: unknown
+  readonly candidates?: readonly CallableDescription[]
+}
+
+/** Resolve one callable's input/output from an installed Domain schema document. */
+export function describeCallableFromSchema(
+  path: Path,
+  schema: unknown,
+): CallableDescription | undefined {
+  if (path.ast.anchor.kind !== 'domain') return undefined
+  const origin = path.ast.anchor.origin
+  const last = path.ast.steps.at(-1)
+  const document = asRecord(schema)
+  if (document === undefined || last === undefined) return undefined
+
+  if (last.kind === 'method') {
+    const owner = path.ast.steps.at(-2)
+    if (
+      owner?.kind === 'projection' &&
+      (owner.projection.kind === 'class' || owner.projection.kind === 'interface')
+    ) {
+      const bag = asRecord(
+        owner.projection.kind === 'class' ? document.classes : document.interfaces,
+      )
+      const definition = asRecord(bag?.[owner.projection.name])
+      const method = asRecord(asRecord(definition?.methods)?.[last.name])
+      if (method !== undefined) {
+        return Object.freeze({
+          path: path.raw,
+          origin,
+          class: owner.projection.name,
+          method: last.name,
+          dispatch: last.dispatch,
+          ...callableFields(method),
+        })
+      }
+    }
+    const matches = findNamedMethods(document, origin, path.raw, last.name, last.dispatch)
+    if (matches.length === 1) return matches[0]
+    if (matches.length > 1) {
+      return Object.freeze({
+        path: path.raw,
+        origin,
+        method: last.name,
+        dispatch: last.dispatch,
+        candidates: Object.freeze(matches),
+      })
+    }
+    return undefined
+  }
+
+  if (last.kind === 'projection' && last.projection.kind === 'function') {
+    const fn = asRecord(asRecord(document.functions)?.[last.projection.name])
+    if (fn === undefined) return undefined
+    return Object.freeze({
+      path: path.raw,
+      origin,
+      function: last.projection.name,
+      ...callableFields(fn),
+    })
+  }
+  return undefined
+}
+
+export function missingCallableDescription(path: string): AstraleError {
+  return new AstraleError(
+    'CALL_DESCRIBE_UNAVAILABLE',
+    `No callable schema is installed for ${path}.`,
+    'Use a Domain-rooted Path such as /:host.astrale.ai:class.Manager:createInstance. Method Paths are not Function nodes.',
+  )
+}
+
+function findNamedMethods(
+  schema: JsonRecord,
+  origin: string,
+  path: string,
+  method: string,
+  dispatch: 'static' | 'instance',
+): CallableDescription[] {
+  const matches: CallableDescription[] = []
+  for (const bag of [schema.classes, schema.interfaces]) {
+    const definitions = asRecord(bag)
+    if (definitions === undefined) continue
+    for (const [className, definition] of Object.entries(definitions)) {
+      const methodDef = asRecord(asRecord(asRecord(definition)?.methods)?.[method])
+      if (methodDef === undefined) continue
+      matches.push(
+        Object.freeze({
+          path,
+          origin,
+          class: className,
+          method,
+          dispatch,
+          ...callableFields(methodDef),
+        }),
+      )
+    }
+  }
+  return matches
+}
+
+function callableFields(value: JsonRecord): Partial<CallableDescription> {
+  return {
+    ...(typeof value.description === 'string' ? { description: value.description } : {}),
+    ...(value.auth === undefined ? {} : { auth: value.auth }),
+    ...(value.input === undefined ? {} : { input: value.input }),
+    ...(value.output === undefined ? {} : { output: value.output }),
+  }
+}
+
+function asRecord(input: unknown): JsonRecord | undefined {
+  return input !== null && typeof input === 'object' && !Array.isArray(input)
+    ? (input as JsonRecord)
+    : undefined
+}

package/src/commands/call.ts

@@ -8,6 +8,7 @@ import { nodeProperty } from '../graph/index'
 import { presentBinary } from '../lib/binary'
 import { log } from '../lib/log'
 import { output, present } from '../lib/output'
+import { describeCallableFromSchema, missingCallableDescription } from './call-describe'
 
 type CallOpts = KernelCommandOpts & {
   data?: string
@@ -97,28 +98,20 @@ async function describeOperation(path: string, opts: CallOpts): Promise<void> {
   await runKernelCommand({
     opts,
     label: `Schema for ${path}`,
-    // The Function node carries the schemas as props (function.get depth:0).
-    fn: async ({ graph }) => await graph.get(Path.parse(path)),
-    format: (node, fmtOpts) => {
-      const input = nodeProperty(node, 'inputSchema')
-      const outputSchema = nodeProperty(node, 'outputSchema')
-      const schema: Record<string, unknown> = {}
-      if (input) schema.input = tryParseJson(input)
-      if (outputSchema) schema.output = tryParseJson(outputSchema)
-      output(Object.keys(schema).length > 0 ? schema : node, fmtOpts)
+    fn: async ({ graph }) => {
+      const parsed = Path.parse(path)
+      if (parsed.ast.anchor.kind !== 'domain') {
+        throw missingCallableDescription(path)
+      }
+      const domain = await graph.getOrThrow(Path.parse(`/:${parsed.ast.anchor.origin}`))
+      const described = describeCallableFromSchema(parsed, nodeProperty(domain, 'schema'))
+      if (described === undefined) throw missingCallableDescription(path)
+      return described
     },
+    format: (schema, fmtOpts) => output(schema, fmtOpts),
   })
 }
 
-function tryParseJson(value: unknown): unknown {
-  if (typeof value !== 'string') return value
-  try {
-    return JSON.parse(value)
-  } catch {
-    return value
-  }
-}
-
 // ── Param parsing ───────────────────────────────────────────
 
 export async function parseParams(
@@ -221,17 +214,20 @@ Self-reference:
   (e.g. via 'astrale get @self --json'). Resolution authenticates to
   the selected Kernel and never trusts a local registration or JWT sub.
 
+  --describe reads the callable's input/output from the installed Domain
+  schema. Method Paths are not Function nodes.
+
 Examples:
-  $ astrale call /:host.astrale.ai:class.KernelInstance:list
+  $ astrale call /:host.astrale.ai:class.Manager:createInstance --describe
   $ astrale call /:blog.acme.com:class.Author:list limit=10
   $ astrale call '@self::deactivate'
-  $ astrale call /:shell.astrale.ai:function.search-domains --json
+  $ astrale call /:kernel.astrale.ai:function.journal --data '{"limit":5}' --json
 `,
   arguments: [
     {
       name: 'path',
       description:
-        'Operation path (e.g., /:host.astrale.ai:class.KernelInstance:list or /node::method)',
+        'Operation path (e.g., /:host.astrale.ai:class.Manager:createInstance or /node::method)',
     },
     { name: 'params...', description: 'Params as key=value pairs', required: false },
   ],

package/src/commands/domain/install.ts

@@ -20,12 +20,35 @@ import { isMachine, output } from '../../lib/output'
 import { confirmWithInput, promptText, selectFrom } from '../../lib/prompt'
 import { isHttpUrl } from '../../lib/validation'
 
-/** Exact output of the public Kernel install syscall for one requested root. */
-type DirectInstallResult = readonly {
-  origin: string
-  revision: string
-  etag?: string
-}[]
+/** Public Kernel install syscall input for one remote URL. */
+export function directInstallCallInput(
+  url: string,
+  token?: string,
+  operation: string = crypto.randomUUID(),
+) {
+  return Object.freeze({
+    operation,
+    domains: [
+      Object.freeze({
+        source: Object.freeze({
+          kind: 'remote' as const,
+          url,
+          ...(token === undefined ? {} : { token }),
+        }),
+      }),
+    ],
+  })
+}
+
+type DirectInstallResult = {
+  readonly operation: string
+  readonly transitions: readonly {
+    readonly intent: {
+      readonly origin: string
+      readonly target?: { readonly schemaRevision?: string } | null
+    }
+  }[]
+}
 
 type InstallOpts = KernelCommandOpts &
   AdminTargetCommandOpts & {
@@ -330,19 +353,22 @@ async function installDirect(target: string | undefined, opts: InstallOpts): Pro
     label: `Installing domain from ${url}`,
     fn: async ({ session }) =>
       (await session.call(
-        createPathCall(Path.project(syscalls.install.ref).raw, {
-          domains: [{ url, ...(opts.token ? { token: opts.token } : {}) }],
-        }),
+        createPathCall(
+          Path.project(syscalls.install.ref).raw,
+          directInstallCallInput(url, opts.token),
+        ),
       )) as DirectInstallResult,
     format: (result, fmtOpts, isRaw) => {
       if (isRaw) {
         output(result, fmtOpts)
         return
       }
-      const installed = result[0]
-      if (!installed) throw new Error('Kernel install returned no installed Domain receipt.')
-      log.success(`Domain installed: ${installed.origin}@${installed.revision}`)
-      if (installed.etag) log.dim(`  publication: ${installed.etag}`)
+      const installed = result.transitions[0]?.intent
+      if (installed === undefined) {
+        throw new Error('Kernel install returned no committed Domain transition.')
+      }
+      const revision = installed.target?.schemaRevision ?? result.operation
+      log.success(`Domain installed: ${installed.origin}@${revision}`)
       // 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 absent `/meta`), say so loudly after the fact.

package/src/commands/domain/list.ts

@@ -66,7 +66,7 @@ Behavior:
   Reads the admin catalog — every domain that has been \`publish\`ed
   (origin → published worker URL). Listing only shows what is INSTALLABLE;
   what is actually mounted where lives on each instance's own graph
-  (\`astrale ls /\` against that instance).
+  (\`astrale query\` against that instance).
 
   Default output is a NAME/ORIGIN/URL/DEFAULT table on a TTY, JSON when piped
   or with --json/--raw (agent-friendly — full DomainInfo objects). -q prints

package/src/commands/get.ts

@@ -4,8 +4,8 @@ import type { KernelCommandOpts } from '../connection'
 import type { CommandDefinition } from '../program/index'
 
 import { expandSelfInPath, runKernelCommand, withSelfHint } from '../connection'
-import { log } from '../lib/log'
-import { output } from '../lib/output'
+import { formatKernelError } from '../connection/errors'
+import { isMachine, output } from '../lib/output'
 
 type GetOpts = KernelCommandOpts
 
@@ -16,7 +16,7 @@ export async function getCommand(target: string, opts: GetOpts): Promise<void> {
   try {
     ;({ path, meta } = await expandSelfInPath(target, opts))
   } catch (error) {
-    log.error(error instanceof Error ? error.message : 'Invalid target')
+    await formatKernelError(error, isMachine(opts), undefined, opts.debug)
     process.exit(1)
   }
 

package/src/commands/instance/list.ts

@@ -4,6 +4,7 @@ import type { KernelCommandOpts } from '../../connection'
 import type { Column } from '../../lib/output'
 import type { CommandDefinition } from '../../program/index'
 
+import { AstraleError } from '../../errors'
 import { listOwnedInstances } from '../../lib/admin-instance'
 import {
   formatInstanceLocation,
@@ -61,9 +62,13 @@ export default {
 
       let managed: OwnedInstanceInfo[] = []
       if (!opts.bookmarked) {
-        managed = await withSpinner('Fetching instances', !isMachine(opts), () =>
-          listOwnedInstances(opts),
-        )
+        try {
+          managed = await withSpinner('Fetching instances', !isMachine(opts), () =>
+            listOwnedInstances(opts),
+          )
+        } catch (error) {
+          throw adminInventoryUnavailable(error)
+        }
       }
       if (isMachine(opts)) {
         output(
@@ -148,3 +153,31 @@ export function buildInstanceRows(
 
   return rows
 }
+
+const ADMIN_INVENTORY_CODES = new Set([
+  'TOKEN_EXCHANGE_SOURCE_INVALID',
+  'TOKEN_EXCHANGE_SOURCE_EXPIRED',
+  'TOKEN_EXCHANGE_UNSUPPORTED',
+  'TOKEN_EXCHANGE_DISCOVERY_FAILED',
+  'TOKEN_EXCHANGE_PROTOCOL_ERROR',
+  'TOKEN_EXCHANGE_INSECURE',
+  'ADMIN_DOMAIN_ISSUER_MISSING',
+])
+
+/** Admin-managed inventory is not available without a deployed Admin Domain + IdP identity. */
+export function adminInventoryUnavailable(cause: unknown): AstraleError {
+  const code = cause instanceof AstraleError ? cause.code : undefined
+  if (code !== undefined && ADMIN_INVENTORY_CODES.has(code)) {
+    return new AstraleError(
+      'ADMIN_INVENTORY_UNAVAILABLE',
+      'Managed instance listing needs the Admin Domain and an IdP-backed identity. Admin is not deployed in this environment.',
+      'Use `astrale instance list --bookmarked` for local kernel bookmarks. Key-backed identities cannot mint an Admin Domain token.',
+    )
+  }
+  if (cause instanceof AstraleError) return cause
+  return new AstraleError(
+    'ADMIN_INVENTORY_UNAVAILABLE',
+    cause instanceof Error ? cause.message : String(cause),
+    'Use `astrale instance list --bookmarked` for local kernel bookmarks.',
+  )
+}

package/src/commands/logs.ts

@@ -29,6 +29,8 @@ export interface JournalRecord {
   readonly timestamp: string
   readonly topic: string
   readonly payload: unknown
+  readonly occurredAt?: string
+  readonly committedAt?: string
   readonly principal?: string
   readonly correlationId?: string
   readonly causationId?: string
@@ -146,27 +148,45 @@ function acceptRecord(input: unknown, index: number): JournalRecord {
   if (
     !isRecord(input) ||
     !Number.isSafeInteger(input.sequence) ||
-    typeof input.timestamp !== 'string' ||
     typeof input.topic !== 'string'
   ) {
     throw new TypeError(`Kernel journal record ${index} is invalid`)
   }
-  for (const key of ['principal', 'correlationId', 'causationId'] as const) {
-    if (input[key] !== undefined && typeof input[key] !== 'string') {
-      throw new TypeError(`Kernel journal record ${index}.${key} must be text`)
-    }
+  const occurredAt = optionalText(input.occurredAt, index, 'occurredAt')
+  const timestamp = optionalText(input.timestamp, index, 'timestamp') ?? occurredAt
+  if (timestamp === undefined) {
+    throw new TypeError(`Kernel journal record ${index} is missing occurredAt/timestamp`)
   }
+  const correlation = isRecord(input.correlation) ? input.correlation : undefined
+  const correlationId =
+    optionalText(input.correlationId, index, 'correlationId') ??
+    optionalText(correlation?.invocationId, index, 'correlation.invocationId')
+  const principal = optionalText(input.principal, index, 'principal')
   return Object.freeze({
     sequence: input.sequence as number,
-    timestamp: input.timestamp,
+    timestamp,
     topic: input.topic,
     payload: input.payload,
-    ...(input.principal === undefined ? {} : { principal: input.principal as string }),
-    ...(input.correlationId === undefined ? {} : { correlationId: input.correlationId as string }),
-    ...(input.causationId === undefined ? {} : { causationId: input.causationId as string }),
+    ...(occurredAt === undefined ? {} : { occurredAt }),
+    ...(optionalText(input.committedAt, index, 'committedAt') === undefined
+      ? {}
+      : { committedAt: input.committedAt as string }),
+    ...(principal === undefined ? {} : { principal }),
+    ...(correlationId === undefined ? {} : { correlationId }),
+    ...(optionalText(input.causationId, index, 'causationId') === undefined
+      ? {}
+      : { causationId: input.causationId as string }),
   })
 }
 
+function optionalText(input: unknown, index: number, field: string): string | undefined {
+  if (input === undefined) return undefined
+  if (typeof input !== 'string') {
+    throw new TypeError(`Kernel journal record ${index}.${field} must be text`)
+  }
+  return input
+}
+
 function positiveInteger(flag: string, raw: string): number {
   if (!/^\d+$/.test(raw)) throw new TypeError(`${flag} must be a positive integer`)
   const value = Number.parseInt(raw, 10)

package/src/graph/__tests__/mutation.test.ts

@@ -38,6 +38,8 @@ describe('prepareMutation', () => {
 
   /** @evidence TEST-CLI-GRAPH-REJECTS-PATCH-DATA */
   test('rejects legacy PatchData instead of narrowing it', () => {
-    expect(() => prepareMutation({ nodes: { create: [] }, edges: { create: [] } })).toThrow()
+    expect(() => prepareMutation({ nodes: { create: [] }, edges: { create: [] } })).toThrow(
+      /Legacy PatchData/,
+    )
   })
 })

package/src/graph/mutation.ts

@@ -4,6 +4,11 @@ import { MutationAST } from '@astrale-os/sdk/mutation'
 
 /** Admit the canonical document or Core's exact rich authoring input at the CLI JSON boundary. */
 export function prepareMutation(input: unknown): MutationASTValue {
+  if (isLegacyPatchData(input)) {
+    throw new TypeError(
+      'Legacy PatchData { nodes, edges } is not Mutation V3. Author { preconditions, operations } or a canonical astrale.graph.mutation/v3 document.',
+    )
+  }
   if (isCanonicalCandidate(input)) return MutationAST.decode(input)
   return MutationAST.create(input as MutationInput)
 }
@@ -16,3 +21,13 @@ function isCanonicalCandidate(input: unknown): boolean {
     (Object.hasOwn(input, 'format') || Object.hasOwn(input, 'version'))
   )
 }
+
+function isLegacyPatchData(input: unknown): boolean {
+  return (
+    input !== null &&
+    typeof input === 'object' &&
+    !Array.isArray(input) &&
+    !Object.hasOwn(input, 'operations') &&
+    (Object.hasOwn(input, 'nodes') || Object.hasOwn(input, 'edges'))
+  )
+}

package/src/lib/__tests__/command-dx.test.ts

@@ -22,8 +22,9 @@ describe('command DX suggestions', () => {
     expect(usages).toContain('admin use [bookmark]')
     expect(usages).toContain('use <name>')
     expect(usages).toContain('update')
-    expect(usages).toContain('ls <source>')
+    expect(usages).toContain('query [sources...]')
     expect(usages).toContain('status')
+    expect(usages).not.toContain('ls <source>')
   })
 
   test('explains shared verbs as namespaced commands, not arity errors', async () => {
@@ -42,6 +43,17 @@ describe('command DX suggestions', () => {
     expect(rendered).not.toContain('too many arguments')
   })
 
+  test('points retired ls at query', async () => {
+    const program = await buildProgram()
+    const error = new CommanderError(1, 'commander.unknownCommand', "error: unknown command 'ls'")
+    const rendered = stripAnsi(renderCommanderError(program, error, ['ls', '@note']))
+
+    expect(rendered).toContain('Unknown command: astrale ls @note')
+    expect(rendered).toContain('astrale ls` was removed')
+    expect(rendered).toContain('astrale query <source> --edge <class>')
+    expect(rendered).not.toContain('Did you mean:')
+  })
+
   test('suggests nearest command for typo paths', async () => {
     const program = await buildProgram()
     const error = new CommanderError(

package/src/lib/command-dx.ts

@@ -72,9 +72,21 @@ export function renderCommanderError(
   ].join('\n')
 }
 
+const RETIRED_COMMANDS: Record<string, string> = {
+  ls: 'astrale query <source> --edge <class>',
+}
+
 function renderUnknownCommand(tokens: string[], catalog: CommandCatalogEntry[]): string {
   const command = tokens.join(' ')
   const first = tokens[0]
+  const retired = first === undefined ? undefined : RETIRED_COMMANDS[first]
+  if (retired !== undefined) {
+    return [
+      `Unknown command: ${chalk.bold(`astrale ${command}`)}`,
+      '',
+      `\`astrale ${first}\` was removed. Use ${chalk.bold(retired)} instead.`,
+    ].join('\n')
+  }
   const namespaceMatches = catalog.filter((entry) => entry.path.at(-1) === first)
   if (namespaceMatches.length > 0) {
     return [

package/src/program/__tests__/program.test.ts

@@ -171,7 +171,6 @@ describe('program composition', () => {
       'instance status',
       'instance use',
       'logs',
-      'ls',
       'mutate',
       'query',
       'session',
@@ -187,7 +186,7 @@ describe('program composition', () => {
       'whoami',
     ])
     expect(createHash('sha256').update(JSON.stringify(surface)).digest('hex')).toBe(
-      'e030c6f672dea850a90bef16cf4222ea6af45e60f50cfc829c85bd90d9543632',
+      '4b053fe80827aeb40aecc13cd17c293b8701e59cb04f5ccb8185e9e255376dd1',
     )
   })
 
@@ -267,7 +266,7 @@ describe('help contract — connect-only command surface', () => {
     const program = await buildProgram()
     const names = allCommands(program).map((command) => command.name())
 
-    // `logs` and `domain` have managed/admin meanings, so only retired local-runtime verbs are absent.
+    // `logs` and `domain` have managed/admin meanings, so only retired verbs are absent.
     for (const removed of [
       'init',
       'start',
@@ -279,6 +278,7 @@ describe('help contract — connect-only command surface', () => {
       'graph',
       'server',
       'env',
+      'ls',
     ]) {
       expect(names).not.toContain(removed)
     }

package/src/program/build.ts

@@ -61,7 +61,6 @@ export async function buildProgram(): Promise<Command> {
   registerCommand(program, withKernelOptions((await import('../commands/token')).default))
   registerCommand(program, withKernelOptions((await import('../commands/get')).default))
   registerCommand(program, withKernelOptions((await import('../commands/mutate')).default))
-  registerCommand(program, withKernelOptions((await import('../commands/ls')).default))
   registerCommand(program, withKernelOptions((await import('../commands/describe')).default))
   registerCommand(program, withKernelOptions((await import('../commands/query')).default))
   registerCommand(program, withKernelOptions((await import('../commands/logs')).default))
@@ -159,7 +158,7 @@ export async function buildProgram(): Promise<Command> {
     `
 Command groups:
   Getting started  setup     (sign in, pick an instance, equip your workspace)
-  Kernel        ls, get, mutate, call, query, describe, token
+  Kernel        get, mutate, call, query, describe, token
   Management    admin, instance, domain, identity, auth, idp, update
   Agent         browser   (drive the GUI via agent-browser)
   Studio        studio    (launch the local Domain Studio GUI for a workspace)
@@ -173,7 +172,6 @@ Path syntax:
   @nodeId::method                Instance method on a node by UID
 
 Examples:
-  $ astrale ls @note --edge /:notes.example.dev:class.references
   $ astrale studio
   $ astrale admin status
   $ astrale update --check

package/src/telemetry/__tests__/gate.test.ts

@@ -49,7 +49,7 @@ describe('extractSignals / hasSignals', () => {
   })
 
   test('quiet session has no signals until a transcript is attached', () => {
-    const s = extractSignals([ev(['status'], 0), ev(['ls', '/'], 0)])
+    const s = extractSignals([ev(['status'], 0), ev(['query', '/'], 0)])
     expect(hasSignals(s)).toBe(false)
     s.harnessSessions = [
       {

package/src/commands/__tests__/ls.test.ts

@@ -1,29 +0,0 @@
-import type { Node } from '@astrale-os/sdk/graph/node'
-
-import { ClassPath } from '@astrale-os/sdk/graph/class'
-import { NodeId } from '@astrale-os/sdk/graph/node'
-import { normalizeProperties } from '@astrale-os/sdk/graph/properties'
-import { describe, expect, test } from 'bun:test'
-
-import { displayName, listProjection } from '../ls'
-
-describe('ls display projection', () => {
-  const node = {
-    id: NodeId('note-1'),
-    class: ClassPath.parse('/:notes.example.dev:class.Note'),
-    props: normalizeProperties({ 'notes.example.dev:class.Note.property.title': 'Hello' }),
-  } satisfies Node
-
-  /** @evidence TEST-CLI-LS-PROJECTS-CANONICAL-NODES */
-  test('uses canonical properties for display and @id for pipeable output', () => {
-    expect(displayName(node)).toBe('Hello')
-    expect(listProjection([node])).toMatchObject({
-      rows: [{ name: 'Hello', class: 'Note', id: 'note-1' }],
-      paths: ['@note-1'],
-    })
-  })
-
-  test('falls back to the canonical Node ID when no display property exists', () => {
-    expect(displayName({ ...node, props: normalizeProperties({}) })).toBe('@note-1')
-  })
-})