@astrale-os/cli 1.0.0-beta.27 → 1.0.0-beta.29

package/src/commands/browser.ts

@@ -13,6 +13,7 @@ import {
   profileDirFor,
   saveSession,
 } from '../lib/browser'
+import { sweepBrowserProfiles } from '../lib/browser-retention'
 import { readLocalStatus } from '../lib/local-status'
 import { fatal, log } from '../lib/log'
 import { isMachine, output, RAW_OUTPUT_OPTIONS, type RawOutputOpts } from '../lib/output'
@@ -25,6 +26,29 @@ type BrowserOpts = RawOutputOpts & {
   check?: boolean
 }
 
+/**
+ * Opportunistic profile retention, the same `git gc --auto` shape the session
+ * store uses: no daemon, no cron, it just rides on the command that created the
+ * mess. Silent when there is nothing to do, and never fatal — losing a sweep is
+ * strictly better than losing the browser command.
+ */
+async function reportSweep(machine: boolean): Promise<void> {
+  try {
+    const swept = await sweepBrowserProfiles()
+    if (machine || swept.bytesFreed === 0) return
+    const freed = `${(swept.bytesFreed / 1024 / 1024).toFixed(0)} MB`
+    const what = [
+      swept.removed.length > 0 ? `${swept.removed.length} dormant profile(s) removed` : null,
+      swept.purged.length > 0 ? `${swept.purged.length} cache(s) trimmed` : null,
+    ]
+      .filter(Boolean)
+      .join(', ')
+    log.dim(`retention: ${what} — ${freed} freed`)
+  } catch {
+    /* retention must never break the browser command */
+  }
+}
+
 const LOGIN_TIMEOUT_MS = 180_000
 const POLL_INTERVAL_MS = 2500
 
@@ -125,6 +149,11 @@ Examples:
     const host = new URL(gui).host
     await requireAgentBrowser(machine, opts)
 
+    // Retention runs BEFORE anything launches, so no profile we touch can be in
+    // use by a browser this command started. Profiles held by someone else's
+    // live browser are skipped by the sweep itself.
+    await reportSweep(machine)
+
     const usingCdp = !!opts.cdp
     const profile = usingCdp ? null : (opts.profile ?? profileDirFor(host))
     const target = usingCdp ? { cdp: opts.cdp } : { profile: profile! }

package/src/commands/domain/install.ts

@@ -426,6 +426,7 @@ export async function installDirect(
       target,
       host,
       opts.allowIdentityOverride ?? false,
+      isMachine(opts),
     )
   } catch (e) {
     fatal(e, opts)
@@ -451,11 +452,13 @@ export async function installDirect(
       // 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}.`,
+          )
+        }
       }
     },
   })
@@ -512,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/get.ts

@@ -46,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.
 

package/src/commands/identity/register.ts

@@ -45,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 \

package/src/commands/logs.ts

@@ -341,11 +341,8 @@ Behavior:
   Calls the public Kernel journal syscall and emits its { records, cursor }
   page. Topic selection is exact or prefix-based; cursors and timestamps are
   opaque strings owned by the journal backend. --follow reuses one Client Session
-  and advances only with the returned cursor. Machine follow output is NDJSON:
-  one complete admitted record per line; YAML follow is unsupported.
-
-  Historical event-glob lowering and the application-specific services-domain
-  log buffer are not part of the Kernel V2 journal contract.
+  and advances only with the returned cursor. With --json, follow output is
+  NDJSON with one complete admitted record per line; YAML follow is unsupported.
 
 Examples:
   $ astrale logs -i staging --limit 50

package/src/commands/session/analyze.ts

@@ -4,13 +4,23 @@ import type { CommandDefinition } from '../../program/index'
 
 import { log } from '../../lib/log'
 import { analyzeSession } from '../../telemetry/analyze'
-import { listSessions } from '../../telemetry/store'
+import { sweepStore } from '../../telemetry/retention'
+import { scanSessions } from '../../telemetry/store'
 import { restampLock, releaseLock } from '../../telemetry/trigger'
 
 export default {
   name: 'analyze',
   description: 'Analyze a recorded session for DX frictions (dry-run: writes report.md)',
-  arguments: [{ name: 'id', description: 'Session id (default: most recent closed, unanalyzed)' }],
+  arguments: [
+    // Optional: the action resolves the most recent closed, unanalyzed session
+    // when no id is given, which is how a human is meant to invoke this. The
+    // opportunistic trigger always passes an explicit id.
+    {
+      name: 'id',
+      description: 'Session id (default: most recent closed, unanalyzed)',
+      required: false,
+    },
+  ],
   options: [
     { flags: '--file', description: 'File cleared findings as issues on the admin tracker' },
     { flags: '--model <model>', description: 'Model for the analyzer pass' },
@@ -22,10 +32,10 @@ export default {
     opts: { file?: boolean; model?: string; force?: boolean; auto?: boolean },
   ) => {
     if (opts.auto) restampLock()
+    let target = id
     try {
-      let target = id
       if (!target) {
-        const candidate = listSessions().find((s) => s.closed && (opts.force || !s.analyzed))
+        const candidate = scanSessions().find((s) => s.closed && (opts.force || !s.analyzed))
         if (!candidate) {
           if (!opts.auto) log.dim('Nothing to analyze — no closed, unanalyzed session.')
           return
@@ -45,6 +55,18 @@ export default {
       }
     } finally {
       if (opts.auto) releaseLock()
+      // The size bound is enforced here, not on the CLI's critical path:
+      // measuring every file of every session is only affordable in this
+      // process, and this is precisely where the store just grew. The session
+      // just analyzed is protected — it is the freshest evidence on disk.
+      try {
+        const swept = sweepStore({ protect: new Set(target === undefined ? [] : [target]) })
+        if (!opts.auto && swept.removed.length > 0) {
+          log.dim(`retention: removed ${swept.removed.length} session(s)`)
+        }
+      } catch {
+        /* retention must never fail the command that triggered it */
+      }
     }
   },
 } satisfies CommandDefinition

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

@@ -28,7 +28,15 @@ selection, and the single safe stale-route recovery. The CLI does not reproduce
 discover destination identity. `SessionAuth.resolve(call, signal)` returns source-Kernel authority and
 ClientSession supplies an audience-free Delegate with omitted attenuation, preserving the exact
 current Grant for routing. Connection itself persists no credential or route; the separate state
-owner persists only exchanged source credentials.
+owner persists exchanged source credentials and the separate Kernel Client route artifact. A valid exchanged credential is selected by the
+authenticated source issuer and subject before any live `whoami`; cache misses alone resolve the
+registered Kernel User and perform delegation plus Domain exchange.
+Exchange authority is bounded to five minutes and never outlives the current source credential,
+matching the CLI route-age ceiling without forcing an unrelated two-minute refresh cycle.
+
+Every ClientSession receives the CLI-owned `state/session-routes` representation capability. Kernel
+Client still owns route keying, admission, expiry, and one safe stale/miss recovery; Connection does
+not reproduce routing or add an Admin-only bypass.
 
 `--anonymous` deliberately suppresses ambient and bookmark-default identities by omitting the
 `SessionAuth` capability. It cannot be combined with `--as` or `--creds`; contradictory selections fail

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

@@ -15,6 +15,7 @@ const config: AstraleConfig = {
     kernelIssuer: 'https://admin.eu.astrale.ai/api',
   },
   telemetry: { enabled: true },
+  browser: {},
 }
 
 describe('resolveKeyIdentityAuthOptions', () => {

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

@@ -18,6 +18,7 @@ const config: AstraleConfig = {
   issuer: 'https://cli.example',
   admin: { name: 'admin', url: SOURCE, kernelIssuer: SOURCE },
   telemetry: { enabled: false },
+  browser: {},
 }
 
 describe('connection credential', () => {

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

@@ -14,13 +14,8 @@ const DOMAIN = issuer.accept('https://admin.example')
 const TARGET = { url: `${KERNEL}/api`, kernelIssuer: KERNEL, domainIssuer: DOMAIN }
 const INVOCATION = `${KERNEL}/invoke`
 const EXPIRES_AT = Math.floor(Date.now() / 1_000) + 500
-const SOURCE_EXPIRES_AT = Math.floor(Date.now() / 1_000) + 120
-const SOURCE_TOKEN = token(
-  issuer.accept('https://workos.example'),
-  KERNEL,
-  'user-1',
-  SOURCE_EXPIRES_AT,
-)
+const SOURCE_EXPIRES_AT = Math.floor(Date.now() / 1_000) + 600
+const SOURCE_TOKEN = sourceToken('user-1')
 let directory: string
 
 beforeEach(async () => {
@@ -33,7 +28,7 @@ afterEach(async () => {
 
 describe('Domain token exchange', () => {
   /** @evidence TEST-CLI-EXCHANGE-WHOAMI-DELEGATE-EXCHANGE-CACHE */
-  test('runs the exact User to Kernel to Domain journey and reuses the bound token', async () => {
+  test('runs the exact User to Kernel to Domain journey once and reuses it before whoami', async () => {
     const observed: Array<{
       url: string
       init: RequestInit | undefined
@@ -91,7 +86,7 @@ describe('Domain token exchange', () => {
     await expect(resolver.resolve(KERNEL, new AbortController().signal)).resolves.toBe(exchanged)
 
     const kernelRequests = observed.filter((entry) => entry.url === INVOCATION)
-    expect(kernelRequests).toHaveLength(3)
+    expect(kernelRequests).toHaveLength(2)
     expect(kernelRequests[0]!.body).toMatchObject({
       credential: SOURCE_TOKEN,
       call: { input: {} },
@@ -107,13 +102,32 @@ describe('Domain token exchange', () => {
     })
     const delegatedTtl = kernelRequests[1]!.body!.call.input.ttlSeconds
     expect(delegatedTtl).toBeGreaterThan(0)
-    expect(delegatedTtl).toBeLessThan(120)
+    expect(delegatedTtl).toBeGreaterThanOrEqual(295)
+    expect(delegatedTtl).toBeLessThanOrEqual(300)
     expect(sourceAudiences).toEqual([KERNEL, KERNEL])
     expect(
       observed.filter((entry) => entry.url.endsWith('/.well-known/astrale/token')),
     ).toHaveLength(1)
   })
 
+  test('rejects a source credential without a stable cache identity before network I/O', async () => {
+    let fetches = 0
+    const resolver = createExchangeCredentialResolver(
+      TARGET,
+      { resolve: async () => sourceToken(undefined) },
+      async () => {
+        fetches += 1
+        throw new Error('network must remain untouched')
+      },
+      5_000,
+      new ExchangeCredentialCache(join(directory, 'credentials.json')),
+    )
+    await expect(resolver.resolve(KERNEL, new AbortController().signal)).rejects.toMatchObject({
+      code: 'TOKEN_EXCHANGE_SOURCE_INVALID',
+    })
+    expect(fetches).toBe(0)
+  })
+
   /** @evidence TEST-CLI-EXCHANGE-NO-LEGACY-FALLBACK */
   test('fails closed when issuer discovery does not advertise exchange', async () => {
     const fetch: Fetch = async (input, init) => {
@@ -293,3 +307,13 @@ function token(iss: string, aud: string, user: string, exp: number): string {
     grant: { v: 1, expr: { kind: 'identity', credential: proof } },
   })}.signature`
 }
+
+function sourceToken(subject: string | undefined): string {
+  const encode = (value: unknown) => Buffer.from(JSON.stringify(value)).toString('base64url')
+  return `${encode({ alg: 'EdDSA', typ: 'JWT' })}.${encode({
+    iss: 'https://workos.example',
+    ...(subject === undefined ? {} : { sub: subject }),
+    aud: KERNEL,
+    exp: SOURCE_EXPIRES_AT,
+  })}.signature`
+}

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

@@ -1,6 +1,7 @@
 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 type { SessionRouteStore } from '@astrale-os/sdk/client/session'
 
 import { issuer } from '@astrale-os/sdk/auth'
 import { describe, expect, test } from 'bun:test'
@@ -23,6 +24,7 @@ const config: AstraleConfig = {
     kernelIssuer: 'https://admin.example',
   },
   telemetry: { enabled: false },
+  browser: {},
 }
 
 const context: ConnectionContext = Object.freeze({
@@ -37,11 +39,13 @@ describe('connection session', () => {
   /** @evidence TEST-CLI-CONNECTION-PINS-SOURCE-ISSUER */
   test('pins the selected canonical Kernel issuer without a transport escape hatch', async () => {
     const auth = { ttlSeconds: 3_600, resolve: async () => ({ credential: 'credential' }) }
-    const options = createClientSessionOptions(target, globalThis.fetch, auth, 2_500)
+    const routeStore: SessionRouteStore = { read: () => undefined, write: () => undefined }
+    const options = createClientSessionOptions(target, globalThis.fetch, auth, 2_500, routeStore)
 
     expect(options.kernel).toBe(target.kernelIssuer)
     expect(options).not.toHaveProperty('url')
     expect(options).not.toHaveProperty('sourceIssuer')
+    expect(options.routeStore).toBe(routeStore)
   })
 
   /** @evidence TEST-CLI-CONNECTION-OMITS-EXPLICIT-ANONYMOUS-CREDENTIAL */

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

@@ -15,6 +15,7 @@ const config: AstraleConfig = {
     domainIssuer: 'https://admin-domain.example',
   },
   telemetry: { enabled: false },
+  browser: {},
 }
 
 const instances: InstanceStore = {

package/src/connection/exchange.ts

@@ -11,7 +11,7 @@ import type { ConnectionTarget } from './target'
 import { AstraleError } from '../errors'
 import { ExchangeCredentialCache } from '../state/exchange-credentials'
 
-const EXCHANGE_TTL_SECONDS = 120
+const EXCHANGE_TTL_SECONDS = 5 * 60
 const MAXIMUM_RESPONSE_BYTES = 256 * 1024
 
 /** Exchange exact authenticated User authority for a Domain bearer bound to this Kernel. */
@@ -27,53 +27,78 @@ export function createExchangeCredentialResolver(
     async resolve(kernelIssuer: IssuerId, signal: AbortSignal): Promise<string> {
       requireLive(signal)
       const sourceToken = await source.resolve(kernelIssuer, signal)
-      const delegationTtlSeconds = delegationLifetime(sourceToken)
+      const sourceIdentity = sourceCacheIdentity(sourceToken)
       requireLive(signal)
 
-      const client = new Client({ url: `${kernelIssuer}/invoke`, fetch, timeoutMs })
-      try {
-        const authenticated = client.as(sourceToken)
-        const auth = createAuth(async (path, input, options) => {
-          const result = await authenticated.call(call(path, input), {
-            ...options,
-            delegate: { ttlSeconds: delegationTtlSeconds },
-          })
-          return result.value
-        })
-        const user = await auth.whoami({ signal })
-        const key = Object.freeze({
+      return await cache.getOrRefresh(
+        Object.freeze({
           kernelIssuer,
           domainIssuer: target.domainIssuer,
-          user: user.id,
-        })
-        return await cache.getOrRefresh(key, async () => {
-          let envelope: string | undefined
-          for (let attempt = 0; attempt < 3; attempt += 1) {
-            try {
-              envelope = await auth.delegate(
-                user.id,
-                {
-                  audience: target.domainIssuer,
-                  ttlSeconds: delegationTtlSeconds,
-                  attenuation: { kind: 'identity', self: true },
-                },
-                { signal },
-              )
-              break
-            } catch (cause) {
-              if (attempt === 2 || !unknownFunctionOutcome(cause)) throw cause
+          sourceIssuer: sourceIdentity.issuer,
+          sourceSubject: sourceIdentity.subject,
+        }),
+        async () => {
+          const delegationTtlSeconds = delegationLifetime(sourceToken)
+          const client = new Client({ url: `${kernelIssuer}/invoke`, fetch, timeoutMs })
+          try {
+            const authenticated = client.as(sourceToken)
+            const auth = createAuth(async (path, input, options) => {
+              const result = await authenticated.call(call(path, input), {
+                ...options,
+                delegate: { ttlSeconds: delegationTtlSeconds },
+              })
+              return result.value
+            })
+            const user = await auth.whoami({ signal })
+            let envelope: string | undefined
+            for (let attempt = 0; attempt < 3; attempt += 1) {
+              try {
+                envelope = await auth.delegate(
+                  user.id,
+                  {
+                    audience: target.domainIssuer,
+                    ttlSeconds: delegationTtlSeconds,
+                    attenuation: { kind: 'identity', self: true },
+                  },
+                  { signal },
+                )
+                break
+              } catch (cause) {
+                if (attempt === 2 || !unknownFunctionOutcome(cause)) throw cause
+              }
             }
+            if (envelope === undefined) throw new Error('Token delegation returned no credential.')
+            return {
+              ...(await exchange(target.domainIssuer, kernelIssuer, envelope, fetch, signal)),
+              user: user.id,
+              sourceIssuer: sourceIdentity.issuer,
+              sourceSubject: sourceIdentity.subject,
+            }
+          } finally {
+            client.close()
           }
-          if (envelope === undefined) throw new Error('Token delegation returned no credential.')
-          return exchange(target.domainIssuer, kernelIssuer, envelope, fetch, signal)
-        })
-      } finally {
-        client.close()
-      }
+        },
+      )
     },
   })
 }
 
+function sourceCacheIdentity(sourceToken: string): { issuer: string; subject: string } {
+  const inspected = credential.inspect(sourceToken)
+  if (
+    typeof inspected.iss !== 'string' ||
+    inspected.iss.length === 0 ||
+    typeof inspected.sub !== 'string' ||
+    inspected.sub.length === 0
+  ) {
+    throw new AstraleError(
+      'TOKEN_EXCHANGE_SOURCE_INVALID',
+      'The source identity credential has no stable issuer and subject.',
+    )
+  }
+  return Object.freeze({ issuer: inspected.iss, subject: inspected.sub })
+}
+
 function unknownFunctionOutcome(cause: unknown): boolean {
   if (cause === null || typeof cause !== 'object') return false
   const error = cause as { readonly code?: unknown; readonly reason?: unknown }

package/src/connection/session.ts

@@ -1,6 +1,10 @@
 import type { AuthApi } from '@astrale-os/sdk/auth'
 import type { GraphApi } from '@astrale-os/sdk/client'
-import type { ClientSessionOptions, SessionAuth } from '@astrale-os/sdk/client/session'
+import type {
+  ClientSessionOptions,
+  SessionAuth,
+  SessionRouteStore,
+} from '@astrale-os/sdk/client/session'
 
 import { createAuth } from '@astrale-os/sdk/auth'
 import { call } from '@astrale-os/sdk/client'
@@ -21,6 +25,7 @@ import { fetchWithCaFile } from '../lib/ca-fetch'
 import { readConfig } from '../lib/config'
 import { log } from '../lib/log'
 import { isMachine } from '../lib/output'
+import { SESSION_ROUTE_STORE } from '../state/session-routes'
 import { bindCredentialIdentity } from './auth'
 import { createCliCredential, validateCredentialSelection } from './credential'
 import { resolveAdminConnectionTarget, resolveConnectionTarget } from './target'
@@ -165,11 +170,13 @@ export function createClientSessionOptions(
   fetch: NonNullable<ClientSessionOptions['fetch']>,
   auth: SessionAuth | undefined,
   timeoutMs: number,
+  routeStore: SessionRouteStore = SESSION_ROUTE_STORE,
 ): ClientSessionOptions {
   return {
     kernel: target.kernelIssuer,
     fetch,
     ...(auth === undefined ? {} : { auth }),
+    routeStore,
     policy: {
       maximumRouteAgeMs: MAXIMUM_ROUTE_AGE_MS,
       ...(new URL(target.url).protocol === 'http:' ? { allowInsecureHttp: true } : {}),

package/src/identity/__tests__/fixtures/registry-journey.ts

@@ -1,5 +1,8 @@
+import { mkdir, readFile, writeFile } from 'node:fs/promises'
+import { dirname } from 'node:path'
+
 import { fileExists, keypairPaths } from '../../../keys/index'
-import { KEYS_DIR } from '../../../state/index'
+import { EXCHANGE_CREDENTIALS_PATH, KEYS_DIR, SESSION_ROUTES_PATH } from '../../../state/index'
 import {
   createIdentity,
   exportIdentity,
@@ -30,6 +33,13 @@ try {
 } catch (error) {
   selectedDeletion = error instanceof Error ? error.message : String(error)
 }
+await mkdir(dirname(SESSION_ROUTES_PATH), { recursive: true })
+await mkdir(dirname(EXCHANGE_CREDENTIALS_PATH), { recursive: true })
+await writeFile(SESSION_ROUTES_PATH, '{"version":1,"entries":{"confidential":{}}}\n')
+await writeFile(
+  EXCHANGE_CREDENTIALS_PATH,
+  '{"version":2,"entries":{"confidential":{"credential":"bearer"}}}\n',
+)
 await deleteIdentity('bob')
 await deleteIdentity('alice-alias')
 await upsertIdpIdentity('workos', {
@@ -49,5 +59,7 @@ console.log(
     selectedDeletion,
     aliceKey: await fileExists(keypairPaths('alice', KEYS_DIR).privatePath),
     bobKey: await fileExists(keypairPaths('bob', KEYS_DIR).privatePath),
+    routeCache: await fileExists(SESSION_ROUTES_PATH),
+    exchangeCache: JSON.parse(await readFile(EXCHANGE_CREDENTIALS_PATH, 'utf8')),
   }),
 )

package/src/identity/__tests__/registry.test.ts

@@ -47,6 +47,8 @@ describe('identity registry journey', () => {
       selectedDeletion: string
       aliceKey: boolean
       bobKey: boolean
+      routeCache: boolean
+      exchangeCache: unknown
     }
     expect(result.store.default).toBe('alice')
     expect(Object.keys(result.store.identities).sort()).toEqual(['alice', 'workos'])
@@ -60,6 +62,8 @@ describe('identity registry journey', () => {
     expect(result.selectedDeletion).toContain('Cannot delete the default identity')
     expect(result.aliceKey).toBe(true)
     expect(result.bobKey).toBe(false)
+    expect(result.routeCache).toBe(false)
+    expect(result.exchangeCache).toEqual({ version: 2, entries: {} })
 
     const persisted = JSON.parse(await readFile(join(root, 'identities.json'), 'utf-8')) as {
       version?: unknown

package/src/identity/registry.ts

@@ -10,6 +10,7 @@ import {
   type IdentityStore,
   type Registration,
   ExchangeCredentialCache,
+  SESSION_ROUTE_STORE,
 } from '../state/index'
 
 export type { Identity, IdentityStore, Registration } from '../state/index'
@@ -68,6 +69,7 @@ export async function deleteIdentity(name: string): Promise<void> {
     return { next: { ...store, identities }, value: undefined }
   })
   await new ExchangeCredentialCache().clear()
+  SESSION_ROUTE_STORE.clear()
 }
 
 function hasAnotherKeyIdentity(store: IdentityStore, name: string, subject: string): boolean {