@astrale-os/cli 1.0.0-beta.4 → 1.0.0-beta.6

package/src/commands/update.ts

@@ -12,7 +12,7 @@ import {
   type SdkOutdated,
 } from '../lib/sdk-deps'
 import { ASTRALE_CLI_SKILL, detectSkill, installSkills, SKILL_INSTALL_HINT } from '../lib/skills'
-import { DEFAULT_UPDATE_CHANNEL, updateAstrale } from '../lib/update'
+import { DEFAULT_UPDATE_CHANNEL, packageManagedUpdateError, updateAstrale } from '../lib/update'
 
 type UpdateOpts = RawOutputOpts & {
   check?: boolean
@@ -104,14 +104,22 @@ async function refreshSdkDeps(check: boolean, assumeYes = false): Promise<boolea
 /**
  * Read-only staleness report for tooling — `astrale update --check --json`.
  * domain-studio polls this on load to drive its "update available" badge. It is
- * unified and NON-THROWING: the CLI axis catches the package-managed / no-metadata
- * case (reported as `managed`, never stale), and the SDK axis is already
- * best-effort. Skills are intentionally absent — they ride along with `astrale
- * update`, so a stale CLI or SDK is the only signal worth surfacing.
+ * unified and NON-THROWING: an explicit package-managed result uses npm release
+ * identity, while script-install failures remain script failures in `error`
+ * instead of being recategorized. The SDK axis is already best-effort. Skills are
+ * intentionally absent — they ride along with `astrale update`, so a stale CLI or
+ * SDK is the only signal worth surfacing.
  */
 export type StaleReport = {
   stale: boolean
-  cli: { stale: boolean; managed: boolean; current?: string; latest?: string; channel?: string }
+  cli: {
+    stale: boolean
+    managed: boolean
+    current?: string
+    latest?: string
+    channel?: string
+    error?: string
+  }
   sdk: { stale: boolean; inProject: boolean; outdated: SdkOutdated[] }
 }
 
@@ -138,6 +146,15 @@ export async function cliStale(
       version: target.version,
       currentVersion: running,
     })
+    if (r.status === 'managed') {
+      const latest = await dependencies.fetchPackageVersion(target).catch(() => undefined)
+      return {
+        stale: latest !== undefined && latest !== running,
+        managed: true,
+        current: running,
+        ...(latest === undefined ? {} : { latest, channel: 'npm' }),
+      }
+    }
     if (r.status === 'updated') {
       return {
         stale: false,
@@ -154,13 +171,12 @@ export async function cliStale(
       latest: r.latestVersion,
       channel: r.channel,
     }
-  } catch {
-    const latest = await dependencies.fetchPackageVersion(target).catch(() => undefined)
+  } catch (error) {
     return {
-      stale: latest !== undefined && latest !== running,
-      managed: true,
+      stale: false,
+      managed: false,
       current: running,
-      ...(latest === undefined ? {} : { latest, channel: 'npm' }),
+      error: error instanceof Error ? error.message : String(error),
     }
   }
 }
@@ -294,6 +310,10 @@ Examples:
         log.success(`Updated astrale ${result.previousVersion} -> ${result.currentVersion}`)
         log.dim(`  channel: ${result.channel}`)
         log.dim(`  binary: ${result.bin}`)
+      } else if (result?.status === 'managed') {
+        const error = packageManagedUpdateError(result.executable)
+        if (!opts.yes) throw error
+        log.warn(`CLI self-update skipped: ${error.message}`)
       }
 
       // Axis B — agent skills. Keep an existing install current with the CLI.

package/src/commands/view.ts

@@ -89,9 +89,10 @@ export async function resolveSession(
   }
   const targetInput =
     parsed.kind === 'target' ? parsed.path : (opts.target ?? viewOwnerTarget(parsed.path))
-  const { path: target } = await expandSelfInPath(targetInput, opts)
-
-  const candidates = await withClientSession(opts, (ctx) => resolveViewCandidates(ctx, target))
+  const { target, candidates } = await withClientSession(opts, async (context) => {
+    const { path: target } = await expandSelfInPath(targetInput, context)
+    return { target, candidates: await resolveViewCandidates(context, target) }
+  })
 
   if (opts.list) {
     return { candidates }

package/src/connection/.spec/api.d.ts

@@ -1,8 +1,7 @@
-import type { Call } from '@astrale-os/kernel-client'
-import type { AuthApi } from '@astrale-os/kernel-client/auth'
-import type { GraphApi } from '@astrale-os/kernel-client/graph'
-import type { ClientSession } from '@astrale-os/kernel-client/session'
 import type { IssuerId } from '@astrale-os/sdk/auth'
+import type { AuthApi } from '@astrale-os/sdk/auth'
+import type { Call, GraphApi } from '@astrale-os/sdk/client'
+import type { ClientSession } from '@astrale-os/sdk/client/session'
 
 /** Existing CLI connection flags accepted by Kernel-touching commands. */
 export interface ConnectionOptions {
@@ -78,17 +77,17 @@ export function withAdminClientSession<Value>(
 /** Expand @self through the effective principal returned by authenticated Identity.whoami. */
 export function expandSelfInPath(
   path: string,
-  options: KernelCommandOpts,
+  context: ConnectionContext,
 ): Promise<{ readonly path: string; readonly meta?: SelfExpansionMeta }>
 
 /** Expand @self once across one Call path and its CLI-authored string parameters. */
 export function expandSelfInCall(
   path: string,
-  parameters: readonly string[],
-  options: KernelCommandOpts,
+  parameters: Readonly<Record<string, unknown>>,
+  context: ConnectionContext,
 ): Promise<{
   readonly path: string
-  readonly parameters: readonly string[]
+  readonly parameters: Readonly<Record<string, unknown>>
   readonly meta?: SelfExpansionMeta
 }>
 

package/src/connection/.spec/architecture.md

@@ -40,7 +40,8 @@ customizes only the Fetch capability passed to Client. `withClientSession` and
 `withAdminClientSession` are terminal lifecycle boundaries: success, failure, and cancellation all
 close both the Client Session and its direct source-Auth client.
 
-The command boundary maps typed Client transport phase and delivery evidence without inspecting a
-private cause message. It preserves every admitted Kernel reason in machine output; human repair
-details are rendered only after the connection owner admits bounded public Function issues or one
-exact Query reason variant.
+The command boundary projects typed Client failure identity, transport context, phase, and
+invocation-only delivery evidence without inspecting a private cause message. Unknown native
+failures become one honest unexpected diagnostic; their bounded cause graph is visible only under
+explicit debug output. Every admitted Kernel reason remains available in machine output, while
+human repair details require a bounded public Function issue or exact Query reason variant.

package/src/connection/.spec/flows/session.ts

@@ -1,5 +1,5 @@
-import type { SessionAuth } from '@astrale-os/kernel-client/session'
-import type { Call } from '@astrale-os/kernel-protocol/invocation'
+import type { Call } from '@astrale-os/sdk/client'
+import type { SessionAuth } from '@astrale-os/sdk/client/session'
 
 import type { ConnectionContext, ConnectionOptions, ConnectionTarget } from '../api.js'
 

package/src/connection/.spec/laws/connection.ts

@@ -111,7 +111,7 @@ export const CLI_AUTH_REGISTRATION_TARGET = defineLaw({
 export const CLI_SELF_AUTHENTICATED_PRINCIPAL = defineLaw({
   id: 'CLI-SELF-AUTHENTICATED-PRINCIPAL',
   statement:
-    '@self resolves only from authenticated Identity.whoami on the selected target, so delegated carriers use their effective principal and never an unverified JWT subject or stale local registration.',
+    '@self resolves inside the command-owned Client Session from authenticated Identity.whoami on the selected target, so resolution and dispatch share one lifecycle and delegated carriers never use an unverified JWT subject or stale local registration.',
   tests: [
     {
       file: '__tests__/self.test.ts',
@@ -183,7 +183,7 @@ export const CLI_CONNECTION_PUBLIC_SEMANTIC_REASON = defineLaw({
 export const CLI_CONNECTION_TYPED_ERROR_PRESENTATION = defineLaw({
   id: 'CLI-CONNECTION-TYPED-ERROR-PRESENTATION',
   statement:
-    'The command boundary maps typed Client transport phase and delivery evidence without parsing a private cause, preserves the admitted Kernel reason in machine output, and renders only bounded public Function issues or one exact Query repair variant for humans.',
+    'The command boundary maps typed Client failure identity, transport context, phase, and invocation-only delivery evidence without parsing a private cause; acquisition never receives retry advice, unknown native failures have one non-blank unexpected diagnostic, and raw causes appear only under explicit debug output.',
   tests: [
     {
       file: '__tests__/errors.test.ts',
@@ -197,5 +197,9 @@ export const CLI_CONNECTION_TYPED_ERROR_PRESENTATION = defineLaw({
       file: '__tests__/reasons.test.ts',
       id: 'TEST-CLI-CONNECTION-ADMITS-BOUNDED-REASONS',
     },
+    {
+      file: '__tests__/failure-safety.test.ts',
+      id: 'TEST-CLI-CONNECTION-FAILURE-SAFETY',
+    },
   ],
 })

package/src/connection/.spec/layout.ts

@@ -8,6 +8,7 @@ export default defineLayout({
     'command.ts',
     'credential.ts',
     'errors.ts',
+    'failure/',
     'exchange.ts',
     'index.ts',
     'reasons.ts',

package/src/connection/__tests__/credential.test.ts

@@ -1,4 +1,4 @@
-import type { SessionAuth } from '@astrale-os/kernel-client/session'
+import type { SessionAuth } from '@astrale-os/sdk/client/session'
 
 import { issuer, type IssuerId } from '@astrale-os/sdk/auth'
 import { Path } from '@astrale-os/sdk/graph/path'

package/src/connection/__tests__/errors.test.ts

@@ -1,7 +1,9 @@
-import { ResponseError, TransportError } from '@astrale-os/kernel-client'
+import { ResponseError } from '@astrale-os/sdk/client'
+import { Path } from '@astrale-os/sdk/graph/path'
 import { describe, expect, test } from 'bun:test'
 
 import { formatKernelError, functionInputIssues, schemaUpgradeHint } from '../errors'
+import { transportFailure } from './failure-fixtures'
 
 const CONFLICT = 4001
 const VALIDATION = 1003
@@ -19,24 +21,28 @@ describe('formatKernelError', () => {
       writes.push(typeof chunk === 'string' ? chunk : new TextDecoder().decode(chunk))
       return true
     }) as typeof process.stderr.write
-    const error = new TransportError('Publication discovery request failed.', {
-      cause: Object.assign(new Error('connect ECONNREFUSED'), { code: 'ECONNREFUSED' }),
-      phase: 'connect',
-      delivery: 'unknown',
-    }) as TransportError & { url?: string }
-    error.url = 'https://localhost:8443/kernel/host'
+    const error = Object.assign(
+      transportFailure('Publication discovery request failed.', 'unknown', {
+        kind: 'acquisition',
+        resource: 'publication',
+      }),
+      {
+        url: 'https://localhost:8443/kernel/host',
+        cause: Object.assign(new Error('connect ECONNREFUSED'), { code: 'ECONNREFUSED' }),
+      },
+    )
     try {
-      await formatKernelError(error, true)
+      await formatKernelError(error, true, 'https://localhost:8443/kernel/host')
     } finally {
       process.stderr.write = original
     }
 
     expect(JSON.parse(writes[0]!)).toMatchObject({
-      error: 'CONNECTION_ERROR',
+      error: 'TRANSPORT_ERROR',
       message: 'Publication discovery request failed.',
       url: 'https://localhost:8443/kernel/host',
-      phase: 'connect',
-      delivery: 'unknown',
+      phase: 'unknown',
+      transport: { kind: 'acquisition', resource: 'publication' },
     })
     expect(writes[0]).not.toContain('ECONNREFUSED')
   })
@@ -50,9 +56,8 @@ describe('formatKernelError', () => {
     }) as typeof process.stderr.write
     try {
       await formatKernelError(
-        new TransportError('Request timed out.', {
-          cause: new Error('timeout'),
-          phase: 'timeout',
+        transportFailure('Request timed out.', 'timeout', {
+          kind: 'invocation',
           delivery: 'unknown',
         }),
         true,
@@ -74,7 +79,7 @@ describe('formatKernelError', () => {
     expect(JSON.parse(writes[0]!)).toMatchObject({
       error: 'TIMEOUT',
       phase: 'timeout',
-      delivery: 'unknown',
+      transport: { kind: 'invocation', delivery: 'unknown' },
       operation: '4a4c9a18-50f6-4d84-a7b7-2d83e3e45dc8',
       retry:
         'astrale domain install https://crm.test --direct --operation 4a4c9a18-50f6-4d84-a7b7-2d83e3e45dc8',
@@ -229,7 +234,7 @@ describe('formatKernelError', () => {
     )
   })
 
-  test('maps SDK class names to stable CLI error codes', async () => {
+  test('maps SDK error identities to stable CLI error codes', async () => {
     const writes: string[] = []
     const original = process.stderr.write
     process.stderr.write = ((chunk: string | Uint8Array) => {
@@ -237,15 +242,17 @@ describe('formatKernelError', () => {
       return true
     }) as typeof process.stderr.write
     try {
-      const pathError = new Error('Path must have an Id or Domain anchor.')
-      pathError.name = 'PathError'
-      await formatKernelError(pathError, true)
+      try {
+        Path.parse('not-a-path')
+      } catch (error) {
+        await formatKernelError(error, true)
+      }
     } finally {
       process.stderr.write = original
     }
     expect(JSON.parse(writes[0]!)).toEqual({
       error: 'PATH_INVALID',
-      message: 'Path must have an Id or Domain anchor.',
+      message: expect.any(String),
     })
   })
 

package/src/connection/__tests__/exchange.test.ts

@@ -1,4 +1,4 @@
-import type { Fetch } from '@astrale-os/kernel-client'
+import type { Fetch } from '@astrale-os/sdk/client'
 
 import { issuer } from '@astrale-os/sdk/auth'
 import { afterEach, beforeEach, describe, expect, test } from 'bun:test'
@@ -190,6 +190,35 @@ describe('Domain token exchange', () => {
       message: 'Token exchange returned an invalid success response.',
     })
   })
+
+  test('normalizes native issuer Fetch failures without exposing their message', async () => {
+    const native = new AggregateError([new Error('private DNS state')], '')
+    const resolver = createExchangeCredentialResolver(
+      TARGET,
+      { resolve: async () => SOURCE_TOKEN },
+      async (input, init) => {
+        if (String(input) === INVOCATION) {
+          const body = JSON.parse(await new Response(init?.body).text()) as Record<string, any>
+          return invocationResponse(
+            body.requestId,
+            body.call.input && Object.keys(body.call.input).length === 0
+              ? { id: 'user-1' }
+              : 'kernel-destination-envelope',
+            new Headers(init?.headers).get('accept')!,
+          )
+        }
+        throw native
+      },
+      5_000,
+      new ExchangeCredentialCache(join(directory, 'native-failure.json')),
+    )
+
+    await expect(resolver.resolve(KERNEL, new AbortController().signal)).rejects.toMatchObject({
+      code: 'TOKEN_EXCHANGE_UNAVAILABLE',
+      message: 'Domain issuer discovery could not be reached.',
+      cause: native,
+    })
+  })
 })
 
 function exchangeFetch(

package/src/connection/__tests__/failure-fixtures.ts

@@ -0,0 +1,39 @@
+import { ClientError, TransportError } from '@astrale-os/sdk/client'
+
+import type { TransportDiagnosticContext } from '../failure/model'
+
+type CompatibleTransportPhase = TransportError['phase'] | 'unknown'
+
+export function transportFailure(
+  message: string,
+  phase: CompatibleTransportPhase,
+  context: TransportDiagnosticContext,
+): TransportError {
+  const error = new Error(message) as TransportError & {
+    context: TransportDiagnosticContext
+  }
+  Object.setPrototypeOf(error, TransportError.prototype)
+  Object.assign(error, { name: 'TransportError', phase, context })
+  return error
+}
+
+export function legacyTransportFailure(
+  message: string,
+  phase: CompatibleTransportPhase,
+  delivery: 'not-sent' | 'unknown',
+): TransportError {
+  const error = new Error(message) as TransportError & { delivery: typeof delivery }
+  Object.setPrototypeOf(error, TransportError.prototype)
+  Object.assign(error, { name: 'TransportError', phase, delivery })
+  return error
+}
+
+export function sessionFailure(
+  message: string,
+  failure: 'cancelled' | 'closed' | 'timeout',
+): ClientError {
+  const error = new Error(message) as ClientError & { failure: typeof failure }
+  Object.setPrototypeOf(error, ClientError.prototype)
+  Object.assign(error, { name: 'SessionError', failure })
+  return error
+}

package/src/connection/__tests__/failure-safety.test.ts

@@ -0,0 +1,75 @@
+import { expect, test } from 'bun:test'
+
+import { formatKernelError } from '../errors'
+import { legacyTransportFailure, sessionFailure, transportFailure } from './failure-fixtures'
+
+/** @evidence TEST-CLI-CONNECTION-FAILURE-SAFETY */
+test('unknown and empty native failures never become ordinary diagnostics', async () => {
+  for (const failure of [new Error('private provider detail'), new Error(''), { secret: true }]) {
+    const output = await capture(() => formatKernelError(failure, true))
+    expect(JSON.parse(output)).toEqual({
+      error: 'UNEXPECTED_ERROR',
+      message: 'The CLI encountered an unexpected internal failure.',
+    })
+    expect(output).not.toContain('private provider detail')
+  }
+})
+
+test('Aggregate children are available only under explicit debug output', async () => {
+  const failure = new AggregateError([new Error('first private'), new Error('second private')], '')
+  const ordinary = await capture(() => formatKernelError(failure, true))
+  expect(ordinary).not.toContain('first private')
+  expect(ordinary).not.toContain('second private')
+
+  const debug = await capture(() => formatKernelError(failure, true, '', true))
+  expect(debug).toContain('aggregate: Error: first private')
+  expect(debug).toContain('aggregate: Error: second private')
+})
+
+test('Session and acquisition failures remain typed without unsafe recovery advice', async () => {
+  const session = await capture(() =>
+    formatKernelError(sessionFailure('Session operation timed out.', 'timeout'), true),
+  )
+  expect(JSON.parse(session)).toEqual({ error: 'TIMEOUT', message: 'Session operation timed out.' })
+
+  const acquisition = await capture(() =>
+    formatKernelError(
+      transportFailure('Publication failed.', 'unknown', {
+        kind: 'acquisition',
+        resource: 'publication',
+      }),
+      true,
+      '',
+      false,
+      { recovery: { operation: 'must-not-leak', retry: 'must-not-leak' } },
+    ),
+  )
+  expect(JSON.parse(acquisition)).toMatchObject({
+    error: 'TRANSPORT_ERROR',
+    transport: { kind: 'acquisition', resource: 'publication' },
+  })
+  expect(acquisition).not.toContain('must-not-leak')
+
+  const legacy = await capture(() =>
+    formatKernelError(legacyTransportFailure('Legacy send failed.', 'send', 'not-sent'), true),
+  )
+  expect(JSON.parse(legacy)).toMatchObject({
+    error: 'TRANSPORT_ERROR',
+    transport: { kind: 'invocation', delivery: 'not-sent' },
+  })
+})
+
+async function capture(action: () => Promise<void>): Promise<string> {
+  const writes: string[] = []
+  const original = process.stderr.write
+  process.stderr.write = ((chunk: string | Uint8Array) => {
+    writes.push(typeof chunk === 'string' ? chunk : new TextDecoder().decode(chunk))
+    return true
+  }) as typeof process.stderr.write
+  try {
+    await action()
+    return writes.join('')
+  } finally {
+    process.stderr.write = original
+  }
+}

package/src/connection/__tests__/self.test.ts

@@ -2,7 +2,11 @@ import { describe, expect, test } from 'bun:test'
 import { SignJWT } from 'jose'
 import { webcrypto } from 'node:crypto'
 
-import { resolveSelfIdAuthenticated } from '../self'
+import type { ConnectionContext } from '../session'
+
+import { expandSelfInCall, resolveSelfIdAuthenticated } from '../self'
+
+const context = Object.freeze({}) as ConnectionContext
 
 describe('resolveSelfIdAuthenticated', () => {
   /** @evidence TEST-CLI-SELF-USES-AUTHENTICATED-EFFECTIVE-PRINCIPAL */
@@ -14,11 +18,9 @@ describe('resolveSelfIdAuthenticated', () => {
       .setSubject('manager-principal')
       .setAudience('https://child.example')
       .sign(key)
-    const opts = { creds: credential, url: 'https://manager.example/children/child/invoke' }
-
-    const resolved = await resolveSelfIdAuthenticated(opts, {
+    const resolved = await resolveSelfIdAuthenticated(context, {
       whoami: async (received) => {
-        expect(received).toBe(opts)
+        expect(received).toBe(context)
         return { id: 'child-kernel-principal', slug: 'child' }
       },
     })
@@ -28,17 +30,35 @@ describe('resolveSelfIdAuthenticated', () => {
 
   test('resolves an imported root without requiring a local registration', async () => {
     await expect(
-      resolveSelfIdAuthenticated(
-        { as: 'platform-root', url: 'https://manager.example/invoke' },
-        { whoami: async () => ({ id: 'manager-kernel-principal' }) },
-      ),
+      resolveSelfIdAuthenticated(context, {
+        whoami: async () => ({ id: 'manager-kernel-principal' }),
+      }),
     ).resolves.toEqual({ id: 'manager-kernel-principal' })
   })
 
   test('fails closed when authenticated whoami returns no NodeId', async () => {
     await expect(
-      resolveSelfIdAuthenticated({}, { whoami: async () => ({ id: '   ' }) }),
-    ).rejects.toMatchObject({ name: 'SelfResolutionError' })
+      resolveSelfIdAuthenticated(context, { whoami: async () => ({ id: '   ' }) }),
+    ).rejects.toMatchObject({ code: 'SELF_RESOLUTION_FAILED' })
+  })
+})
+
+describe('expandSelfInCall', () => {
+  test('expands only top-level string values after local parameter admission', async () => {
+    const callContext = {
+      auth: { whoami: async () => ({ id: 'caller-id' }) },
+      target: {},
+    } as ConnectionContext
+    const expanded = await expandSelfInCall(
+      '/:people.example.dev:class.Person:get',
+      { owner: '@self', count: 2, nested: { owner: '@self' } },
+      callContext,
+    )
+    expect(expanded.parameters).toEqual({
+      owner: '@caller-id',
+      count: 2,
+      nested: { owner: '@self' },
+    })
   })
 })
 

package/src/connection/__tests__/session.test.ts

@@ -1,6 +1,6 @@
-import type { AuthApi } from '@astrale-os/kernel-client/auth'
-import type { GraphApi } from '@astrale-os/kernel-client/graph'
-import type { ClientSession } from '@astrale-os/kernel-client/session'
+import type { AuthApi } from '@astrale-os/sdk/auth'
+import type { GraphApi } from '@astrale-os/sdk/client'
+import type { ClientSession } from '@astrale-os/sdk/client/session'
 
 import { issuer } from '@astrale-os/sdk/auth'
 import { describe, expect, test } from 'bun:test'

package/src/connection/call.ts

@@ -1,4 +1,4 @@
-import { call, type Call } from '@astrale-os/kernel-client'
+import { call, type Call } from '@astrale-os/sdk/client'
 import { Path } from '@astrale-os/sdk/graph/path'
 
 /** Convert the CLI's untrusted text/JSON boundary into the one public Call representation. */

package/src/connection/credential.ts

@@ -1,5 +1,5 @@
-import type { Fetch } from '@astrale-os/kernel-client'
-import type { SessionAuth } from '@astrale-os/kernel-client/session'
+import type { Fetch } from '@astrale-os/sdk/client'
+import type { SessionAuth } from '@astrale-os/sdk/client/session'
 
 import { credential, type IssuerId } from '@astrale-os/sdk/auth'