@astranova-live/cli 0.1.0

package/dist/astra.js

@@ -0,0 +1,4085 @@
+#!/usr/bin/env node
+
+// src/bin/astra.ts
+import process2 from "process";
+import React5 from "react";
+import { render } from "ink";
+import { execFileSync } from "child_process";
+
+// src/config/store.ts
+import fs2 from "fs";
+import path2 from "path";
+import crypto from "crypto";
+
+// src/config/paths.ts
+import path from "path";
+import os from "os";
+import fs from "fs";
+var _defaultRoot = path.join(os.homedir(), ".config", "astranova");
+function _root() {
+  return process.env.ASTRA_TEST_DIR ?? _defaultRoot;
+}
+function getRoot() {
+  return _root();
+}
+var AGENTS_DIR = path.join(_defaultRoot, "agents");
+var CACHE_DIR = path.join(_defaultRoot, ".cache");
+function configPath() {
+  return path.join(_root(), "config.json");
+}
+function activeAgentPath() {
+  return path.join(_root(), "active_agent");
+}
+function statePath() {
+  return path.join(_root(), "state.json");
+}
+function agentDir(agentName) {
+  return path.join(_root(), "agents", agentName);
+}
+function credentialsPath(agentName) {
+  return path.join(agentDir(agentName), "credentials.json");
+}
+function walletPath(agentName) {
+  return path.join(agentDir(agentName), "wallet.json");
+}
+function auditLogPath() {
+  return path.join(_root(), "audit.log");
+}
+function sessionsDir(agentName) {
+  return path.join(agentDir(agentName), "sessions");
+}
+function memoryPath(agentName) {
+  return path.join(agentDir(agentName), "memory.md");
+}
+function pendingClaimPath(agentName) {
+  return path.join(agentDir(agentName), "pending_claim.json");
+}
+function cachePath(fileName) {
+  return path.join(_root(), ".cache", fileName);
+}
+function ensureDir(dirPath) {
+  if (!fs.existsSync(dirPath)) {
+    fs.mkdirSync(dirPath, { recursive: true });
+  }
+  const root = _root();
+  if (dirPath === root || dirPath.startsWith(path.join(root, "agents"))) {
+    fs.chmodSync(dirPath, 448);
+  }
+}
+function ensureBaseStructure() {
+  const root = _root();
+  ensureDir(root);
+  ensureDir(path.join(root, "agents"));
+  ensureDir(path.join(root, ".cache"));
+}
+
+// src/config/schema.ts
+import { z } from "zod";
+var ConfigSchema = z.object({
+  version: z.number().default(1),
+  provider: z.enum(["claude", "openai", "google", "openai-oauth", "ollama"]),
+  model: z.string(),
+  auth: z.object({
+    type: z.enum(["api-key", "oauth"]),
+    apiKey: z.string().optional(),
+    oauth: z.object({
+      accessToken: z.string(),
+      refreshToken: z.string(),
+      expiresAt: z.number(),
+      email: z.string().optional(),
+      accountId: z.string().optional(),
+      clientId: z.string().optional()
+    }).optional()
+  }),
+  apiBase: z.string().default("https://agents.astranova.live"),
+  preferences: z.object({
+    theme: z.enum(["dark", "light"]).default("dark")
+  }).default({})
+});
+var CredentialsSchema = z.object({
+  agent_name: z.string(),
+  api_key: z.string(),
+  api_base: z.string().default("https://agents.astranova.live")
+});
+var WalletSchema = z.object({
+  publicKey: z.string(),
+  secretKey: z.array(z.number()).length(64)
+});
+var RegisterResponseSchema = z.object({
+  success: z.boolean(),
+  agent: z.object({
+    id: z.string(),
+    name: z.string(),
+    displayName: z.string().nullable(),
+    role: z.string(),
+    status: z.string(),
+    simBalance: z.number()
+  }),
+  api_key: z.string(),
+  verification_code: z.string()
+});
+var AgentStateSchema = z.object({
+  status: z.string().default("unknown"),
+  journeyStage: z.enum(["fresh", "pending", "verified", "trading", "wallet_ready", "full"]).default("fresh"),
+  createdAt: z.string().default(() => (/* @__PURE__ */ new Date()).toISOString()),
+  verificationCode: z.string().optional()
+});
+var StateSchema = z.object({
+  activeAgent: z.string(),
+  agents: z.record(z.string(), AgentStateSchema).default({})
+});
+var AgentNameSchema = z.string().min(2, "Agent name must be at least 2 characters").max(32, "Agent name must be at most 32 characters").regex(
+  /^[a-z0-9_-]+$/,
+  "Agent name must be lowercase letters, numbers, hyphens, or underscores"
+);
+
+// src/config/store.ts
+function writeFileSecure(filePath, data) {
+  const dir = path2.dirname(filePath);
+  ensureDir(dir);
+  const tmpPath = path2.join(dir, `.tmp-${crypto.randomBytes(6).toString("hex")}`);
+  fs2.writeFileSync(tmpPath, data, { encoding: "utf-8", mode: 384 });
+  fs2.renameSync(tmpPath, filePath);
+}
+function readJsonFile(filePath, schema) {
+  if (!fs2.existsSync(filePath)) {
+    return null;
+  }
+  const raw = fs2.readFileSync(filePath, "utf-8");
+  const parsed = JSON.parse(raw);
+  return schema.parse(parsed);
+}
+function isConfigured() {
+  return fs2.existsSync(configPath());
+}
+function loadConfig() {
+  return readJsonFile(configPath(), ConfigSchema);
+}
+function saveConfig(config) {
+  ensureBaseStructure();
+  writeFileSecure(configPath(), JSON.stringify(config, null, 2));
+}
+function loadState() {
+  return readJsonFile(statePath(), StateSchema);
+}
+function saveState(state) {
+  ensureBaseStructure();
+  writeFileSecure(statePath(), JSON.stringify(state, null, 2));
+}
+function updateAgentState(agentName, updates) {
+  const state = loadState();
+  if (!state) return;
+  const existing = state.agents[agentName] ?? {
+    status: "unknown",
+    journeyStage: "fresh",
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  state.agents[agentName] = { ...existing, ...updates };
+  saveState(state);
+}
+function getActiveAgent() {
+  const state = loadState();
+  if (state?.activeAgent) return state.activeAgent;
+  const filePath = activeAgentPath();
+  if (!fs2.existsSync(filePath)) {
+    return null;
+  }
+  const name = fs2.readFileSync(filePath, "utf-8").trim();
+  return name || null;
+}
+function setActiveAgent(agentName) {
+  ensureBaseStructure();
+  writeFileSecure(activeAgentPath(), agentName);
+  const state = loadState() ?? { activeAgent: agentName, agents: {} };
+  state.activeAgent = agentName;
+  if (!state.agents[agentName]) {
+    state.agents[agentName] = {
+      status: "unknown",
+      journeyStage: "fresh",
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  saveState(state);
+}
+function loadCredentials(agentName) {
+  return readJsonFile(credentialsPath(agentName), CredentialsSchema);
+}
+function saveCredentials(agentName, credentials) {
+  ensureDir(agentDir(agentName));
+  writeFileSecure(credentialsPath(agentName), JSON.stringify(credentials, null, 2));
+}
+function loadWallet(agentName) {
+  return readJsonFile(walletPath(agentName), WalletSchema);
+}
+function saveWallet(agentName, wallet) {
+  ensureDir(agentDir(agentName));
+  writeFileSecure(walletPath(agentName), JSON.stringify(wallet, null, 2));
+}
+function isRestartRequested() {
+  return fs2.existsSync(path2.join(getRoot(), ".restart"));
+}
+function requestRestart() {
+  writeFileSecure(path2.join(getRoot(), ".restart"), (/* @__PURE__ */ new Date()).toISOString());
+}
+function clearRestartFlag() {
+  const flagPath = path2.join(getRoot(), ".restart");
+  if (fs2.existsSync(flagPath)) {
+    fs2.unlinkSync(flagPath);
+  }
+}
+function hasBoardPost(agentName) {
+  return fs2.existsSync(path2.join(agentDir(agentName), "board_posted"));
+}
+function markBoardPosted(agentName) {
+  ensureDir(agentDir(agentName));
+  writeFileSecure(path2.join(agentDir(agentName), "board_posted"), (/* @__PURE__ */ new Date()).toISOString());
+}
+function savePendingClaim(agentName, data) {
+  ensureDir(agentDir(agentName));
+  writeFileSecure(pendingClaimPath(agentName), JSON.stringify(data, null, 2));
+}
+function loadPendingClaim(agentName) {
+  const filePath = pendingClaimPath(agentName);
+  if (!fs2.existsSync(filePath)) return null;
+  try {
+    const raw = fs2.readFileSync(filePath, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function clearPendingClaim(agentName) {
+  const filePath = pendingClaimPath(agentName);
+  if (fs2.existsSync(filePath)) {
+    fs2.unlinkSync(filePath);
+  }
+}
+function listAgents() {
+  const agentsDir = path2.join(getRoot(), "agents");
+  if (!fs2.existsSync(agentsDir)) {
+    return [];
+  }
+  return fs2.readdirSync(agentsDir, { withFileTypes: true }).filter((entry) => {
+    if (!entry.isDirectory()) return false;
+    return fs2.existsSync(credentialsPath(entry.name));
+  }).map((entry) => entry.name);
+}
+
+// src/onboarding/index.ts
+import * as clack3 from "@clack/prompts";
+
+// src/onboarding/provider.ts
+import { exec } from "child_process";
+import * as clack from "@clack/prompts";
+
+// src/onboarding/oauth.ts
+import { createHash, randomBytes } from "crypto";
+var OPENAI_CLIENT_ID = "app_EMoamEEZ73f0CkXaXp7hrann";
+var OPENAI_AUTHORIZE_ENDPOINT = "https://auth.openai.com/oauth/authorize";
+var OPENAI_TOKEN_ENDPOINT = "https://auth.openai.com/oauth/token";
+var REDIRECT_URI = "http://localhost:1455/auth/callback";
+var SCOPES = ["openid", "profile", "email", "offline_access"];
+var EXPIRY_BUFFER_MS = 5 * 60 * 1e3;
+function generatePkce() {
+  const verifier = randomBytes(32).toString("hex");
+  const challenge = createHash("sha256").update(verifier).digest("base64url");
+  return { verifier, challenge };
+}
+function generateState() {
+  return randomBytes(16).toString("hex");
+}
+function buildAuthorizeUrl(params) {
+  const qs = new URLSearchParams({
+    client_id: OPENAI_CLIENT_ID,
+    redirect_uri: REDIRECT_URI,
+    response_type: "code",
+    scope: SCOPES.join(" "),
+    state: params.state,
+    code_challenge: params.challenge,
+    code_challenge_method: "S256",
+    id_token_add_organizations: "true",
+    codex_cli_simplified_flow: "true"
+  });
+  return `${OPENAI_AUTHORIZE_ENDPOINT}?${qs.toString()}`;
+}
+async function exchangeCodeForTokens(params) {
+  const body = new URLSearchParams({
+    grant_type: "authorization_code",
+    client_id: OPENAI_CLIENT_ID,
+    code: params.code,
+    redirect_uri: REDIRECT_URI,
+    code_verifier: params.codeVerifier
+  });
+  const response = await fetch(OPENAI_TOKEN_ENDPOINT, {
+    method: "POST",
+    headers: { "Content-Type": "application/x-www-form-urlencoded" },
+    body
+  });
+  if (!response.ok) {
+    const text3 = await response.text();
+    throw new Error(`Token exchange failed (HTTP ${response.status}): ${text3.slice(0, 200)}`);
+  }
+  const data = await response.json();
+  const accessToken = data.access_token?.trim();
+  const refreshToken = data.refresh_token?.trim();
+  if (!accessToken) {
+    throw new Error("Token exchange returned no access_token");
+  }
+  if (!refreshToken) {
+    throw new Error("Token exchange returned no refresh_token");
+  }
+  return {
+    accessToken,
+    refreshToken,
+    expiresAt: computeExpiresAt(data.expires_in ?? 0),
+    clientId: OPENAI_CLIENT_ID
+  };
+}
+async function refreshTokens(params) {
+  const clientId = params.clientId ?? OPENAI_CLIENT_ID;
+  const body = new URLSearchParams({
+    grant_type: "refresh_token",
+    client_id: clientId,
+    refresh_token: params.refreshToken
+  });
+  const response = await fetch(OPENAI_TOKEN_ENDPOINT, {
+    method: "POST",
+    headers: { "Content-Type": "application/x-www-form-urlencoded" },
+    body
+  });
+  if (!response.ok) {
+    const text3 = await response.text();
+    throw new Error(`Token refresh failed (HTTP ${response.status}): ${text3.slice(0, 200)}`);
+  }
+  const data = await response.json();
+  const accessToken = data.access_token?.trim();
+  if (!accessToken) {
+    throw new Error("Token refresh returned no access_token");
+  }
+  const newRefreshToken = data.refresh_token?.trim() || params.refreshToken;
+  return {
+    accessToken,
+    refreshToken: newRefreshToken,
+    expiresAt: computeExpiresAt(data.expires_in ?? 0),
+    clientId
+  };
+}
+function computeExpiresAt(expiresInSeconds) {
+  const now = Date.now();
+  const value = now + Math.max(0, Math.floor(expiresInSeconds)) * 1e3 - EXPIRY_BUFFER_MS;
+  return Math.max(value, now + 3e4);
+}
+function isTokenExpired(expiresAt) {
+  return Date.now() >= expiresAt;
+}
+function parseCallbackUrl(input, expectedState) {
+  const trimmed = input.trim();
+  if (!trimmed) {
+    return { error: "No input provided" };
+  }
+  let url;
+  try {
+    url = new URL(trimmed);
+  } catch {
+    const qs = trimmed.startsWith("?") ? trimmed : `?${trimmed}`;
+    try {
+      url = new URL(`http://localhost/${qs}`);
+    } catch {
+      return { error: "Paste the full redirect URL (must include code + state)." };
+    }
+  }
+  const code = url.searchParams.get("code")?.trim();
+  const state = url.searchParams.get("state")?.trim();
+  if (!code) return { error: "Missing 'code' parameter in URL" };
+  if (!state) return { error: "Missing 'state' parameter. Paste the full redirect URL." };
+  if (state !== expectedState) return { error: "State mismatch \u2014 possible CSRF attack. Please retry login." };
+  return { code, state };
+}
+function isRemoteEnvironment() {
+  return !!(process.env.SSH_CLIENT || process.env.SSH_TTY || process.env.SSH_CONNECTION || process.env.REMOTE_CONTAINERS || process.env.CODESPACES);
+}
+
+// src/onboarding/callback-server.ts
+import { createServer } from "http";
+var CALLBACK_TIMEOUT_MS = 3 * 60 * 1e3;
+async function waitForCallback(params) {
+  const redirectUrl = new URL(params.redirectUri);
+  const hostname = redirectUrl.hostname || "127.0.0.1";
+  const port = redirectUrl.port ? Number.parseInt(redirectUrl.port, 10) : 80;
+  const expectedPath = redirectUrl.pathname || "/";
+  const timeoutMs = params.timeoutMs ?? CALLBACK_TIMEOUT_MS;
+  if (hostname !== "127.0.0.1" && hostname !== "localhost" && hostname !== "::1") {
+    throw new Error(
+      `OAuth callback must bind to loopback (got ${hostname}). Use http://127.0.0.1:<port>/...`
+    );
+  }
+  return new Promise((resolve, reject) => {
+    let timeout = null;
+    const server = createServer((req, res) => {
+      try {
+        const requestUrl = new URL(req.url ?? "/", redirectUrl.origin);
+        if (requestUrl.pathname !== expectedPath) {
+          res.statusCode = 404;
+          res.setHeader("Content-Type", "text/plain; charset=utf-8");
+          res.end("Not found");
+          return;
+        }
+        const code = requestUrl.searchParams.get("code")?.trim();
+        const state = requestUrl.searchParams.get("state")?.trim();
+        if (!code) {
+          res.statusCode = 400;
+          res.setHeader("Content-Type", "text/plain; charset=utf-8");
+          res.end("Missing authorization code");
+          return;
+        }
+        if (!state || state !== params.expectedState) {
+          res.statusCode = 400;
+          res.setHeader("Content-Type", "text/plain; charset=utf-8");
+          res.end("Invalid state parameter");
+          return;
+        }
+        res.statusCode = 200;
+        res.setHeader("Content-Type", "text/html; charset=utf-8");
+        res.end(
+          [
+            "<!doctype html>",
+            "<html><head><meta charset='utf-8'><title>AstraNova</title></head>",
+            "<body style='font-family:system-ui;text-align:center;padding:40px'>",
+            "<h2>Login complete</h2>",
+            "<p>You can close this window and return to AstraNova CLI.</p>",
+            "</body></html>"
+          ].join("")
+        );
+        if (timeout) clearTimeout(timeout);
+        server.close();
+        resolve({ code, state });
+      } catch (err) {
+        if (timeout) clearTimeout(timeout);
+        server.close();
+        reject(err);
+      }
+    });
+    server.once("error", (err) => {
+      if (timeout) clearTimeout(timeout);
+      server.close();
+      reject(err);
+    });
+    server.listen(port, hostname, () => {
+      params.onListening?.();
+    });
+    timeout = setTimeout(() => {
+      try {
+        server.close();
+      } catch {
+      }
+      reject(new Error("OAuth callback timeout \u2014 no response received within 3 minutes."));
+    }, timeoutMs);
+  });
+}
+
+// src/onboarding/provider.ts
+var DEFAULT_MODELS = {
+  "openai-oauth": "gpt-5.3-codex",
+  claude: "claude-sonnet-4-20250514",
+  openai: "gpt-4o-mini",
+  google: "gemini-2.0-flash",
+  ollama: "llama3.1"
+};
+async function selectProvider() {
+  for (; ; ) {
+    const provider = await clack.select({
+      message: "Choose your LLM provider",
+      options: [
+        {
+          value: "openai-oauth",
+          label: "ChatGPT / Codex",
+          hint: "login with ChatGPT subscription \u2014 no API key needed"
+        },
+        {
+          value: "claude",
+          label: "Claude (Anthropic)",
+          hint: "API key"
+        },
+        {
+          value: "openai",
+          label: "GPT (OpenAI)",
+          hint: "API key"
+        },
+        {
+          value: "google",
+          label: "Gemini (Google)",
+          hint: "coming soon"
+        },
+        {
+          value: "ollama",
+          label: "Local (Ollama)",
+          hint: "coming soon"
+        }
+      ]
+    });
+    if (clack.isCancel(provider)) {
+      clack.cancel("Setup cancelled.");
+      process.exit(0);
+    }
+    if (provider === "google" || provider === "ollama") {
+      const names = { google: "Gemini", ollama: "Ollama" };
+      clack.log.warn(`${names[provider]} support is coming soon. Please choose another provider for now.`);
+      continue;
+    }
+    if (provider === "openai-oauth") {
+      const oauthResult = await runCodexOAuth();
+      if (!oauthResult) continue;
+      return oauthResult;
+    }
+    const apiKey = await promptApiKey(provider);
+    const model = DEFAULT_MODELS[provider] ?? "";
+    return {
+      provider,
+      model,
+      auth: { type: "api-key", apiKey }
+    };
+  }
+}
+async function runCodexOAuth() {
+  const remote = isRemoteEnvironment();
+  const { verifier, challenge } = generatePkce();
+  const state = generateState();
+  const authorizeUrl = buildAuthorizeUrl({ state, challenge });
+  if (remote) {
+    return runRemoteOAuth(authorizeUrl, state, verifier);
+  }
+  return runLocalOAuth(authorizeUrl, state, verifier);
+}
+async function runLocalOAuth(authorizeUrl, state, verifier) {
+  const spinner4 = clack.spinner();
+  clack.log.info("Opening your browser to log in with ChatGPT...");
+  clack.log.message(`If the browser doesn't open, visit:
+${authorizeUrl}`);
+  openBrowser(authorizeUrl);
+  spinner4.start("Waiting for login... (3 min timeout)");
+  let code;
+  try {
+    const result = await waitForCallback({
+      redirectUri: REDIRECT_URI,
+      expectedState: state
+    });
+    code = result.code;
+    spinner4.stop("Callback received.");
+  } catch {
+    spinner4.stop("Callback not detected.");
+    const manualResult = await promptManualPaste(state);
+    if (!manualResult) return null;
+    code = manualResult;
+  }
+  return exchangeAndReturn(code, verifier);
+}
+async function runRemoteOAuth(authorizeUrl, state, verifier) {
+  clack.log.info(
+    [
+      "You're in a remote environment.",
+      "Open this URL in your local browser:",
+      "",
+      authorizeUrl,
+      "",
+      "After signing in, paste the redirect URL here."
+    ].join("\n")
+  );
+  const code = await promptManualPaste(state);
+  if (!code) return null;
+  return exchangeAndReturn(code, verifier);
+}
+async function promptManualPaste(state) {
+  const input = await clack.text({
+    message: "Paste the redirect URL from your browser",
+    placeholder: `${REDIRECT_URI}?code=...&state=...`,
+    validate(value) {
+      if (!value || value.trim().length === 0) {
+        return "URL is required";
+      }
+      const parsed2 = parseCallbackUrl(value, state);
+      if ("error" in parsed2) {
+        return parsed2.error;
+      }
+      return void 0;
+    }
+  });
+  if (clack.isCancel(input)) {
+    clack.log.warn("OAuth cancelled. Returning to provider selection.");
+    return null;
+  }
+  const parsed = parseCallbackUrl(input, state);
+  if ("error" in parsed) {
+    clack.log.error(parsed.error);
+    return null;
+  }
+  return parsed.code;
+}
+async function exchangeAndReturn(code, verifier) {
+  const spinner4 = clack.spinner();
+  spinner4.start("Exchanging code for tokens...");
+  try {
+    const tokens = await exchangeCodeForTokens({ code, codeVerifier: verifier });
+    spinner4.stop("Authenticated successfully.");
+    return {
+      provider: "openai-oauth",
+      model: DEFAULT_MODELS["openai-oauth"] ?? "gpt-5.3-codex",
+      auth: {
+        type: "oauth",
+        oauth: {
+          accessToken: tokens.accessToken,
+          refreshToken: tokens.refreshToken,
+          expiresAt: tokens.expiresAt,
+          clientId: tokens.clientId
+        }
+      }
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    spinner4.stop(`Authentication failed: ${message}`);
+    clack.log.error("Please try again or choose a different provider.");
+    return null;
+  }
+}
+function openBrowser(url) {
+  const command = process.platform === "darwin" ? `open "${url}"` : process.platform === "win32" ? `start "" "${url}"` : `xdg-open "${url}"`;
+  exec(command, (err) => {
+    if (err) {
+    }
+  });
+}
+async function promptApiKey(provider) {
+  const labels = {
+    claude: "Anthropic API key",
+    openai: "OpenAI API key",
+    google: "Google AI API key"
+  };
+  const placeholders = {
+    claude: "sk-ant-...",
+    openai: "sk-...",
+    google: "AIza..."
+  };
+  const apiKey = await clack.text({
+    message: `Enter your ${labels[provider] ?? "API key"}`,
+    placeholder: placeholders[provider] ?? "your-api-key",
+    validate(value) {
+      if (!value || value.trim().length === 0) {
+        return "API key is required";
+      }
+      return void 0;
+    }
+  });
+  if (clack.isCancel(apiKey)) {
+    clack.cancel("Setup cancelled.");
+    process.exit(0);
+  }
+  const trimmed = apiKey.trim();
+  const spinner4 = clack.spinner();
+  spinner4.start("Validating API key...");
+  const valid = await validateApiKey(provider, trimmed);
+  if (!valid.ok) {
+    spinner4.stop(`API key validation failed: ${valid.error}`);
+    clack.log.error("Please check your key and try again.");
+    return promptApiKey(provider);
+  }
+  spinner4.stop("API key validated.");
+  return trimmed;
+}
+async function validateApiKey(provider, apiKey) {
+  try {
+    switch (provider) {
+      case "claude": {
+        const res = await fetch("https://api.anthropic.com/v1/models", {
+          headers: {
+            "x-api-key": apiKey,
+            "anthropic-version": "2023-06-01"
+          }
+        });
+        if (!res.ok) return { ok: false, error: `Anthropic returned HTTP ${res.status}` };
+        return { ok: true };
+      }
+      case "openai": {
+        const res = await fetch("https://api.openai.com/v1/models", {
+          headers: { Authorization: `Bearer ${apiKey}` }
+        });
+        if (!res.ok) return { ok: false, error: `OpenAI returned HTTP ${res.status}` };
+        return { ok: true };
+      }
+      case "google": {
+        const res = await fetch(
+          `https://generativelanguage.googleapis.com/v1beta/models?key=${apiKey}`
+        );
+        if (!res.ok) return { ok: false, error: `Google AI returned HTTP ${res.status}` };
+        return { ok: true };
+      }
+      default:
+        return { ok: false, error: `Unknown provider: ${provider}` };
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    return { ok: false, error: `Network error: ${message}` };
+  }
+}
+
+// src/onboarding/register.ts
+import * as clack2 from "@clack/prompts";
+
+// src/utils/retry.ts
+var DEFAULTS = {
+  attempts: 3,
+  minDelay: 500,
+  maxDelay: 8e3,
+  jitter: 0.3
+};
+async function withRetry(fn, opts = {}) {
+  const config = { ...DEFAULTS, ...opts };
+  for (let attempt = 1; attempt <= config.attempts; attempt++) {
+    const result = await fn();
+    if (result.ok) return result;
+    if (attempt === config.attempts) return result;
+    const { status } = result;
+    if (status >= 400 && status < 500 && status !== 429 && status !== 408) {
+      return result;
+    }
+    const base = Math.min(config.minDelay * 2 ** (attempt - 1), config.maxDelay);
+    const jitterMs = base * config.jitter * (Math.random() * 2 - 1);
+    const delay = Math.max(0, base + jitterMs);
+    process.stderr.write(
+      `[astra] Retry ${attempt}/${config.attempts - 1}: ${result.error} \u2014 waiting ${Math.round(delay)}ms
+`
+    );
+    await sleep(delay);
+  }
+  throw new Error("Retry loop exited unexpectedly");
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/utils/http.ts
+var FETCH_TIMEOUT_MS = 3e4;
+var FETCH_TIMEOUT_RETRY_MS = 15e3;
+async function apiCall(method, path6, body, agentName, retryOpts) {
+  const config = loadConfig();
+  const baseUrl = config?.apiBase ?? "https://agents.astranova.live";
+  const headers = {
+    "Content-Type": "application/json"
+  };
+  if (agentName) {
+    const creds = loadCredentials(agentName);
+    if (creds?.api_key) {
+      headers["Authorization"] = `Bearer ${creds.api_key}`;
+    }
+  }
+  const url = `${baseUrl}${path6}`;
+  const willRetry = retryOpts !== false && (retryOpts?.attempts ?? 3) > 1;
+  const timeoutMs = willRetry ? FETCH_TIMEOUT_RETRY_MS : FETCH_TIMEOUT_MS;
+  const doFetch = async () => {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+      const response = await fetch(url, {
+        method,
+        headers,
+        body: body ? JSON.stringify(body) : void 0,
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (!response.ok) {
+        return parseErrorResponse(response);
+      }
+      const data = await response.json();
+      return { ok: true, data, status: response.status };
+    } catch (error) {
+      clearTimeout(timeoutId);
+      if (controller.signal.aborted) {
+        return {
+          ok: false,
+          status: 0,
+          error: `Request to ${path6} timed out after ${timeoutMs / 1e3}s`,
+          hint: "The AstraNova API may be slow or unreachable. Try again."
+        };
+      }
+      const message = error instanceof Error ? error.message : "Unknown network error";
+      return {
+        ok: false,
+        status: 0,
+        error: `Network error: ${message}`,
+        hint: "Check your internet connection and try again."
+      };
+    }
+  };
+  if (retryOpts === false) return doFetch();
+  return withRetry(doFetch, retryOpts ?? {});
+}
+async function parseErrorResponse(response) {
+  try {
+    const body = await response.json();
+    return {
+      ok: false,
+      status: response.status,
+      error: body.error ?? body.message ?? `HTTP ${response.status}`,
+      code: body.code,
+      hint: body.hint
+    };
+  } catch {
+    return {
+      ok: false,
+      status: response.status,
+      error: `HTTP ${response.status}: ${response.statusText}`
+    };
+  }
+}
+
+// src/onboarding/register.ts
+async function registerAgent() {
+  const agentName = await promptAgentName();
+  const description = await promptDescription(agentName);
+  const spinner4 = clack2.spinner();
+  spinner4.start("Registering agent...");
+  const result = await apiCall("POST", "/api/v1/agents/register", {
+    name: agentName,
+    description
+  });
+  if (!result.ok) {
+    spinner4.stop("Registration failed.");
+    if (result.status === 409) {
+      clack2.log.error(`The name "${agentName}" is already taken. Try a different name.`);
+      return registerAgent();
+    }
+    if (result.status === 429) {
+      clack2.log.error("Too many registration attempts. Please try again later.");
+      process.exit(1);
+    }
+    clack2.log.error(`Registration error: ${result.error}`);
+    if (result.hint) clack2.log.info(result.hint);
+    return registerAgent();
+  }
+  const parsed = RegisterResponseSchema.safeParse(result.data);
+  if (!parsed.success) {
+    spinner4.stop("Registration failed.");
+    clack2.log.error("Unexpected response from API. Please try again.");
+    return registerAgent();
+  }
+  const { agent, api_key, verification_code } = parsed.data;
+  saveCredentials(agentName, {
+    agent_name: agentName,
+    api_key,
+    api_base: "https://agents.astranova.live"
+  });
+  setActiveAgent(agentName);
+  spinner4.stop(`Agent "${agent.name}" registered.`);
+  clack2.log.success(
+    [
+      `Agent: ${agent.name}`,
+      `Status: ${agent.status}`,
+      `Starting balance: ${agent.simBalance.toLocaleString()} $SIM`,
+      "",
+      `Your API key has been saved securely to your local machine.`,
+      `It will not be displayed again \u2014 it is stored with restricted`,
+      `permissions (chmod 600) and is never sent to the LLM.`
+    ].join("\n")
+  );
+  const tweetSuggestions = buildTweetSuggestions(agent.name, verification_code);
+  clack2.log.info(
+    [
+      "To verify your agent, post a tweet tagging @astranova_live with your code.",
+      "",
+      "Here are some ready-to-post ideas:",
+      "",
+      ...tweetSuggestions.map((t, i) => `  ${i + 1}. ${t}`),
+      "",
+      'After posting, use the "verify" command in the chat with your tweet URL.',
+      "Verification unlocks trading and market access."
+    ].join("\n")
+  );
+  return { agentName, verificationCode: verification_code };
+}
+function buildTweetSuggestions(agentName, code) {
+  return [
+    `Just spawned "${agentName}" into the @astranova_live living market. Let's trade. ${code}`,
+    `My agent "${agentName}" just entered the arena. 10,000 $SIM and a plan. @astranova_live ${code}`,
+    `"${agentName}" is live on @astranova_live \u2014 ready to hunt $NOVA. Verification: ${code}`
+  ];
+}
+var DESCRIPTION_SUGGESTIONS = [
+  "reckless degen trader",
+  "cautious moon watcher",
+  "vibes-based portfolio manager",
+  "calm under pressure",
+  "chaos-loving market surfer",
+  "data-driven strategist",
+  "diamond hands maximalist",
+  "contrarian signal hunter"
+];
+async function promptDescription(agentName) {
+  const suggestions = [...DESCRIPTION_SUGGESTIONS].sort(() => Math.random() - 0.5).slice(0, 5);
+  const WRITE_OWN = "__write_own__";
+  const choice = await clack2.select({
+    message: `Give "${agentName}" a personality`,
+    options: [
+      ...suggestions.map((d) => ({ value: d, label: d })),
+      { value: WRITE_OWN, label: "Write my own" }
+    ]
+  });
+  if (clack2.isCancel(choice)) {
+    clack2.cancel("Setup cancelled.");
+    process.exit(0);
+  }
+  if (choice !== WRITE_OWN) {
+    return choice;
+  }
+  const custom = await clack2.text({
+    message: "Describe your agent",
+    placeholder: "e.g. fearless night trader",
+    validate(value) {
+      if (!value || value.trim().length < 2) {
+        return "Description must be at least 2 characters";
+      }
+      if (value.trim().length > 100) {
+        return "Description must be 100 characters or less";
+      }
+      return void 0;
+    }
+  });
+  if (clack2.isCancel(custom)) {
+    clack2.cancel("Setup cancelled.");
+    process.exit(0);
+  }
+  return custom.trim();
+}
+var NAME_SUGGESTIONS = [
+  "phantom-drift",
+  "signal-hunter",
+  "nova-rider",
+  "deep-current",
+  "void-pulse",
+  "neon-fox",
+  "iron-tide",
+  "solar-ghost",
+  "zero-echo",
+  "dark-momentum",
+  "quantum-wolf",
+  "silent-orbit"
+];
+function pickRandomNames(count) {
+  const shuffled = [...NAME_SUGGESTIONS].sort(() => Math.random() - 0.5);
+  return shuffled.slice(0, count);
+}
+async function promptAgentName() {
+  const suggestions = pickRandomNames(4);
+  clack2.log.info(
+    [
+      "Need inspiration? Here are some names:",
+      "",
+      ...suggestions.map((n) => `  ${n}`),
+      "",
+      "Or type your own (lowercase, 2-32 chars, letters/numbers/hyphens/underscores)"
+    ].join("\n")
+  );
+  const name = await clack2.text({
+    message: "Choose a name for your agent",
+    placeholder: suggestions[0],
+    validate(value) {
+      const result = AgentNameSchema.safeParse(value);
+      if (!result.success) {
+        return result.error.issues[0]?.message ?? "Invalid agent name";
+      }
+      return void 0;
+    }
+  });
+  if (clack2.isCancel(name)) {
+    clack2.cancel("Setup cancelled.");
+    process.exit(0);
+  }
+  return name.trim();
+}
+
+// src/ui/logo.ts
+var GREEN = "\x1B[38;2;184;245;78m";
+var RESET = "\x1B[0m";
+var ROBOT = `
+         __
+ _(\\    |@@|
+(__/\\__ \\--/ __
+   \\___|----|  |   __
+       \\ /\\ /\\ )_ / _\\
+       /\\__/\\ \\__O (__
+      (--/\\--)    \\__/
+      _)(  )(_
+     \`---''---\``;
+var ASTRANOVA = `
+      _    ____ _____ ____      _    _   _  _____     ___
+     / \\  / ___|_   _|  _ \\    / \\  | \\ | |/ _ \\ \\   / / \\
+    / _ \\ \\___ \\ | | | |_) |  / _ \\ |  \\| | | | \\ \\ / / _ \\
+   / ___ \\ ___) || | |  _ <  / ___ \\| |\\  | |_| |\\ V / ___ \\
+  /_/   \\_\\____/ |_| |_| \\_\\/_/   \\_\\_| \\_|\\___/  \\_/_/   \\_\\`;
+var SEPARATOR = "  - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ";
+var LOGO = `${GREEN}${ROBOT}
+${ASTRANOVA}
+${SEPARATOR}${RESET}`;
+var TAGLINE = `${GREEN}AI agents | Live Market | Compete or Spectate${RESET}`;
+var VERSION = `${GREEN}v0.1.0${RESET}`;
+
+// src/onboarding/index.ts
+async function runOnboarding() {
+  if (isConfigured()) {
+    return null;
+  }
+  ensureBaseStructure();
+  console.log(LOGO);
+  console.log(`  ${TAGLINE}`);
+  console.log(`  ${VERSION}
+`);
+  clack3.intro("Enter the Living Market Universe");
+  const { provider, model, auth } = await selectProvider();
+  const config = {
+    version: 1,
+    provider,
+    model,
+    auth,
+    apiBase: "https://agents.astranova.live",
+    preferences: { theme: "dark" }
+  };
+  saveConfig(config);
+  clack3.log.success(`Provider set to ${provider} (${model})`);
+  const { agentName, verificationCode } = await registerAgent();
+  clack3.log.info(
+    "Wallet setup and X/Twitter verification are available after launch \u2014 use the chat to set them up."
+  );
+  clack3.outro("Setup complete \u2014 launching AstraNova...");
+  return { agentName, verificationCode };
+}
+
+// src/onboarding/welcome-back.ts
+import * as clack4 from "@clack/prompts";
+var GREETINGS = [
+  "Welcome back, commander.",
+  "The market never sleeps. Neither do we.",
+  "Back in the arena. Let's make moves.",
+  "Your agent was waiting for you.",
+  "The $NOVA market has been moving. Let's catch up."
+];
+function randomGreeting() {
+  return GREETINGS[Math.floor(Math.random() * GREETINGS.length)];
+}
+async function showWelcomeBack(agentName) {
+  console.log(LOGO);
+  console.log(`  ${TAGLINE}`);
+  console.log(`  ${VERSION}
+`);
+  clack4.intro(randomGreeting());
+  const spinner4 = clack4.spinner();
+  spinner4.start("Checking agent status...");
+  const status = await fetchAgentStatus(agentName);
+  if (!status) {
+    spinner4.stop("Could not reach AstraNova API.");
+    clack4.log.warn(
+      "Launching in offline mode \u2014 some features may be unavailable."
+    );
+    clack4.outro(`Resuming as ${agentName}`);
+    return null;
+  }
+  spinner4.stop(`Agent "${status.name}" \u2014 ${status.status}`);
+  if (status.status === "pending_verification") {
+    showVerificationReminder(status.name, status.verificationCode);
+  } else {
+    clack4.log.info(journeyTip(status));
+  }
+  clack4.outro("");
+  return status;
+}
+function journeyTip(status) {
+  if (status.simBalance === 1e4 && !status.walletAddress) {
+    return `You're verified! Try "check the market" or "buy 500 NOVA" to get started.`;
+  }
+  if (!status.walletAddress) {
+    return 'Ready to trade. Type "set up wallet" when you want to start earning $ASTRA.';
+  }
+  return "All systems go. Check the market, trade, or claim your $ASTRA rewards.";
+}
+function showVerificationReminder(agentName, verificationCode) {
+  const code = verificationCode ?? "your-code";
+  const tweets = [
+    `Just spawned "${agentName}" into the @astranova_live living market. Let's trade. ${code}`,
+    `My agent "${agentName}" just entered the arena. 10,000 $SIM and a plan. @astranova_live ${code}`,
+    `"${agentName}" is live on @astranova_live \u2014 ready to hunt $NOVA. Verification: ${code}`
+  ];
+  clack4.log.warn(
+    [
+      "Your agent is not yet verified. You need to verify on X/Twitter to unlock trading.",
+      "",
+      "Post a tweet tagging @astranova_live with your verification code.",
+      "Here are some ready-to-post ideas:",
+      "",
+      ...tweets.map((t, i) => `  ${i + 1}. ${t}`),
+      "",
+      'After posting, type "verify" in the chat and paste your tweet URL.'
+    ].join("\n")
+  );
+}
+async function fetchAgentStatus(agentName) {
+  const result = await apiCall(
+    "GET",
+    "/api/v1/agents/me",
+    void 0,
+    agentName
+  );
+  if (!result.ok) {
+    return null;
+  }
+  const data = result.data;
+  const agent = data.agent ?? data;
+  return {
+    name: agent.name ?? agentName,
+    status: agent.status ?? "unknown",
+    simBalance: agent.simBalance ?? agent.sim_balance ?? 0,
+    verificationCode: agent.verificationCode ?? agent.verification_code,
+    walletAddress: agent.walletAddress ?? agent.wallet_address
+  };
+}
+
+// src/remote/cache.ts
+import fs3 from "fs";
+import path3 from "path";
+var metaPath = (name) => cachePath(`${name}.meta.json`);
+async function getCached(name, url, ttlMs) {
+  ensureDir(path3.join(getRoot(), ".cache"));
+  const contentPath = cachePath(name);
+  const meta = readMeta(name);
+  if (meta && fs3.existsSync(contentPath)) {
+    const age = Date.now() - new Date(meta.fetchedAt).getTime();
+    if (age < ttlMs) {
+      return fs3.readFileSync(contentPath, "utf-8");
+    }
+  }
+  try {
+    const response = await fetch(url);
+    if (!response.ok) {
+      return fallbackToStale(contentPath, name, url, response.status);
+    }
+    const content = await response.text();
+    fs3.writeFileSync(contentPath, content, "utf-8");
+    fs3.writeFileSync(
+      metaPath(name),
+      JSON.stringify({ fetchedAt: (/* @__PURE__ */ new Date()).toISOString(), url }),
+      "utf-8"
+    );
+    return content;
+  } catch {
+    return fallbackToStale(contentPath, name, url);
+  }
+}
+function readMeta(name) {
+  const mp = metaPath(name);
+  if (!fs3.existsSync(mp)) return null;
+  try {
+    return JSON.parse(fs3.readFileSync(mp, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function fallbackToStale(contentPath, name, url, status) {
+  if (fs3.existsSync(contentPath)) {
+    const hint2 = status ? `HTTP ${status}` : "network error";
+    console.error(
+      `Warning: Could not refresh ${name} from ${url} (${hint2}). Using cached version.`
+    );
+    return fs3.readFileSync(contentPath, "utf-8");
+  }
+  const hint = status ? `HTTP ${status}` : "network error";
+  console.error(
+    `Warning: Could not fetch ${name} from ${url} (${hint}). No cached version available.`
+  );
+  return null;
+}
+
+// src/remote/skill.ts
+var API_BASE = "https://agents.astranova.live";
+var TTL_24H = 24 * 60 * 60 * 1e3;
+async function fetchRemoteContext(name) {
+  return getCached(name, `${API_BASE}/${name}`, TTL_24H);
+}
+async function getSkillContext() {
+  return await fetchRemoteContext("skill.md") ?? "";
+}
+
+// src/config/sessions.ts
+import fs4 from "fs";
+import path4 from "path";
+var MAX_MESSAGES = 100;
+var MAX_SESSIONS = 3;
+var MAX_AGE_MS = 7 * 24 * 60 * 60 * 1e3;
+function newSessionId() {
+  return (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+}
+function serializeMessages(messages) {
+  const recent = messages.slice(-MAX_MESSAGES);
+  return recent.map((msg) => {
+    let content;
+    if (typeof msg.content === "string") {
+      content = msg.content;
+    } else if (Array.isArray(msg.content)) {
+      content = msg.content.filter((part) => typeof part === "object" && part !== null).map((part) => {
+        try {
+          return JSON.parse(JSON.stringify(part));
+        } catch {
+          return { type: "text", text: "[unserializable content]" };
+        }
+      });
+    } else {
+      content = String(msg.content);
+    }
+    return { role: msg.role, content };
+  });
+}
+function saveSession(params) {
+  try {
+    const dir = sessionsDir(params.agentName);
+    ensureDir(dir);
+    const data = {
+      version: 1,
+      agentName: params.agentName,
+      provider: params.provider,
+      sessionId: params.sessionId,
+      createdAt: params.sessionId,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      coreMessages: serializeMessages(params.coreMessages),
+      chatMessages: params.chatMessages.slice(-MAX_MESSAGES)
+    };
+    const filePath = path4.join(dir, `${params.sessionId}.json`);
+    fs4.writeFileSync(filePath, JSON.stringify(data, null, 2), {
+      encoding: "utf-8",
+      mode: 384
+    });
+  } catch {
+    process.stderr.write("[astra] Failed to save session\n");
+  }
+}
+function loadLatestSession(agentName) {
+  const dir = sessionsDir(agentName);
+  if (!fs4.existsSync(dir)) return null;
+  const files = fs4.readdirSync(dir).filter((f) => f.endsWith(".json")).sort().reverse();
+  if (files.length === 0) return null;
+  try {
+    const raw = fs4.readFileSync(path4.join(dir, files[0]), "utf-8");
+    const parsed = JSON.parse(raw);
+    if (parsed.version !== 1) return null;
+    const updatedAt = new Date(parsed.updatedAt).getTime();
+    if (Date.now() - updatedAt > MAX_AGE_MS) return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+function pruneOldSessions(agentName) {
+  const dir = sessionsDir(agentName);
+  if (!fs4.existsSync(dir)) return;
+  try {
+    const files = fs4.readdirSync(dir).filter((f) => f.endsWith(".json")).sort().reverse();
+    for (let i = 0; i < files.length; i++) {
+      const filePath = path4.join(dir, files[i]);
+      if (i >= MAX_SESSIONS) {
+        fs4.unlinkSync(filePath);
+        continue;
+      }
+      try {
+        const stat = fs4.statSync(filePath);
+        if (Date.now() - stat.mtimeMs > MAX_AGE_MS) {
+          fs4.unlinkSync(filePath);
+        }
+      } catch {
+      }
+    }
+  } catch {
+  }
+}
+
+// src/tools/memory.ts
+import fs5 from "fs";
+import { tool } from "ai";
+import { z as z2 } from "zod";
+var MAX_MEMORY_CHARS = 2e3;
+var updateMemorySchema = z2.object({
+  content: z2.string().describe(
+    "The complete memory content to save. Replaces the entire memory file. Use markdown format. Max 2000 characters."
+  )
+});
+var updateMemoryTool = tool({
+  description: "Save persistent memory that survives across sessions. Use this to remember important facts about the user, their preferences, trading patterns, or anything worth recalling next time. Content replaces the entire memory \u2014 include everything worth keeping. Max 2000 characters.",
+  parameters: updateMemorySchema,
+  execute: async ({ content }) => {
+    const agentName = getActiveAgent();
+    if (!agentName) {
+      return { error: "No active agent." };
+    }
+    if (content.length > MAX_MEMORY_CHARS) {
+      return {
+        error: `Memory content too long (${content.length} chars). Maximum is ${MAX_MEMORY_CHARS} characters. Trim it down and try again.`
+      };
+    }
+    try {
+      ensureDir(agentDir(agentName));
+      const filePath = memoryPath(agentName);
+      fs5.writeFileSync(filePath, content, { encoding: "utf-8", mode: 384 });
+      return { ok: true, chars: content.length };
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : "Unknown error";
+      return { error: `Failed to save memory: ${msg}` };
+    }
+  }
+});
+function loadMemory(agentName) {
+  const filePath = memoryPath(agentName);
+  if (!fs5.existsSync(filePath)) return "";
+  try {
+    return fs5.readFileSync(filePath, "utf-8");
+  } catch {
+    return "";
+  }
+}
+
+// src/ui/App.tsx
+import { useState as useState4, useCallback as useCallback2, useRef as useRef2 } from "react";
+import { Box as Box7, Text as Text8, useApp, useInput } from "ink";
+
+// src/ui/StatusBar.tsx
+import React, { useState, useEffect, useRef, useCallback } from "react";
+import { Box, Text } from "ink";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+var POLL_INTERVAL_MS = 3e4;
+var StatusBar = React.memo(function StatusBar2({
+  agentName,
+  journeyStage
+}) {
+  const [data, setData] = useState({ market: null, portfolio: null });
+  const mounted = useRef(true);
+  const canFetchData = journeyStage !== "fresh" && journeyStage !== "pending";
+  const poll = useCallback(async () => {
+    const [marketRes, portfolioRes] = await Promise.all([
+      fetchMarket(agentName),
+      fetchPortfolio(agentName)
+    ]);
+    if (!mounted.current) return;
+    setData((prev) => ({
+      market: marketRes ?? prev.market,
+      portfolio: portfolioRes ?? prev.portfolio
+    }));
+  }, [agentName]);
+  useEffect(() => {
+    mounted.current = true;
+    if (!canFetchData) return;
+    void poll();
+    const interval = setInterval(() => void poll(), POLL_INTERVAL_MS);
+    return () => {
+      mounted.current = false;
+      clearInterval(interval);
+    };
+  }, [canFetchData, poll]);
+  const { market, portfolio } = data;
+  return /* @__PURE__ */ jsx(Box, { flexDirection: "column", width: "100%", children: /* @__PURE__ */ jsxs(Box, { paddingX: 1, children: [
+    /* @__PURE__ */ jsx(Text, { bold: true, color: "green", children: "AstraNova" }),
+    /* @__PURE__ */ jsx(Text, { dimColor: true, children: " \u2502 " }),
+    /* @__PURE__ */ jsx(Text, { color: "white", children: agentName }),
+    canFetchData && market && /* @__PURE__ */ jsxs(Fragment, { children: [
+      /* @__PURE__ */ jsx(Text, { dimColor: true, children: " \u2502 " }),
+      /* @__PURE__ */ jsx(Text, { color: "yellow", children: "$NOVA " }),
+      /* @__PURE__ */ jsx(Text, { color: "white", children: formatPrice(market.price) }),
+      /* @__PURE__ */ jsx(Text, { dimColor: true, children: " \u2502 " }),
+      /* @__PURE__ */ jsx(Text, { color: moodColor(market.mood), children: market.mood })
+    ] }),
+    canFetchData && portfolio && /* @__PURE__ */ jsxs(Fragment, { children: [
+      /* @__PURE__ */ jsx(Text, { dimColor: true, children: " \u2502 " }),
+      /* @__PURE__ */ jsxs(Text, { color: "cyan", children: [
+        formatNum(portfolio.cash),
+        " $SIM"
+      ] }),
+      portfolio.tokens > 0 && /* @__PURE__ */ jsxs(Fragment, { children: [
+        /* @__PURE__ */ jsx(Text, { dimColor: true, children: " \u2502 " }),
+        /* @__PURE__ */ jsxs(Text, { color: "magenta", children: [
+          formatNum(portfolio.tokens),
+          " $NOVA"
+        ] })
+      ] }),
+      portfolio.pnl !== 0 && /* @__PURE__ */ jsxs(Fragment, { children: [
+        /* @__PURE__ */ jsx(Text, { dimColor: true, children: " \u2502 " }),
+        /* @__PURE__ */ jsxs(Text, { color: portfolio.pnl >= 0 ? "green" : "red", children: [
+          "P&L ",
+          portfolio.pnl >= 0 ? "+" : "",
+          formatNum(portfolio.pnl),
+          " (",
+          portfolio.pnlPct >= 0 ? "+" : "",
+          portfolio.pnlPct.toFixed(1),
+          "%)"
+        ] })
+      ] })
+    ] }),
+    !canFetchData && /* @__PURE__ */ jsxs(Fragment, { children: [
+      /* @__PURE__ */ jsx(Text, { dimColor: true, children: " \u2502 " }),
+      /* @__PURE__ */ jsx(Text, { dimColor: true, children: "pending verification" })
+    ] }),
+    canFetchData && !market && !portfolio && /* @__PURE__ */ jsxs(Fragment, { children: [
+      /* @__PURE__ */ jsx(Text, { dimColor: true, children: " \u2502 " }),
+      /* @__PURE__ */ jsx(Text, { dimColor: true, children: "loading..." })
+    ] })
+  ] }) });
+});
+var StatusBar_default = StatusBar;
+function formatPrice(price) {
+  if (price >= 1) return price.toFixed(2);
+  if (price >= 0.01) return price.toFixed(4);
+  return price.toFixed(6);
+}
+function formatNum(n) {
+  if (Math.abs(n) >= 1e6) return `${(n / 1e6).toFixed(1)}M`;
+  if (Math.abs(n) >= 1e3) return `${(n / 1e3).toFixed(1)}K`;
+  return n.toLocaleString(void 0, { maximumFractionDigits: 0 });
+}
+function moodColor(mood) {
+  switch (mood) {
+    case "euphoria":
+    case "bullish":
+      return "green";
+    case "fear":
+    case "bearish":
+      return "red";
+    case "crab":
+      return "yellow";
+    default:
+      return "white";
+  }
+}
+async function fetchMarket(agentName) {
+  const result = await apiCall("GET", "/api/v1/market/state", void 0, agentName);
+  if (!result.ok) return null;
+  const d = result.data;
+  const m = d.market ?? d;
+  return {
+    price: m.price ?? 0,
+    mood: m.mood ?? ""
+  };
+}
+async function fetchPortfolio(agentName) {
+  const result = await apiCall(
+    "GET",
+    "/api/v1/portfolio",
+    void 0,
+    agentName
+  );
+  if (!result.ok) return null;
+  const d = result.data;
+  const p = d.portfolio ?? d;
+  return {
+    cash: p.cash ?? 0,
+    tokens: p.tokens ?? 0,
+    pnl: p.pnl ?? 0,
+    pnlPct: p.pnlPct ?? 0
+  };
+}
+
+// src/ui/ChatView.tsx
+import { Box as Box5, Text as Text5 } from "ink";
+
+// src/ui/MarkdownText.tsx
+import { Text as Text4, Box as Box4 } from "ink";
+
+// src/ui/PortfolioCard.tsx
+import { Box as Box2, Text as Text2 } from "ink";
+import { Fragment as Fragment2, jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+function PortfolioCard({ data }) {
+  const price = data.currentPrice ?? 0;
+  const cash = data.cash ?? 0;
+  const tokens = data.tokens ?? 0;
+  const value = data.portfolioValue ?? cash + tokens * price;
+  const pnl = data.pnl ?? 0;
+  const pnlPct = data.pnlPct ?? 0;
+  const earned = data.totalEarned ? Number(data.totalEarned) / 1e9 : 0;
+  const claimable = data.claimable ? Number(data.claimable) / 1e9 : 0;
+  const pnlColor = pnl >= 0 ? "green" : "red";
+  const pnlSign = pnl >= 0 ? "+" : "";
+  return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", borderStyle: "round", borderColor: "cyan", paddingX: 2, paddingY: 1, marginY: 1, children: [
+    /* @__PURE__ */ jsx2(Box2, { justifyContent: "center", marginBottom: 1, children: /* @__PURE__ */ jsx2(Text2, { bold: true, color: "cyan", children: "  Portfolio Overview  " }) }),
+    /* @__PURE__ */ jsxs2(Box2, { flexDirection: "row", children: [
+      /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", width: "50%", children: [
+        /* @__PURE__ */ jsx2(Row, { label: "$SIM Balance", value: formatNum2(cash), color: "cyan" }),
+        /* @__PURE__ */ jsx2(Row, { label: "$NOVA Holdings", value: tokens > 0 ? formatNum2(tokens) : "\u2014", color: "magenta" }),
+        /* @__PURE__ */ jsx2(Row, { label: "$NOVA Price", value: price > 0 ? formatPrice2(price) : "\u2014", color: "yellow" })
+      ] }),
+      /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", width: "50%", children: [
+        /* @__PURE__ */ jsx2(Row, { label: "Portfolio Value", value: formatNum2(value), color: "white" }),
+        /* @__PURE__ */ jsx2(Row, { label: "P&L", value: `${pnlSign}${formatNum2(pnl)} (${pnlSign}${pnlPct.toFixed(1)}%)`, color: pnlColor }),
+        (data.hasWallet !== void 0 || data.walletLocal !== void 0) && /* @__PURE__ */ jsx2(
+          Row,
+          {
+            label: "Wallet",
+            value: data.hasWallet ? "registered" : data.walletLocal ? "needs registration" : "not set",
+            color: data.hasWallet ? "green" : data.walletLocal ? "yellow" : "gray"
+          }
+        )
+      ] })
+    ] }),
+    (earned > 0 || claimable > 0) && /* @__PURE__ */ jsxs2(Fragment2, { children: [
+      /* @__PURE__ */ jsx2(Box2, { marginTop: 1, marginBottom: 0, children: /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: "\u2500".repeat(36) }) }),
+      /* @__PURE__ */ jsxs2(Box2, { flexDirection: "row", children: [
+        /* @__PURE__ */ jsx2(Box2, { flexDirection: "column", width: "50%", children: /* @__PURE__ */ jsx2(Row, { label: "$ASTRA Earned", value: earned > 0 ? formatAstra(earned) : "\u2014", color: "yellow" }) }),
+        /* @__PURE__ */ jsx2(Box2, { flexDirection: "column", width: "50%", children: /* @__PURE__ */ jsx2(Row, { label: "Claimable", value: claimable > 0 ? formatAstra(claimable) : "\u2014", color: claimable > 0 ? "green" : "gray" }) })
+      ] })
+    ] })
+  ] });
+}
+function Row({ label, value, color }) {
+  return /* @__PURE__ */ jsxs2(Box2, { children: [
+    /* @__PURE__ */ jsxs2(Text2, { dimColor: true, children: [
+      label,
+      ": "
+    ] }),
+    /* @__PURE__ */ jsx2(Text2, { color, bold: true, children: value })
+  ] });
+}
+function formatPrice2(price) {
+  if (price >= 1) return `$${price.toFixed(2)}`;
+  if (price >= 0.01) return `$${price.toFixed(4)}`;
+  return `$${price.toFixed(6)}`;
+}
+function formatNum2(n) {
+  if (Math.abs(n) >= 1e6) return `${(n / 1e6).toFixed(2)}M`;
+  if (Math.abs(n) >= 1e4) return `${(n / 1e3).toFixed(1)}K`;
+  return n.toLocaleString(void 0, { maximumFractionDigits: 2 });
+}
+function formatAstra(n) {
+  if (n >= 1e6) return `${(n / 1e6).toFixed(2)}M ASTRA`;
+  if (n >= 1e3) return `${(n / 1e3).toFixed(2)}K ASTRA`;
+  return `${n.toFixed(2)} ASTRA`;
+}
+
+// src/ui/RewardsCard.tsx
+import { Box as Box3, Text as Text3 } from "ink";
+import { Fragment as Fragment3, jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
+function RewardsCard({ data }) {
+  const total = data.totalAstra ? Number(data.totalAstra) / 1e9 : 0;
+  const epoch = data.epochAstra ? Number(data.epochAstra) / 1e9 : 0;
+  const bonus = data.bonusAstra ? Number(data.bonusAstra) / 1e9 : 0;
+  const statusColor = data.claimStatus === "claimable" ? "green" : data.claimStatus === "sent" ? "cyan" : "yellow";
+  return /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", borderStyle: "round", borderColor: "yellow", paddingX: 2, paddingY: 1, marginY: 1, children: [
+    /* @__PURE__ */ jsxs3(Box3, { justifyContent: "center", marginBottom: 1, children: [
+      /* @__PURE__ */ jsx3(Text3, { bold: true, color: "yellow", children: "  $ASTRA Rewards  " }),
+      data.seasonId && /* @__PURE__ */ jsxs3(Text3, { dimColor: true, children: [
+        " \u2014 ",
+        data.seasonId
+      ] })
+    ] }),
+    /* @__PURE__ */ jsxs3(Box3, { flexDirection: "row", children: [
+      /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", width: "50%", children: [
+        /* @__PURE__ */ jsx3(Row2, { label: "Total Earned", value: formatAstra2(total), color: "yellow" }),
+        /* @__PURE__ */ jsx3(Row2, { label: "Epoch Rewards", value: formatAstra2(epoch), color: "cyan" }),
+        /* @__PURE__ */ jsx3(Row2, { label: "Season Bonus", value: formatAstra2(bonus), color: "magenta" })
+      ] }),
+      /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", width: "50%", children: [
+        /* @__PURE__ */ jsx3(Row2, { label: "Status", value: data.claimStatus ?? "\u2014", color: statusColor }),
+        /* @__PURE__ */ jsx3(Row2, { label: "Epochs Rewarded", value: data.epochsRewarded?.toString() ?? "\u2014", color: "white" }),
+        data.bestEpochPnl !== void 0 && data.bestEpochPnl > 0 && /* @__PURE__ */ jsx3(Row2, { label: "Best Epoch P&L", value: `+${data.bestEpochPnl.toFixed(2)}`, color: "green" })
+      ] })
+    ] }),
+    data.txSignature && /* @__PURE__ */ jsxs3(Fragment3, { children: [
+      /* @__PURE__ */ jsx3(Box3, { marginTop: 1, children: /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: "\u2500".repeat(36) }) }),
+      /* @__PURE__ */ jsxs3(Box3, { children: [
+        /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: "Tx: " }),
+        /* @__PURE__ */ jsx3(Text3, { color: "cyan", children: data.txSignature })
+      ] })
+    ] })
+  ] });
+}
+function Row2({ label, value, color }) {
+  return /* @__PURE__ */ jsxs3(Box3, { children: [
+    /* @__PURE__ */ jsxs3(Text3, { dimColor: true, children: [
+      label,
+      ": "
+    ] }),
+    /* @__PURE__ */ jsx3(Text3, { color, bold: true, children: value })
+  ] });
+}
+function formatAstra2(n) {
+  if (n === 0) return "\u2014";
+  if (n >= 1e6) return `${(n / 1e6).toFixed(2)}M ASTRA`;
+  if (n >= 1e3) return `${(n / 1e3).toFixed(2)}K ASTRA`;
+  return `${n.toFixed(4)} ASTRA`;
+}
+
+// src/ui/MarkdownText.tsx
+import { jsx as jsx4, jsxs as jsxs4 } from "react/jsx-runtime";
+function MarkdownText({ children }) {
+  const lines = children.split("\n");
+  const elements = [];
+  let i = 0;
+  while (i < lines.length) {
+    const line = lines[i];
+    if (line.trimStart().startsWith(":::portfolio") || line.trimStart().startsWith(":::rewards")) {
+      const cardType = line.trimStart().startsWith(":::portfolio") ? "portfolio" : "rewards";
+      const jsonLines = [];
+      i++;
+      while (i < lines.length && !lines[i].trimStart().startsWith(":::")) {
+        jsonLines.push(lines[i]);
+        i++;
+      }
+      i++;
+      try {
+        const raw = jsonLines.join("\n");
+        if (cardType === "portfolio") {
+          const data = JSON.parse(raw);
+          elements.push(/* @__PURE__ */ jsx4(PortfolioCard, { data }, elements.length));
+        } else {
+          const data = JSON.parse(raw);
+          elements.push(/* @__PURE__ */ jsx4(RewardsCard, { data }, elements.length));
+        }
+      } catch {
+        elements.push(
+          /* @__PURE__ */ jsx4(Box4, { children: /* @__PURE__ */ jsx4(Text4, { wrap: "wrap", children: jsonLines.join("\n") }) }, elements.length)
+        );
+      }
+      continue;
+    }
+    if (line.trimStart().startsWith("```")) {
+      const codeLines = [];
+      i++;
+      while (i < lines.length && !lines[i].trimStart().startsWith("```")) {
+        codeLines.push(lines[i]);
+        i++;
+      }
+      i++;
+      elements.push(
+        /* @__PURE__ */ jsx4(Box4, { marginLeft: 2, marginY: 0, children: /* @__PURE__ */ jsx4(Text4, { color: "gray", children: codeLines.join("\n") }) }, elements.length)
+      );
+      continue;
+    }
+    if (/^---+$/.test(line.trim())) {
+      elements.push(
+        /* @__PURE__ */ jsx4(Box4, { children: /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: "\u2500".repeat(40) }) }, elements.length)
+      );
+      i++;
+      continue;
+    }
+    const headerMatch = /^(#{1,4})\s+(.+)$/.exec(line);
+    if (headerMatch) {
+      elements.push(
+        /* @__PURE__ */ jsx4(Box4, { marginTop: elements.length > 0 ? 1 : 0, children: /* @__PURE__ */ jsx4(Text4, { bold: true, color: "cyan", children: headerMatch[2] }) }, elements.length)
+      );
+      i++;
+      continue;
+    }
+    const bulletMatch = /^(\s*)[-*]\s+(.+)$/.exec(line);
+    if (bulletMatch) {
+      const indent = Math.floor((bulletMatch[1]?.length ?? 0) / 2);
+      elements.push(
+        /* @__PURE__ */ jsxs4(Box4, { marginLeft: indent * 2, children: [
+          /* @__PURE__ */ jsx4(Text4, { children: "  \u25CF " }),
+          renderInline(bulletMatch[2])
+        ] }, elements.length)
+      );
+      i++;
+      continue;
+    }
+    const numMatch = /^(\s*)(\d+)[.)]\s+(.+)$/.exec(line);
+    if (numMatch) {
+      const indent = Math.floor((numMatch[1]?.length ?? 0) / 2);
+      elements.push(
+        /* @__PURE__ */ jsxs4(Box4, { marginLeft: indent * 2, children: [
+          /* @__PURE__ */ jsxs4(Text4, { children: [
+            "  ",
+            numMatch[2],
+            ". "
+          ] }),
+          renderInline(numMatch[3])
+        ] }, elements.length)
+      );
+      i++;
+      continue;
+    }
+    if (line.trim() === "") {
+      elements.push(/* @__PURE__ */ jsx4(Box4, { children: /* @__PURE__ */ jsx4(Text4, { children: " " }) }, elements.length));
+      i++;
+      continue;
+    }
+    elements.push(
+      /* @__PURE__ */ jsx4(Box4, { flexWrap: "wrap", children: renderInline(line) }, elements.length)
+    );
+    i++;
+  }
+  return /* @__PURE__ */ jsx4(Box4, { flexDirection: "column", children: elements });
+}
+function renderInline(text3) {
+  const parts = [];
+  let remaining = text3;
+  let key = 0;
+  while (remaining.length > 0) {
+    const candidates = [];
+    const boldMatch = /\*\*(.+?)\*\*|__(.+?)__/.exec(remaining);
+    if (boldMatch) {
+      candidates.push({
+        index: boldMatch.index,
+        length: boldMatch[0].length,
+        node: /* @__PURE__ */ jsx4(Text4, { bold: true, children: boldMatch[1] ?? boldMatch[2] }, key++)
+      });
+    }
+    const codeMatch = /`([^`]+?)`/.exec(remaining);
+    if (codeMatch) {
+      candidates.push({
+        index: codeMatch.index,
+        length: codeMatch[0].length,
+        node: /* @__PURE__ */ jsx4(Text4, { color: "yellow", children: codeMatch[1] }, key++)
+      });
+    }
+    const italicMatch = /(?<!\*)\*(?!\*)(.+?)(?<!\*)\*(?!\*)|(?<!_)_(?!_)(.+?)(?<!_)_(?!_)/.exec(remaining);
+    if (italicMatch) {
+      candidates.push({
+        index: italicMatch.index,
+        length: italicMatch[0].length,
+        node: /* @__PURE__ */ jsx4(Text4, { italic: true, children: italicMatch[1] ?? italicMatch[2] }, key++)
+      });
+    }
+    candidates.sort((a, b) => a.index - b.index);
+    const pick = candidates[0];
+    if (!pick) {
+      parts.push(/* @__PURE__ */ jsx4(Text4, { children: remaining }, key++));
+      break;
+    }
+    if (pick.index > 0) {
+      parts.push(/* @__PURE__ */ jsx4(Text4, { children: remaining.slice(0, pick.index) }, key++));
+    }
+    parts.push(pick.node);
+    remaining = remaining.slice(pick.index + pick.length);
+  }
+  return /* @__PURE__ */ jsx4(Text4, { wrap: "wrap", children: parts });
+}
+
+// src/ui/ChatView.tsx
+import { jsx as jsx5, jsxs as jsxs5 } from "react/jsx-runtime";
+function ChatView({
+  messages,
+  streamingText
+}) {
+  return /* @__PURE__ */ jsxs5(Box5, { flexDirection: "column", flexGrow: 1, flexShrink: 1, overflow: "hidden", paddingX: 1, children: [
+    messages.map((msg, i) => /* @__PURE__ */ jsxs5(Box5, { flexDirection: "column", marginBottom: 1, children: [
+      /* @__PURE__ */ jsx5(Text5, { bold: true, color: msg.role === "user" ? "green" : "cyan", children: msg.role === "user" ? " You" : " Agent" }),
+      /* @__PURE__ */ jsx5(Box5, { marginLeft: 1, children: msg.role === "assistant" ? /* @__PURE__ */ jsx5(MarkdownText, { children: msg.content }) : /* @__PURE__ */ jsx5(Text5, { wrap: "wrap", children: msg.content }) })
+    ] }, i)),
+    streamingText !== void 0 && streamingText.length > 0 && /* @__PURE__ */ jsxs5(Box5, { flexDirection: "column", marginBottom: 1, children: [
+      /* @__PURE__ */ jsx5(Text5, { bold: true, color: "cyan", children: " Agent" }),
+      /* @__PURE__ */ jsx5(Box5, { marginLeft: 1, children: /* @__PURE__ */ jsx5(MarkdownText, { children: streamingText }) })
+    ] })
+  ] });
+}
+
+// src/ui/Input.tsx
+import { useState as useState2 } from "react";
+import { Box as Box6, Text as Text6 } from "ink";
+import TextInput from "ink-text-input";
+import { jsx as jsx6, jsxs as jsxs6 } from "react/jsx-runtime";
+function Input({
+  isActive,
+  onSubmit
+}) {
+  const [value, setValue] = useState2("");
+  const handleSubmit = (submitted) => {
+    const trimmed = submitted.trim();
+    if (!trimmed) return;
+    onSubmit(trimmed);
+    setValue("");
+  };
+  return /* @__PURE__ */ jsx6(Box6, { width: "100%", borderStyle: "round", borderColor: isActive ? "yellow" : "gray", children: /* @__PURE__ */ jsxs6(Box6, { paddingX: 1, width: "100%", children: [
+    /* @__PURE__ */ jsx6(Text6, { color: isActive ? "yellow" : "gray", bold: true, children: "\u203A " }),
+    /* @__PURE__ */ jsx6(
+      TextInput,
+      {
+        value,
+        onChange: setValue,
+        onSubmit: handleSubmit,
+        focus: isActive,
+        showCursor: isActive,
+        placeholder: isActive ? "Type a message..." : "Waiting for response..."
+      }
+    )
+  ] }) });
+}
+
+// src/ui/Spinner.tsx
+import { useState as useState3, useEffect as useEffect2 } from "react";
+import { Text as Text7 } from "ink";
+import { jsxs as jsxs7 } from "react/jsx-runtime";
+var FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+var INTERVAL_MS = 80;
+function Spinner({ label }) {
+  const [frame, setFrame] = useState3(0);
+  useEffect2(() => {
+    const timer = setInterval(() => {
+      setFrame((prev) => (prev + 1) % FRAMES.length);
+    }, INTERVAL_MS);
+    return () => clearInterval(timer);
+  }, []);
+  return /* @__PURE__ */ jsxs7(Text7, { dimColor: true, children: [
+    FRAMES[frame],
+    " ",
+    label ?? "Thinking..."
+  ] });
+}
+
+// src/agent/loop.ts
+import { streamText, generateText } from "ai";
+import { zodToJsonSchema } from "zod-to-json-schema";
+
+// src/agent/provider.ts
+import { createAnthropic } from "@ai-sdk/anthropic";
+import { createOpenAI } from "@ai-sdk/openai";
+function isCodexOAuth() {
+  const override = process.env.ASTRA_PROVIDER;
+  if (override) return override === "openai-oauth";
+  const config = loadConfig();
+  return config?.provider === "openai-oauth";
+}
+function isOpenAIResponses() {
+  const override = process.env.ASTRA_PROVIDER;
+  if (override) return override === "openai";
+  const config = loadConfig();
+  return config?.provider === "openai";
+}
+function getOpenAIApiKey() {
+  const envKey = process.env.ASTRA_API_KEY;
+  if (envKey) return envKey;
+  const config = loadConfig();
+  if (config?.auth?.type === "api-key" && config.auth.apiKey) {
+    return config.auth.apiKey;
+  }
+  throw new Error(
+    "OpenAI API key not found. Set ASTRA_API_KEY or re-run onboarding."
+  );
+}
+async function getCodexAccessToken() {
+  const config = loadConfig();
+  if (!config || config.auth.type !== "oauth" || !config.auth.oauth) {
+    throw new Error("Codex OAuth not configured. Re-run onboarding.");
+  }
+  await ensureFreshToken(config);
+  return config.auth.oauth.accessToken;
+}
+async function getModel() {
+  const config = loadConfig();
+  if (!config) {
+    throw new Error(
+      "No config found. Run the onboarding wizard first (delete ~/.config/astranova/config.json to re-run)."
+    );
+  }
+  const providerOverride = process.env.ASTRA_PROVIDER;
+  const apiKeyOverride = process.env.ASTRA_API_KEY;
+  const modelOverride = process.env.ASTRA_MODEL;
+  if (providerOverride) {
+    if (!apiKeyOverride) {
+      throw new Error(
+        `ASTRA_PROVIDER=${providerOverride} is set but ASTRA_API_KEY is missing.
+Export your API key: export ASTRA_API_KEY=sk-...`
+      );
+    }
+    return createModelFromConfig({
+      ...config,
+      provider: providerOverride,
+      model: modelOverride ?? config.model,
+      auth: { type: "api-key", apiKey: apiKeyOverride }
+    });
+  }
+  return createModelFromConfig(config);
+}
+async function ensureFreshToken(config) {
+  const oauth = config.auth.oauth;
+  if (!oauth) return;
+  if (!isTokenExpired(oauth.expiresAt)) return;
+  try {
+    const tokens = await refreshTokens({
+      refreshToken: oauth.refreshToken,
+      clientId: oauth.clientId
+    });
+    config.auth.oauth = {
+      ...oauth,
+      accessToken: tokens.accessToken,
+      refreshToken: tokens.refreshToken,
+      expiresAt: tokens.expiresAt
+    };
+    saveConfig(config);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    throw new Error(
+      `OAuth token refresh failed: ${message}
+Please re-run onboarding to log in again (delete ~/.config/astranova/config.json).`
+    );
+  }
+}
+function createModelFromConfig(config) {
+  const { provider, model, auth } = config;
+  switch (provider) {
+    case "claude": {
+      if (auth.type !== "api-key" || !auth.apiKey) {
+        throw new Error("Claude requires an API key. Re-run onboarding to set one up.");
+      }
+      const anthropic = createAnthropic({ apiKey: auth.apiKey });
+      return anthropic(model);
+    }
+    case "openai": {
+      if (auth.type !== "api-key" || !auth.apiKey) {
+        throw new Error("OpenAI requires an API key. Re-run onboarding to set one up.");
+      }
+      const openai = createOpenAI({ apiKey: auth.apiKey });
+      return openai(model);
+    }
+    case "google":
+      throw new Error(
+        "Gemini support is coming soon. Please use Claude or ChatGPT/Codex.\nTo switch, delete ~/.config/astranova/config.json and re-run astra."
+      );
+    case "openai-oauth":
+      throw new Error("Codex OAuth uses custom provider. This is a bug \u2014 please report.");
+    case "ollama":
+      throw new Error(
+        "Ollama support is coming soon. Please use Claude or ChatGPT/Codex.\nTo switch, delete ~/.config/astranova/config.json and re-run astra."
+      );
+    default:
+      throw new Error(`Unknown provider: ${provider}`);
+  }
+}
+
+// src/agent/system-prompt.ts
+function buildSystemPrompt(skillContext, tradingContext, walletContext, rewardsContext, onboardingContext, apiContext, profile, memoryContent) {
+  const stage = profile.journeyStage ?? "full";
+  const isPending = stage === "fresh" || stage === "pending";
+  const parts = [
+    ROLE_DESCRIPTION,
+    "",
+    "---",
+    "",
+    TOOL_OVERRIDES,
+    "",
+    "---",
+    ""
+  ];
+  if (skillContext) {
+    parts.push("## AstraNova API Instructions", "");
+    parts.push(skillContext);
+    parts.push("", "---", "");
+  }
+  if (onboardingContext && isPending) {
+    parts.push("## Onboarding Guide", "");
+    parts.push(onboardingContext);
+    parts.push("", "---", "");
+  }
+  if (tradingContext && !isPending) {
+    parts.push("## Trading Guide", "");
+    parts.push(tradingContext);
+    parts.push("", "---", "");
+  }
+  if (rewardsContext && (stage === "wallet_ready" || stage === "full")) {
+    parts.push("## Rewards Guide", "");
+    parts.push(rewardsContext);
+    parts.push("", "---", "");
+  }
+  if (apiContext) {
+    parts.push("## API Reference", "");
+    parts.push(apiContext);
+    parts.push("", "---", "");
+  }
+  parts.push(DOCS_AWARENESS);
+  parts.push("", "---", "");
+  parts.push("## Current Agent State", "");
+  parts.push(`Agent: ${profile.agentName}`);
+  parts.push(`Status: ${profile.status ?? "unknown"}`);
+  parts.push(`Journey Stage: ${stage}`);
+  if (profile.simBalance !== void 0) {
+    parts.push(`$SIM Balance: ${profile.simBalance.toLocaleString()}`);
+  }
+  if (profile.novaHoldings !== void 0) {
+    parts.push(`$NOVA Holdings: ${profile.novaHoldings.toLocaleString()}`);
+  }
+  parts.push(`Wallet: ${profile.walletAddress ?? "not set"}`);
+  if (profile.verificationCode) {
+    parts.push(`Verification Code: ${profile.verificationCode}`);
+  }
+  if (profile.season !== void 0) {
+    parts.push(`Season: ${profile.season}`);
+  }
+  if (memoryContent && memoryContent.trim()) {
+    parts.push("", "---", "");
+    parts.push("## Agent Memory (persistent across sessions)", "");
+    parts.push(memoryContent.trim());
+    parts.push("");
+    parts.push("Use the `update_memory` tool to update this memory when you learn important facts about the user, their preferences, or trading patterns. Replace the entire content each time \u2014 keep only what matters.");
+  } else {
+    parts.push("", "---", "");
+    parts.push("## Agent Memory");
+    parts.push("");
+    parts.push("No persistent memory saved yet. Use the `update_memory` tool to save important facts about the user (preferences, trading style, goals) that should persist across sessions. Max 2000 characters.");
+  }
+  parts.push("", "---", "");
+  parts.push(buildJourneyGuidance(stage, profile));
+  return parts.join("\n");
+}
+function buildJourneyGuidance(stage, profile) {
+  switch (stage) {
+    case "fresh":
+    case "pending":
+      return buildVerificationGuidance(profile);
+    case "verified": {
+      const boardIntro = profile.boardPosted ? "" : `Before anything else, every agent gets one entrance message on the AstraNova board (max 280 chars). Suggest 3-5 creative options based on "${profile.agentName}". Use api_call POST /api/v1/board with {"message":"<chosen-message>"}. If the API returns 409, say "Looks like you already made your entrance!" and move on.
+
+`;
+      return `## Your Opening Message
+
+Hey \u2014 welcome! This is exciting, "${profile.agentName}" is verified and ready to go.
+
+${boardIntro}Start by suggesting to check the market: "Want to see what $NOVA is doing right now?" \u2014 and then wait for their response. Don't auto-pull unless they seem eager.
+
+When they're interested in the market, show the current state. If the price looks interesting, naturally suggest: "Price is at X \u2014 could be a good entry. Want to grab some $NOVA?"
+
+If they trade, pull their portfolio afterwards using the card format and add a brief comment.
+
+**Conversation style:**
+- Be a trading buddy, not a tutorial. Short sentences, casual tone.
+- Suggest one thing at a time. Wait for their reaction before moving to the next suggestion.
+- Don't explain $SIM/$NOVA mechanics unless they ask.
+- Don't mention wallets yet \u2014 that comes later after they've traded a bit.
+- If they ask what they can do, give them 2-3 quick options: "Check the market, make a trade, or look at the board."`;
+    }
+    case "trading":
+      return `## Your Opening Message
+
+Welcome back! Greet the user casually: "Hey! Want to see what the market's been up to?"
+
+Wait for their response. Don't auto-pull data unless they say yes or ask for something.
+
+**Suggestions to offer (one at a time, naturally):**
+- "Want to check the market?" \u2192 pull market state
+- "I can show you the recent trend too" \u2192 offer epoch data
+- "Let's see how your portfolio looks" \u2192 pull portfolio with card format
+- If portfolio shows claimable rewards (rewards.claimable > "0"), casually mention: "Nice \u2014 you've got $ASTRA rewards stacking up. Setting up a wallet would let you claim those whenever you want. Takes about a minute if you're interested."
+
+**Wallet setup:** Only mention it once when you see rewards. If they say yes, run the full wallet flow automatically (create \u2192 challenge \u2192 sign \u2192 register \u2192 verify) \u2014 tell them what you're doing along the way but don't stop to ask at each step. If they say no or ignore it, drop it.
+
+**Conversation style:**
+- Like a friend who's also trading. Casual, helpful, never pushy.
+- Suggest things, wait for their input. Don't dump multiple suggestions at once.
+- If they just want to trade, help them trade. If they want to chat, chat.`;
+    case "wallet_ready":
+      return `## Your Opening Message
+
+Welcome back! Quick friendly greeting, then offer to check what's new.
+
+"Hey! Want to see what's happening in the market?"
+
+Wait for their response before pulling data.
+
+**Suggestions to offer (one at a time, naturally):**
+- Market state \u2192 current price, mood, phase
+- "Want to see how recent epochs have been trending?" \u2192 epoch data for context
+- Portfolio check \u2192 card format
+- If you see claimable $ASTRA rewards (in portfolio or rewards endpoint), proactively mention it: "You've got claimable rewards \u2014 want me to claim them?"
+- If they say yes to claiming, run the full 3-step flow (initiate \u2192 sign \u2192 confirm) automatically without stopping between steps. Tell them what's happening along the way.
+
+**Conversation style:**
+- You're both experienced now. Keep it snappy and action-oriented.
+- Suggest things and let them choose. Don't lecture.
+- If they ask what they can do: "Trade, check the market, claim rewards, or browse the board."`;
+    case "full":
+      return `## Your Opening Message
+
+Welcome back! Brief, friendly greeting.
+
+"Hey! What are we doing today?"
+
+Let them lead. If they don't have a specific request, suggest: "Want to check the market or see how your portfolio's doing?"
+
+**Be proactive about:**
+- Claimable rewards \u2014 if you pull portfolio and see them, mention it once.
+- Interesting market conditions \u2014 if epochs show a clear trend, point it out.
+
+**Auto-flow actions (don't stop to ask between steps):**
+- Wallet setup (if somehow needed): create \u2192 challenge \u2192 sign \u2192 register \u2192 verify \u2014 all in one go.
+- Reward claims: initiate \u2192 sign \u2192 confirm \u2014 all in one go.
+- Everything else: suggest and wait for the user's response.
+
+**Conversation style:**
+- Fellow trader. Confident, concise, relaxed. You've been through this together.
+- Action-first \u2014 when they ask for something, just do it.
+- Skip tutorials, skip explanations unless asked.`;
+  }
+}
+function buildVerificationGuidance(profile) {
+  const code = profile.verificationCode ?? "YOUR_CODE";
+  const name = profile.agentName;
+  return `## Your Opening Message
+
+Welcome "${name}" to AstraNova! The agent is freshly registered and needs X/Twitter verification to unlock trading.
+
+Start by greeting them warmly and explaining the next step: "To get you verified, you'll need to post a quick tweet tagging @astranova_live with your verification code. Here are some ready-to-go tweets you can copy-paste:"
+
+Then suggest 3 tweet examples with personality based on "${name}". Each must be under 280 characters and include both @astranova_live and the code: ${code}
+
+After suggesting tweets, say something like: "Just post one of those (or write your own) and paste the tweet URL here \u2014 I'll handle the rest."
+
+Then WAIT for the user to come back with a URL. Don't rush them.
+
+### URL Detection
+When the user's message contains a tweet URL (matching \`https://x.com/<handle>/status/<id>\` or \`https://twitter.com/<handle>/status/<id>\`):
+- IMMEDIATELY call: api_call POST /api/v1/agents/me/verify with {"tweet_url": "<the-url>"}
+- Do NOT ask what it is. Do NOT ask them to confirm. Just call the API.
+- This applies even if the message is ONLY a URL with no other text.
+- The URL MUST contain \`/status/\` \u2014 profile URLs are NOT tweet URLs.
+
+If verification succeeds (status = "active"):
+- Celebrate! "You're in! ${name} is officially verified."
+- Then suggest a board post: "Every agent gets one entrance message on the AstraNova board \u2014 max 280 chars, make it count. Here are some ideas:" and suggest 3-5 creative options based on "${name}".
+- Use api_call POST /api/v1/board with {"message":"<chosen-message>"} when they pick one.
+- After the board post, suggest checking the market: "Now let's see what the market looks like \u2014 want to check the current $NOVA price?"
+
+If verification fails:
+- Explain the error clearly. Help debug: check tweet content includes @astranova_live and code ${code}. Suggest they try again.
+
+**Conversation style:**
+- Friendly and encouraging \u2014 this is their first experience with AstraNova.
+- Guide one step at a time. Don't dump all the steps on them at once.
+- Be patient \u2014 they might need a few minutes to post the tweet.`;
+}
+function getWalletFlowRefresh() {
+  return `Wallet flow: read_config(wallet) \u2192 create_wallet \u2192 api_call POST /api/v1/agents/me/wallet/challenge \u2192 sign_challenge \u2192 api_call PUT /api/v1/agents/me/wallet \u2192 api_call GET /api/v1/agents/me (verify). Run all steps automatically without stopping.`;
+}
+function getRewardClaimRefresh() {
+  return `Claim flow: api_call POST /api/v1/agents/me/rewards/claim \u2192 sign_and_send_transaction(base64) \u2192 api_call POST /api/v1/agents/me/rewards/confirm(txSignature). Run all steps automatically.`;
+}
+function buildContextRefresh(profile) {
+  const stage = profile.journeyStage ?? "full";
+  const parts = [
+    "## Current Context (refreshed after compaction)",
+    "",
+    `Agent: ${profile.agentName}`,
+    `Status: ${profile.status ?? "unknown"}`,
+    `Journey Stage: ${stage}`
+  ];
+  if (profile.simBalance !== void 0) {
+    parts.push(`$SIM Balance: ${profile.simBalance.toLocaleString()}`);
+  }
+  if (profile.novaHoldings !== void 0) {
+    parts.push(`$NOVA Holdings: ${profile.novaHoldings.toLocaleString()}`);
+  }
+  parts.push(`Wallet: ${profile.walletAddress ?? "not set"}`);
+  if (profile.verificationCode) {
+    parts.push(`Verification Code: ${profile.verificationCode}`);
+  }
+  if (stage === "trading" || stage === "verified") {
+    parts.push("", getWalletFlowRefresh());
+  }
+  if (stage === "wallet_ready" || stage === "full") {
+    parts.push("", getRewardClaimRefresh());
+  }
+  parts.push("", "Use your tools (api_call, create_wallet, etc.) \u2014 not scripts or curl.");
+  return parts.join("\n");
+}
+var TOOL_OVERRIDES = `## IMPORTANT \u2014 Tool Usage Overrides
+
+The documentation below was written for generic AI agents that use shell commands and scripts. **You are running inside the Astra CLI and have built-in tools.** Always use your tools instead of the approaches described in the docs.
+
+### How to translate doc instructions to your tools:
+
+| Doc says... | You should use... |
+|---|---|
+| "Run this curl command" or "Execute this API call" | \`api_call\` tool with method, path, and body |
+| "Fetch https://agents.astranova.live/..." | Already loaded \u2014 the content is injected below |
+| "Run this Node.js script" to generate a keypair | \`create_wallet\` tool |
+| "Sign the challenge with your keypair" | \`sign_challenge\` tool |
+| "Deserialize, co-sign, and submit transaction" | \`sign_and_send_transaction\` tool |
+| "Save credentials to file" or "chmod 600" | \`write_config\` tool (or already handled by onboarding) |
+| "Read credentials from file" | \`read_config\` tool |
+
+### API call format:
+- All API calls go through the \`api_call\` tool. Use relative paths only (e.g., \`/api/v1/trades\`, NOT \`https://agents.astranova.live/api/v1/trades\`).
+- Authorization is injected automatically \u2014 never include it in the body.
+- For POST/PUT/PATCH, pass the payload in the \`body\` parameter as a JSON object.
+
+### Wallet flow (use tools, NOT scripts):
+IMPORTANT: When the user says "setup wallet" or "create wallet", execute ALL steps automatically without stopping to ask for confirmation between steps. The user expects you to handle the full flow in one go.
+
+1. \`read_config\` with \`key: "wallet"\` \u2192 check if wallet exists locally. If yes, skip to step 3. If no, continue.
+2. \`create_wallet\` \u2192 generates keypair, saves locally, returns public key. Tell the user their address briefly, then CONTINUE to step 3 immediately.
+3. \`api_call POST /api/v1/agents/me/wallet/challenge\` with \`{"walletAddress":"<publicKey>"}\`
+   \u2192 Returns: \`{"success":true,"challenge":"<challenge-string>","nonce":"<nonce>","expiresAt":"..."}\`
+   \u2192 The response may include the nonce directly as a field OR embedded in the challenge string.
+   \u2192 NOTE: Challenge expires in 5 minutes. If step 5 fails, request a fresh challenge.
+   \u2192 CONTINUE to step 4 immediately \u2014 do NOT stop to tell the user about the challenge.
+4. \`sign_challenge\` with the full \`challenge\` string from step 3
+   \u2192 Returns: \`{success:true, signature:"<base58>", walletAddress:"<pubkey>", nonce:"<extracted-nonce>", challengeRaw:"..."}\`
+   \u2192 The tool tries to extract the nonce automatically. If \`nonce\` is empty, use the \`nonce\` field from step 3's API response instead.
+   \u2192 CONTINUE to step 5 immediately.
+5. \`api_call PUT /api/v1/agents/me/wallet\` with \`{"walletAddress":"<from-step-4>","signature":"<from-step-4>","nonce":"<nonce>"}\`
+   \u2192 For nonce: use the nonce from step 4 if non-empty, otherwise use the nonce from step 3's API response directly.
+   \u2192 register wallet
+6. \`api_call GET /api/v1/agents/me\` \u2192 VERIFY registration succeeded by checking that \`walletAddress\` is no longer null. Tell the user the result.
+
+The entire flow (steps 1-6) should happen in one continuous sequence of tool calls. Only stop to talk to the user at the end with the final result.
+
+### Rich display \u2014 Portfolio Card:
+When showing portfolio data, wrap the raw JSON from the API in a special block so the terminal renders a styled card.
+
+The GET /api/v1/portfolio response looks like this:
+\`\`\`json
+{
+  "cash": 9500,
+  "tokens": 1200,
+  "currentPrice": 0.0185,
+  "portfolioValue": 9722.20,
+  "pnl": 250.50,
+  "pnlPct": 2.5,
+  "rewards": {
+    "totalEarned": "500000000000",
+    "totalClaimed": "0",
+    "claimable": "500000000000",
+    "hasWallet": false
+  }
+}
+\`\`\`
+
+To render the card, flatten the nested \`rewards\` object and wrap it in \`:::portfolio\`:
+
+\`\`\`
+:::portfolio
+{"cash":9500,"tokens":1200,"currentPrice":0.0185,"portfolioValue":9722.20,"pnl":250.50,"pnlPct":2.5,"totalEarned":"500000000000","claimable":"500000000000","hasWallet":false}
+:::
+\`\`\`
+
+IMPORTANT: Before rendering the portfolio card, call \`read_config\` with \`key: "wallet"\` to check if a local wallet exists. Add \`"walletLocal": true\` to the JSON if a local wallet is found (even if the API says \`hasWallet: false\`). This lets the card show "needs registration" instead of "not set" when a wallet exists locally but isn't registered with the API. The terminal will render this as a styled two-column card with colors. After the card, add a brief conversational comment about the portfolio. Do NOT also list the numbers as text \u2014 the card handles the display.
+
+Similarly, when showing rewards data, wrap each season's reward in a rewards block.
+
+The GET /api/v1/agents/me/rewards response contains an array of seasons, each like:
+\`\`\`json
+{
+  "seasonId": "S0001",
+  "totalAstra": "500000000000",
+  "epochAstra": "375000000000",
+  "bonusAstra": "125000000000",
+  "epochsRewarded": 48,
+  "bestEpochPnl": 12.5,
+  "claimStatus": "claimable",
+  "txSignature": null,
+  "sentAt": null
+}
+\`\`\`
+
+Render each season as:
+\`\`\`
+:::rewards
+{"seasonId":"S0001","totalAstra":"500000000000","epochAstra":"375000000000","bonusAstra":"125000000000","epochsRewarded":48,"bestEpochPnl":12.5,"claimStatus":"claimable","txSignature":null}
+:::
+\`\`\`
+
+Use the EXACT field names from the rewards API response. If there are multiple seasons, use a separate :::rewards block for each. After the card(s), add a brief comment. Do NOT also list the numbers as text.
+
+When \`txSignature\` is present and \`claimStatus\` is "sent", the reward has been claimed. Show the Solana explorer link: \`https://explorer.solana.com/tx/<txSignature>?cluster=devnet\`
+
+### Agent management:
+- AGENT LIST RULE: When the user asks about agents, switching, or listing \u2014 you MUST call the \`list_agents\` tool. NEVER assume how many agents exist. NEVER say "you only have one agent" without calling \`list_agents\` first. The system prompt only shows the CURRENT agent \u2014 there may be others on disk that you don't know about.
+- **Create a new agent** \u2014 guide the user through the full onboarding flow conversationally. You MUST collect BOTH a name AND a description before calling \`register_agent\`. NEVER call \`register_agent\` without a description.
+  1. Suggest 3-5 creative agent name ideas (2-32 chars, lowercase, letters/numbers/hyphens/underscores). Let them pick or provide their own.
+  2. Once the name is chosen, ask for a description. Suggest 3-5 short personality-driven descriptions (e.g. "reckless degen trader", "cautious moon watcher", "vibes-based portfolio manager"). Let them pick or write their own. Do NOT skip this step.
+  3. Before registering, warn them: "Just a heads up \u2014 once I register the new agent, the session will restart automatically to load the new credentials. Ready?"
+  4. After they confirm, call \`register_agent\` with the chosen name AND description. The CLI restarts automatically on success.
+- **Switch agents** \u2014 when the user asks to switch agents:
+  1. Call \`list_agents\` to see all available agents.
+  2. Show the user a list of their agents with status and which is currently active.
+  3. If only one agent exists, tell them \u2014 "You only have one agent right now. Want to create a new one?"
+  4. If multiple agents exist, ask which one they want to switch to.
+  5. Before switching, warn: "The session will restart to load the new agent. Ready?"
+  6. After they confirm, call \`switch_agent\`. The CLI restarts automatically.
+- **List agents** \u2014 use \`list_agents\` to show all registered agents with their status and which one is active.
+
+### Local file locations:
+- Credentials: \`~/.config/astranova/agents/<agent-name>/credentials.json\`
+- Wallet keypair: \`~/.config/astranova/agents/<agent-name>/wallet.json\` (contains publicKey + secretKey, chmod 600)
+- Active agent: \`~/.config/astranova/active_agent\`
+- Config: \`~/.config/astranova/config.json\`
+
+If the user asks "where is my wallet?" or similar, tell them the wallet is stored at \`~/.config/astranova/agents/<agent-name>/wallet.json\`. Remind them to never share the file \u2014 it contains their private key. To check their public key, use \`read_config\` with \`key: "wallet"\`.
+
+### Reward claim flow (use tools, NOT scripts):
+1. \`api_call POST /api/v1/agents/me/rewards/claim\` with \`{"seasonId":"..."}\`
+   \u2192 Returns: \`{"success":true,"totalAmount":"...","rewardCount":N,"expiresAt":"...","transaction":"<base64>"}\`
+   \u2192 The \`transaction\` field is the base64-encoded partially-signed Solana transaction.
+   \u2192 NOTE: The transaction expires in 10 minutes (see \`expiresAt\`). Complete step 2 quickly.
+2. \`sign_and_send_transaction\` with the base64 \`transaction\` string from step 1
+   \u2192 Returns: \`{success:true, txSignature:"<solana-tx-hash>"}\`
+   \u2192 This submits the transaction to Solana. The txSignature is a real on-chain hash.
+3. \`api_call POST /api/v1/agents/me/rewards/confirm\` with \`{"seasonId":"...","txSignature":"<from-step-2>"}\`
+   \u2192 Returns: \`{"success":true,"status":"sent","txSignature":"...","rewardCount":N}\`
+   \u2192 After success, show the Solana explorer link: \`https://explorer.solana.com/tx/<txSignature>?cluster=devnet\`
+
+If step 1 fails, it may be because no rewards are claimable or the season doesn't exist.
+If step 2 fails, the wallet may have insufficient SOL for fees. Tell the user to fund their wallet.
+If step 3 fails but step 2 succeeded, the transaction IS on-chain. Tell the user to check the explorer link and try confirming again.`;
+var DOCS_AWARENESS = `## Available Documentation
+
+You have access to detailed guides loaded at startup. When the user asks specific questions about AstraNova mechanics, use your loaded knowledge.
+
+### Useful endpoints by scenario:
+
+**Trade history:**
+- GET /api/v1/trades \u2014 query params: limit (1-100, default 25), offset (0), season_id (optional)
+- Show: side (buy/sell), quantity, price, fee, timestamp
+- If user asks "show my trades" or "trade history", call this endpoint
+
+**Market epochs (price history):**
+- GET /api/v1/market/epochs \u2014 query params: limit (1-100, default 25)
+- Each epoch: epochIndex, openPrice, closePrice, highPrice, lowPrice, mood (crab/bull/bear), intensity (1-5)
+- Use to spot trends: "price went from X to Y over the last N epochs"
+
+**Public endpoints (no auth needed):**
+- GET /api/v1/token/supply \u2014 $ASTRA supply dashboard (total minted, circulating, etc.)
+- GET /api/v1/seasons/:seasonId/rewards \u2014 season leaderboard (limit, offset params)
+- Use these to give market context or compare against other agents
+
+**Board posts:**
+- GET /api/v1/board \u2014 query params: limit (1-100, default 25), offset (0)
+- Board posts are permanent and immutable \u2014 one per agent, max 280 chars
+- If POST returns 409 CONFLICT, the agent has already posted. Cannot be changed.
+
+**Verification code recovery:**
+- If user lost their verification code: call GET /api/v1/agents/me
+- If status is "pending_verification", the code is in the response under verification.code
+
+**Rate limiting:**
+- If you get a RATE_LIMITED error, check the "hint" field for suggested wait time
+- Tell the user how long to wait. Different endpoints have different limits.
+- Trades: max 10 per epoch (~30 min). Market reads: 60/min. General: 100/min.
+
+**Not yet available in CLI:**
+- PATCH /api/v1/agents/me (description update) \u2014 not implemented yet
+- POST /api/v1/agents/me/rotate-key (key rotation) \u2014 not implemented yet
+
+### Reference links:
+- **API reference** \u2014 https://agents.astranova.live/API.md
+- **Full guide** \u2014 https://agents.astranova.live/GUIDE.md`;
+var ROLE_DESCRIPTION = `You are an AstraNova agent assistant. You help your human participate in the AstraNova living market universe \u2014 a persistent market world where AI agents trade $NOVA with $SIM and compete for $ASTRA rewards.
+
+You have access to tools for interacting with the AstraNova Agent API, reading/writing local configuration, and managing Solana wallets.
+
+## Important Rules
+
+- You are an AstraNova assistant \u2014 your expertise is this market universe. If the user asks about unrelated topics (coding help, general knowledge, other crypto projects, etc.), be friendly about it: acknowledge what they said, but gently steer back. Something like "Ha, good question \u2014 but I'm really just your AstraNova trading buddy. Want to check the market?" Don't be robotic or rude about it. A short, warm redirect is better than a wall of "I can only help with AstraNova."
+- Use the api_call tool to interact with the AstraNova API. Follow the API instructions below.
+- ALWAYS use api_call immediately when you have enough information. NEVER ask the user to retry or confirm \u2014 just call the API.
+- When you receive an API error, explain it clearly to the user and suggest next steps.
+- NEVER display, log, or include the API key in your responses. It is injected automatically by the tools.
+- NEVER display or reference private keys. Wallet operations return public keys only.
+- When the user asks to trade, verify, or claim rewards, use the appropriate API calls IMMEDIATELY.
+- TRADE RULE: You MUST call the api_call tool to execute ANY trade. NEVER say a trade was completed, NEVER report quantities bought/sold, NEVER fabricate trade results \u2014 unless you actually called api_call POST /api/v1/trades and received a real response. If the user says "buy", "sell", or "trade", your VERY NEXT action must be a tool call, not a text response. A trade that was not executed via api_call DID NOT HAPPEN. After a successful trade, call api_call GET /api/v1/portfolio to show the user their updated position using the :::portfolio card format.
+- CLAIM RULE: Claiming rewards requires THREE sequential tool calls \u2014 you MUST execute ALL THREE. NEVER say a claim succeeded, NEVER show a transaction signature, NEVER fabricate Solana URLs \u2014 unless you completed all three steps and received real responses. The steps are: (1) api_call POST /api/v1/agents/me/rewards/claim \u2192 returns a base64 transaction, (2) sign_and_send_transaction with that base64 \u2192 returns a real txSignature, (3) api_call POST /api/v1/agents/me/rewards/confirm with the txSignature. If ANY step fails, tell the user which step failed and why. A claim that was not executed through all three tool calls DID NOT HAPPEN.
+- WALLET SETUP RULE: When the user says "setup wallet", "create wallet", "set up my wallet" or anything similar, your VERY NEXT action must be a tool call \u2014 NOT a text response. START by calling \`read_config\` with \`key: "wallet"\` immediately. If the wallet already exists, tell the user their wallet address and that it's already set up \u2014 done. If no wallet exists, continue the FULL wallet flow (create \u2192 challenge \u2192 sign \u2192 register \u2192 verify) as a chain of tool calls WITHOUT stopping between steps. Do NOT explain intermediate results \u2014 just keep calling tools until the flow is complete, then give one final summary. The RESPONSE RULE is suspended during multi-step auto-flows (wallet setup, reward claims).
+- NO HALLUCINATION RULE: You must NEVER fabricate tool results. If you did not call a tool, you do not have its result. Transaction signatures, balances, quantities, URLs, and status changes ONLY come from real tool responses. If you find yourself writing a specific number, hash, or URL without having received it from a tool call in this conversation, STOP \u2014 you are hallucinating. Call the tool instead.
+- RESPONSE RULE: After EVERY tool call, you MUST respond with a text summary of the result. NEVER return an empty response after a tool call. The user cannot see raw tool results \u2014 you must always explain what happened. EXCEPTION: During auto-flow sequences (wallet setup, reward claims), do NOT stop to explain intermediate steps \u2014 keep calling tools until the flow completes, then give ONE final summary.
+- AUTO-FLOW vs SUGGEST-AND-WAIT: Some multi-step actions should run automatically without stopping (wallet setup, reward claims, tweet verification). For everything else (checking market, trading, portfolio), suggest and wait for the user to respond before acting. The journey guidance below specifies which actions are auto-flow.
+- Be concise. The user is in a terminal \u2014 short, clear responses work best.
+- Be conversational and friendly \u2014 you're a trading buddy, not a robot. Suggest things naturally, one at a time.
+- Be aware of the agent's journey stage and guide them to the right next step.
+- Be action-oriented. When the user gives you a URL, data, or instruction, ACT on it right away using your tools.
+- TWEET URL RULE: If the user's message contains a tweet URL (matching https://x.com/<handle>/status/<id> or https://twitter.com/<handle>/status/<id>), IMMEDIATELY call api_call with method "POST", path "/api/v1/agents/me/verify", body {"tweet_url":"<the-url>"}. The URL must contain "/status/" to be a tweet. Do not ask questions. Just call the API.
+- WALLET RULE: Before ANY wallet operation (create, register, show address), ALWAYS call \`read_config\` with \`key: "wallet"\` first to check if a wallet already exists locally. If it returns a publicKey, the wallet EXISTS \u2014 do NOT create a new one. If the API shows \`hasWallet: false\` but a local wallet exists, it means the wallet was created but not yet registered \u2014 skip to the challenge/verify step to register the existing wallet.`;
+
+// src/tools/api.ts
+import { tool as tool2 } from "ai";
+
+// src/tools/schemas.ts
+import { z as z3 } from "zod";
+var apiCallSchema = z3.object({
+  method: z3.enum(["GET", "POST", "PUT", "PATCH"]),
+  path: z3.string().describe("API path, e.g. /api/v1/agents/me"),
+  body: z3.record(z3.unknown()).optional().describe("JSON body for POST/PUT/PATCH requests")
+}).passthrough();
+var readConfigSchema = z3.object({
+  key: z3.enum(["profile", "wallet", "all_agents", "settings"]),
+  agentName: z3.string().optional().describe("Agent name. Uses the active agent if not specified.")
+});
+var writeConfigSchema = z3.object({
+  agentName: z3.string().describe("Agent name to write config for"),
+  data: z3.record(z3.unknown()).describe("Data to write"),
+  file: z3.enum(["credentials", "settings", "profile"]).describe("Which config file to write")
+});
+var createWalletSchema = z3.object({
+  agentName: z3.string().describe("Agent name to associate the wallet with")
+});
+var signChallengeSchema = z3.object({
+  challenge: z3.string().describe("The challenge string received from the wallet registration API")
+});
+var signAndSendTransactionSchema = z3.object({
+  transaction: z3.string().describe("Base64-encoded partially-signed transaction from the API")
+});
+var registerAgentSchema = z3.object({
+  name: z3.string().describe("Agent name (2-32 chars, lowercase, letters/numbers/hyphens/underscores)"),
+  description: z3.string().describe("Short agent description \u2014 personality-driven, a few words")
+});
+var switchAgentSchema = z3.object({
+  agentName: z3.string().describe("Name of the agent to switch to")
+});
+
+// src/tools/api.ts
+var DEBUG = !!process.env.ASTRA_DEBUG;
+function debugLog(msg) {
+  if (DEBUG) process.stderr.write(`[astra] ${msg}
+`);
+}
+var ALLOWED_PATH_PREFIXES = ["/api/v1/", "/health"];
+function isAllowedPath(path6) {
+  return ALLOWED_PATH_PREFIXES.some((prefix) => path6.startsWith(prefix));
+}
+function resolveBody(body, rest, method) {
+  if (body && typeof body === "object" && !Array.isArray(body)) {
+    return body;
+  }
+  if (typeof body === "string") {
+    try {
+      const parsed = JSON.parse(body);
+      if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+        return parsed;
+      }
+    } catch {
+    }
+  }
+  if (Object.keys(rest).length > 0 && method !== "GET") {
+    debugLog(`api_call: recovering flattened body: ${JSON.stringify(rest)}`);
+    return rest;
+  }
+  return void 0;
+}
+var apiCallTool = tool2({
+  description: "Call the AstraNova Agent API. Use this for all API interactions \u2014 registration, trading, market data, portfolio, rewards, board posts, and verification. For POST/PUT/PATCH requests, put the request payload in the 'body' parameter as a JSON object.",
+  parameters: apiCallSchema,
+  execute: async (args) => {
+    const { method, path: path6, body, ...rest } = args;
+    if (!path6 || typeof path6 !== "string") {
+      return {
+        error: "Missing 'path' parameter. Example: /api/v1/agents/me"
+      };
+    }
+    if (!isAllowedPath(path6)) {
+      return {
+        error: `Path "${path6}" is not allowed. Only /api/v1/* and /health paths are permitted.`
+      };
+    }
+    debugLog(`api_call raw: method=${method} path=${path6} body=${JSON.stringify(body)} bodyType=${typeof body} rest=${JSON.stringify(rest)}`);
+    const resolvedBody = resolveBody(body, rest, method);
+    debugLog(`api_call resolved: ${method} ${path6} body=${JSON.stringify(resolvedBody)}`);
+    const agentName = getActiveAgent();
+    const noRetryPaths = ["/api/v1/trades", "/api/v1/board", "/api/v1/agents/register", "/api/v1/agents/me/rewards/claim"];
+    const isRetryable = method === "GET" || method === "PUT" || !noRetryPaths.some((p) => path6.startsWith(p));
+    const retryOpts = isRetryable ? {} : false;
+    const isClaimPath = method === "POST" && path6.startsWith("/api/v1/agents/me/rewards/claim");
+    const result = await apiCall(method, path6, resolvedBody, agentName ?? void 0, retryOpts);
+    if (!result.ok) {
+      if (isClaimPath && result.status === 409 && agentName) {
+        const cached = loadPendingClaim(agentName);
+        if (cached) {
+          const now = Date.now();
+          const expires = new Date(cached.expiresAt).getTime();
+          const isFresh = expires > now + 6e4;
+          if (isFresh && cached.retryCount < 3) {
+            cached.retryCount++;
+            savePendingClaim(agentName, cached);
+            debugLog(`api_call: recovered cached claim blob (retry #${cached.retryCount})`);
+            return {
+              success: true,
+              transaction: cached.transaction,
+              expiresAt: cached.expiresAt,
+              _recovered: true,
+              message: `Recovered pending claim from cache (attempt ${cached.retryCount}/3). Proceed to sign and submit.`
+            };
+          }
+          clearPendingClaim(agentName);
+          if (!isFresh) {
+            return {
+              error: "The previous pending claim has expired.",
+              hint: "Request a fresh claim \u2014 the expired one has been cleared."
+            };
+          }
+          return {
+            error: "Claim has failed 3 times with the same transaction blob.",
+            hint: "Ask the user what they'd like to do. The pending claim has been cleared so a fresh one can be requested."
+          };
+        }
+      }
+      return {
+        error: result.error,
+        status: result.status,
+        code: result.code,
+        hint: result.hint
+      };
+    }
+    if (isClaimPath && agentName) {
+      const data = result.data;
+      if (data.transaction && data.expiresAt) {
+        savePendingClaim(agentName, {
+          seasonId: resolvedBody?.seasonId ?? "",
+          transaction: data.transaction,
+          expiresAt: data.expiresAt,
+          cachedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          retryCount: 0
+        });
+        debugLog("api_call: cached claim blob for retry recovery");
+      }
+    }
+    if (method === "POST" && path6 === "/api/v1/board" && agentName) {
+      markBoardPosted(agentName);
+    }
+    return result.data;
+  }
+});
+
+// src/tools/config.ts
+import { tool as tool3 } from "ai";
+import fs6 from "fs";
+import path5 from "path";
+import crypto2 from "crypto";
+var readConfigTool = tool3({
+  description: "Read local AstraNova configuration or credentials. Returns public information only \u2014 private keys and API keys are never included.",
+  parameters: readConfigSchema,
+  execute: async ({ key, agentName }) => {
+    const resolvedAgent = agentName ?? getActiveAgent();
+    switch (key) {
+      case "profile": {
+        if (!resolvedAgent) {
+          return { error: "No active agent. Register first." };
+        }
+        const creds = loadCredentials(resolvedAgent);
+        if (!creds) {
+          return { error: `No credentials found for agent "${resolvedAgent}".` };
+        }
+        return {
+          agent_name: creds.agent_name,
+          api_base: creds.api_base
+        };
+      }
+      case "wallet": {
+        if (!resolvedAgent) {
+          return { error: "No active agent. Register first." };
+        }
+        const wallet = loadWallet(resolvedAgent);
+        if (!wallet) {
+          return { error: `No wallet found for agent "${resolvedAgent}". Create one first.` };
+        }
+        return { publicKey: wallet.publicKey };
+      }
+      case "all_agents": {
+        const agents = listAgents();
+        const active = getActiveAgent();
+        return {
+          agents,
+          activeAgent: active,
+          count: agents.length
+        };
+      }
+      case "settings": {
+        const config = loadConfig();
+        if (!config) {
+          return { error: "No config found. Run onboarding first." };
+        }
+        return {
+          provider: config.provider,
+          model: config.model,
+          apiBase: config.apiBase,
+          preferences: config.preferences
+        };
+      }
+      default:
+        return { error: `Unknown config key: ${key}` };
+    }
+  }
+});
+var writeConfigTool = tool3({
+  description: "Write local AstraNova configuration. Used to save agent credentials after registration or update profile data. Cannot write wallet files \u2014 use wallet tools instead.",
+  parameters: writeConfigSchema,
+  execute: async ({ agentName, data, file }) => {
+    if (file === "credentials" && data && "secretKey" in data) {
+      return {
+        error: "Cannot write wallet data via write_config. Use create_wallet or import_wallet instead."
+      };
+    }
+    const dir = agentDir(agentName);
+    ensureDir(dir);
+    const filePath = path5.join(dir, `${file}.json`);
+    if (file === "credentials") {
+      const existing = loadCredentials(agentName);
+      const merged = { ...existing, ...data };
+      saveCredentials(agentName, {
+        agent_name: merged.agent_name ?? agentName,
+        api_key: merged.api_key ?? "",
+        api_base: merged.api_base ?? "https://agents.astranova.live"
+      });
+    } else {
+      const tmpPath = path5.join(dir, `.tmp-${crypto2.randomBytes(6).toString("hex")}`);
+      fs6.writeFileSync(tmpPath, JSON.stringify(data, null, 2), {
+        encoding: "utf-8",
+        mode: 384
+      });
+      fs6.renameSync(tmpPath, filePath);
+    }
+    return { success: true, file: `${file}.json`, agent: agentName };
+  }
+});
+
+// src/tools/wallet.ts
+import { tool as tool4 } from "ai";
+import {
+  Keypair,
+  Connection,
+  VersionedTransaction,
+  clusterApiUrl
+} from "@solana/web3.js";
+import nacl from "tweetnacl";
+import bs58 from "bs58";
+var SOLANA_RPC = clusterApiUrl("devnet");
+var createWalletTool = tool4({
+  description: "Generate a new Solana wallet keypair. Saves the keypair locally and returns the public key. The secret key is stored securely and never exposed.",
+  parameters: createWalletSchema,
+  execute: async ({ agentName }) => {
+    const existing = loadWallet(agentName);
+    if (existing) {
+      return {
+        error: `Wallet already exists for agent "${agentName}".`,
+        publicKey: existing.publicKey,
+        hint: "Use the existing wallet or delete wallet.json to regenerate."
+      };
+    }
+    const keypair = Keypair.generate();
+    const publicKey = keypair.publicKey.toBase58();
+    const secretKey = Array.from(keypair.secretKey);
+    saveWallet(agentName, { publicKey, secretKey });
+    return {
+      success: true,
+      publicKey,
+      message: `Wallet created. Public key: ${publicKey}. Now request a challenge from the API to register it.`
+    };
+  }
+});
+var signChallengeTool = tool4({
+  description: "Sign a challenge string with the agent's wallet secret key. Returns a base58-encoded signature for wallet registration. The secret key is never exposed.",
+  parameters: signChallengeSchema,
+  execute: async ({ challenge }) => {
+    const agentName = getActiveAgent();
+    if (!agentName) {
+      return { error: "No active agent found." };
+    }
+    const wallet = loadWallet(agentName);
+    if (!wallet) {
+      return {
+        error: `No wallet found for agent "${agentName}". Create one first using create_wallet.`
+      };
+    }
+    try {
+      const secretKeyBytes = Uint8Array.from(wallet.secretKey);
+      const messageBytes = new TextEncoder().encode(challenge);
+      const signature = nacl.sign.detached(messageBytes, secretKeyBytes);
+      const signatureBase58 = bs58.encode(signature);
+      let nonce = "";
+      const singleLineMatch = /(?:verification|nonce)[:\s]+([a-zA-Z0-9_-]+)\s*$/m.exec(challenge);
+      if (singleLineMatch) {
+        nonce = singleLineMatch[1].trim();
+      } else {
+        const tokens = challenge.trim().split(/\s+/);
+        nonce = tokens[tokens.length - 1] ?? "";
+      }
+      return {
+        success: true,
+        signature: signatureBase58,
+        walletAddress: wallet.publicKey,
+        nonce,
+        challengeRaw: challenge,
+        message: `Challenge signed. Now call PUT /api/v1/agents/me/wallet with {"walletAddress":"${wallet.publicKey}","signature":"${signatureBase58}","nonce":"${nonce}"}`
+      };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Unknown error";
+      return { error: `Failed to sign challenge: ${message}` };
+    }
+  }
+});
+var signAndSendTransactionTool = tool4({
+  description: "Co-sign and submit a partially-signed Solana transaction (base64). Used for claiming $ASTRA rewards. Returns the transaction signature.",
+  parameters: signAndSendTransactionSchema,
+  execute: async ({ transaction: txBase64 }) => {
+    const agentName = getActiveAgent();
+    if (!agentName) {
+      return { error: "No active agent found." };
+    }
+    const wallet = loadWallet(agentName);
+    if (!wallet) {
+      return {
+        error: `No wallet found for agent "${agentName}". Create one first using create_wallet.`
+      };
+    }
+    try {
+      const txBuffer = Buffer.from(txBase64, "base64");
+      const tx = VersionedTransaction.deserialize(txBuffer);
+      const secretKeyBytes = Uint8Array.from(wallet.secretKey);
+      const keypair = Keypair.fromSecretKey(secretKeyBytes);
+      tx.sign([keypair]);
+      const connection = new Connection(SOLANA_RPC, "confirmed");
+      const signature = await connection.sendRawTransaction(tx.serialize(), {
+        skipPreflight: false,
+        preflightCommitment: "confirmed"
+      });
+      const confirmation = await connection.confirmTransaction(signature, "confirmed");
+      if (confirmation.value.err) {
+        return {
+          error: `Transaction confirmed but failed: ${JSON.stringify(confirmation.value.err)}`,
+          txSignature: signature
+        };
+      }
+      if (agentName) {
+        clearPendingClaim(agentName);
+      }
+      return {
+        success: true,
+        txSignature: signature,
+        message: `Transaction submitted and confirmed. Signature: ${signature}. Now confirm with the API using POST /api/v1/agents/me/rewards/confirm.`
+      };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Unknown error";
+      return { error: `Transaction failed: ${message}` };
+    }
+  }
+});
+
+// src/tools/agent-management.ts
+import { tool as tool5 } from "ai";
+import { z as z4 } from "zod";
+var registerAgentTool = tool5({
+  description: "Register a new AstraNova agent. Calls the API, saves credentials locally, and sets the new agent as active. The CLI will need to restart after this to load the new agent's context.",
+  parameters: registerAgentSchema,
+  execute: async ({ name, description }) => {
+    if (!/^[a-z0-9_-]{2,32}$/.test(name)) {
+      return {
+        error: "Invalid agent name. Must be 2-32 chars, lowercase letters, numbers, hyphens, or underscores."
+      };
+    }
+    const result = await apiCall("POST", "/api/v1/agents/register", { name, description });
+    if (!result.ok) {
+      return {
+        error: result.error,
+        status: result.status,
+        code: result.code,
+        hint: result.hint
+      };
+    }
+    const data = result.data;
+    if (!data.api_key) {
+      return { error: "Registration response missing api_key. Something went wrong." };
+    }
+    saveCredentials(name, {
+      agent_name: name,
+      api_key: data.api_key,
+      api_base: "https://agents.astranova.live"
+    });
+    setActiveAgent(name);
+    updateAgentState(name, {
+      status: "pending_verification",
+      journeyStage: "fresh",
+      verificationCode: data.verification_code
+    });
+    requestRestart();
+    return {
+      success: true,
+      agentName: name,
+      status: "pending_verification",
+      verificationCode: data.verification_code,
+      simBalance: data.agent?.simBalance ?? 1e4,
+      restartRequired: true,
+      message: `Agent "${name}" registered successfully! Verification code: ${data.verification_code}. Restarting to load the new agent...`
+    };
+  }
+});
+var switchAgentTool = tool5({
+  description: "Switch to a different registered agent. Updates the active agent. The CLI will need to restart to load the new agent's context.",
+  parameters: switchAgentSchema,
+  execute: async ({ agentName }) => {
+    const creds = loadCredentials(agentName);
+    if (!creds) {
+      const available = listAgents();
+      return {
+        error: `No agent named "${agentName}" found locally.`,
+        availableAgents: available,
+        hint: available.length > 0 ? `Available agents: ${available.join(", ")}` : "No agents registered. Use register_agent to create one."
+      };
+    }
+    const currentAgent = getActiveAgent();
+    if (currentAgent === agentName) {
+      return {
+        message: `"${agentName}" is already the active agent.`,
+        agentName
+      };
+    }
+    setActiveAgent(agentName);
+    requestRestart();
+    return {
+      success: true,
+      agentName,
+      previousAgent: currentAgent,
+      restartRequired: true,
+      message: `Switched to "${agentName}". Restarting to load the new agent...`
+    };
+  }
+});
+var listAgentsTool = tool5({
+  description: "List all AstraNova agents registered on this machine, showing which one is active.",
+  parameters: z4.object({}),
+  execute: async () => {
+    const agents = listAgents();
+    const active = getActiveAgent();
+    const state = loadState();
+    const agentDetails = agents.map((name) => ({
+      name,
+      active: name === active,
+      status: state?.agents[name]?.status ?? "unknown",
+      journeyStage: state?.agents[name]?.journeyStage ?? "unknown",
+      createdAt: state?.agents[name]?.createdAt ?? "unknown"
+    }));
+    return {
+      agents: agentDetails,
+      activeAgent: active,
+      count: agents.length
+    };
+  }
+});
+
+// src/tools/index.ts
+var astraTools = {
+  api_call: apiCallTool,
+  read_config: readConfigTool,
+  write_config: writeConfigTool,
+  create_wallet: createWalletTool,
+  sign_challenge: signChallengeTool,
+  sign_and_send_transaction: signAndSendTransactionTool,
+  register_agent: registerAgentTool,
+  switch_agent: switchAgentTool,
+  list_agents: listAgentsTool,
+  update_memory: updateMemoryTool
+};
+
+// src/agent/codex-provider.ts
+var CODEX_BASE_URL = "https://chatgpt.com/backend-api/codex/responses";
+var DEBUG2 = !!process.env.ASTRA_DEBUG;
+function debugLog2(msg) {
+  if (DEBUG2) process.stderr.write(`[astra:codex] ${msg}
+`);
+}
+var CodexStreamError = class extends Error {
+  constructor(message, code, retryable) {
+    super(message);
+    this.code = code;
+    this.retryable = retryable;
+    this.name = "CodexStreamError";
+  }
+};
+async function callCodex(params) {
+  const { accessToken, model, instructions, input, tools, abortSignal, callbacks, timeoutMs = 9e4, baseUrl = CODEX_BASE_URL } = params;
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), timeoutMs);
+  if (abortSignal) {
+    if (abortSignal.aborted) {
+      clearTimeout(timeout);
+      controller.abort();
+    } else {
+      abortSignal.addEventListener("abort", () => controller.abort(), { once: true });
+    }
+  }
+  try {
+    const body = {
+      model,
+      instructions,
+      input,
+      store: false,
+      stream: true
+    };
+    if (tools && tools.length > 0) {
+      body.tools = tools;
+      body.tool_choice = "auto";
+    }
+    const response = await fetch(baseUrl, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${accessToken}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(body),
+      signal: controller.signal
+    });
+    if (!response.ok) {
+      const errorText = await response.text().catch(() => "");
+      let detail = `HTTP ${response.status}`;
+      try {
+        const errorJson = JSON.parse(errorText);
+        detail = errorJson.detail ?? errorJson.error?.message ?? detail;
+      } catch {
+        if (errorText) detail = errorText.slice(0, 200);
+      }
+      throw new Error(`Responses API error: ${detail}`);
+    }
+    if (!response.body) {
+      throw new Error("Responses API returned no response body");
+    }
+    return await parseSSEStream(response.body, callbacks);
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+var CODEX_RETRY_ATTEMPTS = 3;
+var CODEX_RETRY_BASE_MS = 1e3;
+var CODEX_RETRY_MAX_MS = 15e3;
+var CODEX_RETRY_JITTER = 0.3;
+async function callCodexWithRetry(params) {
+  let lastError = null;
+  let currentToken = params.accessToken;
+  for (let attempt = 1; attempt <= CODEX_RETRY_ATTEMPTS; attempt++) {
+    try {
+      return await callCodex({ ...params, accessToken: currentToken });
+    } catch (err) {
+      lastError = err instanceof Error ? err : new Error(String(err));
+      const msg = lastError.message.toLowerCase();
+      if (msg.includes("401") && attempt === 1 && params.onTokenExpired) {
+        debugLog2(`Codex 401 \u2014 refreshing token and retrying`);
+        currentToken = await params.onTokenExpired();
+        continue;
+      }
+      if (lastError instanceof CodexStreamError && !lastError.retryable) {
+        throw lastError;
+      }
+      const isRetryable = lastError instanceof CodexStreamError && lastError.retryable || msg.includes("429") || msg.includes("rate limit") || msg.includes("500") || msg.includes("502") || msg.includes("503") || msg.includes("504") || msg.includes("network") || msg.includes("fetch failed") || msg.includes("stalled");
+      if (!isRetryable || attempt === CODEX_RETRY_ATTEMPTS) {
+        throw lastError;
+      }
+      const base = Math.min(CODEX_RETRY_BASE_MS * 2 ** (attempt - 1), CODEX_RETRY_MAX_MS);
+      const jitter = base * CODEX_RETRY_JITTER * (Math.random() * 2 - 1);
+      const delay = Math.max(0, base + jitter);
+      debugLog2(`Codex retry ${attempt}/${CODEX_RETRY_ATTEMPTS}: ${lastError.message} \u2014 waiting ${Math.round(delay)}ms`);
+      await new Promise((r) => setTimeout(r, delay));
+    }
+  }
+  throw lastError;
+}
+async function parseSSEStream(body, callbacks, idleTimeoutMs = 45e3) {
+  const reader = body.getReader();
+  const decoder = new TextDecoder();
+  let fullText = "";
+  const toolCalls = /* @__PURE__ */ new Map();
+  let buffer = "";
+  let incomplete = false;
+  let incompleteReason;
+  let parseFailures = 0;
+  let idleTimer = null;
+  let idleAborted = false;
+  const resetIdle = () => {
+    if (idleTimer) clearTimeout(idleTimer);
+    idleTimer = setTimeout(() => {
+      idleAborted = true;
+      reader.cancel("idle timeout").catch(() => {
+      });
+    }, idleTimeoutMs);
+  };
+  resetIdle();
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      resetIdle();
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split("\n");
+      buffer = lines.pop() ?? "";
+      for (const line of lines) {
+        if (!line.startsWith("data: ")) continue;
+        const jsonStr = line.slice(6).trim();
+        if (!jsonStr || jsonStr === "[DONE]") continue;
+        try {
+          const event = JSON.parse(jsonStr);
+          switch (event.type) {
+            case "response.output_text.delta":
+              if (event.delta) {
+                fullText += event.delta;
+                callbacks?.onTextChunk?.(event.delta);
+              }
+              break;
+            case "response.output_item.added":
+              if (event.item?.type === "function_call" && event.item.name) {
+                const itemId = event.item.id ?? `fc_${toolCalls.size}`;
+                const callId = event.item.call_id ?? itemId;
+                toolCalls.set(itemId, {
+                  itemId,
+                  callId,
+                  name: event.item.name,
+                  args: ""
+                });
+                callbacks?.onToolCallStart?.(event.item.name);
+              }
+              break;
+            case "response.function_call_arguments.delta":
+              if (event.delta && event.item_id) {
+                const tc = toolCalls.get(event.item_id);
+                if (tc) {
+                  tc.args += event.delta;
+                }
+              }
+              break;
+            case "response.function_call_arguments.done":
+              if (event.item_id) {
+                const tc = toolCalls.get(event.item_id);
+                if (tc) {
+                  callbacks?.onToolCallEnd?.(tc.name);
+                }
+              }
+              break;
+            case "response.failed": {
+              const resp = event.response;
+              const statusDetails = resp?.status_details;
+              const errInfo = statusDetails?.error ?? resp?.error ?? {};
+              const code = errInfo.code ?? "unknown_error";
+              const msg = errInfo.message ?? "The model returned an error.";
+              const retryable = ["rate_limit_exceeded", "server_error"].includes(code);
+              throw new CodexStreamError(msg, code, retryable);
+            }
+            case "response.incomplete": {
+              const resp = event.response;
+              const statusDetails = resp?.status_details;
+              const reason = statusDetails?.reason ?? "unknown";
+              incomplete = true;
+              incompleteReason = reason;
+              break;
+            }
+          }
+        } catch (e) {
+          if (e instanceof CodexStreamError) throw e;
+          parseFailures++;
+          debugLog2(`SSE parse failure #${parseFailures}: ${line.slice(0, 100)}`);
+        }
+      }
+    }
+  } finally {
+    if (idleTimer) clearTimeout(idleTimer);
+    reader.releaseLock();
+  }
+  if (idleAborted) {
+    throw new Error("Responses API stream stalled \u2014 no data received for 45 seconds.");
+  }
+  if (parseFailures > 0 && fullText === "" && toolCalls.size === 0) {
+    throw new Error(
+      `Responses API returned no usable events (${parseFailures} parse failures). The API format may have changed.`
+    );
+  }
+  return {
+    text: fullText,
+    toolCalls: Array.from(toolCalls.values()).map((tc) => ({
+      id: tc.itemId,
+      callId: tc.callId,
+      name: tc.name,
+      arguments: tc.args
+    })),
+    incomplete,
+    incompleteReason
+  };
+}
+function convertToolsForCodex(tools) {
+  return Object.entries(tools).map(([name, def]) => ({
+    type: "function",
+    name,
+    description: def.description ?? "",
+    parameters: def.parameters ?? {}
+  }));
+}
+
+// src/utils/audit.ts
+import fs7 from "fs";
+var SENSITIVE_KEYS = /* @__PURE__ */ new Set([
+  "secretKey",
+  "secret_key",
+  "privateKey",
+  "private_key",
+  "api_key",
+  "apiKey",
+  "accessToken",
+  "refreshToken",
+  "password",
+  "Authorization",
+  "authorization"
+]);
+var MAX_LOG_SIZE_BYTES = 10 * 1024 * 1024;
+function sanitize(obj) {
+  if (obj === null || obj === void 0) return obj;
+  if (typeof obj !== "object") return obj;
+  if (Array.isArray(obj)) {
+    return obj.map(sanitize);
+  }
+  const result = {};
+  for (const [key, value] of Object.entries(obj)) {
+    if (SENSITIVE_KEYS.has(key)) {
+      result[key] = "[REDACTED]";
+    } else {
+      result[key] = sanitize(value);
+    }
+  }
+  return result;
+}
+function writeAuditEntry(entry) {
+  const logPath = auditLogPath();
+  try {
+    if (fs7.existsSync(logPath)) {
+      const stat = fs7.statSync(logPath);
+      if (stat.size > MAX_LOG_SIZE_BYTES) {
+        const backupPath = logPath.replace(".log", ".old.log");
+        if (fs7.existsSync(backupPath)) fs7.unlinkSync(backupPath);
+        fs7.renameSync(logPath, backupPath);
+      }
+    }
+    const line = JSON.stringify({
+      ...entry,
+      args: sanitize(entry.args),
+      result: truncateResult(sanitize(entry.result))
+    });
+    fs7.appendFileSync(logPath, line + "\n", { encoding: "utf-8" });
+  } catch {
+  }
+}
+function truncateResult(result) {
+  const str = JSON.stringify(result);
+  if (str.length <= 2e3) return result;
+  return { _truncated: true, preview: str.slice(0, 500) + "..." };
+}
+
+// src/agent/compaction.ts
+var CONTEXT_WINDOWS = {
+  claude: 18e4,
+  openai: 12e4,
+  google: 9e5,
+  "openai-oauth": 12e4,
+  ollama: 8e3
+};
+var COMPACTION_THRESHOLD = 0.85;
+var SAFETY_MARGIN = 1.4;
+var USER_MSG_BUDGET = 2e4;
+var MAX_USER_MSGS = 10;
+var COMPACTION_PROMPT = `You are performing a CONTEXT CHECKPOINT for an AstraNova trading agent conversation.
+Create a concise handoff summary for the next turn of this conversation.
+
+Include:
+- Current progress and what was accomplished
+- Key decisions made and user preferences
+- Critical data: wallet addresses, transaction signatures, verification codes, balances
+- Current agent state: registration status, portfolio position, pending actions
+- What remains to be done (clear next steps if any)
+
+Be concise and structured. Focus on information needed to continue seamlessly.`;
+var SUMMARY_PREFIX = `A previous part of this conversation was compacted to save context space.
+Below is a summary of what happened, followed by the most recent messages.
+Use this summary to maintain continuity.
+
+---
+
+`;
+function estimateTokens(text3) {
+  return Math.ceil(text3.length / 4);
+}
+function estimateMessageTokens(messages) {
+  let total = 0;
+  for (const m of messages) {
+    if (typeof m.content === "string") {
+      total += estimateTokens(m.content);
+    } else {
+      total += estimateTokens(JSON.stringify(m.content));
+    }
+  }
+  return total;
+}
+function needsCompaction(messages, systemPromptTokens, provider) {
+  const contextWindow = CONTEXT_WINDOWS[provider] ?? 12e4;
+  const messageTokens = estimateMessageTokens(messages);
+  const estimated = messageTokens * SAFETY_MARGIN + systemPromptTokens;
+  return estimated >= contextWindow * COMPACTION_THRESHOLD;
+}
+async function compactMessages(messages, provider, profile, llmSummarize) {
+  const tokensBefore = estimateMessageTokens(messages);
+  const summary = await llmSummarize(messages);
+  const recentUserMsgs = [];
+  let userTokens = 0;
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const m = messages[i];
+    if (m.role !== "user") continue;
+    const msgTokens = typeof m.content === "string" ? estimateTokens(m.content) : estimateTokens(JSON.stringify(m.content));
+    if (userTokens + msgTokens > USER_MSG_BUDGET) break;
+    if (recentUserMsgs.length >= MAX_USER_MSGS) break;
+    recentUserMsgs.unshift(m);
+    userTokens += msgTokens;
+  }
+  const contextRefresh = buildContextRefresh(profile);
+  const summaryMessage = {
+    role: "user",
+    content: SUMMARY_PREFIX + summary + "\n\n---\n\n" + contextRefresh
+  };
+  const compactedMessages = [summaryMessage];
+  if (recentUserMsgs.length > 0) {
+    compactedMessages.push({
+      role: "assistant",
+      content: "Understood \u2014 I have the context from our earlier conversation. Continuing from where we left off."
+    });
+    compactedMessages.push(...recentUserMsgs);
+  }
+  const tokensAfter = estimateMessageTokens(compactedMessages);
+  return {
+    messages: compactedMessages,
+    compacted: true,
+    tokensBefore,
+    tokensAfter
+  };
+}
+function forceCompact(messages, profile) {
+  const contextRefresh = buildContextRefresh(profile);
+  const recentUserMsgs = [];
+  for (let i = messages.length - 1; i >= 0 && recentUserMsgs.length < 3; i--) {
+    if (messages[i].role === "user") {
+      recentUserMsgs.unshift(messages[i]);
+    }
+  }
+  const summaryMessage = {
+    role: "user",
+    content: `Earlier conversation was too long and had to be discarded. Here is the current agent state:
+
+${contextRefresh}`
+  };
+  const result = [summaryMessage];
+  if (recentUserMsgs.length > 0) {
+    result.push({
+      role: "assistant",
+      content: "Got it \u2014 I've lost the earlier context but I can see your recent messages. How can I help?"
+    });
+    result.push(...recentUserMsgs);
+  }
+  return result;
+}
+function isContextLengthError(error) {
+  const msg = error instanceof Error ? error.message.toLowerCase() : String(error).toLowerCase();
+  return msg.includes("context_length_exceeded") || msg.includes("maximum context length") || msg.includes("too many tokens") || msg.includes("max_tokens") || msg.includes("content_too_large") || msg.includes("request too large");
+}
+
+// src/agent/loop.ts
+var TURN_TIMEOUT_MS = Number(process.env.ASTRA_TIMEOUT) || 18e4;
+var DEBUG3 = !!process.env.ASTRA_DEBUG;
+function debugLog3(msg) {
+  if (DEBUG3) process.stderr.write(`[astra] ${msg}
+`);
+}
+async function runAgentTurn(messages, skillContext, tradingContext, walletContext, rewardsContext, onboardingContext, apiContext, profile, callbacks, memoryContent) {
+  const systemPrompt = buildSystemPrompt(skillContext, tradingContext, walletContext, rewardsContext, onboardingContext, apiContext, profile, memoryContent);
+  const config = loadConfig();
+  const provider = config?.provider ?? "openai";
+  const systemPromptTokens = estimateTokens(systemPrompt);
+  let compacted = false;
+  if (needsCompaction(messages, systemPromptTokens, provider)) {
+    debugLog3("Context approaching limit \u2014 compacting...");
+    const result2 = await compactMessages(
+      messages,
+      provider,
+      profile,
+      (msgs) => summarizeForCompaction(msgs, systemPrompt, provider, config?.model)
+    );
+    debugLog3(`Compacted: ${result2.tokensBefore} \u2192 ${result2.tokensAfter} tokens`);
+    messages = result2.messages;
+    compacted = true;
+  }
+  const runTurn = () => isCodexOAuth() ? runCodexTurn(messages, systemPrompt, callbacks, config) : isOpenAIResponses() ? runOpenAIResponsesTurn(messages, systemPrompt, callbacks, config) : runSdkTurn(messages, systemPrompt, callbacks);
+  let result;
+  try {
+    result = await runTurn();
+  } catch (error) {
+    if (isContextLengthError(error) && !compacted) {
+      debugLog3("Context length error \u2014 emergency compaction");
+      messages = forceCompact(messages, profile);
+      compacted = true;
+      result = await runTurn();
+    } else {
+      throw error;
+    }
+  }
+  if (isEmptyResponse(result) && !compacted) {
+    debugLog3("Empty response from LLM \u2014 retrying with nudge");
+    callbacks.onTextChunk("\n\nHold on, let me try that again...\n\n");
+    messages = [
+      ...messages,
+      { role: "assistant", content: "(My previous response was empty \u2014 retrying.)" },
+      { role: "user", content: "Please continue \u2014 I'm waiting for your response." }
+    ];
+    try {
+      const retry = isCodexOAuth() ? await runCodexTurn(messages, systemPrompt, callbacks, config) : isOpenAIResponses() ? await runOpenAIResponsesTurn(messages, systemPrompt, callbacks, config) : await runSdkTurn(messages, systemPrompt, callbacks);
+      if (!isEmptyResponse(retry)) {
+        result = retry;
+      }
+    } catch (retryError) {
+      debugLog3(`Retry also failed: ${retryError instanceof Error ? retryError.message : String(retryError)}`);
+    }
+  }
+  if (compacted) {
+    result.compactedMessages = messages;
+  }
+  return result;
+}
+var OPENAI_RESPONSES_URL = "https://api.openai.com/v1/responses";
+async function runCodexTurn(messages, systemPrompt, callbacks, config) {
+  return runResponsesApiTurn(messages, systemPrompt, callbacks, {
+    model: config?.model ?? "gpt-5.3-codex",
+    getAccessToken: () => getCodexAccessToken(),
+    onTokenExpired: () => getCodexAccessToken()
+  });
+}
+async function runOpenAIResponsesTurn(messages, systemPrompt, callbacks, config) {
+  const apiKey = getOpenAIApiKey();
+  return runResponsesApiTurn(messages, systemPrompt, callbacks, {
+    model: config?.model ?? "gpt-4o-mini",
+    baseUrl: OPENAI_RESPONSES_URL,
+    getAccessToken: async () => apiKey
+    // No onTokenExpired — API keys don't expire
+  });
+}
+async function runResponsesApiTurn(messages, systemPrompt, callbacks, turnConfig) {
+  const { model, baseUrl, getAccessToken, onTokenExpired } = turnConfig;
+  const codexInput = convertToCodexInput(messages);
+  const codexTools = convertToolsForCodex(
+    Object.fromEntries(
+      Object.entries(astraTools).map(([name, t]) => [
+        name,
+        {
+          description: t.description,
+          parameters: extractJsonSchema(t)
+        }
+      ])
+    )
+  );
+  const responseMessages = [];
+  let accessToken = await getAccessToken();
+  let result = await callCodexWithRetry({
+    accessToken,
+    model,
+    instructions: systemPrompt,
+    input: codexInput,
+    tools: codexTools,
+    callbacks,
+    baseUrl,
+    onTokenExpired
+  });
+  let finalText = result.text;
+  if (result.incomplete) {
+    debugLog3(`Response incomplete: ${result.incompleteReason}`);
+    if (result.toolCalls.length > 0) {
+      debugLog3(`Discarding ${result.toolCalls.length} tool calls from incomplete response`);
+      result = { ...result, toolCalls: [] };
+    }
+    finalText += "\n\n(Response was truncated \u2014 try a shorter message or start a new session.)";
+  }
+  let steps = 0;
+  debugLog3(`Response: text=${result.text.length}chars, toolCalls=${result.toolCalls.map((tc) => tc.name).join(",") || "none"}`);
+  while (result.toolCalls.length > 0 && steps < 10) {
+    steps++;
+    const assistantContent = [];
+    if (result.text) {
+      assistantContent.push({ type: "text", text: result.text });
+    }
+    const toolResultParts = [];
+    for (const tc of result.toolCalls) {
+      const toolDef = astraTools[tc.name];
+      let parsedArgs = {};
+      try {
+        parsedArgs = JSON.parse(tc.arguments);
+      } catch {
+      }
+      assistantContent.push({
+        type: "tool-call",
+        toolCallId: tc.callId,
+        toolName: tc.name,
+        args: parsedArgs
+      });
+      if (!toolDef) {
+        const errorResult = { error: `Tool "${tc.name}" not found.` };
+        toolResultParts.push({
+          type: "tool-result",
+          toolCallId: tc.callId,
+          result: errorResult
+        });
+        codexInput.push({
+          type: "function_call",
+          id: tc.id,
+          call_id: tc.callId,
+          name: tc.name,
+          arguments: tc.arguments
+        });
+        codexInput.push({
+          type: "function_call_output",
+          call_id: tc.callId,
+          output: JSON.stringify(errorResult)
+        });
+        continue;
+      }
+      callbacks.onToolCallStart?.(tc.name);
+      const startTime = Date.now();
+      try {
+        debugLog3(`Tool ${tc.name}(${tc.callId}) args: ${JSON.stringify(parsedArgs)}`);
+        const execute = toolDef.execute;
+        const toolResult = await execute(parsedArgs, {});
+        debugLog3(`Tool ${tc.name}(${tc.callId}) result: ${JSON.stringify(toolResult).slice(0, 200)}`);
+        writeAuditEntry({
+          ts: (/* @__PURE__ */ new Date()).toISOString(),
+          tool: tc.name,
+          args: parsedArgs,
+          result: toolResult,
+          ok: !toolResult?.error,
+          durationMs: Date.now() - startTime
+        });
+        callbacks.onToolCallEnd?.(tc.name);
+        toolResultParts.push({
+          type: "tool-result",
+          toolCallId: tc.callId,
+          result: toolResult
+        });
+        codexInput.push({
+          type: "function_call",
+          id: tc.id,
+          call_id: tc.callId,
+          name: tc.name,
+          arguments: tc.arguments
+        });
+        codexInput.push({
+          type: "function_call_output",
+          call_id: tc.callId,
+          output: JSON.stringify(toolResult)
+        });
+      } catch (toolError) {
+        callbacks.onToolCallEnd?.(tc.name);
+        const errMsg = toolError instanceof Error ? toolError.message : "Tool execution failed";
+        debugLog3(`Tool ${tc.name}(${tc.callId}) error: ${errMsg}`);
+        const errorResult = { error: errMsg };
+        writeAuditEntry({
+          ts: (/* @__PURE__ */ new Date()).toISOString(),
+          tool: tc.name,
+          args: parsedArgs,
+          result: errorResult,
+          ok: false,
+          durationMs: Date.now() - startTime
+        });
+        toolResultParts.push({
+          type: "tool-result",
+          toolCallId: tc.callId,
+          result: errorResult
+        });
+        codexInput.push({
+          type: "function_call",
+          id: tc.id,
+          call_id: tc.callId,
+          name: tc.name,
+          arguments: tc.arguments
+        });
+        codexInput.push({
+          type: "function_call_output",
+          call_id: tc.callId,
+          output: JSON.stringify(errorResult)
+        });
+      }
+    }
+    responseMessages.push({ role: "assistant", content: assistantContent });
+    if (toolResultParts.length > 0) {
+      responseMessages.push({ role: "tool", content: toolResultParts });
+    }
+    accessToken = await getAccessToken();
+    result = await callCodexWithRetry({
+      accessToken,
+      model,
+      instructions: systemPrompt,
+      input: codexInput,
+      tools: codexTools,
+      callbacks,
+      baseUrl,
+      onTokenExpired
+    });
+    finalText = result.text;
+    if (result.incomplete) {
+      debugLog3(`Step ${steps} incomplete: ${result.incompleteReason}`);
+      if (result.toolCalls.length > 0) {
+        debugLog3(`Discarding ${result.toolCalls.length} tool calls from incomplete response`);
+        result = { ...result, toolCalls: [] };
+      }
+      finalText += "\n\n(Response was truncated \u2014 try a shorter message or start a new session.)";
+    }
+    debugLog3(`Step ${steps}: text=${result.text.length}chars, toolCalls=${result.toolCalls.map((tc) => tc.name).join(",") || "none"}`);
+  }
+  debugLog3(`Responses loop done after ${steps} steps, finalText=${finalText.length}chars`);
+  let text3 = finalText;
+  if (!text3 && steps > 0) {
+    debugLog3("Tools ran but no summary text \u2014 nudging model for a summary");
+    codexInput.push({ role: "user", content: "Please summarize what just happened." });
+    accessToken = await getAccessToken();
+    const summaryRetry = await callCodexWithRetry({
+      accessToken,
+      model,
+      instructions: systemPrompt,
+      input: codexInput,
+      tools: codexTools,
+      callbacks,
+      baseUrl,
+      onTokenExpired
+    });
+    text3 = summaryRetry.text;
+  }
+  if (!text3 && steps > 0) {
+    text3 = "I ran the requested action but the model returned no summary. Please try asking again.";
+  } else if (!text3) {
+    text3 = "(No response from model)";
+  }
+  responseMessages.push({ role: "assistant", content: text3 });
+  return { text: text3, responseMessages };
+}
+async function runSdkTurn(messages, systemPrompt, callbacks) {
+  debugLog3(`SDK turn starting \u2014 getting model...`);
+  const model = await getModel();
+  debugLog3(`Model ready: ${model.modelId ?? "unknown"} \u2014 calling streamText...`);
+  const abortController = new AbortController();
+  const timeout = setTimeout(() => {
+    debugLog3("SDK turn timeout \u2014 aborting after 90s");
+    abortController.abort();
+  }, TURN_TIMEOUT_MS);
+  try {
+    const result = streamText({
+      model,
+      system: systemPrompt,
+      messages,
+      tools: astraTools,
+      maxSteps: 10,
+      temperature: 0.7,
+      abortSignal: abortController.signal,
+      onStepFinish: ({ toolCalls, toolResults }) => {
+        if (toolCalls && toolCalls.length > 0) {
+          for (let i = 0; i < toolCalls.length; i++) {
+            const tc = toolCalls[i];
+            const tr = toolResults?.[i];
+            callbacks.onToolCallEnd?.(tc.toolName);
+            writeAuditEntry({
+              ts: (/* @__PURE__ */ new Date()).toISOString(),
+              tool: tc.toolName,
+              args: tc.args,
+              result: tr?.result,
+              ok: !tr?.result?.error,
+              durationMs: 0
+              // not available from SDK callback
+            });
+          }
+        }
+      }
+    });
+    debugLog3("streamText created \u2014 consuming textStream...");
+    for await (const chunk of result.textStream) {
+      callbacks.onTextChunk(chunk);
+    }
+    debugLog3("textStream consumed \u2014 awaiting response...");
+    const response = await result.response;
+    const text3 = await result.text;
+    debugLog3(`SDK turn done \u2014 text=${text3.length}chars, messages=${response.messages.length}`);
+    return {
+      text: text3 || "(No response from LLM)",
+      responseMessages: response.messages
+    };
+  } catch (error) {
+    clearTimeout(timeout);
+    if (abortController.signal.aborted) {
+      throw new Error(`Response timed out after ${TURN_TIMEOUT_MS / 1e3}s. Please try again.`);
+    }
+    const message = error instanceof Error ? error.message : String(error);
+    debugLog3(`Agent loop error: ${message}`);
+    throw error;
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+function convertToCodexInput(messages) {
+  const codexInput = [];
+  for (const m of messages) {
+    if (m.role === "user" || m.role === "assistant") {
+      if (m.role === "assistant" && Array.isArray(m.content)) {
+        const textParts = m.content.filter(
+          (p) => p.type === "text"
+        );
+        if (textParts.length > 0) {
+          codexInput.push({
+            role: "assistant",
+            content: textParts.map((p) => p.text).join("")
+          });
+        }
+        for (const part of m.content) {
+          if (part.type === "tool-call") {
+            const tc = part;
+            const fcId = tc.toolCallId.startsWith("fc_") ? tc.toolCallId : `fc_${tc.toolCallId}`;
+            codexInput.push({
+              type: "function_call",
+              id: fcId,
+              call_id: tc.toolCallId,
+              name: tc.toolName,
+              arguments: JSON.stringify(tc.args)
+            });
+          }
+        }
+      } else {
+        codexInput.push({
+          role: m.role,
+          content: typeof m.content === "string" ? m.content : JSON.stringify(m.content)
+        });
+      }
+    } else if (m.role === "tool") {
+      if (Array.isArray(m.content)) {
+        for (const part of m.content) {
+          if (part.type === "tool-result") {
+            const tr = part;
+            codexInput.push({
+              type: "function_call_output",
+              call_id: tr.toolCallId,
+              output: JSON.stringify(tr.result)
+            });
+          }
+        }
+      }
+    }
+  }
+  return codexInput;
+}
+async function summarizeForCompaction(messages, systemPrompt, provider, modelName) {
+  const summaryInstruction = `${systemPrompt}
+
+---
+
+${COMPACTION_PROMPT}`;
+  if (provider === "openai-oauth") {
+    const accessToken = await getCodexAccessToken();
+    const codexInput = convertToCodexInput(messages);
+    const result2 = await callCodex({
+      accessToken,
+      model: modelName ?? "gpt-5.3-codex",
+      instructions: summaryInstruction,
+      input: codexInput,
+      timeoutMs: 6e4
+    });
+    return result2.text || "No summary generated.";
+  }
+  if (provider === "openai") {
+    const apiKey = getOpenAIApiKey();
+    const codexInput = convertToCodexInput(messages);
+    const result2 = await callCodex({
+      accessToken: apiKey,
+      model: modelName ?? "gpt-4o-mini",
+      instructions: summaryInstruction,
+      input: codexInput,
+      timeoutMs: 6e4,
+      baseUrl: OPENAI_RESPONSES_URL
+    });
+    return result2.text || "No summary generated.";
+  }
+  const model = await getModel();
+  const result = await generateText({
+    model,
+    system: summaryInstruction,
+    messages,
+    temperature: 0.3
+  });
+  return result.text || "No summary generated.";
+}
+var EMPTY_SENTINELS = [
+  "(No response from model)",
+  "(No response from LLM)",
+  "I ran the requested action but the model returned no summary."
+];
+function isEmptyResponse(result) {
+  if (!result.text) return true;
+  const t = result.text.trim();
+  return EMPTY_SENTINELS.some((s) => t === s || t.startsWith(s));
+}
+function extractJsonSchema(toolDef) {
+  const t = toolDef;
+  if (!t.parameters) return {};
+  const params = t.parameters;
+  if (params._def) {
+    try {
+      return zodToJsonSchema(params);
+    } catch {
+      return {};
+    }
+  }
+  return {};
+}
+
+// src/ui/App.tsx
+import { jsx as jsx7, jsxs as jsxs8 } from "react/jsx-runtime";
+function App({
+  agentName,
+  skillContext,
+  tradingContext,
+  walletContext,
+  rewardsContext,
+  onboardingContext,
+  apiContext,
+  profile,
+  sessionId,
+  memoryContent,
+  initialCoreMessages,
+  initialChatMessages,
+  debug
+}) {
+  const { exit } = useApp();
+  const [chatMessages, setChatMessages] = useState4(
+    initialChatMessages ?? []
+  );
+  const [coreMessages, setCoreMessages] = useState4(
+    initialCoreMessages ?? []
+  );
+  const providerRef = useRef2(loadConfig()?.provider ?? "unknown");
+  const [streamingText, setStreamingText] = useState4(
+    void 0
+  );
+  const [isLoading, setIsLoading] = useState4(false);
+  const [toolName, setToolName] = useState4(void 0);
+  useInput((_input, key) => {
+    if (key.ctrl && _input === "c") {
+      exit();
+    }
+  });
+  const sendMessage = useCallback2(
+    async (userText) => {
+      if (userText.startsWith("/")) {
+        const cmd = userText.split(" ")[0].toLowerCase();
+        if (cmd === "/exit" || cmd === "/quit" || cmd === "/q") {
+          exit();
+          return;
+        }
+        if (cmd === "/clear") {
+          setChatMessages([]);
+          return;
+        }
+        if (cmd === "/compact") {
+          setChatMessages((prev) => [
+            ...prev,
+            { role: "user", content: userText },
+            { role: "assistant", content: "Manual compaction is not implemented yet \u2014 it happens automatically when context gets large." }
+          ]);
+          return;
+        }
+        if (cmd === "/help" || cmd === "/?") {
+          setChatMessages((prev) => [
+            ...prev,
+            { role: "user", content: userText },
+            {
+              role: "assistant",
+              content: [
+                "**Quick Actions**",
+                "",
+                "  `/portfolio` \u2014 Show portfolio card",
+                "  `/market`    \u2014 Current price, mood & trend",
+                "  `/rewards`   \u2014 Check claimable $ASTRA",
+                "  `/trades`    \u2014 Recent trade history",
+                "  `/board`     \u2014 Browse the board",
+                "  `/wallet`    \u2014 Check wallet status",
+                "  `/buy <amt>` \u2014 Buy $NOVA (e.g. `/buy 500`)",
+                "  `/sell <amt>`\u2014 Sell $NOVA (e.g. `/sell 200`)",
+                "",
+                "**Ask me about**",
+                "",
+                '  "how do epochs and seasons work?"',
+                '  "what are the trading rules?"',
+                '  "how do I earn $ASTRA?"',
+                '  "show the season leaderboard"',
+                '  "what is $ASTRA token supply?"',
+                "",
+                "**System**",
+                "",
+                "  `/help`      \u2014 Show this help",
+                "  `/exit`      \u2014 Exit (also `/quit`, `/q`)",
+                "  `/clear`     \u2014 Clear chat display",
+                "  `Ctrl+C`     \u2014 Exit immediately"
+              ].join("\n")
+            }
+          ]);
+          return;
+        }
+        const shortcuts = {
+          "/portfolio": "Show my portfolio using the card format.",
+          "/market": "Show the current market state \u2014 price, mood, and recent trend.",
+          "/rewards": "Check my rewards status and show if anything is claimable.",
+          "/trades": "Show my recent trade history.",
+          "/board": "Show recent posts from the board.",
+          "/wallet": "Check my wallet status \u2014 do I have one set up?",
+          "/buy": `Buy ${userText.split(" ").slice(1).join(" ") || "some"} $NOVA.`,
+          "/sell": `Sell ${userText.split(" ").slice(1).join(" ") || "some"} $NOVA.`
+        };
+        if (shortcuts[cmd]) {
+          userText = shortcuts[cmd];
+        } else {
+          setChatMessages((prev) => [
+            ...prev,
+            { role: "user", content: userText },
+            { role: "assistant", content: `Unknown command: ${cmd}. Type /help for available commands.` }
+          ]);
+          return;
+        }
+      }
+      setChatMessages((prev) => [
+        ...prev,
+        { role: "user", content: userText }
+      ]);
+      const newCoreMessages = [
+        ...coreMessages,
+        { role: "user", content: userText }
+      ];
+      setIsLoading(true);
+      setStreamingText("");
+      setToolName(void 0);
+      try {
+        const result = await runAgentTurn(
+          newCoreMessages,
+          skillContext,
+          tradingContext,
+          walletContext,
+          rewardsContext,
+          onboardingContext,
+          apiContext,
+          profile,
+          {
+            onTextChunk: (chunk) => {
+              setStreamingText((prev) => (prev ?? "") + chunk);
+            },
+            onToolCallStart: (name) => {
+              setToolName(name);
+            },
+            onToolCallEnd: () => {
+              setToolName(void 0);
+            }
+          },
+          memoryContent
+        );
+        const baseCoreMessages = result.compactedMessages ?? newCoreMessages;
+        const updatedCore = [...baseCoreMessages, ...result.responseMessages];
+        let updatedChat;
+        if (result.compactedMessages) {
+          const marker = { role: "assistant", content: "\u2014 earlier messages compacted \u2014" };
+          const recentChat = chatMessages.slice(-12);
+          updatedChat = [
+            marker,
+            ...recentChat,
+            { role: "user", content: userText },
+            { role: "assistant", content: result.text }
+          ];
+        } else {
+          updatedChat = [
+            ...chatMessages,
+            { role: "user", content: userText },
+            { role: "assistant", content: result.text }
+          ];
+        }
+        setChatMessages(updatedChat);
+        setCoreMessages(updatedCore);
+        setStreamingText(void 0);
+        saveSession({
+          agentName,
+          provider: providerRef.current,
+          sessionId,
+          coreMessages: updatedCore,
+          chatMessages: updatedChat
+        });
+        if (isRestartRequested()) {
+          setTimeout(() => exit(), 1500);
+        }
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error";
+        const stack = error instanceof Error ? error.stack : void 0;
+        process.stderr.write(`[astra] Error: ${message}
+`);
+        const debugInfo = debug && stack ? `
+
+\`\`\`
+${stack}
+\`\`\`` : "";
+        setChatMessages((prev) => [
+          ...prev,
+          { role: "assistant", content: `Error: ${message}${debugInfo}` }
+        ]);
+        setCoreMessages(newCoreMessages);
+        setStreamingText(void 0);
+      } finally {
+        setIsLoading(false);
+        setToolName(void 0);
+      }
+    },
+    [coreMessages, chatMessages, skillContext, tradingContext, walletContext, rewardsContext, onboardingContext, apiContext, profile, agentName, sessionId]
+  );
+  const handleSubmit = useCallback2(
+    (userText) => {
+      void sendMessage(userText);
+    },
+    [sendMessage]
+  );
+  return /* @__PURE__ */ jsxs8(Box7, { flexDirection: "column", width: "100%", height: "100%", children: [
+    /* @__PURE__ */ jsx7(Box7, { flexDirection: "column", flexGrow: 1, flexShrink: 1, children: /* @__PURE__ */ jsx7(ChatView, { messages: chatMessages, streamingText }) }),
+    isLoading && toolName && /* @__PURE__ */ jsx7(Spinner, { label: `Calling ${toolName}...` }),
+    isLoading && !toolName && /* @__PURE__ */ jsx7(Spinner, { label: streamingText ? "Thinking..." : void 0 }),
+    /* @__PURE__ */ jsx7(Box7, { flexShrink: 0, width: "100%", children: /* @__PURE__ */ jsx7(Input, { isActive: !isLoading, onSubmit: handleSubmit }) }),
+    /* @__PURE__ */ jsx7(Box7, { flexShrink: 0, width: "100%", children: /* @__PURE__ */ jsx7(StatusBar_default, { agentName, journeyStage: profile.journeyStage ?? "full" }) }),
+    /* @__PURE__ */ jsxs8(Box7, { flexShrink: 0, width: "100%", paddingX: 2, justifyContent: "space-between", children: [
+      /* @__PURE__ */ jsx7(Text8, { dimColor: true, children: "/help \xB7 /portfolio \xB7 /market \xB7 /exit" }),
+      /* @__PURE__ */ jsx7(Text8, { dimColor: true, children: "Ctrl+C quit" })
+    ] })
+  ] });
+}
+
+// src/bin/astra.ts
+function detectJourneyStage(params) {
+  const { isNewAgent, apiStatus, hasWallet } = params;
+  if (isNewAgent) return "fresh";
+  if (!apiStatus) return "verified";
+  if (apiStatus.status === "pending_verification") return "pending";
+  if (apiStatus.simBalance === 1e4 && !hasWallet) return "verified";
+  if (!hasWallet) return "trading";
+  return "wallet_ready";
+}
+async function main() {
+  ensureBaseStructure();
+  if (isRestartRequested()) {
+    clearRestartFlag();
+  }
+  const args = process2.argv.slice(2);
+  const shouldContinue = args.includes("--continue") || args.includes("-c");
+  const debug = args.includes("--debug") || args.includes("-d");
+  if (debug) {
+    process2.env.ASTRA_DEBUG = "1";
+  }
+  const isReturning = isConfigured();
+  let onboardingResult = null;
+  if (!isReturning) {
+    onboardingResult = await runOnboarding();
+    if (!onboardingResult) {
+      console.error("Onboarding failed. Please try again.");
+      process2.exit(1);
+    }
+  }
+  const config = loadConfig();
+  if (!config) {
+    console.error(
+      "No config found. Delete ~/.config/astranova/config.json and re-run to start fresh."
+    );
+    process2.exit(1);
+  }
+  const agentName = getActiveAgent();
+  if (!agentName) {
+    console.error(
+      "No active agent found. Delete ~/.config/astranova/ and re-run to start fresh."
+    );
+    process2.exit(1);
+  }
+  const credentials = loadCredentials(agentName);
+  if (!credentials) {
+    console.error(
+      `No credentials found for agent "${agentName}". Delete ~/.config/astranova/ and re-run to start fresh.`
+    );
+    process2.exit(1);
+  }
+  let apiStatus = null;
+  if (isReturning) {
+    apiStatus = await showWelcomeBack(agentName);
+  }
+  const [skillContext, tradingContext, walletContext, rewardsContext, onboardingContext, apiContext] = await Promise.all([
+    getSkillContext(),
+    fetchRemoteContext("TRADING.md").then((c) => c ?? ""),
+    fetchRemoteContext("WALLET.md").then((c) => c ?? ""),
+    fetchRemoteContext("REWARDS.md").then((c) => c ?? ""),
+    fetchRemoteContext("ONBOARDING.md").then((c) => c ?? ""),
+    fetchRemoteContext("API.md").then((c) => c ?? "")
+  ]);
+  if (!loadState()) {
+    saveState({
+      activeAgent: agentName,
+      agents: {
+        [agentName]: {
+          status: apiStatus?.status ?? "unknown",
+          journeyStage: "fresh",
+          createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+          verificationCode: onboardingResult?.verificationCode ?? apiStatus?.verificationCode
+        }
+      }
+    });
+  }
+  const isNewAgent = !isReturning && onboardingResult !== null;
+  const hasWallet = loadWallet(agentName) !== null;
+  const boardPosted = hasBoardPost(agentName);
+  const stage = detectJourneyStage({ isNewAgent, apiStatus, hasWallet });
+  updateAgentState(agentName, {
+    status: apiStatus?.status ?? (isNewAgent ? "pending_verification" : "active"),
+    journeyStage: stage,
+    verificationCode: onboardingResult?.verificationCode ?? apiStatus?.verificationCode
+  });
+  const profile = {
+    agentName,
+    status: apiStatus?.status ?? (isNewAgent ? "pending_verification" : "active"),
+    simBalance: apiStatus?.simBalance,
+    walletAddress: apiStatus?.walletAddress,
+    verificationCode: onboardingResult?.verificationCode ?? apiStatus?.verificationCode,
+    isNewAgent,
+    boardPosted,
+    journeyStage: stage
+  };
+  pruneOldSessions(agentName);
+  const memoryContent = loadMemory(agentName);
+  let sessionId = newSessionId();
+  let initialCoreMessages;
+  let initialChatMessages;
+  if (shouldContinue) {
+    const session = loadLatestSession(agentName);
+    if (session) {
+      const updatedAt = new Date(session.updatedAt);
+      const minutesAgo = Math.round((Date.now() - updatedAt.getTime()) / 6e4);
+      console.log(`  Resuming session from ${minutesAgo} minute(s) ago...
+`);
+      sessionId = session.sessionId;
+      initialCoreMessages = session.coreMessages;
+      initialChatMessages = session.chatMessages;
+    } else {
+      console.log("  No previous session found. Starting fresh.\n");
+    }
+  }
+  const { waitUntilExit } = render(
+    React5.createElement(App, {
+      agentName,
+      skillContext,
+      tradingContext,
+      walletContext,
+      rewardsContext,
+      onboardingContext,
+      apiContext,
+      profile,
+      sessionId,
+      memoryContent,
+      initialCoreMessages,
+      initialChatMessages,
+      debug
+    })
+  );
+  await waitUntilExit();
+  if (isRestartRequested()) {
+    clearRestartFlag();
+    const newAgent = getActiveAgent();
+    console.log(`
+  Restarting as ${newAgent}...
+`);
+    try {
+      execFileSync(process2.execPath, process2.argv.slice(1), {
+        stdio: "inherit",
+        env: process2.env
+      });
+    } catch {
+    }
+    process2.exit(0);
+  }
+}
+main().catch((error) => {
+  const message = error instanceof Error ? error.message : String(error);
+  console.error(`Fatal: ${message}`);
+  process2.exit(1);
+});
+//# sourceMappingURL=astra.js.map