@hyperflow.fun/ghost 0.0.3 → 0.0.5

package/dist/index.js

@@ -4094,7 +4094,6 @@ var init_schema = __esm(() => {
   });
   cronSchema = exports_external.object({
     enableScheduler: exports_external.boolean().default(true),
-    timezone: exports_external.string().default("UTC"),
     maxConcurrentJobs: exports_external.coerce.number().int().positive().default(5)
   });
   telegramChannelSchema = exports_external.object({
@@ -4360,7 +4359,6 @@ __export(exports_paths, {
   getEvalConfigPath: () => getEvalConfigPath,
   getDbPath: () => getDbPath,
   getDaemonPidPath: () => getDaemonPidPath,
-  getCronStorePath: () => getCronStorePath,
   getCredentialsPath: () => getCredentialsPath,
   getConfigPath: () => getConfigPath,
   getCliWorkspacePath: () => getCliWorkspacePath,
@@ -4405,9 +4403,6 @@ function getModelsConfigPath() {
 function getEvalConfigPath() {
   return join(getGhostDir(), "eval.json");
 }
-function getCronStorePath() {
-  return join(getWorkspaceDir(), "cron", "jobs.json");
-}
 function getCliWorkspacePath() {
   return join(getGhostDir(), "cli-workspace");
 }
@@ -4513,7 +4508,6 @@ __export(exports_config, {
   getEvalConfigPath: () => getEvalConfigPath,
   getDbPath: () => getDbPath,
   getDaemonPidPath: () => getDaemonPidPath,
-  getCronStorePath: () => getCronStorePath,
   getCredentialsPath: () => getCredentialsPath,
   getConfigPath: () => getConfigPath,
   getCliWorkspacePath: () => getCliWorkspacePath,
@@ -151269,6 +151263,34 @@ function formatOrder(order) {
   return `${order.symbol} ${formatSide(order.side)} ${order.type} ${order.size}${priceStr}${triggerStr}`;
 }
 
+// src/services/wizard-data.ts
+function composeOpenPositionWizard(input) {
+  const symbol5 = input.symbol?.toUpperCase();
+  if (!symbol5)
+    return;
+  if (typeof input.size !== "number" || !Number.isFinite(input.size))
+    return;
+  const side = input.side === "buy" || input.side === "long" ? "long" : "short";
+  const leverage = input.leverage && input.leverage > 0 ? input.leverage : 1;
+  const orderType = input.orderType === "limit" ? "limit" : "market";
+  const hasEntry = typeof input.entryPrice === "number" && Number.isFinite(input.entryPrice) && input.entryPrice > 0;
+  const entryPrice = hasEntry ? input.entryPrice : undefined;
+  return {
+    kind: "open_position",
+    symbol: symbol5,
+    side,
+    leverage,
+    size: input.size,
+    orderType,
+    entryPrice,
+    stopLoss: input.stopLoss,
+    takeProfit: input.takeProfit
+  };
+}
+function composeGenericWizard(groups) {
+  return { kind: "generic", groups };
+}
+
 // src/services/confirm-policy.ts
 function isConfirmable(toolName) {
   return CONFIRMABLE_TOOLS.has(toolName);
@@ -151313,15 +151335,25 @@ function describePlaceOrder(params) {
   const sizeStr = size !== undefined ? `${size}` : "";
   const levSuffix = leverage && leverage > 0 ? ` ${leverage}x` : "";
   const sideRow = leverage && leverage > 0 ? `Side: ${side} ${leverage}x` : `Side: ${side}`;
+  const wizard = composeOpenPositionWizard({
+    symbol: getString(params, "symbol") ?? "",
+    side: getString(params, "side") ?? "buy",
+    size: getNumber(params, "size") ?? 0,
+    leverage: getNumber(params, "leverage"),
+    orderType: getString(params, "orderType"),
+    entryPrice: price
+  });
   if (orderType === "limit" && price !== undefined) {
     return {
       title: `Place limit order: ${side} ${sizeStr} ${symbol5} @ ${formatUsd(price)}?`,
-      bullets: [sideRow]
+      bullets: [sideRow],
+      wizard
     };
   }
   return {
     title: `Place market order: ${side} ${sizeStr} ${symbol5}?`,
-    bullets: [sideRow]
+    bullets: [sideRow],
+    wizard
   };
 }
 function describeBracketOrder(params) {
@@ -151329,8 +151361,9 @@ function describeBracketOrder(params) {
   const side = sideLabel(getString(params, "side"));
   const leverage = getNumber(params, "leverage");
   const size = getNumber(params, "size");
-  const orderType = getString(params, "orderType")?.toLowerCase();
+  const rawOrderType = getString(params, "orderType")?.toLowerCase();
   const entryPrice = getNumber(params, "entryPrice") ?? getNumber(params, "price");
+  const orderType = rawOrderType ?? (entryPrice !== undefined ? "limit" : "market");
   const stopLoss = getNumber(params, "stopLoss");
   const takeProfit = getNumber(params, "takeProfit");
   const sizeStr = size !== undefined ? `${size}` : "";
@@ -151343,7 +151376,17 @@ function describeBracketOrder(params) {
     bullets.push(`SL: ${formatUsdCompact(stopLoss)}`);
   if (takeProfit !== undefined)
     bullets.push(`TP: ${formatUsdCompact(takeProfit)}`);
-  return { title, bullets };
+  const wizard = composeOpenPositionWizard({
+    symbol: getString(params, "symbol") ?? "",
+    side: getString(params, "side") ?? "buy",
+    size: getNumber(params, "size") ?? 0,
+    leverage: getNumber(params, "leverage"),
+    orderType,
+    entryPrice,
+    stopLoss: getNumber(params, "stopLoss"),
+    takeProfit: getNumber(params, "takeProfit")
+  });
+  return { title, bullets, wizard };
 }
 function describeSetSlTp(params) {
   const symbol5 = upper(getString(params, "symbol"));
@@ -151414,14 +151457,26 @@ function describePartialClose(params) {
   const symbol5 = upper(getString(params, "symbol"));
   const pct = getNumber(params, "percentage");
   const size = getNumber(params, "size");
+  const sizeBefore = getNumber(params, "sizeBefore");
+  const rows = [];
+  if (pct !== undefined)
+    rows.push({ label: "Close %", value: `${pct}%` });
+  if (size !== undefined)
+    rows.push({ label: "Size", value: `${size} ${symbol5}` });
+  if (sizeBefore !== undefined && pct !== undefined) {
+    const sizeAfter = sizeBefore * (1 - pct / 100);
+    rows.push({ label: "Size before", value: `${sizeBefore}`, tone: "muted" });
+    rows.push({ label: "Size after", value: `${sizeAfter}` });
+  }
+  const wizard = rows.length > 0 ? composeGenericWizard([{ label: `${symbol5} partial close`, rows }]) : undefined;
   if (pct !== undefined) {
     const pctStr = Number.isInteger(pct) ? `${pct}` : pct.toFixed(0);
-    return { title: `Close ${pctStr}% of ${symbol5} position?`, bullets: [] };
+    return { title: `Close ${pctStr}% of ${symbol5} position?`, bullets: [], wizard };
   }
   if (size !== undefined) {
-    return { title: `Close ${size} ${symbol5} position?`, bullets: [] };
+    return { title: `Close ${size} ${symbol5} position?`, bullets: [], wizard };
   }
-  return { title: `Close part of ${symbol5} position?`, bullets: [] };
+  return { title: `Close part of ${symbol5} position?`, bullets: [], wizard };
 }
 function describeAdjustMargin(params) {
   const symbol5 = upper(getString(params, "symbol"));
@@ -151429,17 +151484,26 @@ function describeAdjustMargin(params) {
   if (amount === undefined) {
     return { title: `Adjust margin on ${symbol5}?`, bullets: [] };
   }
+  const sign = amount >= 0 ? "+" : "\u2212";
+  const rows = [
+    {
+      label: "Margin change",
+      value: `${sign}${formatUsd(Math.abs(amount))}`,
+      tone: amount >= 0 ? "reward" : "risk"
+    }
+  ];
+  const wizard = composeGenericWizard([{ label: `${symbol5} margin adjust`, rows }]);
   if (amount >= 0) {
-    return { title: `Add ${formatUsd(amount)} margin to ${symbol5}?`, bullets: [] };
+    return { title: `Add ${formatUsd(amount)} margin to ${symbol5}?`, bullets: [], wizard };
   }
-  return { title: `Reduce ${formatUsd(Math.abs(amount))} margin on ${symbol5}?`, bullets: [] };
+  return { title: `Reduce ${formatUsd(Math.abs(amount))} margin on ${symbol5}?`, bullets: [], wizard };
 }
 function describeConfirm(toolName, params) {
   const safeParams = params && typeof params === "object" ? params : {};
   const describer = CONFIRM_DESCRIBERS[toolName];
   if (describer)
     return describer(safeParams);
-  return { title: `Confirm ${toolName}?`, bullets: [] };
+  return { title: `Run ${toolName}?`, bullets: [] };
 }
 var CONFIRMABLE_TOOLS, CONFIRM_DESCRIBERS;
 var init_confirm_policy = __esm(() => {
@@ -151487,7 +151551,7 @@ function createGhostSdkMcpServer(deps) {
         }
         if (decision.decision === "rejected") {
           const reasonMsg = decision.reason && decision.reason.length > 0 ? `User declined. Reason: ${decision.reason}` : "User declined. Do not retry.";
-          logger.debug({ tool: agentTool.name, reason: decision.reason }, "tool rejected by user");
+          logger.debug({ tool: agentTool.name, reason: decision.reason }, "tool not approved");
           return { content: [{ type: "text", text: reasonMsg }], isError: true };
         }
       }
@@ -151532,7 +151596,36 @@ var init_constants2 = __esm(() => {
     "read_file",
     "list_dir",
     "web_fetch",
-    "web_search"
+    "web_search",
+    "ghost_chat_history",
+    "ghost_get_trade_history",
+    "ghost_get_balance",
+    "ghost_get_positions",
+    "ghost_get_orders",
+    "ghost_list_wallets",
+    "ghost_get_recent_orders",
+    "ghost_get_price",
+    "ghost_get_funding_rates",
+    "ghost_get_orderbook",
+    "ghost_get_klines",
+    "ghost_get_indicators",
+    "ghost_get_levels",
+    "ghost_market_overview",
+    "ghost_pre_trade_check",
+    "ghost_morning_briefing",
+    "ghost_session_info",
+    "ghost_timing_risk",
+    "ghost_cross_exchange_funding",
+    "ghost_liquidation_map",
+    "ghost_get_whale_activity",
+    "ghost_tweets_search",
+    "ghost_news_sources",
+    "ghost_news_search",
+    "ghost_news_discover_rss",
+    "ghost_watchlist_list",
+    "ghost_alert_list",
+    "ghost_alert_history",
+    "ghost_check_alerts"
   ]);
 });
 
@@ -156179,14 +156272,6 @@ function createClaudeCliModel(modelId) {
     maxTokens: known?.maxTokens ?? DEFAULT_SPECS.maxTokens
   };
 }
-function getClaudeCliModels() {
-  return [
-    { id: "claude-opus-4-7", name: "Claude Opus 4.7" },
-    { id: "claude-sonnet-4-6", name: "Claude Sonnet 4.6" },
-    { id: "claude-haiku-4-5", name: "Claude Haiku 4.5" },
-    { id: "claude-opus-4-6", name: "Claude Opus 4.6" }
-  ];
-}
 var KNOWN_MODELS, DEFAULT_SPECS;
 var init_models6 = __esm(() => {
   KNOWN_MODELS = {
@@ -156485,7 +156570,7 @@ function assertValidVersions(sorted) {
     }
   }
 }
-var baselineDbMigration, proactiveCooldownsMigration, dropProactiveCooldownsMigration, alertsKindPayloadMigration, addSettingsKvMigration, addTweetsAiRelevantMigration, addObserverStateMigration, splitAlertsMigration, addXFollowsEnabledSourceMigration, DB_MIGRATIONS, CONFIG_MIGRATIONS;
+var baselineDbMigration, proactiveCooldownsMigration, dropProactiveCooldownsMigration, alertsKindPayloadMigration, addSettingsKvMigration, addTweetsAiRelevantMigration, addObserverStateMigration, splitAlertsMigration, addXFollowsEnabledSourceMigration, addCronJobsMigration, DB_MIGRATIONS, CONFIG_MIGRATIONS;
 var init_registry2 = __esm(() => {
   baselineDbMigration = {
     version: 1,
@@ -156618,6 +156703,42 @@ var init_registry2 = __esm(() => {
       db2.run(`UPDATE x_follows SET user_disabled = 0 WHERE user_disabled IS NULL`);
     }
   };
+  addCronJobsMigration = {
+    version: 10,
+    label: "add_cron_jobs",
+    up: (db2) => {
+      db2.run(`
+      CREATE TABLE IF NOT EXISTS cron_jobs (
+        id                TEXT    PRIMARY KEY,
+        name              TEXT    NOT NULL,
+        enabled           INTEGER NOT NULL DEFAULT 1,
+        schedule_kind     TEXT    NOT NULL,
+        schedule_at_ms    INTEGER,
+        schedule_every_ms INTEGER,
+        schedule_expr     TEXT,
+        schedule_tz       TEXT,
+        payload_kind      TEXT    NOT NULL DEFAULT 'agent_turn',
+        payload_message   TEXT    NOT NULL,
+        payload_deliver   INTEGER NOT NULL DEFAULT 1,
+        payload_channel   TEXT,
+        payload_to        TEXT,
+        next_run_at_ms    INTEGER,
+        last_run_at_ms    INTEGER,
+        last_status       TEXT,
+        last_error        TEXT,
+        run_history       TEXT    NOT NULL DEFAULT '[]',
+        created_at_ms     INTEGER NOT NULL,
+        updated_at_ms     INTEGER NOT NULL,
+        delete_after_run  INTEGER NOT NULL DEFAULT 0
+      );
+    `);
+      db2.run(`CREATE UNIQUE INDEX IF NOT EXISTS idx_cron_jobs_name ON cron_jobs(name);`);
+      db2.run(`
+      CREATE INDEX IF NOT EXISTS idx_cron_jobs_enabled_next
+        ON cron_jobs(enabled, next_run_at_ms) WHERE enabled = 1;
+    `);
+    }
+  };
   DB_MIGRATIONS = [
     baselineDbMigration,
     proactiveCooldownsMigration,
@@ -156627,7 +156748,8 @@ var init_registry2 = __esm(() => {
     addTweetsAiRelevantMigration,
     addObserverStateMigration,
     splitAlertsMigration,
-    addXFollowsEnabledSourceMigration
+    addXFollowsEnabledSourceMigration,
+    addCronJobsMigration
   ];
   CONFIG_MIGRATIONS = [];
 });
@@ -157957,6 +158079,9 @@ class ToolRegistry {
   all() {
     return [...this.tools.values()];
   }
+  taskAgentTools() {
+    return [...this.tools.values()].filter((t2) => READ_TOOLS.has(t2.name) || TASK_AGENT_EXTRAS.has(t2.name));
+  }
   names() {
     return [...this.tools.keys()];
   }
@@ -158003,7 +158128,11 @@ class ToolRegistry {
     return { ...result, content: truncated };
   }
 }
-var MAX_RESULT_CHARS = 16000;
+var MAX_RESULT_CHARS = 16000, TASK_AGENT_EXTRAS;
+var init_registry3 = __esm(() => {
+  init_constants2();
+  TASK_AGENT_EXTRAS = new Set(["save_memory", "cron"]);
+});
 
 // src/tools/read-file.ts
 import { readFileSync as readFileSync11, statSync as statSync2 } from "fs";
@@ -158630,7 +158759,7 @@ var init_web_fetch = __esm(() => {
 // src/tools/cron.ts
 class CronTool {
   service;
-  defaultTz;
+  tzService;
   name = "cron";
   label = "Cron";
   description = "Schedule reminders and recurring tasks. Actions: add, list, remove.";
@@ -158638,9 +158767,9 @@ class CronTool {
   _channel = null;
   _chatId = null;
   _inCron = false;
-  constructor(service, defaultTz = "UTC") {
+  constructor(service, tzService) {
     this.service = service;
-    this.defaultTz = defaultTz;
+    this.tzService = tzService;
   }
   setOrigin(channel, chatId) {
     this._channel = channel || null;
@@ -158674,7 +158803,7 @@ class CronTool {
     if (params.every_seconds) {
       schedule = { kind: "every", everyMs: params.every_seconds * 1000 };
     } else if (params.cron_expr) {
-      schedule = { kind: "cron", expr: params.cron_expr, tz: params.tz ?? this.defaultTz };
+      schedule = { kind: "cron", expr: params.cron_expr, tz: params.tz ?? this.tzService.get() };
     } else if (params.at) {
       const atMs = new Date(params.at).getTime();
       if (isNaN(atMs))
@@ -158791,11 +158920,12 @@ function createToolRegistry(_security, options) {
   reg(new ExecTool);
   reg(new WebSearchTool(options.webSearchConfig));
   reg(new WebFetchTool);
-  reg(new CronTool(options.cronService, options.defaultTimezone));
+  reg(new CronTool(options.cronService, options.timezoneService));
   reg(new SaveMemoryTool(options.memoryStore));
   return registry4;
 }
 var init_tools = __esm(() => {
+  init_registry3();
   init_read_file();
   init_write_file();
   init_edit_file();
@@ -158805,6 +158935,7 @@ var init_tools = __esm(() => {
   init_web_fetch();
   init_cron();
   init_save_memory();
+  init_registry3();
   init_read_file();
   init_write_file();
   init_edit_file();
@@ -159684,7 +159815,7 @@ class ContextBuilder {
     return prompt.toString();
   }
   buildRuntimeContext(channel, chatId) {
-    const tz = this.config.timezone ?? "UTC";
+    const tz = this.config.getTimezone?.() ?? "UTC";
     const now = new Date;
     const timeStr = now.toLocaleString("en-US", {
       timeZone: tz,
@@ -168553,45 +168684,63 @@ var require_dist5 = __commonJS((exports) => {
   exports.default = CronExpressionParser_1.CronExpressionParser;
 });
 
-// src/scheduler/defaults.ts
-function detectUserTimezone() {
-  try {
-    return Intl.DateTimeFormat().resolvedOptions().timeZone || "UTC";
-  } catch {
-    return "UTC";
+// src/scheduler/storage.ts
+function scheduleFromRow(row) {
+  switch (row.schedule_kind) {
+    case "at":
+      return { kind: "at", atMs: row.schedule_at_ms ?? undefined };
+    case "every":
+      return { kind: "every", everyMs: row.schedule_every_ms ?? undefined };
+    case "cron":
+      return {
+        kind: "cron",
+        expr: row.schedule_expr ?? undefined,
+        tz: row.schedule_tz ?? undefined
+      };
+    default:
+      return { kind: "cron" };
   }
 }
-var BRIEFING_PROMPT, RECAP_PROMPT, BUILT_IN_JOBS;
-var init_defaults = __esm(() => {
-  BRIEFING_PROMPT = "Run the morning briefing. Call tools to fetch the latest data: open " + "positions, recent fills / trade history, watchlist, news, and market " + "signals (funding, whale activity, fear & greed). Summarize in under 15 " + "sentences, in the language the user has been chatting in.";
-  RECAP_PROMPT = "Run the end-of-day recap. Call tools to fetch today's trade history and " + "current open positions. Summarize today's PnL, position changes (opened, " + "closed, scaled), and one notable market note. Brief one-liner if I had no " + "activity. Reply in the language the user has been chatting in.";
-  BUILT_IN_JOBS = [
-    {
-      name: "morning-briefing",
-      schedule: {
-        kind: "cron",
-        expr: "0 8 * * *",
-        tz: detectUserTimezone()
-      },
-      message: BRIEFING_PROMPT,
-      deliver: true
+function rowToJob(row) {
+  let runHistory = [];
+  try {
+    runHistory = JSON.parse(row.run_history);
+  } catch {}
+  return {
+    id: row.id,
+    name: row.name,
+    enabled: row.enabled === 1,
+    schedule: scheduleFromRow(row),
+    payload: {
+      kind: "agent_turn",
+      message: row.payload_message,
+      deliver: row.payload_deliver === 1,
+      channel: row.payload_channel ?? undefined,
+      to: row.payload_to ?? undefined
     },
-    {
-      name: "evening-recap",
-      schedule: {
-        kind: "cron",
-        expr: "0 21 * * *",
-        tz: detectUserTimezone()
-      },
-      message: RECAP_PROMPT,
-      deliver: true
-    }
-  ];
-});
+    state: {
+      nextRunAtMs: row.next_run_at_ms,
+      lastRunAtMs: row.last_run_at_ms,
+      lastStatus: row.last_status ?? null,
+      lastError: row.last_error,
+      runHistory
+    },
+    createdAtMs: row.created_at_ms,
+    updatedAtMs: row.updated_at_ms,
+    deleteAfterRun: row.delete_after_run === 1
+  };
+}
+function scheduleBindings(s2) {
+  return {
+    schedule_kind: s2.kind,
+    schedule_at_ms: s2.atMs ?? null,
+    schedule_every_ms: s2.everyMs ?? null,
+    schedule_expr: s2.expr ?? null,
+    schedule_tz: s2.tz ?? null
+  };
+}
 
 // src/scheduler/service.ts
-import { existsSync as existsSync17, readFileSync as readFileSync16, writeFileSync as writeFileSync10, mkdirSync as mkdirSync13, statSync as statSync4 } from "fs";
-import { dirname as dirname8 } from "path";
 function computeNextRun(schedule, nowMs) {
   switch (schedule.kind) {
     case "at":
@@ -168618,255 +168767,292 @@ function computeNextRun(schedule, nowMs) {
       return null;
   }
 }
-
-class CronService {
-  storePath;
-  store = { version: 1, jobs: [] };
-  lastMtime = 0;
-  timerHandle = null;
-  _running = false;
-  onJob;
-  constructor(storePath) {
-    this.storePath = storePath;
-  }
-  setOnJob(fn) {
-    this.onJob = fn;
-  }
-  start(opts = {}) {
-    this._running = true;
-    this.loadStore();
-    this.seedDefaultJobs(opts.defaults ?? BUILT_IN_JOBS);
-    const now = Date.now();
-    for (const job of this.store.jobs) {
-      if (job.enabled && !job.state.nextRunAtMs) {
-        job.state.nextRunAtMs = computeNextRun(job.schedule, now);
+var import_cron_parser, MAX_HISTORY = 20, MIN_INTERVAL_MS = 1e4, CronService;
+var init_service = __esm(() => {
+  import_cron_parser = __toESM(require_dist5(), 1);
+  CronService = class CronService {
+    db;
+    stmts;
+    timerHandle = null;
+    _running = false;
+    onJob;
+    static DEFAULT_JOB_NAMES = ["morning-briefing", "evening-recap"];
+    constructor(db2) {
+      this.db = db2;
+      this.stmts = {
+        selectAll: db2.prepare("SELECT * FROM cron_jobs"),
+        selectById: db2.prepare("SELECT * FROM cron_jobs WHERE id = ?"),
+        selectByName: db2.prepare("SELECT * FROM cron_jobs WHERE name = ?"),
+        insert: db2.prepare(`
+        INSERT INTO cron_jobs (
+          id, name, enabled,
+          schedule_kind, schedule_at_ms, schedule_every_ms, schedule_expr, schedule_tz,
+          payload_kind, payload_message, payload_deliver, payload_channel, payload_to,
+          next_run_at_ms, last_run_at_ms, last_status, last_error,
+          run_history, created_at_ms, updated_at_ms, delete_after_run
+        ) VALUES (
+          $id, $name, $enabled,
+          $schedule_kind, $schedule_at_ms, $schedule_every_ms, $schedule_expr, $schedule_tz,
+          $payload_kind, $payload_message, $payload_deliver, $payload_channel, $payload_to,
+          $next_run_at_ms, NULL, NULL, NULL,
+          '[]', $created_at_ms, $updated_at_ms, $delete_after_run
+        )
+      `),
+        updateFull: db2.prepare(`
+        UPDATE cron_jobs SET
+          last_run_at_ms = $last_run_at_ms,
+          last_status    = $last_status,
+          last_error     = $last_error,
+          next_run_at_ms = $next_run_at_ms,
+          run_history    = $run_history,
+          enabled        = $enabled,
+          updated_at_ms  = $updated_at_ms
+        WHERE id = $id
+      `),
+        updateNext: db2.prepare("UPDATE cron_jobs SET next_run_at_ms = ?, updated_at_ms = ? WHERE id = ?"),
+        updateTzAndNext: db2.prepare("UPDATE cron_jobs SET schedule_tz = ?, next_run_at_ms = ?, updated_at_ms = ? WHERE name = ?"),
+        updateEnabled: db2.prepare("UPDATE cron_jobs SET enabled = ?, next_run_at_ms = ?, updated_at_ms = ? WHERE id = ?"),
+        delete: db2.prepare("DELETE FROM cron_jobs WHERE id = ?")
+      };
+    }
+    setOnJob(fn) {
+      this.onJob = fn;
+    }
+    start(opts = {}) {
+      this._running = true;
+      this.seedDefaultJobs(opts.defaults ?? []);
+      const now = Date.now();
+      const rows = this.stmts.selectAll.all();
+      this.db.transaction(() => {
+        for (const row of rows) {
+          if (row.enabled === 1 && row.next_run_at_ms !== null && row.next_run_at_ms <= now) {
+            const schedule = scheduleFromRow(row);
+            const next = computeNextRun(schedule, now);
+            this.stmts.updateNext.run(next, now, row.id);
+          } else if (row.next_run_at_ms === null && row.enabled) {
+            const schedule = scheduleFromRow(row);
+            const next = computeNextRun(schedule, now);
+            this.stmts.updateNext.run(next, now, row.id);
+          }
+        }
+      })();
+      this.scheduleNextTick();
+    }
+    stop() {
+      this._running = false;
+      if (this.timerHandle) {
+        clearTimeout(this.timerHandle);
+        this.timerHandle = null;
       }
     }
-    this.saveStore();
-    this.armTimer();
-  }
-  stop() {
-    this._running = false;
-    if (this.timerHandle) {
-      clearTimeout(this.timerHandle);
-      this.timerHandle = null;
+    listJobs(includeDisabled = false) {
+      const rows = this.stmts.selectAll.all();
+      const jobs = includeDisabled ? rows.map(rowToJob) : rows.filter((r2) => r2.enabled === 1).map(rowToJob);
+      return jobs.sort((a, b5) => (a.state.nextRunAtMs ?? Infinity) - (b5.state.nextRunAtMs ?? Infinity));
     }
-  }
-  listJobs(includeDisabled = false) {
-    this.loadStore();
-    const jobs = includeDisabled ? this.store.jobs : this.store.jobs.filter((j9) => j9.enabled);
-    return jobs.sort((a, b5) => (a.state.nextRunAtMs ?? Infinity) - (b5.state.nextRunAtMs ?? Infinity));
-  }
-  addJob(opts) {
-    this.loadStore();
-    const now = Date.now();
-    const job = {
-      id: crypto.randomUUID().slice(0, 8),
-      name: opts.name,
-      enabled: true,
-      schedule: opts.schedule,
-      payload: {
-        kind: "agent_turn",
-        message: opts.message,
-        deliver: opts.deliver ?? true,
-        channel: opts.channel,
-        to: opts.to
-      },
-      state: {
-        nextRunAtMs: computeNextRun(opts.schedule, now),
-        lastRunAtMs: null,
-        lastStatus: null,
-        lastError: null,
-        runHistory: []
-      },
-      createdAtMs: now,
-      updatedAtMs: now,
-      deleteAfterRun: opts.deleteAfterRun ?? false
-    };
-    this.store.jobs.push(job);
-    this.saveStore();
-    this.armTimer();
-    return job;
-  }
-  removeJob(jobId) {
-    this.loadStore();
-    const idx = this.store.jobs.findIndex((j9) => j9.id === jobId);
-    if (idx === -1)
-      return false;
-    this.store.jobs.splice(idx, 1);
-    this.saveStore();
-    this.armTimer();
-    return true;
-  }
-  enableJob(jobId, enabled) {
-    this.loadStore();
-    const job = this.store.jobs.find((j9) => j9.id === jobId);
-    if (!job)
-      return;
-    job.enabled = enabled;
-    if (enabled) {
-      job.state.nextRunAtMs = computeNextRun(job.schedule, Date.now());
-    } else {
-      job.state.nextRunAtMs = null;
+    addJob(opts) {
+      const now = Date.now();
+      const id = crypto.randomUUID().slice(0, 12);
+      const sb = scheduleBindings(opts.schedule);
+      try {
+        this.stmts.insert.run({
+          $id: id,
+          $name: opts.name,
+          $enabled: 1,
+          ...Object.fromEntries(Object.entries(sb).map(([k, v4]) => [`$${k}`, v4])),
+          $payload_kind: "agent_turn",
+          $payload_message: opts.message,
+          $payload_deliver: opts.deliver ?? true ? 1 : 0,
+          $payload_channel: opts.channel ?? null,
+          $payload_to: opts.to ?? null,
+          $next_run_at_ms: computeNextRun(opts.schedule, now),
+          $created_at_ms: now,
+          $updated_at_ms: now,
+          $delete_after_run: opts.deleteAfterRun ?? false ? 1 : 0
+        });
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        if (msg.includes("UNIQUE constraint failed") || msg.includes("SQLITE_CONSTRAINT")) {
+          throw new Error(`Cron name already exists: ${opts.name}`);
+        }
+        throw err;
+      }
+      this.scheduleNextTick();
+      const row = this.stmts.selectById.get(id);
+      return rowToJob(row);
     }
-    job.updatedAtMs = Date.now();
-    this.saveStore();
-    this.armTimer();
-  }
-  async runJob(jobId, force = false) {
-    this.loadStore();
-    const job = this.store.jobs.find((j9) => j9.id === jobId);
-    if (!job)
-      return;
-    if (!job.enabled && !force)
-      return;
-    await this.executeJob(job);
-    this.saveStore();
-    this.armTimer();
-  }
-  getJob(jobId) {
-    this.loadStore();
-    return this.store.jobs.find((j9) => j9.id === jobId);
-  }
-  status() {
-    this.loadStore();
-    return {
-      enabled: this._running,
-      jobs: this.store.jobs.filter((j9) => j9.enabled).length,
-      nextWakeAtMs: this.getNextWakeMs()
-    };
-  }
-  seedDefaultJobs(specs) {
-    const existingNames = new Set(this.store.jobs.map((j9) => j9.name));
-    let dirty = false;
-    const now = Date.now();
-    for (const spec of specs) {
-      if (existingNames.has(spec.name))
-        continue;
-      const job = {
-        id: crypto.randomUUID().slice(0, 8),
-        name: spec.name,
-        enabled: true,
-        schedule: spec.schedule,
-        payload: {
-          kind: "agent_turn",
-          message: spec.message,
-          deliver: spec.deliver
-        },
-        state: {
-          nextRunAtMs: computeNextRun(spec.schedule, now),
-          lastRunAtMs: null,
-          lastStatus: null,
-          lastError: null,
-          runHistory: []
-        },
-        createdAtMs: now,
-        updatedAtMs: now,
-        deleteAfterRun: false
+    removeJob(jobId) {
+      const row = this.stmts.selectById.get(jobId);
+      if (!row)
+        return false;
+      this.stmts.delete.run(jobId);
+      this.scheduleNextTick();
+      return true;
+    }
+    enableJob(jobId, enabled) {
+      const now = Date.now();
+      const row = this.stmts.selectById.get(jobId);
+      if (!row)
+        return;
+      const nextRun = enabled ? computeNextRun(scheduleFromRow(row), now) : null;
+      this.stmts.updateEnabled.run(enabled ? 1 : 0, nextRun, now, jobId);
+      this.scheduleNextTick();
+    }
+    async runJob(jobId, force = false) {
+      const row = this.stmts.selectById.get(jobId);
+      if (!row)
+        return;
+      const job = rowToJob(row);
+      if (!job.enabled && !force)
+        return;
+      await this.executeJob(job);
+    }
+    getJob(jobId) {
+      const row = this.stmts.selectById.get(jobId);
+      return row ? rowToJob(row) : undefined;
+    }
+    status() {
+      const rows = this.stmts.selectAll.all();
+      const enabled = rows.filter((r2) => r2.enabled === 1);
+      return {
+        enabled: this._running,
+        jobs: enabled.length,
+        nextTickAtMs: this.getNextTickMs()
       };
-      this.store.jobs.push(job);
-      dirty = true;
     }
-    if (dirty)
-      this.saveStore();
-  }
-  async executeJob(job) {
-    const startMs = Date.now();
-    let status = "ok";
-    let error45;
-    try {
-      if (this.onJob) {
-        await this.onJob(job);
+    updateBuiltinJobsTimezone(tz) {
+      const updated = [];
+      const now = Date.now();
+      this.db.transaction(() => {
+        for (const name of CronService.DEFAULT_JOB_NAMES) {
+          const row = this.stmts.selectByName.get(name);
+          if (!row || row.schedule_kind !== "cron")
+            continue;
+          const nextRun = computeNextRun({ kind: "cron", expr: row.schedule_expr ?? undefined, tz }, now);
+          this.stmts.updateTzAndNext.run(tz, nextRun, now, name);
+          updated.push(name);
+        }
+      })();
+      this.scheduleNextTick();
+      return updated;
+    }
+    seedDefaultJobs(specs) {
+      const now = Date.now();
+      this.db.transaction(() => {
+        for (const spec of specs) {
+          const existing = this.stmts.selectByName.get(spec.name);
+          if (existing)
+            continue;
+          const id = crypto.randomUUID().slice(0, 12);
+          const sb = scheduleBindings(spec.schedule);
+          this.stmts.insert.run({
+            $id: id,
+            $name: spec.name,
+            $enabled: 1,
+            ...Object.fromEntries(Object.entries(sb).map(([k, v4]) => [`$${k}`, v4])),
+            $payload_kind: "agent_turn",
+            $payload_message: spec.message,
+            $payload_deliver: spec.deliver ? 1 : 0,
+            $payload_channel: null,
+            $payload_to: null,
+            $next_run_at_ms: computeNextRun(spec.schedule, now),
+            $created_at_ms: now,
+            $updated_at_ms: now,
+            $delete_after_run: 0
+          });
+        }
+      })();
+    }
+    async executeJob(job) {
+      const startMs = Date.now();
+      let status = "ok";
+      let error45;
+      try {
+        if (this.onJob) {
+          await this.onJob(job);
+        }
+      } catch (err) {
+        status = "error";
+        error45 = err instanceof Error ? err.message : String(err);
+      }
+      const durationMs = Date.now() - startMs;
+      const record6 = { runAtMs: startMs, status, durationMs, error: error45 };
+      const currentRow = this.stmts.selectById.get(job.id);
+      let runHistory = [];
+      if (currentRow) {
+        try {
+          runHistory = JSON.parse(currentRow.run_history);
+        } catch {}
       }
-    } catch (err) {
-      status = "error";
-      error45 = err instanceof Error ? err.message : String(err);
-    }
-    const durationMs = Date.now() - startMs;
-    const record6 = { runAtMs: startMs, status, durationMs, error: error45 };
-    job.state.lastRunAtMs = startMs;
-    job.state.lastStatus = status;
-    job.state.lastError = error45 ?? null;
-    job.state.runHistory.push(record6);
-    if (job.state.runHistory.length > MAX_HISTORY) {
-      job.state.runHistory = job.state.runHistory.slice(-MAX_HISTORY);
-    }
-    if (job.schedule.kind === "at") {
-      if (job.deleteAfterRun) {
-        const idx = this.store.jobs.indexOf(job);
-        if (idx >= 0)
-          this.store.jobs.splice(idx, 1);
-      } else {
-        job.enabled = false;
-        job.state.nextRunAtMs = null;
+      runHistory.push(record6);
+      if (runHistory.length > MAX_HISTORY) {
+        runHistory = runHistory.slice(-MAX_HISTORY);
       }
-    } else {
-      job.state.nextRunAtMs = computeNextRun(job.schedule, Date.now());
+      let nextRunAtMs;
+      let enabled = 1;
+      if (job.schedule.kind === "at") {
+        if (job.deleteAfterRun) {
+          this.stmts.delete.run(job.id);
+          this.scheduleNextTick();
+          return;
+        }
+        enabled = 0;
+        nextRunAtMs = null;
+      } else {
+        const freshSchedule = currentRow ? scheduleFromRow(currentRow) : job.schedule;
+        nextRunAtMs = computeNextRun(freshSchedule, Date.now());
+      }
+      this.db.transaction(() => {
+        this.stmts.updateFull.run({
+          $last_run_at_ms: startMs,
+          $last_status: status,
+          $last_error: error45 ?? null,
+          $next_run_at_ms: nextRunAtMs,
+          $run_history: JSON.stringify(runHistory),
+          $enabled: enabled,
+          $updated_at_ms: Date.now(),
+          $id: job.id
+        });
+      })();
+      this.scheduleNextTick();
     }
-    job.updatedAtMs = Date.now();
-  }
-  getNextWakeMs() {
-    let earliest = null;
-    for (const job of this.store.jobs) {
-      if (job.enabled && job.state.nextRunAtMs) {
-        if (earliest === null || job.state.nextRunAtMs < earliest) {
-          earliest = job.state.nextRunAtMs;
+    getNextTickMs() {
+      const rows = this.stmts.selectAll.all();
+      let earliest = null;
+      for (const row of rows) {
+        if (row.enabled === 1 && row.next_run_at_ms !== null) {
+          if (earliest === null || row.next_run_at_ms < earliest) {
+            earliest = row.next_run_at_ms;
+          }
         }
       }
+      return earliest;
     }
-    return earliest;
-  }
-  armTimer() {
-    if (this.timerHandle) {
-      clearTimeout(this.timerHandle);
-      this.timerHandle = null;
-    }
-    if (!this._running)
-      return;
-    const nextMs = this.getNextWakeMs();
-    if (nextMs === null)
-      return;
-    const delayMs = Math.max(nextMs - Date.now(), 0);
-    this.timerHandle = setTimeout(() => this.onTimer(), delayMs);
-  }
-  async onTimer() {
-    if (!this._running)
-      return;
-    this.loadStore();
-    const now = Date.now();
-    const due = this.store.jobs.filter((j9) => j9.enabled && j9.state.nextRunAtMs !== null && j9.state.nextRunAtMs <= now);
-    for (const job of due) {
-      await this.executeJob(job);
+    scheduleNextTick() {
+      if (this.timerHandle) {
+        clearTimeout(this.timerHandle);
+        this.timerHandle = null;
+      }
+      if (!this._running)
+        return;
+      const nextMs = this.getNextTickMs();
+      if (nextMs === null)
+        return;
+      const delayMs = Math.max(nextMs - Date.now(), 0);
+      this.timerHandle = setTimeout(() => void this.onTimer(), delayMs);
     }
-    this.saveStore();
-    this.armTimer();
-  }
-  loadStore() {
-    if (!existsSync17(this.storePath))
-      return;
-    try {
-      const stat2 = statSync4(this.storePath);
-      const mtime = stat2.mtimeMs;
-      if (mtime === this.lastMtime && this.store.jobs.length > 0)
+    async onTimer() {
+      if (!this._running)
         return;
-      const raw = readFileSync16(this.storePath, "utf-8");
-      const parsed = JSON.parse(raw);
-      this.store = parsed;
-      this.lastMtime = mtime;
-    } catch {}
-  }
-  saveStore() {
-    mkdirSync13(dirname8(this.storePath), { recursive: true });
-    writeFileSync10(this.storePath, JSON.stringify(this.store, null, 2));
-    try {
-      this.lastMtime = statSync4(this.storePath).mtimeMs;
-    } catch {}
-  }
-}
-var import_cron_parser, MAX_HISTORY = 20, MIN_INTERVAL_MS = 1e4;
-var init_service = __esm(() => {
-  init_defaults();
-  import_cron_parser = __toESM(require_dist5(), 1);
+      const now = Date.now();
+      const rows = this.stmts.selectAll.all();
+      const due = rows.filter((r2) => r2.enabled === 1 && r2.next_run_at_ms !== null && r2.next_run_at_ms <= now);
+      for (const row of due) {
+        await this.executeJob(rowToJob(row));
+      }
+      this.scheduleNextTick();
+    }
+  };
 });
 
 // src/bus/queue.ts
@@ -169560,6 +169746,9 @@ class ApprovalManager {
   getReason(approvalId) {
     return this.pending.get(approvalId)?.reason ?? null;
   }
+  getPreview(approvalId) {
+    return this.pending.get(approvalId)?.preview;
+  }
   getPending(sessionKey) {
     const id = this.bySession.get(sessionKey);
     if (!id)
@@ -169893,7 +170082,7 @@ var init_approval_events = __esm(() => {
 });
 
 // src/services/trading-confirm.ts
-function buildPreview(title, body) {
+function buildPreview(title, body, extras) {
   const lines = (body.lines ?? []).filter((l2) => l2 !== undefined && l2 !== null);
   const steps = (body.steps ?? []).filter((s2) => s2 !== undefined && s2 !== null);
   const details = {};
@@ -169919,7 +170108,10 @@ function buildPreview(title, body) {
     summary,
     details,
     warnings: warnings.length > 0 ? warnings : undefined,
-    direction: blob.includes("buy") || blob.includes("long") ? "long" : blob.includes("sell") || blob.includes("short") ? "short" : undefined
+    symbol: extras?.symbol,
+    direction: blob.includes("buy") || blob.includes("long") ? "long" : blob.includes("sell") || blob.includes("short") ? "short" : undefined,
+    wizard: extras?.wizard,
+    suggestedValue: extras?.suggestedValue
   };
 }
 
@@ -169932,8 +170124,8 @@ class DaemonConfirmService {
     this.eventBus = eventBus;
     this.orchestrator = orchestrator;
   }
-  async confirm(title, body) {
-    const preview = buildPreview(title, body);
+  async confirm(title, body, extras) {
+    const preview = buildPreview(title, body, extras);
     const sessionKey = `trade:${crypto.randomUUID().slice(0, 8)}`;
     const preText = this.orchestrator.getCurrentTurnText();
     const origin = this.orchestrator.getCurrentTurnOrigin();
@@ -180691,6 +180883,50 @@ var init_cloid = __esm(() => {
   SUFFIX_BYTE_LENGTH = SUFFIX_HEX_LENGTH / 2;
 });
 
+// src/services/live/info-cache.ts
+class InfoCache {
+  entries = new Map;
+  ttlMs;
+  constructor(ttlMs = 3000) {
+    this.ttlMs = ttlMs;
+  }
+  get(key, fetcher) {
+    const now = Date.now();
+    const existing = this.entries.get(key);
+    if (existing !== undefined && now - existing.insertedAt < this.ttlMs) {
+      return existing.promise;
+    }
+    const promise6 = fetcher().catch((err) => {
+      if (this.entries.get(key)?.promise === promise6) {
+        this.entries.delete(key);
+      }
+      throw err;
+    });
+    this.entries.set(key, { promise: promise6, insertedAt: now });
+    return promise6;
+  }
+  clear() {
+    this.entries.clear();
+  }
+}
+async function runWithConcurrency(items, concurrency, fn) {
+  const results = new Array(items.length);
+  let nextIndex = 0;
+  async function worker() {
+    while (nextIndex < items.length) {
+      const index = nextIndex++;
+      try {
+        results[index] = { status: "fulfilled", value: await fn(items[index], index) };
+      } catch (reason) {
+        results[index] = { status: "rejected", reason };
+      }
+    }
+  }
+  const workers = Array.from({ length: Math.min(concurrency, items.length) }, () => worker());
+  await Promise.all(workers);
+  return results;
+}
+
 // src/services/live/client.ts
 function mapFill(f2) {
   return {
@@ -180734,6 +180970,45 @@ function parseDex(symbol5) {
     return { dex: null, name: trimmed };
   return { dex, name: trimmed };
 }
+function mapPositionsFromRaw(raw) {
+  const positions = [];
+  for (const ap of raw.assetPositions ?? []) {
+    const pos = ap.position;
+    const szi = parseFloat(pos.szi);
+    if (szi === 0)
+      continue;
+    const entryPx = parseFloat(pos.entryPx);
+    const markPx = pos.positionValue ? Math.abs(parseFloat(pos.positionValue) / szi) : entryPx;
+    positions.push({
+      symbol: pos.coin,
+      side: szi > 0 ? "long" : "short",
+      size: Math.abs(szi),
+      entryPrice: entryPx,
+      markPrice: markPx,
+      liquidationPrice: pos.liquidationPx && pos.liquidationPx !== "0.0" && parseFloat(pos.liquidationPx) > 0 ? parseFloat(pos.liquidationPx) : null,
+      unrealizedPnl: parseFloat(pos.unrealizedPnl),
+      unrealizedPnlPct: parseFloat(pos.returnOnEquity ?? "0") * 100,
+      leverage: parseFloat(pos.leverage?.value ?? "1"),
+      marginMode: pos.leverage?.type === "isolated" ? "isolated" : "cross",
+      margin: parseFloat(pos.marginUsed)
+    });
+  }
+  return positions;
+}
+function mapOpenOrderFromRaw(o10) {
+  return {
+    orderId: String(o10.oid),
+    symbol: o10.coin,
+    side: o10.side === "B" ? "buy" : "sell",
+    orderType: o10.orderType ?? "Limit",
+    price: o10.limitPx ? parseFloat(o10.limitPx) : null,
+    triggerPrice: o10.triggerPx && o10.triggerPx !== "0.0" ? parseFloat(o10.triggerPx) : null,
+    size: parseFloat(o10.sz),
+    filled: parseFloat(o10.origSz ?? o10.sz) - parseFloat(o10.sz),
+    reduceOnly: o10.reduceOnly ?? false,
+    timestamp: o10.timestamp ?? Date.now()
+  };
+}
 function ctxToTicker(ctx, symbol5) {
   const markPx = parseFloat(ctx.markPx ?? "0");
   const prevDay = parseFloat(ctx.prevDayPx ?? "0");
@@ -180759,12 +181034,18 @@ class HyperliquidClient {
   assetMap = new Map;
   szDecimals = new Map;
   maxLeverage = new Map;
-  assetNames = [];
+  assets = [];
   metaLoaded = false;
+  metaInFlight = null;
   dexUniverses = new Map;
   dexListCache = null;
   dexListCacheAt = 0;
   DEX_CACHE_TTL_MS = 60 * 60 * 1000;
+  infoCache = new InfoCache(3000);
+  wsTransport = null;
+  wsSubClient = null;
+  wsLifecycle = null;
+  wsDisposed = false;
   constructor(config3, logger) {
     this.defaultAddress = config3?.address ?? "";
     this.testnet = config3?.testnet ?? false;
@@ -180785,6 +181066,7 @@ class HyperliquidClient {
   connect(config3) {
     this.defaultAddress = config3.address || this.defaultAddress;
     this.baseUrl = config3.testnet ? TESTNET_URL : MAINNET_URL;
+    this.wsDisposed = false;
     if (config3.privateKey) {
       const wallet = privateKeyToAccount(config3.privateKey);
       const transport = new HttpTransport({ isTestnet: config3.testnet });
@@ -180794,18 +181076,35 @@ class HyperliquidClient {
   disconnect() {
     this.defaultAddress = "";
     this.exchange = null;
+    this.closeWs();
   }
   requireExchange() {
     if (!this.exchange)
       throw new Error("Write operations require a private key. Use the connect_wallet tool or set hlPrivateKey in config.");
     return this.exchange;
   }
-  async info(type5, extra = {}) {
+  async info(type5, extra = {}, options = {}) {
+    if (!options.cache)
+      return this.fetchInfo(type5, extra, 0);
+    const key = `${type5}:${JSON.stringify(extra)}`;
+    return this.infoCache.get(key, () => this.fetchInfo(type5, extra, 0));
+  }
+  async fetchInfo(type5, extra, attempt) {
     const res = await fetch(`${this.baseUrl}/info`, {
       method: "POST",
       headers: { "Content-Type": "application/json" },
       body: JSON.stringify({ type: type5, ...extra })
     });
+    if (res.status === 429 && attempt < 3) {
+      const retryAfterRaw = res.headers.get("retry-after");
+      const retryAfterSec = retryAfterRaw !== null ? Number(retryAfterRaw) : NaN;
+      const MAX_RETRY_AFTER_MS = 5000;
+      const baseMs = Number.isFinite(retryAfterSec) && retryAfterSec > 0 ? Math.min(retryAfterSec * 1000, MAX_RETRY_AFTER_MS) : 250 * Math.pow(2, attempt);
+      const jitterMs = Math.random() * 100;
+      this.log.debug({ type: type5, dex: extra.dex, attempt, delayMs: baseMs + jitterMs }, "rate limited \u2014 retrying after backoff");
+      await new Promise((resolve) => setTimeout(resolve, baseMs + jitterMs));
+      return this.fetchInfo(type5, extra, attempt + 1);
+    }
     if (!res.ok) {
       const text = await res.text();
       throw new Error(`Hyperliquid ${type5}: ${res.status} ${text}`);
@@ -180841,8 +181140,16 @@ class HyperliquidClient {
       const hasNewDex = currentDexes.some((d2) => !knownDexNames.has(d2.name));
       if (!hasNewDex)
         return;
-      this.metaLoaded = false;
     }
+    if (this.metaInFlight !== null)
+      return this.metaInFlight;
+    this.metaInFlight = this.rebuildMeta().finally(() => {
+      this.metaInFlight = null;
+    });
+    return this.metaInFlight;
+  }
+  async rebuildMeta() {
+    this.metaLoaded = false;
     let nativeUniverse = [];
     try {
       const nativeData = await this.info("meta");
@@ -180851,7 +181158,7 @@ class HyperliquidClient {
       this.log.warn({ err }, "Native meta fetch failed \u2014 daemon starts degraded (HIP-3 may still load)");
     }
     const dexes = await this.listPerpDexes().catch(() => []);
-    const dexResults = await Promise.allSettled(dexes.map((d2) => this.info("meta", { dex: d2.name })));
+    const dexResults = await runWithConcurrency(dexes, 4, (d2) => this.info("meta", { dex: d2.name }));
     let merged = [...nativeUniverse];
     const nativeNames = nativeUniverse.map((a) => a.name);
     this.dexUniverses.set("", nativeNames);
@@ -180865,7 +181172,7 @@ class HyperliquidClient {
         this.log.warn({ err: result.reason, dex: dexes[i].name }, "HIP-3 dex meta fetch failed \u2014 skipping");
       }
     }
-    this.assetNames = merged.map((a) => a.name);
+    this.assets = merged.map((a) => a.isDelisted ? { symbol: a.name, isDelisted: true } : { symbol: a.name });
     merged.forEach((a, idx) => {
       const key = this.resolveSymbol(a.name);
       this.assetMap.set(key, idx);
@@ -180875,10 +181182,63 @@ class HyperliquidClient {
       }
     });
     this.metaLoaded = true;
+    this.log.info({ dexCount: dexes.length }, "meta rebuild complete");
   }
   getMaxLeverage(symbol5) {
     return this.maxLeverage.get(this.resolveSymbol(symbol5));
   }
+  getAllAssetNames() {
+    return this.assets.map((a) => a.symbol);
+  }
+  getAllAssets() {
+    return this.assets;
+  }
+  isKnownSymbol(symbol5) {
+    return this.assetMap.has(this.resolveSymbol(symbol5));
+  }
+  getDexUniverses() {
+    return this.dexUniverses;
+  }
+  async getSubscriptionClient() {
+    if (this.wsSubClient !== null)
+      return this.wsSubClient;
+    if (this.wsLifecycle !== null)
+      return this.wsLifecycle;
+    this.wsLifecycle = (async () => {
+      if (this.wsDisposed)
+        throw new Error("trading client disposed");
+      const transport = new WebSocketTransport({ isTestnet: this.testnet });
+      const client4 = new SubscriptionClient({ transport });
+      if (this.wsDisposed) {
+        await transport.close().catch(() => {});
+        throw new Error("trading client disposed");
+      }
+      this.wsTransport = transport;
+      this.wsSubClient = client4;
+      return client4;
+    })().finally(() => {
+      this.wsLifecycle = null;
+    });
+    return this.wsLifecycle;
+  }
+  async subscribeAllDexsAssetCtxs(listener) {
+    const client4 = await this.getSubscriptionClient();
+    const sub = await client4.allDexsAssetCtxs((e2) => {
+      listener({ ctxs: e2.ctxs });
+    });
+    return { unsubscribe: () => sub.unsubscribe() };
+  }
+  async closeWs() {
+    this.wsDisposed = true;
+    if (this.wsTransport !== null) {
+      try {
+        await this.wsTransport.close();
+      } catch {}
+    }
+    this.wsTransport = null;
+    this.wsSubClient = null;
+    this.wsLifecycle = null;
+  }
   resolveSymbol(symbol5) {
     const { dex, name } = parseDex(symbol5);
     if (dex !== null) {
@@ -180937,52 +181297,17 @@ class HyperliquidClient {
   async getPositions(address) {
     const user = address ?? this.defaultAddress;
     const data = await this.info("clearinghouseState", { user });
-    const positions = [];
-    for (const ap of data.assetPositions ?? []) {
-      const pos = ap.position;
-      const szi = parseFloat(pos.szi);
-      if (szi === 0)
-        continue;
-      const entryPx = parseFloat(pos.entryPx);
-      const markPx = pos.positionValue ? Math.abs(parseFloat(pos.positionValue) / szi) : entryPx;
-      const upnl = parseFloat(pos.unrealizedPnl);
-      const margin = parseFloat(pos.marginUsed);
-      positions.push({
-        symbol: pos.coin,
-        side: szi > 0 ? "long" : "short",
-        size: Math.abs(szi),
-        entryPrice: entryPx,
-        markPrice: markPx,
-        liquidationPrice: pos.liquidationPx && pos.liquidationPx !== "0.0" && parseFloat(pos.liquidationPx) > 0 ? parseFloat(pos.liquidationPx) : null,
-        unrealizedPnl: upnl,
-        unrealizedPnlPct: parseFloat(pos.returnOnEquity ?? "0") * 100,
-        leverage: parseFloat(pos.leverage?.value ?? "1"),
-        marginMode: pos.leverage?.type === "isolated" ? "isolated" : "cross",
-        margin
-      });
-    }
-    return positions;
+    return mapPositionsFromRaw(data);
   }
   async getOpenOrders(address) {
     const user = address ?? this.defaultAddress;
     const data = await this.info("frontendOpenOrders", { user });
-    return data.map((o10) => ({
-      orderId: String(o10.oid),
-      symbol: o10.coin,
-      side: o10.side === "B" ? "buy" : "sell",
-      orderType: o10.orderType ?? "Limit",
-      price: o10.limitPx ? parseFloat(o10.limitPx) : null,
-      triggerPrice: o10.triggerPx && o10.triggerPx !== "0.0" ? parseFloat(o10.triggerPx) : null,
-      size: parseFloat(o10.sz),
-      filled: parseFloat(o10.origSz ?? o10.sz) - parseFloat(o10.sz),
-      reduceOnly: o10.reduceOnly ?? false,
-      timestamp: o10.timestamp ?? Date.now()
-    }));
+    return data.map(mapOpenOrderFromRaw);
   }
   async getFills(address, limit2 = 20) {
     const user = address ?? this.defaultAddress;
     const data = await this.info("userFills", { user });
-    return data.slice(0, limit2).map((f2) => mapFill(f2));
+    return data.slice(0, limit2).map(mapFill);
   }
   async getFillsByTime(address, startTime, endTime) {
     const user = address ?? this.defaultAddress;
@@ -180990,7 +181315,7 @@ class HyperliquidClient {
     if (endTime !== undefined)
       params.endTime = endTime;
     const data = await this.info("userFillsByTime", params);
-    return data.map((f2) => mapFill(f2));
+    return data.map(mapFill);
   }
   async getHistoricalOrders(address, startTime) {
     const user = address ?? this.defaultAddress;
@@ -181018,7 +181343,7 @@ class HyperliquidClient {
   async getAllTickers() {
     await this.ensureMeta();
     const tickers = [];
-    const nativeData = await this.info("metaAndAssetCtxs");
+    const nativeData = await this.info("metaAndAssetCtxs", {}, { cache: true });
     const nativeCtxs = nativeData[1] ?? [];
     const responseNativeUniverse = nativeData[0]?.universe ?? [];
     const nativeNames = responseNativeUniverse.length > 0 ? responseNativeUniverse.map((a) => a.name) : this.dexUniverses.get("") ?? [];
@@ -181029,7 +181354,7 @@ class HyperliquidClient {
       tickers.push(ctxToTicker(nativeCtxs[i], name));
     }
     const dexes = await this.listPerpDexes().catch(() => []);
-    const dexCtxResults = await Promise.allSettled(dexes.map((d2) => this.info("metaAndAssetCtxs", { dex: d2.name })));
+    const dexCtxResults = await runWithConcurrency(dexes, 4, (d2) => this.info("metaAndAssetCtxs", { dex: d2.name }, { cache: true }));
     for (let i = 0;i < dexCtxResults.length; i++) {
       const r2 = dexCtxResults[i];
       if (r2.status !== "fulfilled") {
@@ -181077,7 +181402,8 @@ class HyperliquidClient {
       "1w": 604800000
     };
     const ms2 = intervalMs[interval] ?? 3600000;
-    const endTime = Date.now();
+    const QUANTISE_MS = 3000;
+    const endTime = Math.floor(Date.now() / QUANTISE_MS) * QUANTISE_MS;
     const startTime = endTime - limit2 * ms2;
     let timer;
     try {
@@ -181085,7 +181411,7 @@ class HyperliquidClient {
         timer = setTimeout(() => reject(new Error("Hyperliquid klines timeout (10s)")), 1e4);
       });
       const data = await Promise.race([
-        this.info("candleSnapshot", { req: { coin: resolved, interval, startTime, endTime } }),
+        this.info("candleSnapshot", { req: { coin: resolved, interval, startTime, endTime } }, { cache: true }),
         timeout
       ]);
       return (data ?? []).slice(-limit2).map((c2) => ({
@@ -181118,12 +181444,16 @@ class HyperliquidClient {
     const decimals = this.szDecimals.get(resolved) ?? 0;
     return size2.toFixed(decimals);
   }
-  formatPrice(price) {
-    return parseFloat(price.toPrecision(5)).toString();
+  formatPrice(symbol5, price) {
+    const resolved = this.resolveSymbol(symbol5);
+    const szDecimals = this.szDecimals.get(resolved) ?? 0;
+    const maxDecimals = Math.max(0, 6 - szDecimals);
+    const trimmed = parseFloat(price.toPrecision(5));
+    return parseFloat(trimmed.toFixed(maxDecimals)).toString();
   }
-  slippagePrice(midPrice, isBuy, slippagePct) {
+  slippagePrice(symbol5, midPrice, isBuy, slippagePct) {
     const factor = isBuy ? 1 + slippagePct / 100 : 1 - slippagePct / 100;
-    return this.formatPrice(midPrice * factor);
+    return this.formatPrice(symbol5, midPrice * factor);
   }
   async placeOrder(params) {
     const ex = this.requireExchange();
@@ -181139,42 +181469,42 @@ class HyperliquidClient {
     switch (params.orderType) {
       case "market": {
         const ticker = await this.getTicker(params.symbol);
-        price = this.slippagePrice(ticker.midPrice, isBuy, params.slippagePct ?? 0.5);
+        price = this.slippagePrice(params.symbol, ticker.midPrice, isBuy, params.slippagePct ?? 0.5);
         orderType = { limit: { tif: "Ioc" } };
         break;
       }
       case "limit": {
         if (!params.price)
           throw new Error("Limit order requires price");
-        price = this.formatPrice(params.price);
+        price = this.formatPrice(params.symbol, params.price);
         orderType = { limit: { tif: params.tif ?? "Gtc" } };
         break;
       }
       case "stop_market": {
         if (!params.price)
           throw new Error("Stop market order requires trigger price");
-        price = this.formatPrice(params.price);
+        price = this.formatPrice(params.symbol, params.price);
         orderType = { trigger: { isMarket: true, triggerPx: price, tpsl: "sl" } };
         break;
       }
       case "stop_limit": {
         if (!params.price)
           throw new Error("Stop limit order requires trigger price");
-        price = this.formatPrice(params.price);
+        price = this.formatPrice(params.symbol, params.price);
         orderType = { trigger: { isMarket: false, triggerPx: price, tpsl: "sl" } };
         break;
       }
       case "take_profit": {
         if (!params.price)
           throw new Error("Take profit order requires trigger price");
-        price = this.formatPrice(params.price);
+        price = this.formatPrice(params.symbol, params.price);
         orderType = { trigger: { isMarket: true, triggerPx: price, tpsl: "tp" } };
         break;
       }
       case "take_profit_limit": {
         if (!params.price)
           throw new Error("Take profit limit order requires price");
-        price = this.formatPrice(params.price);
+        price = this.formatPrice(params.symbol, params.price);
         orderType = { trigger: { isMarket: false, triggerPx: price, tpsl: "tp" } };
         break;
       }
@@ -181902,6 +182232,24 @@ class PaperTradingClient {
   getMaxLeverage(symbol5) {
     return this.marketClient.getMaxLeverage(symbol5);
   }
+  getAllAssetNames() {
+    return this.marketClient.getAllAssetNames();
+  }
+  isKnownSymbol(symbol5) {
+    return this.marketClient.isKnownSymbol(symbol5);
+  }
+  getAllAssets() {
+    return this.marketClient.getAllAssets();
+  }
+  getDexUniverses() {
+    return this.marketClient.getDexUniverses();
+  }
+  subscribeAllDexsAssetCtxs(_listener) {
+    return Promise.resolve(NOOP_SUB);
+  }
+  closeWs() {
+    return Promise.resolve();
+  }
   getBalance(_address) {
     return this.engine.getBalance();
   }
@@ -181948,8 +182296,10 @@ class PaperTradingClient {
     this.engine.reset(newBalance);
   }
 }
+var NOOP_SUB;
 var init_client7 = __esm(() => {
   init_engine();
+  NOOP_SUB = { unsubscribe: async () => {} };
 });
 
 // src/services/intel.ts
@@ -182234,7 +182584,7 @@ var init_alert_rules = __esm(() => {
 
 // src/services/notifications.ts
 function isKind(raw) {
-  return raw === "price_target" || raw === "liquidation_risk" || raw === "position_closed" || raw === "tp_hit" || raw === "sl_hit" || raw === "order_filled" || raw === "order_canceled" || raw === "proactive";
+  return raw === "price_target" || raw === "liquidation_risk" || raw === "position_closed" || raw === "tp_hit" || raw === "sl_hit" || raw === "order_filled" || raw === "order_canceled" || raw === "news" || raw === "proactive";
 }
 function rowToNotification(r2) {
   let payload;
@@ -182304,8 +182654,8 @@ class NotificationsService {
 // src/services/price-cache.ts
 class PriceCache {
   prices = new Map;
-  set(symbol5, price) {
-    this.prices.set(symbol5, { price, timestamp: Date.now() });
+  set(symbol5, price, prevDayPrice) {
+    this.prices.set(symbol5, { price, timestamp: Date.now(), prevDayPrice });
   }
   get(symbol5, maxAgeMs = 30000) {
     const entry = this.prices.get(symbol5);
@@ -182905,6 +183255,23 @@ class NewsService {
     ];
     return this.db.prepare(sql).all(...params).map((r2) => mapRow(r2));
   }
+  listRecentRelevant(sinceTs, limit2 = 20) {
+    const sql = `
+      SELECT id, source_id, external_id, url, title, snippet, image_url, coins,
+             importance, published_at, fetched_at, expires_at, full_summary,
+             ai_relevant, ai_duplicate_of
+      FROM articles
+      WHERE ai_relevant = 1
+        AND full_summary IS NOT NULL
+        AND ai_duplicate_of IS NULL
+        AND dismissed_at IS NULL
+        AND expires_at > unixepoch()
+        AND published_at > ?
+      ORDER BY published_at DESC, id DESC
+      LIMIT ?
+    `;
+    return this.db.prepare(sql).all(sinceTs, limit2).map((r2) => mapRow(r2));
+  }
   searchArticles(opts = {}) {
     const limit2 = Math.min(opts.limit ?? 50, 100);
     const conditions = ["ai_duplicate_of IS NULL"];
@@ -183640,8 +184007,90 @@ class PreferenceStore {
     else
       this.set(NEWS_FILTER_PROMPT_KEY, prompt);
   }
+  getTimezone() {
+    return this.get(USER_TIMEZONE_KEY);
+  }
+  setTimezone(tz) {
+    if (tz.length === 0)
+      this.delete(USER_TIMEZONE_KEY);
+    else
+      this.set(USER_TIMEZONE_KEY, tz);
+  }
+}
+var TWEET_FILTER_PROMPT_KEY = "tweets.filter_prompt", NEWS_FILTER_PROMPT_KEY = "news.filter_prompt", USER_TIMEZONE_KEY = "user.timezone";
+
+// src/scheduler/defaults.ts
+function detectUserTimezone() {
+  try {
+    return Intl.DateTimeFormat().resolvedOptions().timeZone || "UTC";
+  } catch {
+    return "UTC";
+  }
+}
+function buildBuiltInJobs(tz) {
+  return [
+    {
+      name: "morning-briefing",
+      schedule: { kind: "cron", expr: "0 8 * * *", tz },
+      message: BRIEFING_PROMPT,
+      deliver: true
+    },
+    {
+      name: "evening-recap",
+      schedule: { kind: "cron", expr: "0 21 * * *", tz },
+      message: RECAP_PROMPT,
+      deliver: true
+    }
+  ];
 }
-var TWEET_FILTER_PROMPT_KEY = "tweets.filter_prompt", NEWS_FILTER_PROMPT_KEY = "news.filter_prompt";
+var BRIEFING_PROMPT, RECAP_PROMPT;
+var init_defaults = __esm(() => {
+  BRIEFING_PROMPT = "Run the morning briefing. Call tools to fetch the latest data: open " + "positions, recent fills / trade history, watchlist, news, and market " + "signals (funding, whale activity, fear & greed). Summarize in under 15 " + "sentences, in the language the user has been chatting in.";
+  RECAP_PROMPT = "Run the end-of-day recap. Call tools to fetch today's trade history and " + "current open positions. Summarize today's PnL, position changes (opened, " + "closed, scaled), and one notable market note. Brief one-liner if I had no " + "activity. Reply in the language the user has been chatting in.";
+});
+
+// src/services/timezone.ts
+function validateTimezone(input) {
+  if (typeof input !== "string") {
+    return { ok: false, error: "Timezone must be a string" };
+  }
+  const trimmed = input.trim();
+  if (!trimmed) {
+    return { ok: false, error: "Timezone cannot be empty" };
+  }
+  if (trimmed.includes("\x00")) {
+    return { ok: false, error: "Timezone contains invalid characters" };
+  }
+  if (trimmed.length > 64) {
+    return { ok: false, error: "Timezone exceeds maximum length" };
+  }
+  try {
+    const resolved = new Intl.DateTimeFormat(undefined, { timeZone: trimmed }).resolvedOptions().timeZone;
+    return { ok: true, tz: resolved };
+  } catch {
+    return { ok: false, error: "Unknown timezone" };
+  }
+}
+function detectHostTimezone() {
+  return detectUserTimezone();
+}
+function createTimezoneService(prefs) {
+  return {
+    get() {
+      return prefs.getTimezone() ?? "UTC";
+    },
+    set(input) {
+      const result = validateTimezone(input);
+      if (!result.ok)
+        return result;
+      prefs.setTimezone(result.tz);
+      return result;
+    }
+  };
+}
+var init_timezone = __esm(() => {
+  init_defaults();
+});
 
 // src/services/x-follows.ts
 function sleep8(ms2) {
@@ -187422,11 +187871,8 @@ function createAdvancedTradingTools(hl2, watchlist, alerts, priceCache) {
       async execute(_toolCallId, params) {
         try {
           const upper2 = params.symbol.toUpperCase();
-          try {
-            await hl2.getTicker(upper2);
-          } catch {
+          if (!hl2.isKnownSymbol(upper2))
             return errorResult(`Symbol ${upper2} not found on Hyperliquid`);
-          }
           const item = await watchlist.add(upper2, params.notes);
           return textResult(`Added ${item.symbol} to watchlist.${item.notes ? ` Notes: ${item.notes}` : ""}`);
         } catch (e2) {
@@ -187493,11 +187939,8 @@ function createAdvancedTradingTools(hl2, watchlist, alerts, priceCache) {
         try {
           const cond = params.condition;
           const upper2 = params.symbol.toUpperCase();
-          try {
-            await hl2.getTicker(upper2);
-          } catch {
+          if (!hl2.isKnownSymbol(upper2))
             return errorResult(`Symbol ${upper2} not found on Hyperliquid.`);
-          }
           const lookup2 = await getCurrentPrice(hl2, priceCache, upper2);
           if (lookup2.price !== undefined) {
             const past = cond === "above" ? lookup2.price >= params.price : lookup2.price <= params.price;
@@ -188384,7 +188827,7 @@ class Runner {
   }
   async call(opts) {
     const next = this.inFlight.then(async () => {
-      const tools = this.registry.all();
+      const tools = this.registry.taskAgentTools();
       this.agent.state.tools = tools;
       for (const tool2 of tools) {
         if (isOriginAware(tool2))
@@ -188576,7 +189019,9 @@ function emptySnapshot() {
     openOrderIds: [],
     lastRestSyncAtMs: 0,
     recentCancelOids: [],
-    recentEmittedFillIds: []
+    recentEmittedFillIds: [],
+    recentEmittedNewsIds: [],
+    lastNewsScanTs: 0
   };
 }
 
@@ -188601,7 +189046,9 @@ class ObserverStateStore {
         openOrderIds: Array.isArray(parsed.openOrderIds) ? parsed.openOrderIds : [],
         lastRestSyncAtMs: typeof parsed.lastRestSyncAtMs === "number" ? parsed.lastRestSyncAtMs : 0,
         recentCancelOids: Array.isArray(parsed.recentCancelOids) ? parsed.recentCancelOids.filter((o10) => typeof o10 === "string") : [],
-        recentEmittedFillIds: Array.isArray(parsed.recentEmittedFillIds) ? parsed.recentEmittedFillIds.filter((o10) => typeof o10 === "string") : []
+        recentEmittedFillIds: Array.isArray(parsed.recentEmittedFillIds) ? parsed.recentEmittedFillIds.filter((o10) => typeof o10 === "string") : [],
+        recentEmittedNewsIds: Array.isArray(parsed.recentEmittedNewsIds) ? parsed.recentEmittedNewsIds.filter((o10) => typeof o10 === "string") : [],
+        lastNewsScanTs: typeof parsed.lastNewsScanTs === "number" ? parsed.lastNewsScanTs : 0
       };
     } catch {
       return emptySnapshot();
@@ -188614,7 +189061,7 @@ class ObserverStateStore {
     this.write.run(KEY_SNAPSHOT, JSON.stringify(emptySnapshot()));
   }
 }
-var RECENT_CANCEL_OIDS_CAP = 500, RECENT_FILL_IDS_CAP = 500, KEY_SNAPSHOT = "snapshot";
+var RECENT_CANCEL_OIDS_CAP = 500, RECENT_FILL_IDS_CAP = 500, RECENT_NEWS_IDS_CAP = 200, KEY_SNAPSHOT = "snapshot";
 
 // src/observer/detect/positions.ts
 function posKey(symbol5, side) {
@@ -188902,6 +189349,36 @@ function detectCanceledOrders(input) {
   return { events, emittedOids };
 }
 
+// src/observer/detect/news.ts
+function detectNews(input) {
+  const events = [];
+  const emittedIds = [];
+  const seenThisTick = new Set;
+  for (const article of input.articles) {
+    if (input.priorEmittedIds.has(article.id))
+      continue;
+    if (seenThisTick.has(article.id))
+      continue;
+    if (article.fullSummary === null)
+      continue;
+    events.push({
+      type: "news",
+      detectedAt: input.nowMs,
+      articleId: article.id,
+      title: article.title,
+      summary: article.fullSummary,
+      source: article.sourceId,
+      url: article.url,
+      publishedAt: article.publishedAt * 1000,
+      importance: article.importance,
+      coins: [...article.coins]
+    });
+    emittedIds.push(article.id);
+    seenThisTick.add(article.id);
+  }
+  return { events, emittedIds };
+}
+
 // src/observer/diff.ts
 function diffSnapshot(input) {
   const positionsR = detectPositions({
@@ -188933,18 +189410,25 @@ function diffSnapshot(input) {
     prices: input.prices,
     nowMs: input.nowMs
   });
+  const newsR = detectNews({
+    articles: input.articles,
+    priorEmittedIds: new Set(input.prior.recentEmittedNewsIds),
+    nowMs: input.nowMs
+  });
   return {
     events: [
       ...positionsR.events,
       ...fillsR.events,
       ...fallbackEvents,
       ...cancelR.events,
-      ...priceTargetR.events
+      ...priceTargetR.events,
+      ...newsR.events
     ],
     nextPositions: positionsR.nextPositions,
     firedAlertIds: priceTargetR.firedIds,
     emittedCancelOids: cancelR.emittedOids,
-    emittedFillIds: fillsR.emittedFillIds
+    emittedFillIds: fillsR.emittedFillIds,
+    emittedNewsIds: newsR.emittedIds
   };
 }
 var init_diff = () => {};
@@ -189060,7 +189544,8 @@ var init_judge2 = __esm(() => {
     Type.Literal("order_canceled"),
     Type.Literal("liquidation_risk"),
     Type.Literal("pnl_snapshot"),
-    Type.Literal("price_alert")
+    Type.Literal("price_alert"),
+    Type.Literal("news")
   ];
   JudgeResponseSchema = Type.Object({
     decision: Type.Union([Type.Literal("fire"), Type.Literal("silent")]),
@@ -189072,6 +189557,42 @@ var init_judge2 = __esm(() => {
   });
 });
 
+// src/observer/pnl-drift.ts
+function decidePnlDrift(input) {
+  const { state, currentPnl, lastUserActivityMs, nowMs } = input;
+  if (state.lastSnapshotPnl === null) {
+    return { fire: false, nextSnapshotPnl: currentPnl, reason: "seed_baseline" };
+  }
+  const base = Math.max(Math.abs(state.lastSnapshotPnl), PNL_DRIFT_MIN_BASE);
+  const deltaPct = (currentPnl - state.lastSnapshotPnl) / base;
+  const absDeltaPct = Math.abs(deltaPct);
+  if (absDeltaPct < PNL_DRIFT_THRESHOLD_PCT) {
+    return { fire: false, nextSnapshotPnl: state.lastSnapshotPnl, reason: "below_threshold" };
+  }
+  const idleMs = lastUserActivityMs === null ? SENTINEL_MAX_IDLE_MS : nowMs - lastUserActivityMs;
+  if (idleMs < PNL_DRIFT_IDLE_GATE_MS) {
+    return { fire: false, nextSnapshotPnl: state.lastSnapshotPnl, reason: "user_active" };
+  }
+  if (state.lastSentAtMs !== null && nowMs - state.lastSentAtMs < PNL_DRIFT_COOLDOWN_MS) {
+    return { fire: false, nextSnapshotPnl: state.lastSnapshotPnl, reason: "cooldown" };
+  }
+  const event2 = {
+    type: "portfolio_pnl_drift",
+    detectedAt: nowMs,
+    fromPnl: state.lastSnapshotPnl,
+    toPnl: currentPnl,
+    deltaPct,
+    idleMs
+  };
+  return { fire: true, event: event2, nextSnapshotPnl: currentPnl };
+}
+var PNL_DRIFT_THRESHOLD_PCT = 0.15, PNL_DRIFT_IDLE_GATE_MS, PNL_DRIFT_COOLDOWN_MS, PNL_DRIFT_MIN_BASE = 10, SENTINEL_MAX_IDLE_MS;
+var init_pnl_drift = __esm(() => {
+  PNL_DRIFT_IDLE_GATE_MS = 2 * 60 * 60 * 1000;
+  PNL_DRIFT_COOLDOWN_MS = 6 * 60 * 60 * 1000;
+  SENTINEL_MAX_IDLE_MS = 7 * 24 * 60 * 60 * 1000;
+});
+
 // src/channels/base.ts
 class BaseChannel {
   config;
@@ -193876,6 +194397,7 @@ function stripCustomTags(text) {
   out = out.replace(/<verdict\s*[^>]*>([\s\S]*?)<\/verdict>/gi, `${SENTINEL_I_OPEN}$1${SENTINEL_I_CLOSE}`);
   out = out.replace(/(\n)(\x00I_OPEN\x00(?:\uD83D\uDC02 |\uD83D\uDC3B |\u3030\uFE0F )?)/g, `$1
 $2`);
+  out = out.replace(/<ask_user_question\s*>([\s\S]*?)<\/ask_user_question>/gi, (_full, inner) => formatAskFallback(inner));
   const chartHint = (attrs) => {
     const symMatch = /\bsymbol\s*=\s*"([^"]+)"/i.exec(attrs);
     const intMatch = /\binterval\s*=\s*"([^"]+)"/i.exec(attrs);
@@ -193896,6 +194418,43 @@ $2`);
   out = out.replace(/<[a-zA-Z][^>]*$/g, "");
   return out;
 }
+function formatAskFallback(inner) {
+  const questionRe = /<question>([\s\S]*?)<\/question>/gi;
+  const titleRe = /<title>([\s\S]*?)<\/title>/i;
+  const optionsRe = /<options>([\s\S]*?)<\/options>/i;
+  const optionRe = /<option>([\s\S]*?)<\/option>/gi;
+  const lines = [];
+  let m6;
+  let i = 1;
+  while ((m6 = questionRe.exec(inner)) !== null) {
+    const body = m6[1];
+    const title = titleRe.exec(body)?.[1]?.trim();
+    if (!title)
+      continue;
+    let entry = `${i}. ${title}`;
+    const optionsBlock = optionsRe.exec(body)?.[1];
+    if (optionsBlock) {
+      const opts = [];
+      optionRe.lastIndex = 0;
+      let om2;
+      while ((om2 = optionRe.exec(optionsBlock)) !== null) {
+        const v4 = om2[1].trim();
+        if (v4)
+          opts.push(v4);
+      }
+      if (opts.length > 0)
+        entry += `
+   Options: ${opts.join(" / ")}`;
+    }
+    lines.push(entry);
+    i++;
+  }
+  if (lines.length === 0)
+    return "";
+  return `
+${lines.join(`
+`)}`;
+}
 var CHART_RE_PAIRED, CHART_RE_SELF;
 var init_tags = __esm(() => {
   CHART_RE_PAIRED = /<chart\s*([^>]*)>([\s\S]*?)<\/chart>/gi;
@@ -195305,6 +195864,7 @@ class ObserverLoop {
   store;
   cachedRest = null;
   lastProactiveAtMs;
+  pnlDriftState = { lastSnapshotPnl: null, lastSentAtMs: null };
   constructor(deps) {
     this.deps = deps;
     this.store = new ObserverStateStore(deps.db);
@@ -195341,6 +195901,7 @@ class ObserverLoop {
     const currentOpenOrderIds = rest4.openOrders.map((o10) => o10.orderId);
     const prices = this.deps.priceCache.snapshot();
     const alertRules = this.deps.alertRules.list();
+    const articles = rest4.positions.length === 0 ? [] : this.deps.newsService.listRecentRelevant(newsScanSinceTs(prior.lastNewsScanTs, nowMs));
     const diff = diffSnapshot({
       prior,
       positions: rest4.positions,
@@ -195350,19 +195911,42 @@ class ObserverLoop {
       alertRules,
       prices,
       liqProgressThreshold: this.deps.config.liquidationProgressThreshold,
+      articles,
       nowMs
     });
     for (const id of diff.firedAlertIds) {
       this.deps.alertRules.markFired(id, Math.floor(nowMs / 1000));
     }
     const gatedEvents = filterPnlSnapshots(diff.events, prior.positions, nowMs);
+    if (rest4.positions.length === 0) {
+      this.pnlDriftState = { lastSnapshotPnl: null, lastSentAtMs: null };
+    } else {
+      const totalUnrealizedPnl = rest4.positions.reduce((sum, p) => sum + p.unrealizedPnl, 0);
+      const session = this.deps.sessionManager.getOrCreate(MAIN_SESSION_KEY);
+      const lastUserActivityMs = session.lastActiveAt?.getTime() ?? null;
+      const driftDecision = decidePnlDrift({
+        state: this.pnlDriftState,
+        currentPnl: totalUnrealizedPnl,
+        lastUserActivityMs,
+        nowMs
+      });
+      if (driftDecision.fire) {
+        gatedEvents.push(driftDecision.event);
+      }
+      this.pnlDriftState = {
+        lastSnapshotPnl: driftDecision.nextSnapshotPnl,
+        lastSentAtMs: driftDecision.fire ? nowMs : this.pnlDriftState.lastSentAtMs
+      };
+    }
     const nextSnapshot = {
       positions: diff.nextPositions,
       lastFillTimestamp: rest4.latestFillTimestamp,
       openOrderIds: currentOpenOrderIds,
       lastRestSyncAtMs: synced ? nowMs : prior.lastRestSyncAtMs,
       recentCancelOids: mergeCancelOids(prior.recentCancelOids, diff.emittedCancelOids),
-      recentEmittedFillIds: mergeBoundedIds(prior.recentEmittedFillIds, diff.emittedFillIds, RECENT_FILL_IDS_CAP)
+      recentEmittedFillIds: mergeBoundedIds(prior.recentEmittedFillIds, diff.emittedFillIds, RECENT_FILL_IDS_CAP),
+      recentEmittedNewsIds: mergeBoundedIds(prior.recentEmittedNewsIds, diff.emittedNewsIds, RECENT_NEWS_IDS_CAP),
+      lastNewsScanTs: maxArticlePublishedAtSec(articles, prior.lastNewsScanTs)
     };
     const scanCounts = {
       positions: rest4.positions.length,
@@ -195451,6 +196035,7 @@ class ObserverLoop {
         alertRules: this.deps.alertRules.list(),
         prices: this.deps.priceCache.snapshot(),
         liqProgressThreshold: this.deps.config.liquidationProgressThreshold,
+        articles: [],
         nowMs
       });
       this.store.save({
@@ -195459,7 +196044,9 @@ class ObserverLoop {
         openOrderIds: rest4.openOrders.map((o10) => o10.orderId),
         lastRestSyncAtMs: syncDue ? nowMs : prior.lastRestSyncAtMs,
         recentCancelOids: mergeCancelOids(prior.recentCancelOids, diff.emittedCancelOids),
-        recentEmittedFillIds: mergeBoundedIds(prior.recentEmittedFillIds, diff.emittedFillIds, RECENT_FILL_IDS_CAP)
+        recentEmittedFillIds: mergeBoundedIds(prior.recentEmittedFillIds, diff.emittedFillIds, RECENT_FILL_IDS_CAP),
+        recentEmittedNewsIds: prior.recentEmittedNewsIds,
+        lastNewsScanTs: prior.lastNewsScanTs
       });
     } catch (err) {
       this.deps.logger.warn({ err }, "observer: baseline refresh failed under confirm gate");
@@ -195522,12 +196109,14 @@ class ObserverLoop {
       const m6 = msg;
       if (m6.role !== "user" && m6.role !== "assistant")
         continue;
-      if (!Array.isArray(m6.content))
-        continue;
       let text = "";
-      for (const block of m6.content) {
-        if (block?.type === "text" && typeof block.text === "string") {
-          text += block.text;
+      if (typeof m6.content === "string") {
+        text = m6.content;
+      } else if (Array.isArray(m6.content)) {
+        for (const block of m6.content) {
+          if (block?.type === "text" && typeof block.text === "string") {
+            text += block.text;
+          }
         }
       }
       if (text.trim().length === 0)
@@ -195597,22 +196186,38 @@ function mapKindFromEventType(t2) {
       return "order_canceled";
     case "order_filled":
       return "order_filled";
+    case "news":
+      return "news";
     default:
       return "proactive";
   }
 }
-var RECENT_CHAT_MAX = 20, MIN_PRICE_PCT_DELTA = 0.5, MIN_COOLDOWN_MS;
+function newsScanSinceTs(lastScanTs, nowMs) {
+  const slidingFloor = Math.floor(nowMs / 1000) - NEWS_LOOKBACK_FLOOR_SEC;
+  return lastScanTs > slidingFloor ? lastScanTs : slidingFloor;
+}
+function maxArticlePublishedAtSec(articles, prior) {
+  let max = prior;
+  for (const a of articles) {
+    if (a.publishedAt > max)
+      max = a.publishedAt;
+  }
+  return max;
+}
+var RECENT_CHAT_MAX = 20, MIN_PRICE_PCT_DELTA = 0.5, MIN_COOLDOWN_MS, NEWS_LOOKBACK_FLOOR_SEC;
 var init_loop = __esm(() => {
   init_diff();
   init_judge2();
+  init_pnl_drift();
   init_channels();
   init_types5();
   MIN_COOLDOWN_MS = 60 * 60 * 1000;
+  NEWS_LOOKBACK_FLOOR_SEC = 30 * 60;
 });
 
 // src/runtime.ts
 import { join as join14 } from "path";
-import { existsSync as existsSync18, mkdirSync as mkdirSync14, copyFileSync as copyFileSync2, readdirSync as readdirSync7 } from "fs";
+import { existsSync as existsSync17, mkdirSync as mkdirSync13, copyFileSync as copyFileSync2, readdirSync as readdirSync7 } from "fs";
 async function createRuntime(options) {
   const configPath = options.configPath ?? getConfigPath();
   const rawConfig = loadConfig(configPath);
@@ -195652,12 +196257,14 @@ async function createRuntime(options) {
   const skillsLoader = new SkillsLoader(workspaceDir, builtinSkillsDir);
   const skillService = new SkillService(db2, skillsLoader);
   skillService.syncState();
-  const contextBuilder = new ContextBuilder({ workspaceDir, model: config3.model }, memoryStore, skillsLoader);
+  const preferenceStore = new PreferenceStore(db2, logger.child({ module: "prefs" }));
+  const timezoneService = createTimezoneService(preferenceStore);
+  const contextBuilder = new ContextBuilder({ workspaceDir, model: config3.model, getTimezone: () => timezoneService.get() }, memoryStore, skillsLoader);
   contextBuilder.setDisabledSkillsProvider(() => skillService.getDisabledNames());
-  const cronService = new CronService(getCronStorePath());
+  const cronService = new CronService(db2);
   const tools = createToolRegistry(security2, {
     cronService,
-    defaultTimezone: config3.cron.timezone,
+    timezoneService,
     memoryStore,
     logger: logger.child({ module: "tool" })
   });
@@ -195668,7 +196275,6 @@ async function createRuntime(options) {
   const watchlistService = new WatchlistService(db2);
   const newsService = new NewsService(db2, watchlistService, credentials2, logger.child({ module: "news" }));
   const tweetService = new TweetService(db2, logger.child({ module: "tweets" }));
-  const preferenceStore = new PreferenceStore(db2, logger.child({ module: "prefs" }));
   const xQueryIdCache = new XQueryIdCache;
   const xFollowService = new XFollowService(db2, credentials2, xQueryIdCache, logger.child({ module: "x-follows" }));
   const taIndicators = new TaIndicatorService(tradingClient);
@@ -195707,7 +196313,7 @@ async function createRuntime(options) {
     eventBus,
     logger,
     customModelRegistry,
-    confirmDeps: { getConfirmService: () => confirmServiceRef }
+    confirmDeps: { getConfirmService: () => confirmServiceRef, approvalManager }
   });
   const taskAgent = createAgent({
     config: config3,
@@ -195724,7 +196330,8 @@ async function createRuntime(options) {
     logger: logger.child({ module: "task-agent" }),
     customModelRegistry,
     confirmDeps: { getConfirmService: () => null },
-    bypassConfirm: true
+    bypassConfirm: true,
+    taskMode: true
   });
   const runner = new Runner(taskAgent, sessionManager, tools, logger.child({ module: "runner" }));
   const rssDiscoveryService = new RssDiscoveryService(runner, logger.child({ module: "rss-discovery" }));
@@ -195791,7 +196398,7 @@ async function createRuntime(options) {
     tools.register(t2);
   contextBuilder.setTools(tools.all().map((t2) => ({ name: t2.name, description: t2.description })));
   agent3.state.tools = tools.all();
-  taskAgent.state.tools = tools.all();
+  taskAgent.state.tools = tools.taskAgentTools();
   setupClaudeCliProvider({
     config: config3,
     logger,
@@ -195831,6 +196438,7 @@ async function createRuntime(options) {
     config: config3.observer,
     tradingClient,
     alertRules,
+    newsService,
     notifications,
     priceCache,
     approvalManager,
@@ -195876,6 +196484,7 @@ async function createRuntime(options) {
     rssDiscoveryService,
     tweetService,
     preferenceStore,
+    timezoneService,
     xFollowService,
     skillService,
     chartSeries,
@@ -195909,16 +196518,16 @@ function getApiKey(oauthManager, credentials2, customModelRegistry) {
   };
 }
 function createAgent(opts) {
-  const initialOptions = buildAgentOptions(opts.config, opts.model, opts.security, opts.leakDetector, opts.oauthManager, opts.tools, opts.systemPrompt, opts.credentials, opts.extraReadDirs, opts.approvalManager, opts.eventBus, opts.logger, opts.customModelRegistry, opts.confirmDeps, opts.bypassConfirm ?? false);
+  const initialOptions = buildAgentOptions(opts.config, opts.model, opts.security, opts.leakDetector, opts.oauthManager, opts.tools, opts.systemPrompt, opts.credentials, opts.extraReadDirs, opts.approvalManager, opts.eventBus, opts.logger, opts.customModelRegistry, opts.confirmDeps, opts.bypassConfirm ?? false, opts.taskMode ?? false);
   return new Agent(initialOptions);
 }
-function buildAgentOptions(config3, model, security2, leakDetector, oauthManager, tools, systemPrompt, credentials2, extraReadDirs, approvalManager, eventBus, logger, customModelRegistry, confirmDeps, bypassConfirm = false) {
+function buildAgentOptions(config3, model, security2, leakDetector, oauthManager, tools, systemPrompt, credentials2, extraReadDirs, approvalManager, eventBus, logger, customModelRegistry, confirmDeps, bypassConfirm = false, taskMode = false) {
   const effectiveThinkingLevel = shouldForceThinkingOff({ id: model.id, baseUrl: model.baseUrl ?? "" }) ? "off" : config3.agent.thinkingLevel;
   return {
     initialState: {
       systemPrompt,
       model,
-      tools: config3.provider === "claude-cli" ? [] : tools.all(),
+      tools: config3.provider === "claude-cli" ? [] : taskMode ? tools.taskAgentTools() : tools.all(),
       thinkingLevel: effectiveThinkingLevel
     },
     getApiKey: config3.provider === "claude-cli" ? async () => "claude-cli-no-key-needed" : getApiKey(oauthManager, credentials2, customModelRegistry),
@@ -196007,6 +196616,7 @@ async function runBatchedConfirm(assistantMessage, callName, callArgs, batchCach
     let title;
     const lines = [];
     let steps;
+    let extras;
     if (isMulti) {
       title = `Confirm ${confirmable.length} actions?`;
       const stepList = [];
@@ -196017,14 +196627,22 @@ async function runBatchedConfirm(assistantMessage, callName, callArgs, batchCach
         stepList.push(`${head}${tail}`);
       }
       steps = stepList;
+      extras = undefined;
     } else {
       const only = confirmable[0];
+      const args = only.args ?? {};
+      const symbol5 = typeof args.symbol === "string" ? args.symbol : undefined;
       const desc = describeConfirm(only.name, only.args);
       title = desc.title;
       lines.push(...desc.bullets);
+      extras = {
+        wizard: desc.wizard,
+        suggestedValue: desc.suggestedValue,
+        symbol: symbol5
+      };
     }
     try {
-      const res = await confirmService.confirm(title, { lines, steps });
+      const res = await confirmService.confirm(title, { lines, steps }, extras);
       return { decision: res.decision, reason: res.reason };
     } catch (err) {
       logger.warn({ err }, "confirm service threw; treating as rejected");
@@ -196173,19 +196791,19 @@ function makeTransformContext(maxTokens) {
 }
 function resolveDefaultBuiltinSkillsDir() {
   const candidate = join14(import.meta.dir, "skills", "builtin");
-  return existsSync18(candidate) ? candidate : undefined;
+  return existsSync17(candidate) ? candidate : undefined;
 }
 function seedWorkspaceTemplates(workspaceDir) {
   const templatesDir = join14(import.meta.dir, "templates");
-  if (!existsSync18(templatesDir))
+  if (!existsSync17(templatesDir))
     return;
   try {
-    mkdirSync14(workspaceDir, { recursive: true });
+    mkdirSync13(workspaceDir, { recursive: true });
     for (const entry of readdirSync7(templatesDir, { withFileTypes: true })) {
       if (!entry.isFile())
         continue;
       const target = join14(workspaceDir, entry.name);
-      if (!existsSync18(target))
+      if (!existsSync17(target))
         copyFileSync2(join14(templatesDir, entry.name), target);
     }
   } catch {}
@@ -196237,6 +196855,7 @@ var init_runtime2 = __esm(() => {
   init_news();
   init_rss_discovery();
   init_tweets();
+  init_timezone();
   init_x_follows();
   init_x_query_ids();
   init_ta_indicators();
@@ -196420,14 +197039,6 @@ function getProviderList() {
       });
     }
   }
-  list.push({
-    id: "claude-cli",
-    label: "Claude Code",
-    description: "Use Claude Code subscription (no API key)",
-    tier: 0,
-    tierLabel: TIER_LABELS[0] ?? "Other",
-    supportsOAuth: false
-  });
   list.push({
     id: "custom",
     label: "Custom",
@@ -196458,9 +197069,6 @@ function getProviderList() {
   return list;
 }
 function getModelList(providerId) {
-  if (providerId === "claude-cli") {
-    return getClaudeCliModels();
-  }
   try {
     const raw = getModels(providerId).map((m6) => ({ id: m6.id, name: m6.name || m6.id }));
     return filterModelCatalog(providerId, raw);
@@ -196471,7 +197079,6 @@ function getModelList(providerId) {
 var OAUTH_PROVIDERS2, PROVIDER_META, TIER_LABELS;
 var init_providers = __esm(() => {
   init_dist();
-  init_models6();
   init_model_catalog();
   OAUTH_PROVIDERS2 = new Set(["anthropic", "openai-codex", "github-copilot", "google-gemini-cli", "google-antigravity"]);
   PROVIDER_META = {
@@ -196479,7 +197086,6 @@ var init_providers = __esm(() => {
     anthropic: { label: "Anthropic", description: "Claude Sonnet & Opus (direct)", tier: 0, apiKeyUrl: "https://console.anthropic.com/settings/keys" },
     openai: { label: "OpenAI", description: "GPT-4o, GPT-5 (direct)", tier: 0, apiKeyUrl: "https://platform.openai.com/api-keys" },
     "openai-codex": { label: "OpenAI Codex", description: "ChatGPT subscription (OAuth, no API key)", tier: 0 },
-    "claude-cli": { label: "Claude Code", description: "Use Claude Code subscription (no API key)", tier: 0 },
     google: { label: "Google Gemini", description: "Gemini 2.0 Flash & Pro", tier: 0, apiKeyUrl: "https://aistudio.google.com/app/apikey" },
     "google-gemini-cli": { label: "Google Gemini CLI", description: "Gemini via CLI auth", tier: 0 },
     xai: { label: "xAI", description: "Grok 3 & 4", tier: 0, apiKeyUrl: "https://console.x.ai" },
@@ -196516,17 +197122,15 @@ __export(exports_cli_providers, {
   listModels: () => listModels
 });
 function requiresApiKey(provider) {
-  if (provider.id === "claude-cli")
-    return false;
-  if (provider.supportsOAuth)
-    return false;
-  return true;
+  return !provider.supportsOAuth;
 }
 function listProviders() {
   const builtIn = getProviderList().map((p) => ({
     id: p.id,
     label: p.label,
     description: p.description,
+    tier: p.tier,
+    tierLabel: p.tierLabel,
     requiresApiKey: requiresApiKey(p),
     supportsOAuth: p.supportsOAuth,
     apiKeyUrl: p.apiKeyUrl ?? null
@@ -196537,6 +197141,8 @@ function listProviders() {
     id: name,
     label: name,
     description: "Custom provider (from ~/.ghost/models.json)",
+    tier: 4,
+    tierLabel: "\uD83D\uDD27 Custom",
     requiresApiKey: true,
     supportsOAuth: false,
     apiKeyUrl: null,
@@ -198590,11 +199196,11 @@ ${je2}${r2.trimStart()}`), s2 = 3 + ne(r2.trimStart()).length);
 });
 
 // src/services/os/utils.ts
-import { accessSync, constants, existsSync as existsSync19, mkdirSync as mkdirSync15, realpathSync as realpathSync2 } from "fs";
+import { accessSync, constants, existsSync as existsSync18, mkdirSync as mkdirSync14, realpathSync as realpathSync2 } from "fs";
 import { join as join15 } from "path";
 import { homedir as homedir3 } from "os";
 function isExecutable(filePath) {
-  if (!existsSync19(filePath))
+  if (!existsSync18(filePath))
     return false;
   try {
     accessSync(filePath, constants.X_OK);
@@ -198641,8 +199247,8 @@ function resolveBunPath() {
   return candidates[0];
 }
 function ensureLogDir(dir) {
-  if (!existsSync19(dir)) {
-    mkdirSync15(dir, { recursive: true });
+  if (!existsSync18(dir)) {
+    mkdirSync14(dir, { recursive: true });
   }
 }
 function defaultLogDir() {
@@ -198708,7 +199314,7 @@ __export(exports_launchd, {
   LaunchdController: () => LaunchdController
 });
 import { spawnSync } from "child_process";
-import { existsSync as existsSync20, unlinkSync as unlinkSync6, writeFileSync as writeFileSync11, rmSync as rmSync5 } from "fs";
+import { existsSync as existsSync19, unlinkSync as unlinkSync6, writeFileSync as writeFileSync10, rmSync as rmSync5 } from "fs";
 import { join as join16 } from "path";
 import { homedir as homedir4 } from "os";
 function plistPath() {
@@ -198758,7 +199364,7 @@ class LaunchdController {
       stderrLog,
       env: opts.env ?? {}
     });
-    writeFileSync11(definitionPath, plist, { encoding: "utf8", mode: 420 });
+    writeFileSync10(definitionPath, plist, { encoding: "utf8", mode: 420 });
     const domain2 = guiDomain();
     const uid = process.getuid?.() ?? 0;
     const serviceTarget = `${domain2}/${LABEL}`;
@@ -198808,12 +199414,12 @@ class LaunchdController {
     const domain2 = guiDomain();
     const definition = plistPath();
     launchctl(["bootout", domain2, definition]);
-    if (existsSync20(definition)) {
+    if (existsSync19(definition)) {
       unlinkSync6(definition);
     }
     if (opts.purgeLogs) {
       const logDir = defaultLogDir();
-      if (existsSync20(logDir)) {
+      if (existsSync19(logDir)) {
         rmSync5(logDir, { recursive: true, force: true });
       }
     }
@@ -198897,8 +199503,8 @@ __export(exports_systemd, {
   SystemdController: () => SystemdController
 });
 import { spawnSync as spawnSync2 } from "child_process";
-import { copyFileSync as copyFileSync3, existsSync as existsSync21, mkdirSync as mkdirSync16, rmSync as rmSync6, unlinkSync as unlinkSync7, writeFileSync as writeFileSync12 } from "fs";
-import { dirname as dirname9, join as join17 } from "path";
+import { copyFileSync as copyFileSync3, existsSync as existsSync20, mkdirSync as mkdirSync15, rmSync as rmSync6, unlinkSync as unlinkSync7, writeFileSync as writeFileSync11 } from "fs";
+import { dirname as dirname8, join as join17 } from "path";
 import { homedir as homedir5 } from "os";
 function unitPath() {
   return join17(homedir5(), ".config", "systemd", "user", SERVICE_NAME);
@@ -198942,11 +199548,11 @@ class SystemdController {
     assertSystemdAvailable();
     ensureLogDir(opts.logDir);
     const path4 = unitPath();
-    const dir = dirname9(path4);
-    if (!existsSync21(dir)) {
-      mkdirSync16(dir, { recursive: true });
+    const dir = dirname8(path4);
+    if (!existsSync20(dir)) {
+      mkdirSync15(dir, { recursive: true });
     }
-    if (existsSync21(path4)) {
+    if (existsSync20(path4)) {
       copyFileSync3(path4, `${path4}.bak`);
     }
     const unit = buildUnit({
@@ -198959,7 +199565,7 @@ class SystemdController {
         GHOST_LOG_DIR: opts.logDir
       }
     });
-    writeFileSync12(path4, unit, "utf8");
+    writeFileSync11(path4, unit, "utf8");
     const reload = systemctlStrict("daemon-reload");
     if (!reload.ok) {
       const msg = `daemon-reload failed: ${reload.stderr || reload.stdout}`;
@@ -199005,7 +199611,7 @@ class SystemdController {
     }
     for (const file3 of [path4, `${path4}.bak`]) {
       try {
-        if (existsSync21(file3)) {
+        if (existsSync20(file3)) {
           unlinkSync7(file3);
         }
       } catch {
@@ -199016,7 +199622,7 @@ class SystemdController {
     if (opts.purgeLogs) {
       const logDir = defaultLogDir();
       try {
-        if (existsSync21(logDir)) {
+        if (existsSync20(logDir)) {
           rmSync6(logDir, { recursive: true, force: true });
         }
       } catch {
@@ -199034,7 +199640,7 @@ class SystemdController {
     if (stdout === "active") {
       return "running";
     }
-    if (existsSync21(unitPath())) {
+    if (existsSync20(unitPath())) {
       return "stopped";
     }
     return "not-installed";
@@ -199056,7 +199662,7 @@ __export(exports_schtasks, {
 });
 import { spawnSync as spawnSync3 } from "child_process";
 import { Buffer as Buffer2 } from "buffer";
-import { existsSync as existsSync22, mkdirSync as mkdirSync17, writeFileSync as writeFileSync13, rmSync as rmSync7 } from "fs";
+import { existsSync as existsSync21, mkdirSync as mkdirSync16, writeFileSync as writeFileSync12, rmSync as rmSync7 } from "fs";
 import { join as join18 } from "path";
 import { homedir as homedir6, tmpdir } from "os";
 function launcherPath() {
@@ -199198,7 +199804,7 @@ function buildScheduledTaskXml(invisibleVbs, userId) {
 function writeTaskXml(xml) {
   const xmlPath = join18(tmpdir(), `ghost-task-${process.pid}.xml`);
   const bom = Buffer2.from([255, 254]);
-  writeFileSync13(xmlPath, Buffer2.concat([bom, Buffer2.from(xml, "utf16le")]));
+  writeFileSync12(xmlPath, Buffer2.concat([bom, Buffer2.from(xml, "utf16le")]));
   return xmlPath;
 }
 function killOrphanedSupervisorChain() {
@@ -199232,17 +199838,17 @@ class SchtasksController {
     }
     ensureLogDir(opts.logDir);
     const stateDir = join18(homedir6(), ".ghost", "state");
-    if (!existsSync22(stateDir)) {
-      mkdirSync17(stateDir, { recursive: true });
+    if (!existsSync21(stateDir)) {
+      mkdirSync16(stateDir, { recursive: true });
     }
     const legacy = legacyStartupPath();
-    if (existsSync22(legacy)) {
+    if (existsSync21(legacy)) {
       rmSync7(legacy, RM_RETRY_OPTS);
     }
     const launcher = launcherPath();
-    writeFileSync13(launcher, buildLauncherCmd(opts.bunPath, opts.execPath, opts.env), { encoding: "utf8" });
+    writeFileSync12(launcher, buildLauncherCmd(opts.bunPath, opts.execPath, opts.env), { encoding: "utf8" });
     const invisibleVbs = invisibleLauncherPath();
-    writeFileSync13(invisibleVbs, buildInvisibleVbs(launcher), { encoding: "utf8" });
+    writeFileSync12(invisibleVbs, buildInvisibleVbs(launcher), { encoding: "utf8" });
     const create4 = createScheduledTask(invisibleVbs, taskUser);
     if (create4.status !== 0) {
       return {
@@ -199287,20 +199893,20 @@ class SchtasksController {
     await new Promise((resolve) => setTimeout(resolve, 500));
     schtasks(["/Delete", "/F", "/TN", TASK_NAME]);
     const launcher = launcherPath();
-    if (existsSync22(launcher)) {
+    if (existsSync21(launcher)) {
       rmSync7(launcher, RM_RETRY_OPTS);
     }
     const invisibleVbs = invisibleLauncherPath();
-    if (existsSync22(invisibleVbs)) {
+    if (existsSync21(invisibleVbs)) {
       rmSync7(invisibleVbs, RM_RETRY_OPTS);
     }
     const legacy = legacyStartupPath();
-    if (existsSync22(legacy)) {
+    if (existsSync21(legacy)) {
       rmSync7(legacy, RM_RETRY_OPTS);
     }
     if (opts.purgeLogs) {
       const logDir = defaultLogDir();
-      if (existsSync22(logDir)) {
+      if (existsSync21(logDir)) {
         rmSync7(logDir, { recursive: true, ...RM_RETRY_OPTS });
       }
     }
@@ -212192,7 +212798,7 @@ function handleHealth() {
 }
 
 // src/gateway/static.ts
-import { existsSync as existsSync23 } from "fs";
+import { existsSync as existsSync22 } from "fs";
 import { join as join20, extname as extname3 } from "path";
 function mime2(path4) {
   return MIME[extname3(path4).toLowerCase()] ?? "application/octet-stream";
@@ -212200,7 +212806,7 @@ function mime2(path4) {
 function resolveWebDist(candidates) {
   const list = candidates ?? defaultWebDistCandidates();
   for (const c4 of list) {
-    if (existsSync23(join20(c4, "index.html")))
+    if (existsSync22(join20(c4, "index.html")))
       return c4;
   }
   return null;
@@ -212455,7 +213061,7 @@ function semverGt(a, b5) {
 }
 
 // src/update/version.ts
-import { readFileSync as readFileSync17, existsSync as existsSync24 } from "fs";
+import { readFileSync as readFileSync16, existsSync as existsSync23 } from "fs";
 import { join as join21 } from "path";
 function resolvePackageJsonPath(candidates) {
   const list = candidates ?? [
@@ -212464,7 +213070,7 @@ function resolvePackageJsonPath(candidates) {
     join21(process.cwd(), "package.json")
   ];
   for (const p2 of list) {
-    if (existsSync24(p2))
+    if (existsSync23(p2))
       return p2;
   }
   return null;
@@ -212486,7 +213092,7 @@ function getCurrentVersion(pkgPath) {
   if (!resolved)
     return UNKNOWN_VERSION;
   try {
-    const pkg = JSON.parse(readFileSync17(resolved, "utf-8"));
+    const pkg = JSON.parse(readFileSync16(resolved, "utf-8"));
     if (pkg.version && pkg.version.length > 0)
       return pkg.version;
   } catch {}
@@ -212543,14 +213149,14 @@ var init_status = __esm(() => {
 });
 
 // src/gateway/memory.ts
-import { readFileSync as readFileSync18, existsSync as existsSync25 } from "fs";
+import { readFileSync as readFileSync17, existsSync as existsSync24 } from "fs";
 function registerMemoryMethods(register, deps) {
   register("memory.get", async () => {
     const memory = deps.memoryStore.readLongTerm();
     let history = "";
-    if (existsSync25(deps.memoryStore.historyFile)) {
+    if (existsSync24(deps.memoryStore.historyFile)) {
       try {
-        history = readFileSync18(deps.memoryStore.historyFile, "utf-8");
+        history = readFileSync17(deps.memoryStore.historyFile, "utf-8");
       } catch {}
     }
     return { memory, history };
@@ -212713,6 +213319,22 @@ function registerCronMethods(register, deps) {
   });
 }
 
+// src/gateway/config.ts
+function registerConfigMethods(register, deps) {
+  register("config.timezone.get", async () => ({
+    tz: deps.timezoneService.get()
+  }));
+  register("config.timezone.set", async (_ctx, payload) => {
+    const p2 = payload;
+    const result = deps.timezoneService.set(p2.tz);
+    if (!result.ok) {
+      return { ok: false, error: result.error };
+    }
+    const updatedJobs = deps.cronService.updateBuiltinJobsTimezone(result.tz);
+    return { ok: true, tz: result.tz, updatedJobs };
+  });
+}
+
 // src/gateway/route-orchestrator-error.ts
 function routeOrchestratorError(runId, classified, emit) {
   if (classified.type === "TOOL_BLOCKED") {
@@ -213083,34 +213705,19 @@ function registerTradingMethods(register, deps) {
     return { fills: filtered, window: { startTime, endTime }, capped };
   });
   register("trading.tokens.list", async () => {
-    try {
-      const tickers = await deps.tradingClient.getAllTickers();
-      const prices = {};
-      const prevDayPrices = {};
-      const maxLeverages = {};
-      const tokens = [];
-      for (const t10 of tickers) {
-        tokens.push(t10.symbol);
-        prices[t10.symbol] = t10.markPrice;
-        if (t10.prevDayPrice > 0)
-          prevDayPrices[t10.symbol] = t10.prevDayPrice;
-        const lev = deps.tradingClient.getMaxLeverage(t10.symbol);
-        if (typeof lev === "number" && lev > 0)
-          maxLeverages[t10.symbol] = lev;
-      }
-      tokens.sort();
-      return { tokens, prices, prevDayPrices, maxLeverages };
-    } catch {
-      return { tokens: [], prices: {}, prevDayPrices: {}, maxLeverages: {} };
-    }
+    return deps.tokensSnapshot.build();
   });
   register("trading.price", async (_ctx, payload) => {
     const params = typeof payload === "object" && payload !== null ? payload : {};
     const symbol5 = typeof params.symbol === "string" ? params.symbol : undefined;
     if (!symbol5)
       return { price: null, symbol: null };
+    const resolved = deps.tradingClient.resolveSymbol(symbol5);
+    const entry = deps.priceCache.get(resolved, 30000);
+    if (entry)
+      return { symbol: resolved, price: entry.price };
     try {
-      const ticker = await deps.tradingClient.getTicker(symbol5);
+      const ticker = await deps.tradingClient.getTicker(resolved);
       return { symbol: ticker.symbol, price: ticker.markPrice };
     } catch {
       return { price: null, symbol: symbol5 };
@@ -213129,9 +213736,7 @@ function registerTradingMethods(register, deps) {
     if (!symbol5)
       return { error: "symbol required" };
     const resolved = deps.tradingClient.resolveSymbol(symbol5);
-    try {
-      await deps.tradingClient.getTicker(resolved);
-    } catch {
+    if (!deps.tradingClient.isKnownSymbol(resolved)) {
       return { error: `Symbol ${resolved} not found on Hyperliquid` };
     }
     try {
@@ -213840,7 +214445,7 @@ class CompositePriceFeed {
     this.log.info({ sources: names }, "composite price feed starting");
     await Promise.all(this.sources.map(async (source2) => {
       try {
-        await source2.start((symbol5, price) => this.handleTick(source2, symbol5, price));
+        await source2.start((symbol5, price, prevDayPrice) => this.handleTick(source2, symbol5, price, prevDayPrice));
       } catch (err) {
         this.log.warn({ err, source: source2.name }, "source failed to start");
       }
@@ -213871,7 +214476,7 @@ class CompositePriceFeed {
     this.healthySince.clear();
     this.onPrice = null;
   }
-  handleTick(source2, symbol5, price) {
+  handleTick(source2, symbol5, price, prevDayPrice) {
     if (!this.onPrice)
       return;
     if (this.currentPrimary === null) {
@@ -213881,7 +214486,7 @@ class CompositePriceFeed {
     }
     if (source2.name !== this.currentPrimary)
       return;
-    this.onPrice(symbol5, price);
+    this.onPrice(symbol5, price, prevDayPrice);
   }
   isHealthy(source2) {
     const last = source2.getLastTickAt();
@@ -213960,44 +214565,6 @@ var init_composite3 = __esm(() => {
   init_types6();
 });
 
-// src/services/price-feed/sources/bun-ws-compat.ts
-function applyShim() {
-  const proto = globalThis.WebSocket?.prototype;
-  if (!proto || proto.__ghostBlobSetterPatched)
-    return proto?.__ghostBlobSetterPatched === true;
-  const desc = Object.getOwnPropertyDescriptor(proto, "binaryType");
-  if (!desc?.set)
-    return false;
-  const originalSet = desc.set;
-  Object.defineProperty(proto, "binaryType", {
-    configurable: true,
-    enumerable: desc.enumerable ?? false,
-    get: desc.get,
-    set(value2) {
-      if (value2 === "blob") {
-        const g7 = globalThis;
-        if (!g7.__ghostBlobWarned) {
-          g7.__ghostBlobWarned = true;
-          console.warn("[ghost] WebSocket.binaryType='blob' silently dropped (Bun compat shim \u2014 see src/services/price-feed/sources/bun-ws-compat.ts)");
-        }
-        return;
-      }
-      originalSet.call(this, value2);
-    }
-  });
-  Object.defineProperty(proto, "__ghostBlobSetterPatched", {
-    value: true,
-    writable: false,
-    enumerable: false,
-    configurable: false
-  });
-  return true;
-}
-var BUN_WS_COMPAT_APPLIED;
-var init_bun_ws_compat = __esm(() => {
-  BUN_WS_COMPAT_APPLIED = applyShim();
-});
-
 // src/services/price-feed/sources/hyperliquid.ts
 class HyperliquidSource {
   name = "hyperliquid";
@@ -214011,13 +214578,10 @@ class HyperliquidSource {
   healthCheckIntervalMs;
   onTick = null;
   stopped = true;
-  transport = null;
-  client = null;
-  subscription = null;
+  wsSubscription = null;
   wsRetryTimer = null;
   wsRetryCount = 0;
   lastWsTickAt = 0;
-  universe = [];
   restTimer = null;
   restPolling = false;
   lastRestTickAt = 0;
@@ -214052,12 +214616,34 @@ class HyperliquidSource {
       restIntervalMs: this.restIntervalMs
     }, "hyperliquid source starting (WS primary, REST dormant)");
     await this.connectWs();
+    if (this.stopped)
+      return;
+    await this.hydrateFromRest();
     if (this.stopped)
       return;
     this.healthTimer = setInterval(() => {
       this.reconcileTransports();
     }, this.healthCheckIntervalMs);
   }
+  async hydrateFromRest() {
+    try {
+      const tickers = await this.tradingClient.getAllTickers();
+      if (this.stopped)
+        return;
+      const callback = this.onTick;
+      if (!callback)
+        return;
+      for (const t10 of tickers) {
+        if (!Number.isFinite(t10.markPrice))
+          continue;
+        const prev = Number.isFinite(t10.prevDayPrice) && t10.prevDayPrice > 0 ? t10.prevDayPrice : undefined;
+        callback(t10.symbol, t10.markPrice, prev);
+      }
+      this.log.info({ count: tickers.length }, "hyperliquid source: REST hydration complete");
+    } catch (err) {
+      this.log.warn({ err }, "hyperliquid source: REST hydration failed; relying on WS");
+    }
+  }
   async stop() {
     if (this.stopped)
       return;
@@ -214077,89 +214663,53 @@ class HyperliquidSource {
   async connectWs() {
     if (this.stopped)
       return;
-    let transport = null;
-    let client4 = null;
-    let subscription = null;
     try {
-      transport = new WebSocketTransport({ isTestnet: this.testnet });
-      client4 = new SubscriptionClient({ transport });
-      await this.refreshUniverse();
-      subscription = await client4.assetCtxs((event2) => this.handleAssetCtxsEvent(event2));
+      await this.tradingClient.ensureMeta();
+      if (this.stopped)
+        return;
+      const sub = await this.tradingClient.subscribeAllDexsAssetCtxs((event2) => this.handleAllDexsAssetCtxsEvent(event2));
       if (this.stopped) {
         try {
-          await subscription.unsubscribe();
-        } catch {}
-        try {
-          await transport.close();
+          await sub.unsubscribe();
         } catch {}
         return;
       }
-      this.transport = transport;
-      this.client = client4;
-      this.subscription = subscription;
+      this.wsSubscription = sub;
       this.wsRetryCount = 0;
-      this.log.info("hyperliquid source: WS connected");
-      this.subscription.failureSignal.addEventListener("abort", () => {
-        if (this.stopped)
-          return;
-        this.log.warn("hyperliquid source: WS subscription failed, scheduling retry");
-        this.scheduleWsRetry();
-      });
-      this.transport.socket.addEventListener("terminate", (ev2) => {
-        if (this.stopped)
-          return;
-        this.log.warn({ reason: ev2.detail?.code, cause: serializeError(ev2.detail?.cause) }, "hyperliquid source: WS transport terminated, scheduling retry");
-        this.scheduleWsRetry();
-      });
-      this.transport.socket.addEventListener("error", (ev2) => {
-        if (this.stopped)
-          return;
-        this.log.warn({ event: serializeWsErrorEvent(ev2) }, "hyperliquid source: WS transport error");
-      });
+      this.log.info("hyperliquid source: WS connected (allDexsAssetCtxs)");
     } catch (err) {
       this.log.warn({ err }, "hyperliquid source: WS failed to connect");
-      if (subscription) {
-        try {
-          await subscription.unsubscribe();
-        } catch {}
-      }
-      if (transport) {
-        try {
-          await transport.close();
-        } catch {}
-      }
       await this.cleanupWs();
       this.scheduleWsRetry();
     }
   }
-  async refreshUniverse() {
-    try {
-      const tickers = await this.tradingClient.getAllTickers();
-      this.universe = tickers.map((t10) => t10.symbol);
-    } catch (err) {
-      this.log.warn({ err }, "hyperliquid source: universe refresh failed");
-    }
-  }
-  handleAssetCtxsEvent(event2) {
+  handleAllDexsAssetCtxsEvent(event2) {
     if (this.stopped)
       return;
     const callback = this.onTick;
     if (!callback)
       return;
+    const dexUniverses = this.tradingClient.getDexUniverses();
     const now = Date.now();
     let anyEmitted = false;
-    for (let i = 0;i < event2.ctxs.length; i++) {
-      const symbol5 = this.universe[i];
-      if (!symbol5)
-        continue;
-      const raw = event2.ctxs[i]?.markPx;
-      if (raw === null || raw === undefined)
-        continue;
-      const mark = typeof raw === "string" ? parseFloat(raw) : Number(raw);
-      if (!Number.isFinite(mark))
-        continue;
-      callback(symbol5, mark);
-      anyEmitted = true;
+    for (const [dex, ctxs] of event2.ctxs) {
+      const universe = dexUniverses.get(dex) ?? [];
+      for (let i = 0;i < ctxs.length; i++) {
+        const symbol5 = universe[i];
+        if (!symbol5)
+          continue;
+        const ctx = ctxs[i];
+        const raw = ctx?.markPx;
+        if (raw === null || raw === undefined)
+          continue;
+        const mark = typeof raw === "string" ? parseFloat(raw) : Number(raw);
+        if (!Number.isFinite(mark))
+          continue;
+        const prevRaw = ctx?.prevDayPx;
+        const prevDay = prevRaw != null ? typeof prevRaw === "string" ? parseFloat(prevRaw) : Number(prevRaw) : undefined;
+        callback(symbol5, mark, Number.isFinite(prevDay) ? prevDay : undefined);
+        anyEmitted = true;
+      }
     }
     if (anyEmitted)
       this.lastWsTickAt = now;
@@ -214179,19 +214729,12 @@ class HyperliquidSource {
     }, delay4);
   }
   async cleanupWs() {
-    if (this.subscription) {
+    if (this.wsSubscription) {
       try {
-        await this.subscription.unsubscribe();
+        await this.wsSubscription.unsubscribe();
       } catch {}
-      this.subscription = null;
+      this.wsSubscription = null;
     }
-    if (this.transport) {
-      try {
-        await this.transport.close();
-      } catch {}
-      this.transport = null;
-    }
-    this.client = null;
   }
   activateRest() {
     if (this.stopped)
@@ -214229,7 +214772,8 @@ class HyperliquidSource {
           return;
         if (!Number.isFinite(t10.markPrice))
           continue;
-        callback(t10.symbol, t10.markPrice);
+        const prevDay = Number.isFinite(t10.prevDayPrice) && t10.prevDayPrice > 0 ? t10.prevDayPrice : undefined;
+        callback(t10.symbol, t10.markPrice, prevDay);
         anyEmitted = true;
       }
       if (anyEmitted)
@@ -214274,7 +214818,7 @@ class HyperliquidSource {
     this.deactivateRest();
   }
   maybeForceWsReconnect(wsAge) {
-    if (!this.subscription)
+    if (!this.wsSubscription)
       return;
     if (this.wsRetryTimer)
       return;
@@ -214288,27 +214832,7 @@ class HyperliquidSource {
     });
   }
 }
-function serializeWsErrorEvent(ev2) {
-  const e2 = ev2;
-  const underlying = e2.error;
-  return {
-    type: ev2.type,
-    message: typeof e2.message === "string" ? e2.message : undefined,
-    error: underlying instanceof Error ? { name: underlying.name, message: underlying.message } : underlying !== undefined ? String(underlying) : undefined
-  };
-}
-function serializeError(cause) {
-  if (cause === undefined || cause === null)
-    return;
-  if (cause instanceof Error)
-    return `${cause.name}: ${cause.message}`;
-  return String(cause);
-}
 var DEFAULT_REST_INTERVAL_MS = 5000, DEFAULT_WS_STALE_MS = 1e4, DEFAULT_WS_STABILITY_MS = 5000, DEFAULT_HEALTH_CHECK_INTERVAL_MS = 1000;
-var init_hyperliquid = __esm(() => {
-  init_bun_ws_compat();
-  init_mod6();
-});
 
 // src/services/price-feed/symbol-mapping.ts
 function mapBinanceSymbol(binanceSymbol) {
@@ -214581,7 +215105,7 @@ class BinanceSource {
       ws.addEventListener("error", (ev2) => {
         if (this.stopped)
           return;
-        this.log.warn({ event: serializeWsErrorEvent2(ev2) }, "binance source: WS error");
+        this.log.warn({ event: serializeWsErrorEvent(ev2) }, "binance source: WS error");
       });
     } catch (err) {
       this.log.warn({ err }, "binance source: WS failed to open");
@@ -214612,7 +215136,7 @@ class BinanceSource {
       const mark = entry?.p;
       if (typeof sym !== "string" || typeof mark !== "string")
         continue;
-      const emitted = this.emitMapped(sym, mark, callback);
+      const emitted = this.emitMapped(sym, mark, entry.o, callback);
       if (emitted)
         anyEmitted = true;
     }
@@ -214685,7 +215209,7 @@ class BinanceSource {
               const mark = row?.markPrice;
               if (typeof sym !== "string" || typeof mark !== "string")
                 continue;
-              const emitted = this.emitMapped(sym, mark, callback);
+              const emitted = this.emitMapped(sym, mark, row.openPrice, callback);
               if (emitted)
                 anyEmitted = true;
             }
@@ -214702,7 +215226,7 @@ class BinanceSource {
       }
     }
   }
-  emitMapped(binanceSymbol, priceStr, callback) {
+  emitMapped(binanceSymbol, priceStr, prevDayPriceStr, callback) {
     if (!binanceSymbol.endsWith("USDT"))
       return false;
     const base = binanceSymbol.slice(0, -4);
@@ -214719,7 +215243,14 @@ class BinanceSource {
     if (!Number.isFinite(binancePrice))
       return false;
     const hlPrice = binancePrice * mapping.multiplier;
-    callback(mapping.hlSymbol, hlPrice);
+    let prevDayPrice;
+    if (prevDayPriceStr !== undefined) {
+      const rawPrev = Number.parseFloat(prevDayPriceStr);
+      if (Number.isFinite(rawPrev) && rawPrev > 0) {
+        prevDayPrice = rawPrev * mapping.multiplier;
+      }
+    }
+    callback(mapping.hlSymbol, hlPrice, prevDayPrice);
     return true;
   }
   reconcileTransports() {
@@ -214751,7 +215282,7 @@ class BinanceSource {
     this.deactivateRest();
   }
 }
-function serializeWsErrorEvent2(ev2) {
+function serializeWsErrorEvent(ev2) {
   const e2 = ev2;
   const underlying = e2.error;
   return {
@@ -214778,6 +215309,37 @@ var init_binance2 = __esm(() => {
   LEVERAGED_SUFFIX_RE = /(?:UP|DOWN|BULL|BEAR)$/;
 });
 
+// src/services/tokens-snapshot.ts
+class TokensSnapshotService {
+  client;
+  priceCache;
+  constructor(client4, priceCache) {
+    this.client = client4;
+    this.priceCache = priceCache;
+  }
+  build() {
+    const assets = this.client.getAllAssets();
+    const prices = {};
+    const prevDayPrices = {};
+    const maxLeverages = {};
+    const tokens = [];
+    for (const { symbol: symbol5, isDelisted } of assets) {
+      const entry = this.priceCache.get(symbol5, 30000);
+      if (entry) {
+        prices[symbol5] = entry.price;
+        if (entry.prevDayPrice !== undefined)
+          prevDayPrices[symbol5] = entry.prevDayPrice;
+      }
+      const lev = this.client.getMaxLeverage(symbol5);
+      if (typeof lev === "number" && lev > 0)
+        maxLeverages[symbol5] = lev;
+      tokens.push(isDelisted ? { symbol: symbol5, isDelisted: true } : { symbol: symbol5 });
+    }
+    tokens.sort((a, b5) => a.symbol.localeCompare(b5.symbol));
+    return { tokens, prices, prevDayPrices, maxLeverages };
+  }
+}
+
 // node_modules/viem/_esm/utils/address/isAddressEqual.js
 function isAddressEqual(a, b5) {
   if (!isAddress(a, { strict: false }))
@@ -214901,7 +215463,12 @@ function createGateway(gatewayConfig, deps) {
   registerToolsMethods(registry4.register.bind(registry4), { tools: deps.tools });
   registerSessionsMethods(registry4.register.bind(registry4), { sessionManager: deps.sessionManager });
   registerCronMethods(registry4.register.bind(registry4), { cronService: deps.cronService });
-  registerTradingMethods(registry4.register.bind(registry4), { tradingClient: deps.tradingClient, walletStore: deps.walletStore, alertRules: deps.alertRules, notifications: deps.notifications, newsService: deps.newsService, rssDiscovery: deps.rssDiscoveryService, tweetService: deps.tweetService, xFollowService: deps.xFollowService, preferenceStore: deps.preferenceStore, watchlist: deps.watchlistService, logger: deps.logger });
+  registerConfigMethods(registry4.register.bind(registry4), {
+    timezoneService: deps.timezoneService,
+    cronService: deps.cronService
+  });
+  const tokensSnapshot = new TokensSnapshotService(deps.tradingClient, deps.priceCache);
+  registerTradingMethods(registry4.register.bind(registry4), { tradingClient: deps.tradingClient, walletStore: deps.walletStore, alertRules: deps.alertRules, notifications: deps.notifications, newsService: deps.newsService, rssDiscovery: deps.rssDiscoveryService, tweetService: deps.tweetService, xFollowService: deps.xFollowService, preferenceStore: deps.preferenceStore, watchlist: deps.watchlistService, logger: deps.logger, tokensSnapshot, priceCache: deps.priceCache });
   registerApprovalMethods(registry4.register.bind(registry4), { approvalManager: deps.approvalManager });
   registerToolApprovalMethods(registry4.register.bind(registry4), { approvalManager: deps.approvalManager });
   registerSkillsMethods(registry4.register.bind(registry4), { skillService: deps.skillService });
@@ -214930,10 +215497,6 @@ function createGateway(gatewayConfig, deps) {
     deps.eventBus.publish(TradingEvents.watchlistChanged({ action, symbol: symbol5 }));
   });
   const lastPrices = new Map;
-  let watchedSymbols = new Set(deps.watchlistService.list().map((i) => i.symbol));
-  deps.watchlistService.onChanged(() => {
-    watchedSymbols = new Set(deps.watchlistService.list().map((i) => i.symbol));
-  });
   const priceFeedConfig = deps.config.priceFeed;
   const priceFeedLogger = deps.logger.child({ module: "price-feed" });
   function buildPriceSources() {
@@ -214956,15 +215519,13 @@ function createGateway(gatewayConfig, deps) {
     staleThresholdMs: priceFeedConfig.staleThresholdMs,
     stabilityWindowMs: priceFeedConfig.stabilityWindowMs
   }, priceFeedLogger);
-  function broadcastPrice(symbol5, price) {
+  function broadcastPrice(symbol5, price, prevDayPrice) {
+    deps.priceCache.set(symbol5, price, prevDayPrice);
     const prev = lastPrices.get(symbol5);
-    if (prev === price)
+    if (prev === price && prevDayPrice === undefined)
       return;
     lastPrices.set(symbol5, price);
-    deps.priceCache.set(symbol5, price);
-    if (watchedSymbols.has(symbol5)) {
-      deps.eventBus.publish(TradingEvents.priceUpdate({ symbol: symbol5, price }));
-    }
+    deps.eventBus.publish(TradingEvents.priceUpdate({ symbol: symbol5, price, prevDayPrice }));
   }
   async function startPriceFeed() {
     if (!priceFeedConfig.enabled) {
@@ -214973,7 +215534,7 @@ function createGateway(gatewayConfig, deps) {
     }
     lastPrices.clear();
     try {
-      await compositeFeed.start((symbol5, price) => broadcastPrice(symbol5, price));
+      await compositeFeed.start((symbol5, price, prevDayPrice) => broadcastPrice(symbol5, price, prevDayPrice));
     } catch (err) {
       priceFeedLogger.warn({ err }, "composite price feed failed to start");
     }
@@ -215202,7 +215763,6 @@ var init_server = __esm(() => {
   init_wallet_events();
   init_trading_events();
   init_composite3();
-  init_hyperliquid();
   init_binance2();
   init_accounts();
   init__esm();
@@ -215229,12 +215789,16 @@ function snapshotRecentUserMessages(sessionManager, limit2) {
   const out = [];
   for (const msg of session.messages) {
     const m6 = msg;
-    if (m6.role !== "user" || !Array.isArray(m6.content))
+    if (m6.role !== "user")
       continue;
     let text = "";
-    for (const block of m6.content) {
-      if (block?.type === "text" && typeof block.text === "string") {
-        text += block.text;
+    if (typeof m6.content === "string") {
+      text = m6.content;
+    } else if (Array.isArray(m6.content)) {
+      for (const block of m6.content) {
+        if (block?.type === "text" && typeof block.text === "string") {
+          text += block.text;
+        }
       }
     }
     const trimmed = text.trim();
@@ -215935,6 +216499,7 @@ async function startDaemon(options) {
     tweetService,
     xFollowService,
     preferenceStore,
+    timezoneService,
     security: security2,
     leakDetector,
     skillService,
@@ -215980,6 +216545,7 @@ async function startDaemon(options) {
     tools,
     sessionManager,
     cronService,
+    timezoneService,
     configPath,
     channels: runtime.channelManager.listChannels().map((ch2) => ({ name: ch2.name })),
     tradingClient,
@@ -216021,7 +216587,7 @@ async function startDaemon(options) {
   }));
   runtime.channelManager.startAllChannels();
   if (config3.cron.enableScheduler) {
-    cronService.start();
+    cronService.start({ defaults: buildBuiltInJobs(timezoneService.get()) });
   }
   const runner = new BackgroundJobRunner({
     taskAgent: runtime.taskAgent,
@@ -216035,6 +216601,9 @@ async function startDaemon(options) {
   runner.start();
   runtime.xFollowService.onEnable(() => runner.kick("tweet-fetch"));
   await runtime.walletReady;
+  await tradingClient.ensureMeta().catch((err) => {
+    logger.warn({ err }, "ensureMeta on startup failed \u2014 will retry on first use");
+  });
   app.listen({ port: config3.gateway.port, hostname: config3.gateway.host });
   printDaemonStartupBanner({
     runtime,
@@ -216061,6 +216630,7 @@ var init_daemon = __esm(() => {
   init_plugin();
   init_types5();
   init_pairing_events();
+  init_defaults();
 });
 
 // node_modules/colorette/index.cjs
@@ -218686,7 +219256,7 @@ __export(exports_uninstall, {
   WIN_HANDLE_RELEASE_MS: () => WIN_HANDLE_RELEASE_MS,
   SIGKILL_DELAY_MS: () => SIGKILL_DELAY_MS
 });
-import { existsSync as fsExistsSync, readFileSync as readFileSync20, writeFileSync as writeFileSync15, unlinkSync as unlinkSync9, rmSync as fsRmSync } from "fs";
+import { existsSync as fsExistsSync, readFileSync as readFileSync19, writeFileSync as writeFileSync14, unlinkSync as unlinkSync9, rmSync as fsRmSync } from "fs";
 import { join as join22 } from "path";
 import { homedir as homedir7 } from "os";
 async function runUninstall(deps) {
@@ -219012,8 +219582,8 @@ async function runUninstallCli() {
       return !isCancel(r2) && r2 === true;
     },
     existsSync: fsExistsSync,
-    readFile: (p2) => readFileSync20(p2, "utf8"),
-    writeFile: (p2, content) => writeFileSync15(p2, content, "utf8"),
+    readFile: (p2) => readFileSync19(p2, "utf8"),
+    writeFile: (p2, content) => writeFileSync14(p2, content, "utf8"),
     unlink: (p2) => unlinkSync9(p2),
     rmSync: (p2) => fsRmSync(p2, { recursive: true, force: true, maxRetries: 10, retryDelay: 200 }),
     spawn: (cmd, args) => {
@@ -219469,7 +220039,7 @@ init_cli_providers();
 
 // src/onboard/wizard.ts
 init_dist8();
-import { existsSync as existsSync28 } from "fs";
+import { existsSync as existsSync27 } from "fs";
 init_providers();
 init_oauth3();
 init_secrets();
@@ -219483,7 +220053,7 @@ init_dist8();
 init_dist8();
 init_utils8();
 init_logs();
-import { existsSync as existsSync26 } from "fs";
+import { existsSync as existsSync25 } from "fs";
 
 // src/onboard/steps/service.ts
 async function runServiceStep(deps) {
@@ -219578,7 +220148,7 @@ async function finalizeOnboard(opts) {
   }
   const execPath = resolveGhostExecPath();
   const bunPath = resolveBunPath();
-  if (!existsSync26(execPath)) {
+  if (!existsSync25(execPath)) {
     O2.warn(`Ghost executable not found at ${execPath}. Service may fail to start.`);
   }
   const result = await runServiceStep({
@@ -219654,22 +220224,22 @@ async function startForegroundDaemon(logger) {
 init_models_config();
 import {
   chmodSync,
-  existsSync as existsSync27,
-  mkdirSync as mkdirSync18,
-  readFileSync as readFileSync19,
+  existsSync as existsSync26,
+  mkdirSync as mkdirSync17,
+  readFileSync as readFileSync18,
   renameSync as renameSync4,
   unlinkSync as unlinkSync8,
-  writeFileSync as writeFileSync14
+  writeFileSync as writeFileSync13
 } from "fs";
-import { dirname as dirname10 } from "path";
+import { dirname as dirname9 } from "path";
 var MODELS_FILE_MODE = 384;
 var MODELS_DIR_MODE = 448;
 function readModelsConfig(path4) {
-  if (!existsSync27(path4))
+  if (!existsSync26(path4))
     return { kind: "missing" };
   let raw;
   try {
-    raw = readFileSync19(path4, "utf-8");
+    raw = readFileSync18(path4, "utf-8");
   } catch (err) {
     return { kind: "malformed", reason: describeError2(err) };
   }
@@ -219730,15 +220300,15 @@ function upsertModel(current, incoming) {
   return next;
 }
 function writeAtomic(path4, contents) {
-  mkdirSync18(dirname10(path4), { recursive: true, mode: MODELS_DIR_MODE });
+  mkdirSync17(dirname9(path4), { recursive: true, mode: MODELS_DIR_MODE });
   const tmp = `${path4}.tmp-${process.pid}-${Date.now()}`;
   try {
-    writeFileSync14(tmp, contents, { mode: MODELS_FILE_MODE });
+    writeFileSync13(tmp, contents, { mode: MODELS_FILE_MODE });
     chmodSync(tmp, MODELS_FILE_MODE);
     renameSync4(tmp, path4);
   } catch (err) {
     try {
-      if (existsSync27(tmp))
+      if (existsSync26(tmp))
         unlinkSync8(tmp);
     } catch {}
     throw err;
@@ -219764,6 +220334,22 @@ function applyUpdateModeChanges(existing, overlay) {
 }
 
 // src/onboard/wizard.ts
+init_timezone();
+init_database();
+init_db();
+init_registry2();
+async function persistTimezone(tz, logger) {
+  try {
+    const db2 = initDatabase(getDbPath());
+    await runDbMigrations(db2, DB_MIGRATIONS);
+    const prefs = new PreferenceStore(db2, logger.child({ module: "prefs" }));
+    const tzService = createTimezoneService(prefs);
+    tzService.set(tz);
+    db2.close();
+  } catch (err) {
+    logger.warn({ err }, "onboard: failed to persist timezone");
+  }
+}
 function validateCustomProviderName(name) {
   if (!name)
     return "Provider name is required.";
@@ -219778,31 +220364,7 @@ function validateCustomProviderName(name) {
 function isLocalBaseUrl(url3) {
   return /^https?:\/\/(localhost|127\.0\.0\.1)(:\d+)?(\/|$)/u.test(url3);
 }
-async function validateClaudeCli(binaryPath) {
-  const which = Bun.spawnSync({ cmd: ["which", binaryPath] });
-  if (which.exitCode !== 0) {
-    return { ok: false, error: `Claude Code not found at "${binaryPath}". Install: curl -fsSL https://claude.ai/install.sh | bash` };
-  }
-  const versionProc = Bun.spawnSync({ cmd: [binaryPath, "--version"] });
-  const version3 = versionProc.stdout.toString().trim();
-  const authProc = Bun.spawnSync({ cmd: [binaryPath, "auth", "status", "--json"] });
-  if (authProc.exitCode !== 0) {
-    return { ok: false, version: version3, error: "Not authenticated. Run: claude login" };
-  }
-  try {
-    const auth = JSON.parse(authProc.stdout.toString());
-    const authenticated = auth.authenticated ?? auth.loggedIn ?? false;
-    if (!authenticated) {
-      return { ok: false, version: version3, error: "Not authenticated. Run: claude login" };
-    }
-    return { ok: true, version: version3, authStatus: auth.plan ?? auth.subscription ?? "authenticated" };
-  } catch {
-    return { ok: true, version: version3, authStatus: "authenticated" };
-  }
-}
-function providerRequiresApiKey(providerId, supportsOAuth) {
-  if (providerId === "claude-cli")
-    return false;
+function providerRequiresApiKey(_providerId, supportsOAuth) {
   if (supportsOAuth)
     return false;
   return true;
@@ -219830,6 +220392,8 @@ async function runHeadless(headless, daemonOptions) {
       if (daemonOptions.paper)
         customConfig.paper = daemonOptions.paper;
       saveConfig(customConfig, configPath);
+      const tzForCustom = resolveHeadlessTz(daemonOptions.logger);
+      await persistTimezone(tzForCustom, daemonOptions.logger);
       console.log(`[ghost] Custom provider: ${headless.provider} (from models.json)`);
       console.log(`[ghost] Model:    ${modelTrimmed}`);
       if (daemonOptions?.paper) {
@@ -219905,8 +220469,11 @@ async function runHeadless(headless, daemonOptions) {
     await credentials2.set("api_key", apiKey);
   }
   saveConfig(config3, configPath);
+  const tz = resolveHeadlessTz(daemonOptions.logger);
+  await persistTimezone(tz, daemonOptions.logger);
   console.log(`[ghost] Provider: ${providerInfo.label} (${headless.provider})`);
   console.log(`[ghost] Model:    ${model}`);
+  console.log(`[ghost] Timezone: ${tz}`);
   if (daemonOptions?.paper) {
     console.log(`[ghost] Mode:     Paper trading (${daemonOptions.paper.initialBalance ?? 1e4} USDC)`);
   }
@@ -219914,6 +220481,18 @@ async function runHeadless(headless, daemonOptions) {
   console.log("[ghost] Config saved. Run 'ghost onboard --service' to register the auto-start service, or 'ghost daemon' to start manually.");
   console.log("[ghost] Onboard complete!");
 }
+function resolveHeadlessTz(logger) {
+  const envTz = process.env["GHOST_TIMEZONE"];
+  if (envTz) {
+    const result = validateTimezone(envTz);
+    if (!result.ok) {
+      console.error(`[ghost] GHOST_TIMEZONE="${envTz}" is invalid: ${result.error}`);
+      process.exit(1);
+    }
+    return result.tz;
+  }
+  return detectHostTimezone();
+}
 async function runWizard(daemonOptions) {
   if (daemonOptions.headless) {
     const { headless, ...rest4 } = daemonOptions;
@@ -219926,7 +220505,7 @@ async function runWizard(daemonOptions) {
   const credentials2 = new CredentialStore(getCredentialsPath(), secretStore, daemonOptions.logger.child({ module: "credentials" }));
   let config3 = configSchema.parse({});
   let mode = "full";
-  if (existsSync28(configPath)) {
+  if (existsSync27(configPath)) {
     const modeAnswer = await _t({
       message: "Existing config found. What would you like to do?",
       options: [
@@ -219945,7 +220524,7 @@ async function runWizard(daemonOptions) {
 This wizard will configure your agent in under 60 seconds.`);
   if (mode === "full" && !daemonOptions.paper) {
     const tradingMode = await _t({
-      message: "Step 1/6 \u2014 Select trading mode",
+      message: "Step 1/5 \u2014 Select trading mode",
       options: [
         { value: "paper", label: "Paper trading (simulated, safe to explore)", hint: "10,000 USDC starting balance" },
         { value: "live", label: "Live trading (real funds on Hyperliquid)" }
@@ -219963,11 +220542,11 @@ This wizard will configure your agent in under 60 seconds.`);
   const providers = getProviderList();
   const providerOptions = providers.map((p2) => ({
     value: p2.id,
-    label: p2.label,
+    label: `${p2.label} \u2014 ${p2.tierLabel}`,
     hint: p2.description
   }));
   const providerId = await _t({
-    message: "Step 2/6 \u2014 Select your AI provider",
+    message: "Step 2/5 \u2014 Select your AI provider",
     options: providerOptions
   });
   if (q(providerId)) {
@@ -219978,18 +220557,6 @@ This wizard will configure your agent in under 60 seconds.`);
   let authMethod = "apikey";
   let customProviderName = "";
   let customApiKey = "";
-  if (providerId === "claude-cli") {
-    const s1 = fe2();
-    s1.start("Validating Claude Code...");
-    const validation2 = await validateClaudeCli("claude");
-    if (!validation2.ok) {
-      s1.stop(`\u2717 ${validation2.error}`);
-      pt("Fix the issue above and try again.");
-      process.exit(1);
-    }
-    s1.stop(`\u2713 Claude Code ${validation2.version ?? ""} (${validation2.authStatus})`);
-    authMethod = "skip";
-  }
   if (providerId === "custom") {
     const nameAnswer = await Ot({
       message: "Provider name (identifier for ~/.ghost/models.json)",
@@ -220036,7 +220603,7 @@ This wizard will configure your agent in under 60 seconds.`);
       { value: "__custom__", label: "Custom model ID (type manually)" }
     ];
     const selected = await _t({
-      message: "Step 3/6 \u2014 Select your default model",
+      message: "Step 3/5 \u2014 Select your default model",
       options: modelOptions
     });
     if (q(selected)) {
@@ -220055,7 +220622,7 @@ This wizard will configure your agent in under 60 seconds.`);
     }
   } else {
     const manual = await Ot({
-      message: "Step 3/6 \u2014 Enter model ID",
+      message: "Step 3/5 \u2014 Enter model ID",
       placeholder: "e.g. claude-sonnet-4-6"
     });
     if (q(manual)) {
@@ -220068,7 +220635,7 @@ This wizard will configure your agent in under 60 seconds.`);
   let apiKey = "";
   if (providerInfo?.supportsOAuth && authMethod !== "skip") {
     const auth = await _t({
-      message: "Step 4/6 \u2014 How do you want to authenticate?",
+      message: "Step 4/5 \u2014 How do you want to authenticate?",
       options: [
         { value: "oauth", label: "OAuth Login (authenticate in browser)", hint: "recommended" },
         { value: "apikey", label: "API Key (paste your key)" },
@@ -220104,7 +220671,7 @@ This wizard will configure your agent in under 60 seconds.`);
     const keyUrl = providerInfo?.apiKeyUrl ? `
   Get your key at: ${providerInfo.apiKeyUrl}` : "";
     const key = await Ot({
-      message: `Step 4/6 \u2014 Paste your ${providerInfo?.label ?? providerId} API key${keyUrl}`,
+      message: `Step 4/5 \u2014 Paste your ${providerInfo?.label ?? providerId} API key${keyUrl}`,
       placeholder: "sk-...",
       validate: (v4) => !v4 || v4.length >= 5 ? undefined : "API key seems too short"
     });
@@ -220114,7 +220681,7 @@ This wizard will configure your agent in under 60 seconds.`);
     }
     apiKey = key;
   }
-  if (authMethod === "skip" && providerId !== "claude-cli" && providerId !== "custom") {
+  if (authMethod === "skip" && providerId !== "custom") {
     O2.warn("No API key set. Export GHOST_API_KEY before running ghost daemon.");
   }
   if (mode === "update") {
@@ -220172,14 +220739,59 @@ This wizard will configure your agent in under 60 seconds.`);
     config3.paper = daemonOptions.paper;
   }
   saveConfig(config3, configPath);
+  const chosenTz = await promptTimezone();
+  await persistTimezone(chosenTz, daemonOptions.logger);
   O2.success("Configuration saved.");
   if (providerId === "custom") {
     O2.info(`Custom provider "${customProviderName}" written to ${getModelsConfigPath()}`);
   }
+  O2.info(`Timezone: ${chosenTz}`);
   O2.info("Tip: connect channels from the dashboard after starting the daemon.");
   console.log("");
   await finalizeOnboard({ interactive: true, logger: daemonOptions.logger });
 }
+function listSupportedTimezones() {
+  const fn = Intl.supportedValuesOf;
+  if (typeof fn !== "function")
+    return [];
+  return [...fn("timeZone")].sort();
+}
+async function promptTimezone() {
+  const detected = detectHostTimezone();
+  const allZones = listSupportedTimezones();
+  if (allZones.length === 0) {
+    const entered = await Ot({
+      message: "Step 5/5 \u2014 IANA timezone (e.g. America/New_York):",
+      initialValue: detected,
+      validate(value2) {
+        const v4 = validateTimezone(value2);
+        return v4.ok ? undefined : v4.error;
+      }
+    });
+    if (q(entered)) {
+      pt("Setup cancelled.");
+      process.exit(0);
+    }
+    const result = validateTimezone(entered);
+    return result.ok ? result.tz : detected;
+  }
+  const initialValue = allZones.includes(detected) ? detected : allZones[0];
+  const choice = await Ae2({
+    message: "Step 5/5 \u2014 Select your timezone (type to filter)",
+    placeholder: "e.g. berlin, new_york, utc",
+    options: allZones.map((tz) => ({
+      value: tz,
+      label: tz === detected ? `${tz} (detected)` : tz
+    })),
+    initialValue,
+    maxItems: 10
+  });
+  if (q(choice)) {
+    pt("Setup cancelled.");
+    process.exit(0);
+  }
+  return choice;
+}
 // src/index.ts
 init_errors2();
 init_logger();
@@ -220410,14 +221022,14 @@ async function runSkills(subArgs, opts) {
       const configPath = opts.config ?? getPath();
       const config3 = loadConfig2(configPath);
       const workspaceDir = getWorkspaceDir2();
-      const { existsSync: existsSync29 } = await import("fs");
+      const { existsSync: existsSync28 } = await import("fs");
       const { join: join23 } = await import("path");
       let builtinDir;
       if (config3.skills.builtinSkillsDir) {
         builtinDir = expandHome2(config3.skills.builtinSkillsDir);
       } else {
         const candidate = join23(import.meta.dir, "skills", "builtin");
-        if (existsSync29(candidate))
+        if (existsSync28(candidate))
           builtinDir = candidate;
       }
       const loader2 = new SkillsLoader2(workspaceDir, builtinDir);