lyra-ai-agent 0.1.9 → 0.1.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lyra-ai-agent",
-  "version": "0.1.9",
+  "version": "0.1.10",
   "type": "module",
   "description": "lyra CLI: a Sui-native, policy-bound AI finance agent. Real on-chain work gated by deterministic policy, simulation, and approval",
   "license": "MIT",
@@ -35,11 +35,11 @@
     "@mysten/sui": "^1.45.2",
     "@opentui/core": "^0.1.97",
     "@opentui/solid": "^0.1.97",
-    "lyra-core": "^0.1.2",
-    "lyra-gateway": "^0.1.6",
-    "lyra-plugin-onchain": "^0.1.9",
-    "lyra-plugin-system": "^0.1.2",
-    "lyra-plugin-telegram": "^0.1.2",
+    "lyra-core": "^0.1.10",
+    "lyra-gateway": "^0.1.10",
+    "lyra-plugin-onchain": "^0.1.10",
+    "lyra-plugin-system": "^0.1.10",
+    "lyra-plugin-telegram": "^0.1.10",
     "picocolors": "^1.1.1",
     "qrcode-terminal": "^0.12.0",
     "solid-js": "^1.9.12"

package/src/commands/chat.tsx

@@ -264,9 +264,9 @@ export async function runChat(opts?: { cwd?: string; yolo?: boolean }): Promise<
   )
   // Onchain side-band ctx: the Sui client + agent keypair drive every PTB, and
   // the deterministic policy (mirrored on-chain by lyra::policy) bounds writes.
-  let onchain: ReturnType<typeof buildOnchainContext> | undefined
+  let onchain: Awaited<ReturnType<typeof buildOnchainContext>> | undefined
   if (pluginNames.includes('onchain')) {
-    onchain = buildOnchainContext({
+    onchain = await buildOnchainContext({
       agent,
       network: config.network,
       agentDir: paths.dir,
@@ -278,11 +278,13 @@ export async function runChat(opts?: { cwd?: string; yolo?: boolean }): Promise<
   // works regardless of which plugins loaded.
   const balanceClient =
     onchain?.client ??
-    buildOnchainContext({
-      agent,
-      network: config.network,
-      agentDir: paths.dir,
-    }).client
+    (
+      await buildOnchainContext({
+        agent,
+        network: config.network,
+        agentDir: paths.dir,
+      })
+    ).client
   // Phase 12: telegram side-band ctx. We build the runtime context now (before
   // brain.init) so the plugin can register its listener via ctx.registerListener,
   // but the dispatch callback is deferred — the slot's `.current` is null until

package/src/commands/demo.ts

@@ -68,7 +68,7 @@ export async function runDemo(opts: DemoOpts = {}): Promise<void> {
 
   console.log(`lyra demo — agent ${agent.address} on ${config.network}\n`)
 
-  const onchain = buildOnchainContext({
+  const onchain = await buildOnchainContext({
     agent,
     network: config.network,
     agentDir: found.path,

package/src/config/defaults.ts

@@ -9,7 +9,7 @@
 
 /** Deployed `lyra::policy` Move package on mainnet (on-chain receipts). */
 export const DEFAULT_PACKAGE_ID =
-  '0x8e984145d636037cebf5c402ac4b338567411ba6dd275948d7ff593b1ed01a04'
+  '0x8ffdbda0bec2e3604757d435c567d52451317ed5752cef8fc5321a1050872cbf'
 
 /** Default Sui network. */
 export const DEFAULT_NETWORK = 'mainnet' as const

package/src/util/sui-runtime.ts

@@ -20,6 +20,7 @@ import {
   keypairFromSecret,
   makeSuiClient,
   policyFromEnv,
+  resolveVaultForAgent,
 } from 'lyra-plugin-onchain'
 import { resolvePackageId, resolvePolicyEnv } from '../config/defaults'
 
@@ -97,11 +98,16 @@ export interface BuildOnchainOpts {
  * wrote (`LYRA_PACKAGE_ID` / `LYRA_POLICY_OBJECT_ID`); the off-chain policy
  * mirror comes from `policyFromEnv()` (the `LYRA_POLICY_*` vars).
  */
-export function buildOnchainContext(opts: BuildOnchainOpts): OnchainRuntimeContext {
+export async function buildOnchainContext(opts: BuildOnchainOpts): Promise<OnchainRuntimeContext> {
   // packageId: explicit opt wins, then LYRA_PACKAGE_ID, then the deployed
   // mainnet default — so on-chain receipts work with zero env config.
   const packageId = opts.packageId ?? resolvePackageId()
-  const policyObjectId = opts.policyObjectId ?? process.env.LYRA_POLICY_OBJECT_ID ?? undefined
+  // Auto-resolve this agent's treasury vault (if provisioned) so DeFi tools draw
+  // from the vault via the policy-gated vault_spend; falls back to the agent's own
+  // SUI when there's none. Owner-agnostic (found by the agent tag on-chain).
+  const vault = await resolveVaultForAgent(opts.agent.address, opts.network).catch(() => null)
+  const policyObjectId =
+    opts.policyObjectId ?? process.env.LYRA_POLICY_OBJECT_ID ?? vault?.policyId ?? undefined
   return {
     client: makeSuiClient(opts.network),
     keypair: opts.agent.keypair,
@@ -112,6 +118,9 @@ export function buildOnchainContext(opts: BuildOnchainOpts): OnchainRuntimeConte
     policy: policyFromEnv(resolvePolicyEnv()),
     packageId: packageId || undefined,
     policyObjectId: policyObjectId || undefined,
+    vaultId: vault?.vaultId,
+    vaultMist: vault?.vaultMist,
+    ownerAddress: vault?.owner,
     agentDir: opts.agentDir,
     brainProvider: opts.brainProvider ?? null,
     brainModel: opts.brainModel ?? null,

package/src/commands/login.test.ts

@@ -1,104 +0,0 @@
-import { afterEach, beforeEach, describe, expect, test } from 'bun:test'
-import { mkdtempSync } from 'node:fs'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-import { Ed25519Keypair } from '@mysten/sui/keypairs/ed25519'
-import { type LoginDeps, deviceLink, resolveWebBase } from './login'
-
-// Isolate the agent dir so writeAgentKey() (called on approval) doesn't touch
-// the real ~/.lyra.
-let prevRoot: string | undefined
-beforeEach(() => {
-  prevRoot = process.env.LYRA_ROOT
-  process.env.LYRA_ROOT = mkdtempSync(join(tmpdir(), 'lyra-login-'))
-})
-afterEach(() => {
-  if (prevRoot === undefined) Reflect.deleteProperty(process.env, 'LYRA_ROOT')
-  else process.env.LYRA_ROOT = prevRoot
-})
-
-/** Build a mock fetch over a scripted sequence of poll responses. */
-function mockFetch(start: unknown, polls: unknown[]): { fetchImpl: typeof fetch; calls: string[] } {
-  const calls: string[] = []
-  let pollIdx = 0
-  const fetchImpl = (async (url: string | URL | Request) => {
-    const u = String(url)
-    calls.push(u)
-    if (u.includes('/api/cli/login/start')) {
-      return new Response(JSON.stringify(start), { status: 200 })
-    }
-    if (u.includes('/api/cli/login/poll')) {
-      const body = polls[Math.min(pollIdx, polls.length - 1)]
-      pollIdx += 1
-      return new Response(JSON.stringify(body), { status: 200 })
-    }
-    return new Response('not found', { status: 404 })
-  }) as unknown as typeof fetch
-  return { fetchImpl, calls }
-}
-
-const baseDeps = (fetchImpl: typeof fetch): LoginDeps => ({
-  base: 'https://example.test',
-  fetchImpl,
-  sleep: async () => {},
-  log: () => {},
-  openBrowser: () => {},
-})
-
-describe('resolveWebBase', () => {
-  test('defaults to lyraai.space, env override wins', () => {
-    expect(resolveWebBase({})).toBe('https://lyraai.space')
-    expect(resolveWebBase({ LYRA_WEB_URL: 'http://localhost:3000' })).toBe('http://localhost:3000')
-  })
-})
-
-describe('deviceLink contract', () => {
-  test('calls start then poll, writes key on approved, returns address', async () => {
-    const kp = new Ed25519Keypair()
-    const agentKey = kp.getSecretKey()
-    const owner = `0x${'a'.repeat(64)}`
-    const { fetchImpl, calls } = mockFetch(
-      { code: 'ABCD', pollToken: 'tok-1', verifyUrl: 'https://example.test/cli', expiresInSec: 60 },
-      [{ status: 'pending' }, { status: 'approved', owner, agentKey }],
-    )
-    const res = await deviceLink(baseDeps(fetchImpl))
-    expect(res.owner).toBe(owner)
-    expect(res.address).toBe(kp.toSuiAddress())
-    // start first, then at least two polls.
-    expect(calls[0]).toContain('/api/cli/login/start')
-    expect(calls[1]).toContain('/api/cli/login/poll?pollToken=tok-1')
-    expect(calls.length).toBeGreaterThanOrEqual(3)
-  })
-
-  test('throws a friendly error on expired', async () => {
-    const { fetchImpl } = mockFetch(
-      { code: 'X', pollToken: 't', verifyUrl: 'https://example.test/cli', expiresInSec: 60 },
-      [{ status: 'expired' }],
-    )
-    await expect(deviceLink(baseDeps(fetchImpl))).rejects.toThrow(/expired/i)
-  })
-
-  test('throws on not_found', async () => {
-    const { fetchImpl } = mockFetch(
-      { code: 'X', pollToken: 't', verifyUrl: 'https://example.test/cli', expiresInSec: 60 },
-      [{ status: 'not_found' }],
-    )
-    await expect(deviceLink(baseDeps(fetchImpl))).rejects.toThrow(/not found/i)
-  })
-
-  test('times out when expiresInSec elapses without approval', async () => {
-    const { fetchImpl } = mockFetch(
-      { code: 'X', pollToken: 't', verifyUrl: 'https://example.test/cli', expiresInSec: 4 },
-      [{ status: 'pending' }],
-    )
-    // Advancing clock: each read jumps 1s, so a 4s window closes after a few
-    // polls without ever hitting the wall clock.
-    let t = 0
-    const now = (): number => {
-      t += 1000
-      return t
-    }
-    const deps: LoginDeps = { ...baseDeps(fetchImpl), now }
-    await expect(deviceLink(deps)).rejects.toThrow(/timed out/i)
-  })
-})

package/src/commands/pairing.test.ts

@@ -1,88 +0,0 @@
-import { describe, expect, it } from 'bun:test'
-import { parsePairingArgs } from './pairing'
-
-describe('parsePairingArgs', () => {
-  it('errors on no args', () => {
-    const r = parsePairingArgs([])
-    expect('error' in r).toBe(true)
-  })
-
-  it('errors on unknown subcommand', () => {
-    const r = parsePairingArgs(['quack'])
-    expect('error' in r).toBe(true)
-  })
-
-  it('parses `list`', () => {
-    const r = parsePairingArgs(['list']) as Exclude<
-      ReturnType<typeof parsePairingArgs>,
-      { error: string }
-    >
-    expect(r.sub).toBe('list')
-  })
-
-  it('parses `list telegram` with platform filter', () => {
-    const r = parsePairingArgs(['list', 'telegram']) as Exclude<
-      ReturnType<typeof parsePairingArgs>,
-      { error: string }
-    >
-    expect(r.sub).toBe('list')
-    expect(r.platform).toBe('telegram')
-  })
-
-  it('parses `approve telegram ABCDEFGH`', () => {
-    const r = parsePairingArgs(['approve', 'telegram', 'ABCDEFGH']) as Exclude<
-      ReturnType<typeof parsePairingArgs>,
-      { error: string }
-    >
-    expect(r.sub).toBe('approve')
-    expect(r.platform).toBe('telegram')
-    expect(r.code).toBe('ABCDEFGH')
-  })
-
-  it('errors on `approve` without arguments', () => {
-    const r = parsePairingArgs(['approve'])
-    expect('error' in r).toBe(true)
-  })
-
-  it('errors on `approve telegram` without code', () => {
-    const r = parsePairingArgs(['approve', 'telegram'])
-    expect('error' in r).toBe(true)
-  })
-
-  it('parses `revoke telegram 12345`', () => {
-    const r = parsePairingArgs(['revoke', 'telegram', '12345']) as Exclude<
-      ReturnType<typeof parsePairingArgs>,
-      { error: string }
-    >
-    expect(r.sub).toBe('revoke')
-    expect(r.platform).toBe('telegram')
-    expect(r.userId).toBe('12345')
-  })
-
-  it('parses `clear-pending` and `clear-pending telegram`', () => {
-    const a = parsePairingArgs(['clear-pending']) as Exclude<
-      ReturnType<typeof parsePairingArgs>,
-      { error: string }
-    >
-    expect(a.sub).toBe('clear-pending')
-    expect(a.platform).toBeUndefined()
-    const b = parsePairingArgs(['clear-pending', 'telegram']) as Exclude<
-      ReturnType<typeof parsePairingArgs>,
-      { error: string }
-    >
-    expect(b.platform).toBe('telegram')
-  })
-
-  it('extracts --yes / -y flag', () => {
-    const r = parsePairingArgs(['revoke', 'telegram', '12345', '--yes']) as Exclude<
-      ReturnType<typeof parsePairingArgs>,
-      { error: string }
-    >
-    expect(r.yes).toBe(true)
-    const s = parsePairingArgs(['clear-pending', '-y']) as Exclude<
-      ReturnType<typeof parsePairingArgs>,
-      { error: string }
-    >
-    expect(s.yes).toBe(true)
-  })
-})

package/src/commands/telegram.test.ts

@@ -1,50 +0,0 @@
-import { describe, expect, it } from 'bun:test'
-import { parseTelegramArgs } from './telegram'
-
-describe('parseTelegramArgs', () => {
-  it('errors on missing subcommand', () => {
-    const r = parseTelegramArgs([])
-    expect('error' in r).toBe(true)
-    if ('error' in r) expect(r.error).toContain('usage')
-  })
-
-  it('errors on unknown subcommand', () => {
-    const r = parseTelegramArgs(['nuke'])
-    expect('error' in r).toBe(true)
-    if ('error' in r) expect(r.error).toContain('nuke')
-  })
-
-  it('parses setup', () => {
-    const r = parseTelegramArgs(['setup'])
-    expect('error' in r).toBe(false)
-    if (!('error' in r)) expect(r.sub).toBe('setup')
-  })
-
-  it('parses status', () => {
-    const r = parseTelegramArgs(['status'])
-    if (!('error' in r)) expect(r.sub).toBe('status')
-  })
-
-  it('parses remove without --yes', () => {
-    const r = parseTelegramArgs(['remove'])
-    if (!('error' in r)) {
-      expect(r.sub).toBe('remove')
-      expect(r.yes).toBeFalsy()
-    }
-  })
-
-  it('parses remove --yes', () => {
-    const r = parseTelegramArgs(['remove', '--yes'])
-    if (!('error' in r)) {
-      expect(r.sub).toBe('remove')
-      expect(r.yes).toBe(true)
-    }
-  })
-
-  it('parses remove -y', () => {
-    const r = parseTelegramArgs(['remove', '-y'])
-    if (!('error' in r)) {
-      expect(r.yes).toBe(true)
-    }
-  })
-})

package/src/config/defaults.test.ts

@@ -1,95 +0,0 @@
-import { describe, expect, test } from 'bun:test'
-import {
-  DEFAULT_ALLOWED_COINS,
-  DEFAULT_ALLOWED_PROTOCOLS,
-  DEFAULT_AUTO_MAX_SUI,
-  DEFAULT_LLM_BASE_URL,
-  DEFAULT_LLM_MODEL,
-  DEFAULT_MAX_PER_TX_SUI,
-  DEFAULT_MAX_SLIPPAGE_BPS,
-  DEFAULT_NETWORK,
-  DEFAULT_PACKAGE_ID,
-  defaultPolicyEnv,
-  hasNoPolicyEnv,
-  resolveLlmBaseUrl,
-  resolveLlmModel,
-  resolveNetwork,
-  resolvePackageId,
-  resolvePolicyEnv,
-} from './defaults'
-
-describe('config defaults (zero-env-var)', () => {
-  test('exported constant values match the shared contract', () => {
-    expect(DEFAULT_PACKAGE_ID).toBe(
-      '0x8e984145d636037cebf5c402ac4b338567411ba6dd275948d7ff593b1ed01a04',
-    )
-    expect(DEFAULT_NETWORK).toBe('mainnet')
-    expect(DEFAULT_LLM_BASE_URL).toBe('https://api.openai.com/v1')
-    expect(DEFAULT_LLM_MODEL).toBe('gpt-4o-mini')
-    expect(DEFAULT_MAX_PER_TX_SUI).toBe(1)
-    expect(DEFAULT_AUTO_MAX_SUI).toBe(0.1)
-    expect(DEFAULT_MAX_SLIPPAGE_BPS).toBe(100)
-    expect(DEFAULT_ALLOWED_COINS).toEqual(['0x2::sui::SUI'])
-    expect(DEFAULT_ALLOWED_PROTOCOLS).toEqual([
-      'transfer',
-      'swap',
-      'stake',
-      'borrow',
-      'deepbook',
-      'scallop',
-      'navi',
-      'suilend',
-      'walrus',
-    ])
-  })
-
-  test('resolvePackageId: default when env unset, env wins when set', () => {
-    expect(resolvePackageId({})).toBe(DEFAULT_PACKAGE_ID)
-    expect(resolvePackageId({ LYRA_PACKAGE_ID: '0xabc' })).toBe('0xabc')
-    // Blank/whitespace env falls back to the default.
-    expect(resolvePackageId({ LYRA_PACKAGE_ID: '   ' })).toBe(DEFAULT_PACKAGE_ID)
-  })
-
-  test('resolveNetwork: default mainnet, env override, ignores garbage', () => {
-    expect(resolveNetwork({})).toBe('mainnet')
-    expect(resolveNetwork({ LYRA_NETWORK: 'testnet' })).toBe('testnet')
-    expect(resolveNetwork({ LYRA_NETWORK: 'devnet' })).toBe('mainnet')
-  })
-
-  test('resolveLlmBaseUrl / resolveLlmModel: default then env override', () => {
-    expect(resolveLlmBaseUrl({})).toBe(DEFAULT_LLM_BASE_URL)
-    expect(resolveLlmBaseUrl({ LYRA_LLM_BASE_URL: 'https://gw' })).toBe('https://gw')
-    expect(resolveLlmModel({})).toBe(DEFAULT_LLM_MODEL)
-    expect(resolveLlmModel({ LYRA_LLM_MODEL: 'gpt-4o' })).toBe('gpt-4o')
-  })
-
-  test('defaultPolicyEnv produces a bounded LYRA_POLICY_* record', () => {
-    const env = defaultPolicyEnv()
-    expect(env.LYRA_POLICY_MAX_PER_TX_SUI).toBe('1')
-    expect(env.LYRA_POLICY_AUTO_MAX_SUI).toBe('0.1')
-    expect(env.LYRA_POLICY_MAX_SLIPPAGE_BPS).toBe('100')
-    expect(env.LYRA_POLICY_ALLOWED_COINS).toBe('0x2::sui::SUI')
-    expect(env.LYRA_POLICY_ALLOWED_PROTOCOLS).toBe(
-      'transfer,swap,stake,borrow,deepbook,scallop,navi,suilend,walrus',
-    )
-  })
-
-  test('hasNoPolicyEnv: true with no policy vars, false when any set', () => {
-    expect(hasNoPolicyEnv({})).toBe(true)
-    expect(hasNoPolicyEnv({ OPENAI_API_KEY: 'x' })).toBe(true)
-    expect(hasNoPolicyEnv({ LYRA_POLICY_MAX_PER_TX_SUI: '5' })).toBe(false)
-  })
-
-  test('resolvePolicyEnv: seeds defaults only when no policy var is set', () => {
-    // No policy env → defaults applied.
-    const seeded = resolvePolicyEnv({})
-    expect(seeded.LYRA_POLICY_MAX_PER_TX_SUI).toBe('1')
-    expect(seeded.LYRA_POLICY_ALLOWED_PROTOCOLS).toContain('deepbook')
-
-    // Any policy env present → caller's env passed through untouched (no merge).
-    const userEnv = { LYRA_POLICY_MAX_PER_TX_SUI: '5' }
-    const passed = resolvePolicyEnv(userEnv)
-    expect(passed.LYRA_POLICY_MAX_PER_TX_SUI).toBe('5')
-    expect(passed.LYRA_POLICY_ALLOWED_PROTOCOLS).toBeUndefined()
-  })
-})

package/src/config/render.test.ts

@@ -1,96 +0,0 @@
-import { describe, expect, test } from 'bun:test'
-import type { LyraConfig } from 'lyra-core'
-import { renderConfigTs } from './render'
-
-const baseConfig: LyraConfig = {
-  identity: { operator: null, agent: null },
-  network: 'mainnet',
-  storage: { network: 'mainnet' },
-  brain: { provider: null, model: null },
-  plugins: ['system'],
-  tools: {},
-  imports: { claudeCode: true },
-}
-
-describe('renderConfigTs sandbox block', () => {
-  test('fresh config (no sandbox set) emits default + commented examples for each tier', () => {
-    const out = renderConfigTs(baseConfig)
-    // Active default
-    expect(out).toContain(`sandbox: { mode: 'none' }`)
-    // Commented OPTION 2 (os)
-    expect(out).toContain('OPTION 2: os')
-    expect(out).toContain(`//  sandbox: { mode: 'os' }`)
-    // Commented OPTION 3 (docker)
-    expect(out).toContain('OPTION 3: docker')
-    expect(out).toContain(`//    mode: 'docker'`)
-    expect(out).toContain(`//    dockerImage: 'nikolaik/python-nodejs:python3.11-nodejs20'`)
-    expect(out).toContain('//    dockerMountWorkspace: false')
-    // LYRA_SANDBOX_MODE override hint
-    expect(out).toContain('LYRA_SANDBOX_MODE')
-  })
-
-  test('config with sandbox.mode="os" already set emits the chosen value, not the template', () => {
-    const out = renderConfigTs({ ...baseConfig, sandbox: { mode: 'os' } })
-    expect(out).toContain(`"mode": "os"`)
-    // No verbose template when operator already chose
-    expect(out).not.toContain('OPTION 2: os')
-    expect(out).not.toContain('OPTION 3: docker')
-  })
-
-  test('config with sandbox.mode="docker" + image emits the full chosen object', () => {
-    const out = renderConfigTs({
-      ...baseConfig,
-      sandbox: {
-        mode: 'docker',
-        dockerImage: 'custom/img:tag',
-        dockerMountWorkspace: true,
-      },
-    })
-    expect(out).toContain(`"mode": "docker"`)
-    expect(out).toContain(`"dockerImage": "custom/img:tag"`)
-    expect(out).toContain(`"dockerMountWorkspace": true`)
-    expect(out).not.toContain('OPTION')
-  })
-
-  test('annotated template documents resource caps with hermes default values', () => {
-    const out = renderConfigTs(baseConfig)
-    expect(out).toContain('// dockerCpu: 1')
-    expect(out).toContain('// dockerMemoryMb: 5120')
-    expect(out).toContain('// dockerDiskMb: 51200')
-    expect(out).toContain('// dockerNoNetwork: true')
-  })
-
-  test('config with sandbox docker + resource caps emits chosen numeric values', () => {
-    const out = renderConfigTs({
-      ...baseConfig,
-      sandbox: {
-        mode: 'docker',
-        dockerCpu: 2,
-        dockerMemoryMb: 4096,
-        dockerNoNetwork: true,
-      },
-    })
-    expect(out).toContain(`"dockerCpu": 2`)
-    expect(out).toContain(`"dockerMemoryMb": 4096`)
-    expect(out).toContain(`"dockerNoNetwork": true`)
-    expect(out).not.toContain('OPTION')
-  })
-
-  test('output is valid TypeScript (parses as a default-export module)', async () => {
-    const out = renderConfigTs(baseConfig)
-    const { writeFile, rm, mkdtemp } = await import('node:fs/promises')
-    const { tmpdir } = await import('node:os')
-    const { join } = await import('node:path')
-    const dir = await mkdtemp(join(tmpdir(), 'lyra-render-test-'))
-    const path = join(dir, 'config.ts')
-    try {
-      await writeFile(path, out, 'utf8')
-      const mod = await import(path)
-      expect(mod.default).toBeDefined()
-      expect(mod.default.sandbox).toEqual({ mode: 'none' })
-      expect(mod.default.network).toBe('mainnet')
-    } finally {
-      await rm(dir, { recursive: true, force: true })
-    }
-  })
-})

package/src/ui/approval-summary.test.ts

@@ -1,132 +0,0 @@
-import { describe, expect, it } from 'bun:test'
-import { summarizeApprovalSubject } from './approval-summary'
-
-describe('summarizeApprovalSubject', () => {
-  it('renders chain.send native with amount + recipient', () => {
-    expect(
-      summarizeApprovalSubject({
-        kind: 'chain.send',
-        amount: '0.001',
-        recipient: '0xC635e6Eb223aE14143E23cEEa9440bC773dc87Ec',
-        token: 'SUI',
-        reason: 'SUI transfer',
-      }),
-    ).toBe('send 0.001 SUI to 0xC635…87Ec')
-  })
-
-  it('renders chain.send coin with explicit token symbol', () => {
-    expect(
-      summarizeApprovalSubject({
-        kind: 'chain.send',
-        amount: '0.5',
-        recipient: '0xC635e6Eb223aE14143E23cEEa9440bC773dc87Ec',
-        token: 'USDC',
-        reason: 'coin transfer',
-      }),
-    ).toBe('send 0.5 USDC to 0xC635…87Ec')
-  })
-
-  it('renders chain.send native fallback label when token omitted', () => {
-    expect(
-      summarizeApprovalSubject({
-        kind: 'chain.send',
-        amount: '0.001',
-        recipient: '0xC635e6Eb223aE14143E23cEEa9440bC773dc87Ec',
-        reason: 'SUI transfer',
-      }),
-    ).toBe('send 0.001 SUI to 0xC635…87Ec')
-  })
-
-  it('renders the arrow form (no recipient noise)', () => {
-    expect(
-      summarizeApprovalSubject({
-        kind: 'chain.send',
-        amount: '0.01',
-        token: 'SUI→USDC',
-        reason: 'wrap',
-      }),
-    ).toBe('0.01 SUI→USDC')
-  })
-
-  it('renders chain.swap with token-pair encoding', () => {
-    expect(
-      summarizeApprovalSubject({
-        kind: 'chain.swap',
-        amount: '0.005',
-        token: 'SUI→USDC',
-        reason: 'Cetus swap execution',
-      }),
-    ).toBe('swap 0.005 SUI→USDC')
-  })
-
-  it('renders chain.swap with empty amt + tok', () => {
-    expect(
-      summarizeApprovalSubject({
-        kind: 'chain.swap',
-        reason: 'Cetus swap execution',
-      }),
-    ).toBe('swap')
-  })
-
-  it('renders chain.write with signature + recipient + value', () => {
-    expect(
-      summarizeApprovalSubject({
-        kind: 'chain.write',
-        recipient: '0x9e71d79f06f956d4d2666b5c93dafab721c84721',
-        command: 'transfer(address,uint256)',
-        amount: '1 wei',
-        reason: 'arbitrary state-changing call',
-      }),
-    ).toBe('transfer(address,uint256) (value: 1 wei) on 0x9e71…4721')
-  })
-
-  it('renders chain.write with no recipient (Aave command) without a trailing "on"', () => {
-    expect(
-      summarizeApprovalSubject({
-        kind: 'chain.write',
-        command: 'aave.borrow 100 USDC',
-        reason: 'borrow from Aave V3 (leverage)',
-      }),
-    ).toBe('aave.borrow 100 USDC')
-  })
-
-  it('renders chain.write with no value', () => {
-    expect(
-      summarizeApprovalSubject({
-        kind: 'chain.write',
-        recipient: '0x9e71d79f06f956d4d2666b5c93dafab721c84721',
-        command: 'totalSupply()',
-        reason: 'arbitrary state-changing call',
-      }),
-    ).toBe('totalSupply() on 0x9e71…4721')
-  })
-
-  it('falls back to command for shell.run', () => {
-    expect(
-      summarizeApprovalSubject({
-        kind: 'shell.run',
-        command: 'rm -rf /tmp/foo',
-        reason: 'shell command execution',
-      }),
-    ).toBe('rm -rf /tmp/foo')
-  })
-
-  it('falls back to path for fs.write', () => {
-    expect(
-      summarizeApprovalSubject({
-        kind: 'fs.write',
-        path: '/tmp/x.txt',
-        reason: 'fs.write request',
-      }),
-    ).toBe('/tmp/x.txt')
-  })
-
-  it('falls back to (unspecified) when nothing usable', () => {
-    expect(
-      summarizeApprovalSubject({
-        kind: 'fs.patch',
-        reason: 'fs.patch request',
-      }),
-    ).toBe('(unspecified)')
-  })
-})