opencandle 0.11.0 → 0.12.0

package/dist/infra/cache.js

@@ -1,11 +1,14 @@
 import { AsyncLocalStorage } from "node:async_hooks";
-const staleMetadataStorage = new AsyncLocalStorage();
+const cacheMetadataStorage = new AsyncLocalStorage();
 export async function runWithStaleMetadata(fn) {
-    const metadata = { stale: false, cachedAt: 0 };
-    const value = await staleMetadataStorage.run(metadata, fn);
+    const metadata = { status: "none", cachedAt: 0 };
+    const value = await cacheMetadataStorage.run(metadata, fn);
     return {
         value,
-        stale: metadata.stale ? { cachedAt: metadata.cachedAt } : undefined,
+        cache: metadata.status === "cached" || metadata.status === "stale"
+            ? { status: metadata.status, cachedAt: metadata.cachedAt }
+            : undefined,
+        stale: metadata.status === "stale" ? { cachedAt: metadata.cachedAt } : undefined,
     };
 }
 export class Cache {
@@ -16,6 +19,11 @@ export class Cache {
             return undefined;
         if (Date.now() > entry.expiresAt)
             return undefined;
+        const metadata = cacheMetadataStorage.getStore();
+        if (metadata && metadata.status === "none") {
+            metadata.status = "cached";
+            metadata.cachedAt = entry.cachedAt;
+        }
         return entry.value;
     }
     /**
@@ -31,9 +39,9 @@ export class Cache {
             this.store.delete(key);
             return undefined;
         }
-        const metadata = staleMetadataStorage.getStore();
+        const metadata = cacheMetadataStorage.getStore();
         if (metadata) {
-            metadata.stale = true;
+            metadata.status = "stale";
             metadata.cachedAt = entry.cachedAt;
         }
         return { value: entry.value, stale: true, cachedAt: entry.cachedAt };
@@ -69,6 +77,7 @@ export const TTL = {
     CRUMB: 900_000, // 15 minutes
     WEB_SEARCH: 300_000, // 5 minutes
     FINNHUB_NEWS: 300_000, // 5 minutes
+    PREDICTION_MARKETS: 300_000, // 5 minutes
 };
 // Stale limits — how long past TTL expiry a cached value is still useful as fallback
 export const STALE_LIMIT = {
@@ -81,5 +90,5 @@ export const STALE_LIMIT = {
     SCREENER: 15 * 60_000, // 15 minutes
     WEB_SEARCH: 3_600_000, // 1 hour
     FINNHUB_NEWS: 3_600_000, // 1 hour
+    PREDICTION_MARKETS: 3_600_000, // 1 hour
 };
-//# sourceMappingURL=cache.js.map

package/dist/infra/freshness.d.ts

@@ -0,0 +1,21 @@
+import { type MarketSession } from "./market-calendar.js";
+export interface FreshnessStamp {
+    fetchedAt: string;
+    providerDataAt?: string;
+    providerDataDate?: string;
+    cacheStatus: "live" | "cached" | "stale";
+    cachedAt?: string;
+    marketSession: MarketSession;
+    dataDelayMs?: number;
+    isStaleForSession: boolean;
+}
+export declare function buildFreshnessStamp(input: {
+    asOf?: string | number | Date;
+    cached?: boolean;
+    stale?: boolean;
+    cachedAt?: string;
+    dataDelayMs?: number;
+    now?: Date;
+    assetClass?: "equity" | "crypto";
+}): FreshnessStamp;
+export declare function formatAsOfLine(stamp: FreshnessStamp): string;

package/dist/infra/freshness.js

@@ -0,0 +1,118 @@
+import { classifyMarketStatusAt, lastTradingDay, localDateTimeParts, } from "./market-calendar.js";
+export function buildFreshnessStamp(input) {
+    const now = input.now ?? new Date();
+    const parsedAsOf = normalizeAsOf(input.asOf);
+    const fetchedAt = now.toISOString();
+    const cacheStatus = input.stale ? "stale" : input.cached ? "cached" : "live";
+    const marketSession = input.assetClass === "crypto" ? "unknown" : classifyMarketStatusAt(now);
+    const cachedAt = input.cachedAt ? normalizeDate(input.cachedAt)?.toISOString() : undefined;
+    const providerDataAt = parsedAsOf?.date.toISOString();
+    const providerDataDate = parsedAsOf?.dateOnly;
+    const isStaleForSession = input.assetClass === "crypto"
+        ? isCryptoStale(parsedAsOf?.date, cachedAt, now, cacheStatus)
+        : isEquityStale(parsedAsOf, cacheStatus, now);
+    return {
+        fetchedAt,
+        providerDataAt,
+        providerDataDate,
+        cacheStatus,
+        cachedAt,
+        marketSession,
+        dataDelayMs: input.dataDelayMs,
+        isStaleForSession,
+    };
+}
+export function formatAsOfLine(stamp) {
+    if (stamp.isStaleForSession && stamp.providerDataAt) {
+        const date = stamp.providerDataDate ?? formatEtDate(new Date(stamp.providerDataAt));
+        const parenthetical = staleSessionParenthetical(stamp.marketSession);
+        const cached = stamp.cachedAt
+            ? ` Cached from ${formatEtDateTime(new Date(stamp.cachedAt))} ET.`
+            : "";
+        return `Last available price as of ${date}${parenthetical}. This is not a live quote.${cached}`;
+    }
+    if (stamp.cacheStatus === "stale" && stamp.cachedAt) {
+        const notLive = stamp.isStaleForSession ? " This is not a live quote." : "";
+        return `Using cached data from ${formatEtDateTime(new Date(stamp.cachedAt))} ET (provider unavailable).${notLive}`;
+    }
+    if (stamp.providerDataAt || stamp.dataDelayMs !== undefined) {
+        const reference = stamp.providerDataAt ?? stamp.cachedAt ?? stamp.fetchedAt;
+        const asOf = stamp.providerDataDate ?? formatEtDateTime(new Date(reference));
+        if (stamp.dataDelayMs !== undefined)
+            return `As of ${asOf} ET (~${Math.round(stamp.dataDelayMs / 60_000)}m delayed).`;
+        return `As of ${asOf} ET (${marketSessionLabel(stamp.marketSession)}).`;
+    }
+    return `As of ${formatEtDateTime(new Date(stamp.fetchedAt))} ET (${marketSessionLabel(stamp.marketSession)}).`;
+}
+function normalizeAsOf(asOf) {
+    if (asOf === undefined)
+        return undefined;
+    if (asOf instanceof Date)
+        return Number.isNaN(asOf.getTime()) ? undefined : { date: asOf };
+    if (typeof asOf === "number") {
+        const milliseconds = asOf < 10_000_000_000 ? asOf * 1000 : asOf;
+        const date = new Date(milliseconds);
+        return Number.isNaN(date.getTime()) ? undefined : { date };
+    }
+    if (/^\d{4}-\d{2}-\d{2}$/.test(asOf)) {
+        const date = new Date(`${asOf}T00:00:00.000Z`);
+        return Number.isNaN(date.getTime()) ? undefined : { date, dateOnly: asOf };
+    }
+    const date = new Date(asOf);
+    return Number.isNaN(date.getTime()) ? undefined : { date };
+}
+function normalizeDate(value) {
+    const date = new Date(value);
+    return Number.isNaN(date.getTime()) ? undefined : date;
+}
+function isEquityStale(parsedAsOf, cacheStatus, now) {
+    if (!parsedAsOf)
+        return cacheStatus === "stale";
+    const localNow = localDateTimeParts(now, "America/New_York");
+    const providerTradingDate = parsedAsOf.dateOnly ?? localDateTimeParts(parsedAsOf.date, "America/New_York").date;
+    const marketSession = classifyMarketStatusAt(now);
+    const requiredTradingDate = marketSession === "open" ||
+        marketSession === "after_close" ||
+        marketSession === "closed_after_hours"
+        ? localNow.date
+        : lastTradingDay(localNow.date);
+    return providerTradingDate < requiredTradingDate;
+}
+function isCryptoStale(providerDate, cachedAt, now, cacheStatus) {
+    const reference = providerDate ?? (cacheStatus === "stale" && cachedAt ? new Date(cachedAt) : undefined);
+    if (!reference)
+        return cacheStatus === "stale";
+    return now.getTime() - reference.getTime() > 15 * 60_000;
+}
+function formatEtDate(date) {
+    return localDateTimeParts(date, "America/New_York").date;
+}
+function formatEtDateTime(date) {
+    const parts = localDateTimeParts(date, "America/New_York");
+    return `${parts.date} ${parts.time}`;
+}
+function staleSessionParenthetical(marketSession) {
+    if (marketSession === "closed_weekend")
+        return " (market closed — weekend)";
+    if (marketSession === "closed_holiday")
+        return " (market closed — holiday)";
+    return "";
+}
+function marketSessionLabel(marketSession) {
+    switch (marketSession) {
+        case "open":
+            return "market open";
+        case "pre_market":
+            return "pre-market";
+        case "closed_weekend":
+            return "market closed — weekend";
+        case "closed_holiday":
+            return "market closed — holiday";
+        case "after_close":
+            return "after close";
+        case "closed_after_hours":
+            return "market closed";
+        case "unknown":
+            return "market session unknown";
+    }
+}

package/dist/infra/http-client.js

@@ -72,7 +72,7 @@ async function httpRequest(url, options) {
             await sleep(retryDelayMs);
         }
     }
-    throw lastError;
+    throw lastError ?? new Error("HTTP request failed without an error");
 }
 function isRetryableError(error) {
     if (!(error instanceof HttpError))
@@ -104,4 +104,3 @@ function capRetryAfterMs(retryAfterMs, maxRetryAfterMs) {
 function sleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
-//# sourceMappingURL=http-client.js.map

package/dist/infra/index.js

@@ -2,4 +2,3 @@ export { Cache, cache, TTL } from "./cache.js";
 export { HttpError, httpGet } from "./http-client.js";
 export { ensureOpenCandleHomeDir, ensureParentDir, getBrowserProfileDir, getConfigPath, getLogsDir, getOnboardingPath, getOpenCandleHomeDir, getStateDbPath, resolveOpenCandlePath, } from "./opencandle-paths.js";
 export { RateLimiter, rateLimiter } from "./rate-limiter.js";
-//# sourceMappingURL=index.js.map

package/dist/infra/market-calendar.d.ts

@@ -0,0 +1,14 @@
+export type MarketSession = "closed_weekend" | "closed_holiday" | "pre_market" | "open" | "after_close" | "closed_after_hours" | "unknown";
+export interface LocalDateTimeParts {
+    date: string;
+    time: string;
+    weekday: string;
+    minutesSinceMidnight: number;
+}
+export declare const KNOWN_US_MARKET_HOLIDAYS: Record<string, string>;
+export declare function marketHolidayName(key: string): string | undefined;
+export declare function classifyMarketStatus(local: LocalDateTimeParts, isWeekend: boolean, isMarketHoliday: boolean, temporalReferences: string[]): Exclude<MarketSession, "unknown">;
+export declare function classifyMarketStatusAt(now: Date): MarketSession;
+export declare function localDateTimeParts(date: Date, timezone: string): LocalDateTimeParts;
+export declare function lastTradingDay(localDate: string): string;
+export declare function isWeekendOrKnownHoliday(key: string): boolean;

package/dist/infra/market-calendar.js

@@ -0,0 +1,136 @@
+export const KNOWN_US_MARKET_HOLIDAYS = new Proxy({}, {
+    get(_target, property) {
+        return typeof property === "string" ? marketHolidayName(property) : undefined;
+    },
+    has(_target, property) {
+        return typeof property === "string" && marketHolidayName(property) !== undefined;
+    },
+});
+export function marketHolidayName(key) {
+    const date = dateFromKey(key);
+    const year = date.getUTCFullYear();
+    for (const candidateYear of [year - 1, year, year + 1]) {
+        const holiday = marketHolidaysForYear(candidateYear).find((entry) => entry.date === key);
+        if (holiday)
+            return holiday.name;
+    }
+    return undefined;
+}
+export function classifyMarketStatus(local, isWeekend, isMarketHoliday, temporalReferences) {
+    if (isWeekend)
+        return "closed_weekend";
+    if (isMarketHoliday)
+        return "closed_holiday";
+    if (local.minutesSinceMidnight < 9 * 60 + 30)
+        return "pre_market";
+    if (local.minutesSinceMidnight < 16 * 60)
+        return "open";
+    if (temporalReferences.includes("after_close"))
+        return "after_close";
+    return "closed_after_hours";
+}
+export function classifyMarketStatusAt(now) {
+    const local = localDateTimeParts(now, "America/New_York");
+    return classifyMarketStatus(local, local.weekday === "Sat" || local.weekday === "Sun", marketHolidayName(local.date) !== undefined, []);
+}
+export function localDateTimeParts(date, timezone) {
+    const formatter = new Intl.DateTimeFormat("en-US", {
+        timeZone: timezone,
+        year: "numeric",
+        month: "2-digit",
+        day: "2-digit",
+        hour: "2-digit",
+        minute: "2-digit",
+        hour12: false,
+        weekday: "short",
+    });
+    const parts = formatter.formatToParts(date).reduce((acc, part) => {
+        acc[part.type] = part.value;
+        return acc;
+    }, {});
+    const hour = Number(parts.hour);
+    const minute = Number(parts.minute);
+    return {
+        date: `${parts.year}-${parts.month}-${parts.day}`,
+        time: `${parts.hour}:${parts.minute}`,
+        weekday: parts.weekday ?? "",
+        minutesSinceMidnight: hour * 60 + minute,
+    };
+}
+export function lastTradingDay(localDate) {
+    let cursor = dateFromKey(localDate);
+    do {
+        cursor = addDays(cursor, -1);
+    } while (isWeekendOrKnownHoliday(dateKey(cursor)));
+    return dateKey(cursor);
+}
+export function isWeekendOrKnownHoliday(key) {
+    const date = dateFromKey(key);
+    const day = date.getUTCDay();
+    return day === 0 || day === 6 || marketHolidayName(key) !== undefined;
+}
+function marketHolidaysForYear(year) {
+    return [
+        observedFixedHoliday(year, 1, 1, "New Year's Day"),
+        nthWeekdayHoliday(year, 1, 1, 3, "Martin Luther King Jr. Day"),
+        nthWeekdayHoliday(year, 2, 1, 3, "Washington's Birthday"),
+        { date: dateKey(addDays(easterDate(year), -2)), name: "Good Friday" },
+        lastWeekdayHoliday(year, 5, 1, "Memorial Day"),
+        observedFixedHoliday(year, 6, 19, "Juneteenth"),
+        observedFixedHoliday(year, 7, 4, "Independence Day"),
+        nthWeekdayHoliday(year, 9, 1, 1, "Labor Day"),
+        nthWeekdayHoliday(year, 11, 4, 4, "Thanksgiving Day"),
+        observedFixedHoliday(year, 12, 25, "Christmas Day"),
+    ];
+}
+function observedFixedHoliday(year, month, day, name) {
+    const actual = new Date(Date.UTC(year, month - 1, day));
+    const weekday = actual.getUTCDay();
+    const observed = weekday === 0 ? addDays(actual, 1) : weekday === 6 ? addDays(actual, -1) : actual;
+    return {
+        date: dateKey(observed),
+        name: observed.getTime() === actual.getTime() ? name : `${name} observed`,
+    };
+}
+function nthWeekdayHoliday(year, month, weekday, occurrence, name) {
+    const first = new Date(Date.UTC(year, month - 1, 1));
+    const offset = (weekday - first.getUTCDay() + 7) % 7;
+    return { date: dateKey(addDays(first, offset + (occurrence - 1) * 7)), name };
+}
+function lastWeekdayHoliday(year, month, weekday, name) {
+    const last = new Date(Date.UTC(year, month, 0));
+    const offset = (last.getUTCDay() - weekday + 7) % 7;
+    return { date: dateKey(addDays(last, -offset)), name };
+}
+function easterDate(year) {
+    const a = year % 19;
+    const b = Math.floor(year / 100);
+    const c = year % 100;
+    const d = Math.floor(b / 4);
+    const e = b % 4;
+    const f = Math.floor((b + 8) / 25);
+    const g = Math.floor((b - f + 1) / 3);
+    const h = (19 * a + b - d - g + 15) % 30;
+    const i = Math.floor(c / 4);
+    const k = c % 4;
+    const l = (32 + 2 * e + 2 * i - h - k) % 7;
+    const m = Math.floor((a + 11 * h + 22 * l) / 451);
+    const easterMonth = Math.floor((h + l - 7 * m + 114) / 31);
+    const easterDay = ((h + l - 7 * m + 114) % 31) + 1;
+    return new Date(Date.UTC(year, easterMonth - 1, easterDay));
+}
+function dateFromKey(key) {
+    const [year, month, day] = key.split("-").map(Number);
+    return new Date(Date.UTC(year, month - 1, day));
+}
+function addDays(date, days) {
+    const next = new Date(date);
+    next.setUTCDate(next.getUTCDate() + days);
+    return next;
+}
+function dateKey(date) {
+    const year = date.getUTCFullYear();
+    const month = String(date.getUTCMonth() + 1).padStart(2, "0");
+    const day = String(date.getUTCDate()).padStart(2, "0");
+    return `${year}-${month}-${day}`;
+}

package/dist/infra/native-dependencies.js

@@ -56,4 +56,3 @@ export async function ensureOpenCandleNativeDependencies() {
         },
     });
 }
-//# sourceMappingURL=native-dependencies.js.map

package/dist/infra/node-version.js

@@ -17,4 +17,3 @@ export function assertSupportedNodeVersion(version) {
     if (message)
         throw new Error(message);
 }
-//# sourceMappingURL=node-version.js.map

package/dist/infra/open-url.js

@@ -26,4 +26,3 @@ export function openInBrowser(url) {
         child.unref();
     });
 }
-//# sourceMappingURL=open-url.js.map

package/dist/infra/opencandle-paths.js

@@ -41,4 +41,3 @@ export function getLogsDir() {
 export function getBrowserProfileDir() {
     return resolveOpenCandlePath("browser-profile");
 }
-//# sourceMappingURL=opencandle-paths.js.map

package/dist/infra/rate-limiter.js

@@ -47,6 +47,6 @@ rateLimiter.configure("exa", 5, 0.1); // 5 req, ~6 req/min
 rateLimiter.configure("finnhub", 60, 1); // 60 req/min (free tier)
 // TradingView scanner is undocumented; keep usage batch-first and paced.
 rateLimiter.configure("tradingview", 5, 1); // 5 burst, 1 req/s sustained
+rateLimiter.configure("polymarket", 10, 5); // 10 burst, 5 req/s sustained
 // SEC EDGAR fair-access guideline is 10 req/s; stay below it.
 rateLimiter.configure("sec_edgar", 5, 5); // 5 burst, 5 req/s sustained
-//# sourceMappingURL=rate-limiter.js.map

package/dist/market-state/alert-conditions.js

@@ -20,4 +20,3 @@ export function rsiThreshold(period, threshold, direction) {
 export function volumeSpike(lookbackPeriod, multiplier) {
     return { lookback_period: lookbackPeriod, multiplier };
 }
-//# sourceMappingURL=alert-conditions.js.map

package/dist/market-state/alert-runner.d.ts

@@ -3,6 +3,7 @@ import type { MarketStateService } from "./service.js";
 export interface AlertQuoteObservation {
     symbol: string;
     value: number;
+    observationDetails?: Record<string, number>;
     sourceProvider: string;
     observedAt: string;
     providerDataAt?: string | null;

package/dist/market-state/alert-runner.js

@@ -161,6 +161,7 @@ export async function runAlertChecks(service, options) {
             const observed = {
                 value: observation.value,
                 field: observationField(item.rule),
+                ...observation.observationDetails,
                 at: now,
                 observedAt: now,
                 providerDataAt: observation.providerDataAt ?? null,
@@ -324,7 +325,7 @@ async function loadHistoricalObservation(item, providers, providerBudget, histor
             const latestSma = sma.at(-1);
             if (latestClose == null || latestSma == null)
                 return null;
-            return historicalObservation(item.instrument.symbol, latestClose - latestSma, bars.at(-1)?.date ?? null, now);
+            return historicalObservation(item.instrument.symbol, latestClose - latestSma, bars.at(-1)?.date ?? null, now, { price: latestClose, sma: latestSma });
         }
         if (item.rule.conditionType === "percent_move") {
             const bars = await loadHistory(item.instrument.symbol, "5d", "1d", providers, providerBudget, historyCache, now);
@@ -345,7 +346,7 @@ async function loadHistoricalObservation(item, providers, providerBudget, histor
             const slow = computeSMA(closes, slowPeriod).at(-1);
             if (fast == null || slow == null)
                 return null;
-            return historicalObservation(item.instrument.symbol, roundObservation(fast - slow), bars.at(-1)?.date ?? null, now);
+            return historicalObservation(item.instrument.symbol, roundObservation(fast - slow), bars.at(-1)?.date ?? null, now, { fast_sma: fast, slow_sma: slow });
         }
         if (item.rule.conditionType === "rsi_threshold") {
             const condition = item.rule.conditionJson;
@@ -412,10 +413,11 @@ function isProviderWideFailure(reason) {
         normalized.includes("econn") ||
         normalized.includes("enotfound"));
 }
-function historicalObservation(symbol, value, providerDataAt, now) {
+function historicalObservation(symbol, value, providerDataAt, now, observationDetails) {
     return {
         symbol,
         value,
+        observationDetails,
         sourceProvider: "yahoo",
         observedAt: now,
         providerDataAt,
@@ -631,4 +633,3 @@ function alertDedupeKey(rule, observation, triggerType) {
         observation.value,
     ].join(":");
 }
-//# sourceMappingURL=alert-runner.js.map

package/dist/market-state/daily-report.js

@@ -165,4 +165,3 @@ function numberPart(parts, type) {
         throw new Error(`Missing ${type} in formatted date`);
     return Number(value);
 }
-//# sourceMappingURL=daily-report.js.map

package/dist/market-state/local-automation-service.js

@@ -116,4 +116,3 @@ async function runDueReports(service, params) {
     }
     return runs;
 }
-//# sourceMappingURL=local-automation-service.js.map

package/dist/market-state/notification-delivery.js

@@ -136,4 +136,3 @@ function webhookUrlHost(raw) {
         return "(invalid URL)";
     }
 }
-//# sourceMappingURL=notification-delivery.js.map

package/dist/market-state/resolve-for-mutation.js

@@ -12,4 +12,3 @@ export async function resolveInstrumentForMutation(symbol) {
         throw error;
     }
 }
-//# sourceMappingURL=resolve-for-mutation.js.map

package/dist/market-state/resolve.js

@@ -86,4 +86,3 @@ function assetTypeFromQuoteType(quoteType, symbol) {
         return "equity";
     return inferAssetType(symbol.toUpperCase());
 }
-//# sourceMappingURL=resolve.js.map

package/dist/market-state/service.d.ts

@@ -55,12 +55,6 @@ export interface WatchlistItemRecord {
     assetType: string;
     exchange: string | null;
     currency: string | null;
-    targetPrice: number | null;
-    stopPrice: number | null;
-    priceCurrency: string | null;
-    thesis: string | null;
-    notes: string | null;
-    tags: string[] | null;
     source: string | null;
     sourceRowId: string | null;
     sourceMetadata: unknown;
@@ -226,32 +220,28 @@ export declare class MarketStateService {
     private readonly db;
     constructor(db: Database.Database);
     getDefaultWatchlist(): CollectionRecord;
+    listWatchlists(): CollectionRecord[];
+    createWatchlist(name: string): CollectionRecord;
+    getWatchlistByName(name: string): CollectionRecord | null;
+    renameWatchlist(currentName: string, nextName: string): CollectionRecord;
+    deleteWatchlist(name: string): CollectionRecord;
+    getOrCreateWatchlist(name?: string | null): CollectionRecord;
     getDefaultPortfolio(): CollectionRecord;
+    listPortfolios(): CollectionRecord[];
+    createPortfolio(name: string, baseCurrency?: string): CollectionRecord;
+    getPortfolioByName(name: string): CollectionRecord | null;
+    renamePortfolio(currentName: string, nextName: string): CollectionRecord;
+    getOrCreatePortfolio(name?: string | null): CollectionRecord;
     findInstrumentByAlias(lookup: InstrumentAliasLookup): InstrumentRecord | null;
     addWatchlistItem(params: {
         instrument: InstrumentInput;
         watchlistId?: number;
-        targetPrice?: number | null;
-        stopPrice?: number | null;
-        priceCurrency?: string | null;
-        thesis?: string | null;
-        notes?: string | null;
-        tags?: string[];
         source?: string;
         sourceRowId?: string;
         sourceMetadata?: unknown;
     }): WatchlistItemRecord;
     listWatchlistItems(watchlistId?: number): WatchlistItemRecord[];
     removeWatchlistItemBySymbol(symbol: string, watchlistId?: number): boolean;
-    updateWatchlistItemBySymbol(symbol: string, params: {
-        watchlistId?: number;
-        targetPrice?: number | null;
-        stopPrice?: number | null;
-        priceCurrency?: string | null;
-        thesis?: string | null;
-        notes?: string | null;
-        tags?: string[];
-    }): WatchlistItemRecord | null;
     addPortfolioLot(params: {
         instrument: InstrumentInput;
         portfolioId?: number;
@@ -300,6 +290,21 @@ export declare class MarketStateService {
     }): AlertRuleRecord;
     listAlertRules(): AlertRuleRecord[];
     setAlertRuleEnabled(id: number, enabled: boolean): AlertRuleRecord | null;
+    updateAlertRule(id: number, params: {
+        scopeType?: AlertScopeType;
+        scopeId?: number | null;
+        instrumentId?: number | null;
+        conditionType?: string;
+        conditionVersion?: number;
+        condition?: unknown;
+        timeframe?: string;
+        enabled?: boolean;
+        checkIntervalSeconds?: number | null;
+        nextCheckAt?: string | null;
+        cooldownSeconds?: number | null;
+        retriggerMode?: string;
+    }): AlertRuleRecord | null;
+    deleteAlertRule(id: number): AlertRuleRecord | null;
     getInstrument(id: number): InstrumentRecord | null;
     upsertInstrumentRecord(input: InstrumentInput): InstrumentRecord;
     acquireAutomationRunnerLease(params: {