@astrale-os/cli 1.0.0-beta.0 → 1.0.0-beta.2

package/dist/types/lib/idp.d.ts

@@ -162,6 +162,8 @@ export declare const IdpSessionSchema: z.ZodObject<{
     idp: z.ZodString;
     issuer: z.ZodString;
     subject: z.ZodString;
+    /** OAuth client that issued this session's refresh token. */
+    clientId: z.ZodOptional<z.ZodString>;
     audience: z.ZodOptional<z.ZodString>;
     organizationId: z.ZodOptional<z.ZodString>;
     access_token: z.ZodString;
@@ -194,6 +196,8 @@ export declare const IdpSessionSchema: z.ZodObject<{
     idp: z.ZodString;
     issuer: z.ZodString;
     subject: z.ZodString;
+    /** OAuth client that issued this session's refresh token. */
+    clientId: z.ZodOptional<z.ZodString>;
     audience: z.ZodOptional<z.ZodString>;
     organizationId: z.ZodOptional<z.ZodString>;
     access_token: z.ZodString;
@@ -226,6 +230,8 @@ export declare const IdpSessionSchema: z.ZodObject<{
     idp: z.ZodString;
     issuer: z.ZodString;
     subject: z.ZodString;
+    /** OAuth client that issued this session's refresh token. */
+    clientId: z.ZodOptional<z.ZodString>;
     audience: z.ZodOptional<z.ZodString>;
     organizationId: z.ZodOptional<z.ZodString>;
     access_token: z.ZodString;

package/dist/types/lib/meta.d.ts

@@ -6,8 +6,8 @@
  * `jwks_uri`) and JWKS at `/.well-known/jwks.json`. These helpers probe
  * both to verify the issuer is alive and publishes at least one key.
  *
- * Domain workers may expose `/meta` for deployment drift detection; that is
- * outside this connect-only CLI surface.
+ * Domain deployment readiness uses the canonical Domain Publication; that is
+ * outside this issuer-connectivity helper.
  */
 type FetchLike = (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
 export type DiscoveryDocument = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrale-os/cli",
-  "version": "1.0.0-beta.0",
+  "version": "1.0.0-beta.2",
   "description": "Astrale CLI — connect to existing Astrale kernels",
   "keywords": [
     "astrale",
@@ -62,9 +62,10 @@
     "zod": "^3.25.0"
   },
   "devDependencies": {
-    "@astrale-os/kernel-client": ">=0.6.0-beta.3 <1.0.0",
+    "@astrale-os/kernel-client": ">=0.6.0-beta.4 <1.0.0",
+    "@astrale-os/kernel-protocol": ">=0.5.0-beta.3 <1.0.0",
     "@astrale-os/ox": ">=0.1.0 <1.0.0",
-    "@astrale-os/sdk": ">=0.5.0-beta.3 <1.0.0",
+    "@astrale-os/sdk": ">=0.5.0-beta.4 <1.0.0",
     "@astrale-os/shell": ">=0.3.8-beta.2 <1.0.0",
     "@astrale/commitlint-config": "npm:@jsr/astrale__commitlint-config@~2.0.1",
     "@commitlint/cli": "~20.3.1",
@@ -107,7 +108,8 @@
     "lint:fix": "oxlint --fix .",
     "format": "pnpm exec oxfmt --write .",
     "format:check": "pnpm exec oxfmt --check .",
-    "test": "bun test src && node --test scripts/*.test.mjs",
+    "test": "bun test src studio/client/src studio/server studio/shared && node --test scripts/*.test.mjs",
+    "test:studio": "pnpm --dir studio test",
     "test:watch": "bun test --watch src"
   }
 }

package/src/admin/binding.ts

@@ -0,0 +1,168 @@
+import type { Input, Result } from '@astrale-os/kernel-client'
+import type {
+  ClientSession,
+  SessionRequestOptions,
+  SessionSnapshot,
+} from '@astrale-os/kernel-client/session'
+import type {
+  Definition,
+  Domain as RichDomain,
+  InstanceMethod,
+  StaticMethod,
+} from '@astrale-os/sdk/domain'
+import type { PathLike } from '@astrale-os/sdk/graph/path'
+import type { Key } from '@astrale-os/sdk/schema'
+
+import { call } from '@astrale-os/kernel-client'
+import * as sessionModule from '@astrale-os/kernel-client/session'
+import { Domain } from '@astrale-os/sdk/domain'
+import { Path } from '@astrale-os/sdk/graph/path'
+
+const ADMIN_ORIGIN = 'admin.astrale.ai'
+
+type DynamicCallable =
+  | (Definition<'function'> & { readonly path: NonNullable<Definition<'function'>['path']> })
+  | StaticMethod
+  | InstanceMethod
+
+export interface AdminBindingOperations {
+  readonly installation: unknown
+  readonly publication: SessionSnapshot['publication']
+  invoke(
+    callable: DynamicCallable,
+    receiverOrInput: PathLike | Input,
+    inputOrOptions?: Input | SessionRequestOptions,
+    options?: SessionRequestOptions,
+  ): Promise<unknown>
+}
+
+export type AdminBinding = RichDomain & {
+  readonly $: RichDomain['$'] & AdminBindingOperations
+}
+
+interface CompatibleCallableReference {
+  readonly origin: typeof ADMIN_ORIGIN
+  readonly revision: SessionSnapshot['publication']['schema']['revision']
+  readonly callable: Key.Callable
+  readonly target: PathLike
+  readonly outputMode: DynamicCallable['definition']['output']['mode']
+}
+
+interface CompatibleSession {
+  readonly installation?: (origin: typeof ADMIN_ORIGIN) => Promise<unknown>
+  readonly installed?: (origin: typeof ADMIN_ORIGIN) => Promise<unknown>
+  readonly invoke?: (
+    reference: CompatibleCallableReference,
+    input: Input,
+    options?: SessionRequestOptions,
+  ) => Promise<unknown>
+}
+
+type LegacyDispatchBound = (
+  session: ClientSession,
+  request: ReturnType<typeof call>,
+  expected: {
+    readonly schema: { readonly revision: CompatibleCallableReference['revision'] }
+    readonly publication: {
+      readonly origin: SessionSnapshot['publication']['origin']
+      readonly identity: SessionSnapshot['publication']['identity']
+      readonly revision: CompatibleCallableReference['revision']
+      readonly etag: SessionSnapshot['publication']['etag']
+    }
+  },
+  options?: SessionRequestOptions,
+) => Promise<Result>
+
+/** Bind the Admin revision advertised by this exact Session snapshot. */
+export async function bindAdmin(session: ClientSession): Promise<AdminBinding> {
+  const snapshot = await session.snapshot()
+  if (
+    snapshot.publication.origin !== ADMIN_ORIGIN ||
+    snapshot.bundle.root.origin !== ADMIN_ORIGIN
+  ) {
+    throw new TypeError('Configured Admin target does not serve the Admin Domain.')
+  }
+  const compatible = session as unknown as CompatibleSession
+  const resolveInstallation = compatible.installation ?? compatible.installed
+  if (resolveInstallation === undefined) {
+    throw new TypeError('Client Session cannot resolve an installed Admin Domain.')
+  }
+  const installation = await resolveInstallation.call(session, ADMIN_ORIGIN)
+  const domain = Domain.fromSchema(snapshot.bundle.root)
+  const invoke = ((
+    callable: DynamicCallable,
+    receiverOrInput: PathLike | Input,
+    inputOrOptions?: Input | SessionRequestOptions,
+    options?: SessionRequestOptions,
+  ) => {
+    const target =
+      'on' in callable ? callable.on(Path.from(receiverOrInput as PathLike)) : callable.path
+    const reference: CompatibleCallableReference = Object.freeze({
+      origin: ADMIN_ORIGIN,
+      revision: snapshot.publication.schema.revision,
+      callable: callable.key as Key.Callable,
+      target,
+      outputMode: callable.definition.output.mode,
+    })
+    return invokeCompatible(
+      session,
+      snapshot,
+      reference,
+      ('on' in callable ? inputOrOptions : receiverOrInput) as Input,
+      ('on' in callable ? options : inputOrOptions) as SessionRequestOptions | undefined,
+    )
+  }) as AdminBindingOperations['invoke']
+
+  return Object.freeze({
+    ...domain,
+    $: Object.freeze({
+      ...domain.$,
+      installation,
+      publication: snapshot.publication,
+      invoke,
+    }),
+  }) as AdminBinding
+}
+
+async function invokeCompatible(
+  session: ClientSession,
+  snapshot: SessionSnapshot,
+  reference: CompatibleCallableReference,
+  input: Input,
+  options: SessionRequestOptions | undefined,
+): Promise<unknown> {
+  const current = session as unknown as CompatibleSession
+  if (current.invoke !== undefined) return current.invoke(reference, input, options)
+
+  const dispatchBound = (sessionModule as unknown as { dispatchBound?: LegacyDispatchBound })
+    .dispatchBound
+  if (dispatchBound === undefined) {
+    throw new TypeError('Client Session cannot invoke an exact Admin publication.')
+  }
+  const result = await dispatchBound(
+    session,
+    call(reference.target, input),
+    {
+      schema: { revision: reference.revision },
+      publication: {
+        origin: snapshot.publication.origin,
+        identity: snapshot.publication.identity,
+        revision: snapshot.publication.schema.revision,
+        etag: snapshot.publication.etag,
+      },
+    },
+    options,
+  )
+  return requireOutput(reference.outputMode, result)
+}
+
+function requireOutput(
+  expected: CompatibleCallableReference['outputMode'],
+  result: Result,
+): unknown {
+  if (result.kind !== expected) {
+    if (result.kind === 'stream') void result.stream.cancel(`Admin callable declared ${expected}.`)
+    throw new TypeError(`Admin callable declared ${expected} output but returned ${result.kind}.`)
+  }
+  return result.kind === 'stream' ? result.stream : result.value
+}

package/src/admin/catalog/__tests__/client.test.ts

@@ -1,4 +1,3 @@
-import type { DomainBinding } from '@astrale-os/kernel-client/domain'
 import type { Node } from '@astrale-os/sdk/graph/node'
 import type { QueryAST } from '@astrale-os/sdk/query'
 
@@ -7,6 +6,7 @@ import { NodeId } from '@astrale-os/sdk/graph/node'
 import { Path } from '@astrale-os/sdk/graph/path'
 import { describe, expect, mock, test } from 'bun:test'
 
+import type { AdminBinding } from '../../binding'
 import type { AdminGraphApi } from '../../graph'
 
 import { connectAdminCatalog } from '../client'
@@ -61,7 +61,7 @@ function fixture(input: {
       core: { nodes: { fleet: { path: Path.id(NodeId('fleet')) } } },
       invoke,
     },
-  } as unknown as DomainBinding
+  } as unknown as AdminBinding
   const query = mock(async (_ast: QueryAST) => ({
     result: {
       kind: 'nodes' as const,

package/src/admin/catalog/client.ts

@@ -1,11 +1,10 @@
-import type { DomainBinding } from '@astrale-os/kernel-client/domain'
 import type { ClientSession } from '@astrale-os/kernel-client/session'
 import type { Node } from '@astrale-os/sdk/graph/node'
 
-import { bind } from '@astrale-os/kernel-client/domain'
 import { Path } from '@astrale-os/sdk/graph/path'
 import { Query } from '@astrale-os/sdk/query'
 
+import { bindAdmin, type AdminBinding } from '../binding'
 import { readAllNodes, type AdminGraphApi } from '../graph'
 import {
   AdminDomainNotFoundError,
@@ -37,7 +36,7 @@ export interface AdminCatalogApi {
 }
 
 export interface AdminCatalogDependencies {
-  readonly bind?: (session: ClientSession) => Promise<DomainBinding>
+  readonly bind?: (session: ClientSession) => Promise<AdminBinding>
   readonly operationId?: (kind: 'publish' | 'configure-default') => string
 }
 
@@ -46,7 +45,7 @@ export async function connectAdminCatalog(
   context: AdminCatalogContext,
   dependencies: AdminCatalogDependencies = {},
 ): Promise<AdminCatalogApi> {
-  const binding = await (dependencies.bind ?? bindInstalledAdmin)(context.session)
+  const binding = await (dependencies.bind ?? bindAdmin)(context.session)
   if (binding.$.publication?.origin !== ADMIN_ORIGIN || binding.$.origin !== ADMIN_ORIGIN) {
     throw new TypeError('Configured Admin target does not serve the Admin Domain.')
   }
@@ -145,11 +144,7 @@ export async function connectAdminCatalog(
   })
 }
 
-async function bindInstalledAdmin(session: ClientSession): Promise<DomainBinding> {
-  return bind(session, await session.installed(ADMIN_ORIGIN))
-}
-
-type DynamicDefinition = ReturnType<DomainBinding['$']['class']>
+type DynamicDefinition = ReturnType<AdminBinding['$']['class']>
 
 function domainFromNode(
   definition: DynamicDefinition,

package/src/admin/instance/__tests__/client.test.ts

@@ -1,4 +1,3 @@
-import type { DomainBinding } from '@astrale-os/kernel-client/domain'
 import type { Node } from '@astrale-os/sdk/graph/node'
 import type { QueryAST } from '@astrale-os/sdk/query'
 
@@ -7,6 +6,7 @@ import { NodeId } from '@astrale-os/sdk/graph/node'
 import { Path } from '@astrale-os/sdk/graph/path'
 import { describe, expect, mock, test } from 'bun:test'
 
+import type { AdminBinding } from '../../binding'
 import type { AdminGraphApi } from '../../graph'
 
 import { connectAdminInstances } from '../client'
@@ -78,7 +78,7 @@ function fixture(input: {
       core: { nodes: { fleet: { path: Path.id(NodeId('fleet')) } } },
       invoke,
     },
-  } as unknown as DomainBinding
+  } as unknown as AdminBinding
   const query = mock(async (ast: QueryAST) => {
     const name = sourceName(ast)
     if (name === 'Instance') return graphResult(input.instances ?? [])
@@ -153,7 +153,7 @@ describe('V2 Admin Instance adapter', () => {
     )
   })
 
-  test('invokes Fleet.createInstance with an internal operation identity', async () => {
+  test('delegates default placement to Fleet without reading Host inventory', async () => {
     const created = {
       id: '@instance-node',
       slug: 'demo',
@@ -179,6 +179,8 @@ describe('V2 Admin Instance adapter', () => {
       Path.id(NodeId('fleet')),
       { operationId: 'cli.instance.create:test', slug: 'demo' },
     )
+    expect(contract.graph.query).not.toHaveBeenCalled()
+    expect(contract.graph.neighbors).not.toHaveBeenCalled()
   })
 
   test('resolves --host-id to an exact Host receiver and rejects the reserved Admin Host', async () => {

package/src/admin/instance/client.ts

@@ -1,11 +1,10 @@
-import type { DomainBinding } from '@astrale-os/kernel-client/domain'
 import type { ClientSession } from '@astrale-os/kernel-client/session'
 import type { Node } from '@astrale-os/sdk/graph/node'
 
-import { bind } from '@astrale-os/kernel-client/domain'
 import { Path } from '@astrale-os/sdk/graph/path'
 import { Query } from '@astrale-os/sdk/query'
 
+import { bindAdmin, type AdminBinding } from '../binding'
 import { readAllNodes, type AdminGraphApi } from '../graph'
 import {
   AdminHostNotFoundError,
@@ -43,7 +42,7 @@ export interface AdminInstanceApi {
 }
 
 export interface AdminInstanceDependencies {
-  readonly bind?: (session: ClientSession) => Promise<DomainBinding>
+  readonly bind?: (session: ClientSession) => Promise<AdminBinding>
   readonly operationId?: (kind: 'create' | 'status' | 'delete' | 'install-domain') => string
 }
 
@@ -55,7 +54,7 @@ export async function connectAdminInstances(
   context: AdminInstanceContext,
   dependencies: AdminInstanceDependencies = {},
 ): Promise<AdminInstanceApi> {
-  const binding = await (dependencies.bind ?? bindInstalledAdmin)(context.session)
+  const binding = await (dependencies.bind ?? bindAdmin)(context.session)
   if (binding.$.publication?.origin !== ADMIN_ORIGIN || binding.$.origin !== ADMIN_ORIGIN) {
     throw new TypeError('Configured Admin target does not serve the Admin Domain.')
   }
@@ -119,15 +118,9 @@ export async function connectAdminInstances(
         )
       }
 
-      // Preserve the existing interactive multi-Host picker without accepting a
-      // doomed operation first. Graph read policy exposes only caller-usable
-      // Hosts; the reserved Admin Host is excluded explicitly.
-      const inventory = await hostInventory(context.graph, binding, Host, fleet)
-      const eligible = inventory.hosts.filter(
-        (host) => host.state === 'ready' && host.path !== inventory.reserved,
-      )
-      if (eligible.length > 1) throw hostSelectionRequired(eligible.map((host) => host.id))
-
+      // Default placement belongs to Admin. Avoid a redundant Host graph read:
+      // it requires broader graph authority than this Fleet operation and can
+      // deny an otherwise authorized caller before the server selects a Host.
       return instanceFromSummary(
         await binding.$.invoke(Fleet.$.method('createInstance') as never, fleet, input as never),
       )
@@ -149,10 +142,6 @@ export async function connectAdminInstances(
   })
 }
 
-async function bindInstalledAdmin(session: ClientSession): Promise<DomainBinding> {
-  return bind(session, await session.installed(ADMIN_ORIGIN))
-}
-
 interface HostInventoryItem {
   readonly id: string
   readonly nodeId: string
@@ -162,8 +151,8 @@ interface HostInventoryItem {
 
 async function hostInventory(
   graph: AdminGraphApi,
-  binding: DomainBinding,
-  Host: ReturnType<DomainBinding['$']['class']>,
+  binding: AdminBinding,
+  Host: ReturnType<AdminBinding['$']['class']>,
   fleet: Path,
 ): Promise<{ readonly hosts: readonly HostInventoryItem[]; readonly reserved?: string }> {
   const [nodes, reservedPage] = await Promise.all([
@@ -200,14 +189,7 @@ async function hostInventory(
   })
 }
 
-function hostSelectionRequired(ids: readonly string[]): Error {
-  return new Error(
-    `alphaCreate could not choose a host: ${ids.length} ready hosts are assigned (${[...ids].sort().join(', ')}). ` +
-      'Specify host_id once multi-host placement is enabled.',
-  )
-}
-
-type DynamicDefinition = ReturnType<DomainBinding['$']['class']>
+type DynamicDefinition = ReturnType<AdminBinding['$']['class']>
 
 function instanceFromSummary(input: unknown): InstanceInfo {
   const value = record(input, 'Admin Instance summary')

package/src/commands/__tests__/auth-login.test.ts

@@ -81,11 +81,56 @@ describe('auth login command', () => {
       expect(result.exitCode).toBe(0)
       const session = JSON.parse(await readFile(join(tmp, 'idp-sessions', 'alice.json'), 'utf-8'))
       expect(session.audience).toBe('https://kernel.example.com')
+      expect(session.clientId).toBe('client_123')
       expect(session.subject).toBe('user_123')
     } finally {
       await server.stop()
     }
   })
+
+  test('persists an explicit client id and reuses it for a named login', async () => {
+    const server = oauthServer({
+      accessToken: unsignedJwt({
+        iss: 'http://127.0.0.1',
+        sub: 'user_123',
+        exp: 1893456000,
+      }),
+    })
+    try {
+      await writeIdpConfig(server.url)
+
+      const explicit = await runAuthLogin(
+        '--idp',
+        'test',
+        '--name',
+        'alice',
+        '--client-id',
+        'client_override',
+        '--client-credentials',
+        '--client-secret-env',
+        'TEST_CLIENT_SECRET',
+        '--raw',
+      )
+      const reused = await runAuthLogin(
+        '--idp',
+        'test',
+        '--name',
+        'alice',
+        '--client-credentials',
+        '--client-secret-env',
+        'TEST_CLIENT_SECRET',
+        '--raw',
+      )
+
+      expect(explicit.exitCode).toBe(0)
+      expect(reused.exitCode).toBe(0)
+      expect(server.clientIds()).toEqual(['client_override', 'client_override'])
+      const session = JSON.parse(await readFile(join(tmp, 'idp-sessions', 'alice.json'), 'utf-8'))
+      expect(session.clientId).toBe('client_override')
+    } finally {
+      await server.stop()
+    }
+  })
 })
 
 async function writeIdpConfig(baseUrl: string): Promise<void> {
@@ -131,12 +176,19 @@ async function writeIdpConfig(baseUrl: string): Promise<void> {
   )
 }
 
-function oauthServer(args: { accessToken: string }): { url: string; stop: () => Promise<void> } {
+function oauthServer(args: { accessToken: string }): {
+  url: string
+  clientIds: () => Array<string | null>
+  stop: () => Promise<void>
+} {
+  const clientIds: Array<string | null> = []
   const server = Bun.serve({
     port: 0,
     fetch: async (request) => {
       const url = new URL(request.url)
       if (url.pathname !== '/token') return new Response('not found', { status: 404 })
+      const form = new URLSearchParams(await request.text())
+      clientIds.push(form.get('client_id'))
       return Response.json({
         access_token: args.accessToken,
         token_type: 'Bearer',
@@ -146,6 +198,7 @@ function oauthServer(args: { accessToken: string }): { url: string; stop: () =>
   })
   return {
     url: `http://${server.hostname}:${server.port}`,
+    clientIds: () => clientIds,
     stop: () => server.stop(true),
   }
 }

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

@@ -14,7 +14,11 @@ describe('call command result lifetime', () => {
     }
 
     const sessionStream = Object.assign(stream(), { async cancel() {} })
-    const materialized = await materializeCallResult({ kind: 'stream', stream: sessionStream })
+    const materialized = await materializeCallResult({
+      kind: 'stream',
+      invocation: { source: 'https://kernel.test' as never, id: 'test-stream' },
+      stream: sessionStream,
+    })
     sessionOpen = false
 
     expect(materialized).toEqual({ kind: 'stream', values: ['first', 'second'] })

package/src/commands/__tests__/domain-install-operation.test.ts

@@ -1,3 +1,7 @@
+import { defineDomain } from '@astrale-os/sdk'
+import { issuer } from '@astrale-os/sdk/auth'
+import { createDeployment } from '@astrale-os/sdk/deployment'
+import { defineSchema } from '@astrale-os/sdk/schema/v1'
 import { afterEach, describe, expect, mock, test } from 'bun:test'
 
 import { installDirect } from '../domain/install'
@@ -7,6 +11,22 @@ const RETRY = '139137b5-af47-47ce-92b2-b64a2b0c63d7'
 
 const originalFetch = globalThis.fetch
 
+const schema = defineSchema('crm.test', {})
+const definition = defineDomain({
+  schema,
+  handlers: { functions: {}, classes: {}, interfaces: {} },
+})
+const deployed = createDeployment({
+  definition,
+  issuer: issuer.accept('https://crm.test'),
+  bundleHref: 'https://crm.test/domain.bundle.json',
+  bindings: { callables: [] },
+}).publication
+
+function publicationResponse(): Response {
+  return Response.json(deployed)
+}
+
 class ExitError extends Error {}
 
 afterEach(() => {
@@ -15,9 +35,7 @@ afterEach(() => {
 
 describe('direct domain install operation identity', () => {
   test('generates one operation before transport and exposes it for recovery', async () => {
-    globalThis.fetch = mock(async () =>
-      Response.json({ domainName: 'crm.test' }),
-    ) as unknown as typeof fetch
+    globalThis.fetch = mock(async () => publicationResponse()) as unknown as typeof fetch
     const create = mock(() => GENERATED)
     const requests: unknown[] = []
     let recovery: unknown
@@ -54,9 +72,7 @@ describe('direct domain install operation identity', () => {
   })
 
   test('accepts an explicit operation only as the exact retry identity', async () => {
-    globalThis.fetch = mock(async () =>
-      Response.json({ domainName: 'crm.test' }),
-    ) as unknown as typeof fetch
+    globalThis.fetch = mock(async () => publicationResponse()) as unknown as typeof fetch
     const create = mock(() => GENERATED)
     const accepted: string[] = []
     const requests: unknown[] = []
@@ -95,7 +111,7 @@ describe('direct domain install operation identity', () => {
   test('rejects a non-UUID operation before metadata or Kernel transport', async () => {
     const originalExit = process.exit
     const originalWrite = process.stderr.write
-    const fetch = mock(async () => Response.json({ domainName: 'crm.test' }))
+    const fetch = mock(async () => publicationResponse())
     const run = mock(async () => undefined)
     globalThis.fetch = fetch as unknown as typeof globalThis.fetch
     process.exit = (() => {

package/src/commands/__tests__/domain-install-owned.test.ts

@@ -11,6 +11,10 @@ class ExitError extends Error {
 
 const calls: Array<{ path: string; params: unknown }> = []
 let inventory: OwnedInstanceInfo[] = []
+const TEST_INVOCATION = {
+  source: 'https://kernel.test',
+  id: 'domain-install-owned',
+} as ConstructorParameters<typeof ResponseError>[2]
 
 const hostCall = mock(async (call: { target: string; input: unknown }): Promise<unknown> => {
   const path = call.target
@@ -137,7 +141,7 @@ describe('admin domain install owner boundary', () => {
       createdAt: '2026-08-20T00:00:00.000Z',
       updatedAt: '2026-08-20T00:00:00.000Z',
     }
-    const failure = new ResponseError(5001, 'Schema operation is not supported.', {
+    const failure = new ResponseError(5001, 'Schema operation is not supported.', TEST_INVOCATION, {
       code: 'SCHEMA_UPGRADE_INCOMPATIBLE',
       details: {
         phase: 'upgrade',