@swarmclawai/swarmclaw 1.2.8 → 1.2.9

package/src/lib/wallet/wallet.test.ts

@@ -1,333 +0,0 @@
-import { describe, it } from 'node:test'
-import assert from 'node:assert/strict'
-import {
-  normalizeWalletChainInput,
-  getWalletChainOrDefault,
-  normalizeAtomicString,
-  parseDisplayAmountToAtomic,
-  formatAtomicAmount,
-  formatWalletAmount,
-  getWalletChainMeta,
-  getWalletDefaultLimitAtomic,
-  getWalletExplorerUrl,
-  getWalletAssetSymbol,
-  getWalletAtomicAmount,
-  getWalletFeeAtomicAmount,
-  getWalletLimitAtomic,
-  getWalletBalanceAtomic,
-} from '@/lib/wallet/wallet'
-
-describe('normalizeWalletChainInput', () => {
-  it('normalizes solana variants', () => {
-    assert.equal(normalizeWalletChainInput('solana'), 'solana')
-    assert.equal(normalizeWalletChainInput('Solana'), 'solana')
-    assert.equal(normalizeWalletChainInput('SOL'), 'solana')
-    assert.equal(normalizeWalletChainInput('sol'), 'solana')
-    assert.equal(normalizeWalletChainInput('  sol  '), 'solana')
-  })
-
-  it('normalizes ethereum variants', () => {
-    assert.equal(normalizeWalletChainInput('ethereum'), 'ethereum')
-    assert.equal(normalizeWalletChainInput('Ethereum'), 'ethereum')
-    assert.equal(normalizeWalletChainInput('ETH'), 'ethereum')
-    assert.equal(normalizeWalletChainInput('eth'), 'ethereum')
-    assert.equal(normalizeWalletChainInput('evm'), 'ethereum')
-    assert.equal(normalizeWalletChainInput('EVM'), 'ethereum')
-  })
-
-  it('returns null for unsupported or empty input', () => {
-    assert.equal(normalizeWalletChainInput('bitcoin'), null)
-    assert.equal(normalizeWalletChainInput(''), null)
-    assert.equal(normalizeWalletChainInput(null), null)
-    assert.equal(normalizeWalletChainInput(undefined), null)
-    assert.equal(normalizeWalletChainInput(0), null)
-    assert.equal(normalizeWalletChainInput(false), null)
-  })
-})
-
-describe('getWalletChainOrDefault', () => {
-  it('returns recognized chain', () => {
-    assert.equal(getWalletChainOrDefault('sol'), 'solana')
-    assert.equal(getWalletChainOrDefault('eth'), 'ethereum')
-  })
-
-  it('returns fallback for empty/null/undefined', () => {
-    assert.equal(getWalletChainOrDefault(''), 'solana')
-    assert.equal(getWalletChainOrDefault(null), 'solana')
-    assert.equal(getWalletChainOrDefault(undefined), 'solana')
-    assert.equal(getWalletChainOrDefault(undefined, 'ethereum'), 'ethereum')
-  })
-
-  it('throws for unrecognized non-empty value', () => {
-    assert.throws(() => getWalletChainOrDefault('bitcoin'), /Unsupported wallet chain/)
-    assert.throws(() => getWalletChainOrDefault('base'), /Unsupported wallet chain or provider: base/)
-    assert.throws(() => getWalletChainOrDefault('ethereun'), /Unsupported wallet chain or provider: ethereun/)
-  })
-})
-
-describe('normalizeAtomicString', () => {
-  it('handles string integers', () => {
-    assert.equal(normalizeAtomicString('12345'), '12345')
-    assert.equal(normalizeAtomicString('0'), '0')
-    assert.equal(normalizeAtomicString('007'), '7')
-    assert.equal(normalizeAtomicString('0000'), '0')
-  })
-
-  it('handles bigint', () => {
-    assert.equal(normalizeAtomicString(BigInt(999)), '999')
-    assert.equal(normalizeAtomicString(BigInt(0)), '0')
-    assert.equal(normalizeAtomicString(BigInt(-5)), '0')
-    assert.equal(normalizeAtomicString(BigInt(-1), 'fallback'), 'fallback')
-  })
-
-  it('handles number', () => {
-    assert.equal(normalizeAtomicString(100), '100')
-    assert.equal(normalizeAtomicString(3.9), '3')
-    assert.equal(normalizeAtomicString(0), '0')
-  })
-
-  it('returns fallback for invalid input', () => {
-    assert.equal(normalizeAtomicString('abc'), '0')
-    assert.equal(normalizeAtomicString('12.5'), '0')
-    assert.equal(normalizeAtomicString(-1), '0')
-    assert.equal(normalizeAtomicString(NaN), '0')
-    assert.equal(normalizeAtomicString(Infinity), '0')
-    assert.equal(normalizeAtomicString(null), '0')
-    assert.equal(normalizeAtomicString(undefined), '0')
-    assert.equal(normalizeAtomicString('  '), '0')
-    assert.equal(normalizeAtomicString(null, 'custom'), 'custom')
-  })
-
-  it('strips leading zeros from strings', () => {
-    assert.equal(normalizeAtomicString('00100'), '100')
-    assert.equal(normalizeAtomicString('00'), '0')
-  })
-})
-
-describe('parseDisplayAmountToAtomic', () => {
-  it('converts whole numbers (SOL, 9 decimals)', () => {
-    assert.equal(parseDisplayAmountToAtomic('1', 9), '1000000000')
-    assert.equal(parseDisplayAmountToAtomic('0', 9), '0')
-    assert.equal(parseDisplayAmountToAtomic('100', 9), '100000000000')
-  })
-
-  it('converts fractional numbers (SOL)', () => {
-    assert.equal(parseDisplayAmountToAtomic('0.1', 9), '100000000')
-    assert.equal(parseDisplayAmountToAtomic('1.5', 9), '1500000000')
-    assert.equal(parseDisplayAmountToAtomic('0.000000001', 9), '1')
-  })
-
-  it('converts with ETH decimals (18)', () => {
-    assert.equal(parseDisplayAmountToAtomic('1', 18), '1000000000000000000')
-    assert.equal(parseDisplayAmountToAtomic('0.01', 18), '10000000000000000')
-    assert.equal(parseDisplayAmountToAtomic('0.000000000000000001', 18), '1')
-  })
-
-  it('accepts number input', () => {
-    assert.equal(parseDisplayAmountToAtomic(1.5, 9), '1500000000')
-    assert.equal(parseDisplayAmountToAtomic(0, 9), '0')
-    assert.equal(parseDisplayAmountToAtomic(0.000000000000000001, 18), '1')
-  })
-
-  it('throws for empty amount', () => {
-    assert.throws(() => parseDisplayAmountToAtomic('', 9), /Amount is required/)
-  })
-
-  it('throws for non-numeric strings', () => {
-    assert.throws(() => parseDisplayAmountToAtomic('abc', 9), /Amount must be a positive decimal/)
-    assert.throws(() => parseDisplayAmountToAtomic('-1', 9), /Amount must be a positive decimal/)
-  })
-
-  it('throws for too many decimal places', () => {
-    assert.throws(() => parseDisplayAmountToAtomic('1.0000000001', 9), /up to 9 decimal places/)
-  })
-})
-
-describe('formatAtomicAmount', () => {
-  it('formats SOL (9 decimals)', () => {
-    assert.equal(formatAtomicAmount('1000000000', 9), '1')
-    assert.equal(formatAtomicAmount('1500000000', 9), '1.5')
-    assert.equal(formatAtomicAmount('100000000', 9), '0.1')
-    assert.equal(formatAtomicAmount('1', 9), '0.000000001')
-    assert.equal(formatAtomicAmount('0', 9), '0')
-  })
-
-  it('formats ETH (18 decimals)', () => {
-    assert.equal(formatAtomicAmount('1000000000000000000', 18), '1')
-    assert.equal(formatAtomicAmount('10000000000000000', 18), '0.01')
-  })
-
-  it('respects minFractionDigits', () => {
-    assert.equal(formatAtomicAmount('1000000000', 9, { minFractionDigits: 2 }), '1.00')
-    assert.equal(formatAtomicAmount('1500000000', 9, { minFractionDigits: 4 }), '1.5000')
-  })
-
-  it('respects maxFractionDigits', () => {
-    assert.equal(formatAtomicAmount('1', 9, { maxFractionDigits: 2 }), '0')
-    assert.equal(formatAtomicAmount('1000000000', 9, { maxFractionDigits: 0 }), '1')
-  })
-
-  it('handles bigint input', () => {
-    assert.equal(formatAtomicAmount(BigInt('1000000000'), 9), '1')
-  })
-
-  it('handles number input', () => {
-    assert.equal(formatAtomicAmount(1000000000, 9), '1')
-  })
-})
-
-describe('formatWalletAmount', () => {
-  it('uses chain-specific decimals', () => {
-    assert.equal(formatWalletAmount('solana', '1000000000'), '1')
-    assert.equal(formatWalletAmount('ethereum', '1000000000000000000'), '1')
-  })
-})
-
-describe('getWalletChainMeta', () => {
-  it('returns solana metadata', () => {
-    const meta = getWalletChainMeta('solana')
-    assert.equal(meta.symbol, 'SOL')
-    assert.equal(meta.decimals, 9)
-    assert.equal(meta.chain, 'solana')
-  })
-
-  it('returns ethereum metadata', () => {
-    const meta = getWalletChainMeta('ethereum')
-    assert.equal(meta.symbol, 'ETH')
-    assert.equal(meta.decimals, 18)
-  })
-
-  it('falls back to solana for unknown chain', () => {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const meta = getWalletChainMeta('unknown' as any)
-    assert.equal(meta.chain, 'solana')
-  })
-})
-
-describe('getWalletDefaultLimitAtomic', () => {
-  it('returns perTx and daily defaults', () => {
-    assert.equal(getWalletDefaultLimitAtomic('solana', 'perTx'), '100000000')
-    assert.equal(getWalletDefaultLimitAtomic('solana', 'daily'), '1000000000')
-    assert.equal(getWalletDefaultLimitAtomic('ethereum', 'perTx'), '10000000000000000')
-    assert.equal(getWalletDefaultLimitAtomic('ethereum', 'daily'), '50000000000000000')
-  })
-})
-
-describe('getWalletExplorerUrl', () => {
-  it('builds address explorer URLs', () => {
-    assert.equal(
-      getWalletExplorerUrl('solana', 'address', 'abc123'),
-      'https://solscan.io/account/abc123',
-    )
-    assert.equal(
-      getWalletExplorerUrl('ethereum', 'address', '0xdef'),
-      'https://etherscan.io/address/0xdef',
-    )
-  })
-
-  it('builds transaction explorer URLs', () => {
-    assert.equal(
-      getWalletExplorerUrl('solana', 'transaction', 'tx1'),
-      'https://solscan.io/tx/tx1',
-    )
-    assert.equal(
-      getWalletExplorerUrl('ethereum', 'transaction', '0xtx'),
-      'https://etherscan.io/tx/0xtx',
-    )
-  })
-})
-
-describe('getWalletAssetSymbol', () => {
-  it('returns chain symbols', () => {
-    assert.equal(getWalletAssetSymbol('solana'), 'SOL')
-    assert.equal(getWalletAssetSymbol('ethereum'), 'ETH')
-  })
-})
-
-describe('getWalletAtomicAmount', () => {
-  it('prefers amountAtomic', () => {
-    assert.equal(getWalletAtomicAmount({ amountAtomic: '500' }), '500')
-  })
-
-  it('falls back to amountLamports', () => {
-    assert.equal(getWalletAtomicAmount({ amountLamports: 300 }), '300')
-  })
-
-  it('returns 0 for null/undefined', () => {
-    assert.equal(getWalletAtomicAmount(null), '0')
-    assert.equal(getWalletAtomicAmount(undefined), '0')
-  })
-
-  it('returns 0 for empty object', () => {
-    assert.equal(getWalletAtomicAmount({}), '0')
-  })
-})
-
-describe('getWalletFeeAtomicAmount', () => {
-  it('prefers feeAtomic', () => {
-    assert.equal(getWalletFeeAtomicAmount({ feeAtomic: '5000' }), '5000')
-  })
-
-  it('falls back to feeLamports', () => {
-    assert.equal(getWalletFeeAtomicAmount({ feeLamports: 5000 }), '5000')
-  })
-
-  it('returns 0 for null/undefined', () => {
-    assert.equal(getWalletFeeAtomicAmount(null), '0')
-    assert.equal(getWalletFeeAtomicAmount(undefined), '0')
-  })
-})
-
-describe('getWalletLimitAtomic', () => {
-  it('uses spendingLimitAtomic for perTx', () => {
-    assert.equal(
-      getWalletLimitAtomic({ chain: 'solana', spendingLimitAtomic: '50000' }, 'perTx'),
-      '50000',
-    )
-  })
-
-  it('falls back to spendingLimitLamports then default for perTx', () => {
-    assert.equal(
-      getWalletLimitAtomic({ chain: 'solana', spendingLimitLamports: 25000 }, 'perTx'),
-      '25000',
-    )
-    assert.equal(
-      getWalletLimitAtomic({ chain: 'solana' }, 'perTx'),
-      '100000000',
-    )
-  })
-
-  it('uses dailyLimitAtomic for daily', () => {
-    assert.equal(
-      getWalletLimitAtomic({ chain: 'ethereum', dailyLimitAtomic: '99999' }, 'daily'),
-      '99999',
-    )
-  })
-
-  it('falls back for daily', () => {
-    assert.equal(
-      getWalletLimitAtomic({ chain: 'ethereum' }, 'daily'),
-      '50000000000000000',
-    )
-  })
-})
-
-describe('getWalletBalanceAtomic', () => {
-  it('prefers balanceAtomic', () => {
-    assert.equal(getWalletBalanceAtomic({ balanceAtomic: '12345' }), '12345')
-  })
-
-  it('falls back to balanceLamports', () => {
-    assert.equal(getWalletBalanceAtomic({ balanceLamports: 9999 }), '9999')
-  })
-
-  it('returns 0 for null/undefined/empty', () => {
-    assert.equal(getWalletBalanceAtomic(null), '0')
-    assert.equal(getWalletBalanceAtomic(undefined), '0')
-    assert.equal(getWalletBalanceAtomic({}), '0')
-  })
-
-  it('handles null balanceLamports', () => {
-    assert.equal(getWalletBalanceAtomic({ balanceLamports: null }), '0')
-  })
-})

package/src/lib/wallet/wallet.ts

@@ -1,183 +0,0 @@
-import type { WalletChain } from '@/types'
-
-export const SUPPORTED_WALLET_CHAINS = ['solana', 'ethereum'] as const
-
-export interface WalletChainMeta {
-  chain: WalletChain
-  label: string
-  symbol: string
-  decimals: number
-  defaultPerTxAtomic: string
-  defaultDailyAtomic: string
-  addressExplorerBaseUrl: string
-  transactionExplorerBaseUrl: string
-  createDescription: string
-  fundingInstructions: string[]
-}
-
-const WALLET_CHAIN_META: Record<WalletChain, WalletChainMeta> = {
-  solana: {
-    chain: 'solana',
-    label: 'Solana',
-    symbol: 'SOL',
-    decimals: 9,
-    defaultPerTxAtomic: '100000000',
-    defaultDailyAtomic: '1000000000',
-    addressExplorerBaseUrl: 'https://solscan.io/account/',
-    transactionExplorerBaseUrl: 'https://solscan.io/tx/',
-    createDescription: 'Create a Solana wallet for agents that need SOL-native transfers and Solana ecosystem access.',
-    fundingInstructions: [
-      'Send SOL to this wallet address from any Solana wallet or exchange.',
-      'Make sure you are sending real SOL on Solana mainnet.',
-    ],
-  },
-  ethereum: {
-    chain: 'ethereum',
-    label: 'Ethereum',
-    symbol: 'ETH',
-    decimals: 18,
-    defaultPerTxAtomic: '10000000000000000',
-    defaultDailyAtomic: '50000000000000000',
-    addressExplorerBaseUrl: 'https://etherscan.io/address/',
-    transactionExplorerBaseUrl: 'https://etherscan.io/tx/',
-    createDescription: 'Create an Ethereum-compatible EVM wallet for ETH-native transfers, exchange auth, and EVM ecosystem access.',
-    fundingInstructions: [
-      'Send ETH to this wallet address from any Ethereum-compatible wallet or exchange.',
-      'Make sure the sending network matches the wallet network you intend to use before transferring funds.',
-    ],
-  },
-}
-
-export function getWalletChainMeta(chain: WalletChain): WalletChainMeta {
-  return WALLET_CHAIN_META[chain] || WALLET_CHAIN_META.solana
-}
-
-export function normalizeWalletChainInput(value: unknown): WalletChain | null {
-  const normalized = String(value || '').trim().toLowerCase()
-  if (!normalized) return null
-  if (normalized === 'sol' || normalized === 'solana') return 'solana'
-  if (normalized === 'eth' || normalized === 'ethereum' || normalized === 'evm') {
-    return 'ethereum'
-  }
-  return null
-}
-
-export function getWalletChainOrDefault(value: unknown, fallback: WalletChain = 'solana'): WalletChain {
-  const normalized = normalizeWalletChainInput(value)
-  if (normalized) return normalized
-  const raw = String(value ?? '').trim()
-  if (raw) {
-    throw new Error(`Unsupported wallet chain or provider: ${raw}`)
-  }
-  return fallback
-}
-
-export function getWalletDefaultLimitAtomic(chain: WalletChain, limit: 'perTx' | 'daily'): string {
-  const meta = getWalletChainMeta(chain)
-  return limit === 'perTx' ? meta.defaultPerTxAtomic : meta.defaultDailyAtomic
-}
-
-export function normalizeAtomicString(value: unknown, fallback = '0'): string {
-  if (typeof value === 'bigint') return value >= BigInt(0) ? value.toString() : fallback
-  if (typeof value === 'number' && Number.isFinite(value) && value >= 0) return Math.floor(value).toString()
-  if (typeof value === 'string') {
-    const trimmed = value.trim()
-    if (/^\d+$/.test(trimmed)) return trimmed.replace(/^0+(?=\d)/, '') || '0'
-  }
-  return fallback
-}
-
-export function parseDisplayAmountToAtomic(value: string | number, decimals: number): string {
-  const raw = typeof value === 'number'
-    ? value.toLocaleString('en-US', {
-      useGrouping: false,
-      maximumFractionDigits: decimals,
-    }).trim()
-    : String(value ?? '').trim()
-  if (!raw) throw new Error('Amount is required')
-  if (!/^\d+(\.\d+)?$/.test(raw)) throw new Error('Amount must be a positive decimal number')
-
-  const [whole, fraction = ''] = raw.split('.')
-  if (fraction.length > decimals) {
-    throw new Error(`Amount supports up to ${decimals} decimal places`)
-  }
-
-  const wholePart = BigInt(whole || '0')
-  const fractionPadded = `${fraction}${'0'.repeat(decimals)}`.slice(0, decimals)
-  const fractionPart = BigInt(fractionPadded || '0')
-  const scale = BigInt(10) ** BigInt(decimals)
-  return ((wholePart * scale) + fractionPart).toString()
-}
-
-export function formatAtomicAmount(
-  atomicValue: string | number | bigint,
-  decimals: number,
-  opts?: { minFractionDigits?: number; maxFractionDigits?: number }
-): string {
-  const atomic = BigInt(normalizeAtomicString(atomicValue, '0'))
-  const scale = BigInt(10) ** BigInt(decimals)
-  const whole = atomic / scale
-  const fraction = atomic % scale
-  const maxFractionDigits = Math.max(0, Math.min(decimals, opts?.maxFractionDigits ?? decimals))
-  const minFractionDigits = Math.max(0, Math.min(maxFractionDigits, opts?.minFractionDigits ?? 0))
-
-  if (maxFractionDigits === 0) return whole.toString()
-
-  let fractionText = fraction.toString().padStart(decimals, '0').slice(0, maxFractionDigits)
-  if (fractionText.length < minFractionDigits) fractionText = fractionText.padEnd(minFractionDigits, '0')
-  if (fractionText.length > minFractionDigits) fractionText = fractionText.replace(/0+$/, '')
-  if (fractionText.length < minFractionDigits) fractionText = fractionText.padEnd(minFractionDigits, '0')
-
-  return fractionText.length > 0 ? `${whole.toString()}.${fractionText}` : whole.toString()
-}
-
-export function formatWalletAmount(
-  chain: WalletChain,
-  atomicValue: string | number | bigint,
-  opts?: { minFractionDigits?: number; maxFractionDigits?: number }
-): string {
-  return formatAtomicAmount(atomicValue, getWalletChainMeta(chain).decimals, opts)
-}
-
-export function getWalletExplorerUrl(chain: WalletChain, kind: 'address' | 'transaction', value: string): string {
-  const meta = getWalletChainMeta(chain)
-  const base = kind === 'address' ? meta.addressExplorerBaseUrl : meta.transactionExplorerBaseUrl
-  return `${base}${value}`
-}
-
-export function getWalletAssetSymbol(chain: WalletChain): string {
-  return getWalletChainMeta(chain).symbol
-}
-
-export function getWalletAtomicAmount(value: { amountAtomic?: string; amountLamports?: number } | null | undefined): string {
-  if (!value) return '0'
-  return normalizeAtomicString(value.amountAtomic, normalizeAtomicString(value.amountLamports, '0'))
-}
-
-export function getWalletFeeAtomicAmount(value: { feeAtomic?: string; feeLamports?: number } | null | undefined): string {
-  if (!value) return '0'
-  return normalizeAtomicString(value.feeAtomic, normalizeAtomicString(value.feeLamports, '0'))
-}
-
-export function getWalletLimitAtomic(
-  wallet: { chain: WalletChain; spendingLimitAtomic?: string; spendingLimitLamports?: number; dailyLimitAtomic?: string; dailyLimitLamports?: number },
-  limit: 'perTx' | 'daily',
-): string {
-  if (limit === 'perTx') {
-    return normalizeAtomicString(
-      wallet.spendingLimitAtomic,
-      normalizeAtomicString(wallet.spendingLimitLamports, getWalletDefaultLimitAtomic(wallet.chain, 'perTx')),
-    )
-  }
-  return normalizeAtomicString(
-    wallet.dailyLimitAtomic,
-    normalizeAtomicString(wallet.dailyLimitLamports, getWalletDefaultLimitAtomic(wallet.chain, 'daily')),
-  )
-}
-
-export function getWalletBalanceAtomic(
-  wallet: { balanceAtomic?: string; balanceLamports?: number | null } | null | undefined,
-): string {
-  if (!wallet) return '0'
-  return normalizeAtomicString(wallet.balanceAtomic, normalizeAtomicString(wallet.balanceLamports, '0'))
-}

package/src/types/mission.ts

@@ -1,185 +0,0 @@
-export type MissionSource =
-  | 'chat'
-  | 'connector'
-  | 'heartbeat'
-  | 'main-loop-followup'
-  | 'task'
-  | 'schedule'
-  | 'delegation'
-  | 'manual'
-
-export type MissionStatus = 'active' | 'waiting' | 'completed' | 'failed' | 'cancelled'
-export type MissionPhase = 'intake' | 'planning' | 'dispatching' | 'executing' | 'verifying' | 'waiting' | 'completed' | 'failed'
-export type MissionWaitKind =
-  | 'human_reply'
-  | 'approval'
-  | 'external_dependency'
-  | 'provider'
-  | 'blocked_task'
-  | 'blocked_mission'
-  | 'scheduled'
-  | 'other'
-
-export type MissionPlannerDecision =
-  | 'dispatch_task'
-  | 'dispatch_session_turn'
-  | 'spawn_child_mission'
-  | 'wait'
-  | 'verify_now'
-  | 'complete_candidate'
-  | 'replan'
-  | 'fail_terminal'
-  | 'cancel'
-
-export type MissionVerificationVerdict =
-  | 'continue'
-  | 'waiting'
-  | 'completed'
-  | 'failed'
-  | 'replan'
-
-export type MissionSourceRef =
-  | { kind: 'chat'; sessionId: string; messageId?: string | null }
-  | { kind: 'connector'; sessionId: string; connectorId: string; channelId: string; threadId?: string | null }
-  | { kind: 'schedule'; scheduleId: string; recurring: boolean }
-  | { kind: 'task'; taskId: string }
-  | { kind: 'delegation'; parentMissionId: string; backend?: 'agent' | 'codex' | 'claude' | 'opencode' | 'gemini' | null }
-  | { kind: 'heartbeat'; sessionId: string }
-  | { kind: 'manual' }
-
-export interface MissionWaitState {
-  kind: MissionWaitKind
-  reason: string
-  approvalId?: string | null
-  untilAt?: number | null
-  dependencyTaskId?: string | null
-  dependencyMissionId?: string | null
-  providerKey?: string | null
-}
-
-export interface MissionControllerState {
-  leaseId?: string | null
-  leaseExpiresAt?: number | null
-  tickRequestedAt?: number | null
-  tickReason?: string | null
-  plannerRunId?: string | null
-  verifierRunId?: string | null
-  activeRunId?: string | null
-  currentTaskId?: string | null
-  currentChildMissionId?: string | null
-  pendingWakeId?: string | null
-  attemptCount?: number
-  lastEvidenceAt?: number | null
-}
-
-export interface MissionPlannerState {
-  lastDecision?: MissionPlannerDecision | null
-  lastPlannedAt?: number | null
-  planSummary?: string | null
-}
-
-export interface MissionVerificationState {
-  candidate: boolean
-  requiredTaskIds?: string[]
-  requiredChildMissionIds?: string[]
-  requiredArtifacts?: string[]
-  evidenceSummary?: string | null
-  lastVerdict?: MissionVerificationVerdict | null
-  lastVerifiedAt?: number | null
-}
-
-export interface MissionSummary {
-  id: string
-  objective: string
-  status: MissionStatus
-  phase: MissionPhase
-  source: MissionSource
-  currentStep?: string | null
-  waitingReason?: string | null
-  sessionId?: string | null
-  agentId?: string | null
-  projectId?: string | null
-  parentMissionId?: string | null
-  rootMissionId?: string | null
-  taskIds?: string[]
-  openTaskCount?: number
-  completedTaskCount?: number
-  childCount?: number
-  sourceRef?: MissionSourceRef
-  updatedAt: number
-}
-
-export interface Mission {
-  id: string
-  source: MissionSource
-  sourceRef?: MissionSourceRef
-  objective: string
-  successCriteria?: string[]
-  status: MissionStatus
-  phase: MissionPhase
-  sessionId?: string | null
-  agentId?: string | null
-  projectId?: string | null
-  rootMissionId?: string | null
-  parentMissionId?: string | null
-  childMissionIds?: string[]
-  dependencyMissionIds?: string[]
-  dependencyTaskIds?: string[]
-  taskIds?: string[]
-  rootTaskId?: string | null
-  currentStep?: string | null
-  plannerSummary?: string | null
-  verifierSummary?: string | null
-  blockerSummary?: string | null
-  waitState?: MissionWaitState | null
-  controllerState?: MissionControllerState
-  plannerState?: MissionPlannerState
-  verificationState?: MissionVerificationState
-  lastRunId?: string | null
-  sourceRunId?: string | null
-  sourceMessage?: string | null
-  createdAt: number
-  updatedAt: number
-  lastActiveAt?: number | null
-  completedAt?: number | null
-  failedAt?: number | null
-  cancelledAt?: number | null
-}
-
-export type MissionEventType =
-  | 'created'
-  | 'source_triggered'
-  | 'attached'
-  | 'planner_decision'
-  | 'dispatch_started'
-  | 'task_linked'
-  | 'task_started'
-  | 'task_completed'
-  | 'task_failed'
-  | 'child_created'
-  | 'child_completed'
-  | 'child_failed'
-  | 'run_result'
-  | 'verifier_decision'
-  | 'waiting'
-  | 'resumed'
-  | 'replanned'
-  | 'completed'
-  | 'failed'
-  | 'cancelled'
-  | 'interrupted'
-  | 'operator_action'
-  | 'status_change'
-
-export interface MissionEvent {
-  id: string
-  missionId: string
-  type: MissionEventType
-  source: MissionSource | 'system'
-  summary: string
-  data?: Record<string, unknown> | null
-  sessionId?: string | null
-  taskId?: string | null
-  runId?: string | null
-  createdAt: number
-}