opencandle 0.5.0 → 0.7.0

package/src/pi/session.ts

@@ -1,17 +1,17 @@
 import "../infra/node-version.js";
 import {
   type AuthStorage,
+  type CreateAgentSessionResult,
   createAgentSession,
   DefaultResourceLoader,
+  getAgentDir,
   type ModelRegistry,
-  type CreateAgentSessionResult,
-  type SettingsManager,
   type SessionManager,
-  getAgentDir,
+  type SettingsManager,
 } from "@earendil-works/pi-coding-agent";
 import { loadEnv } from "../config.js";
-import openCandleExtension from "./opencandle-extension.js";
 import type { AskUserHandler } from "../types/index.js";
+import openCandleExtension from "./opencandle-extension.js";
 
 export interface CreateOpenCandleSessionOptions {
   cwd?: string;
@@ -38,7 +38,9 @@ export async function createOpenCandleSession(
         cwd,
         agentDir,
         settingsManager: options.settingsManager,
-        extensionFactories: [(pi) => openCandleExtension(pi, { askUserHandler: options.askUserHandler })],
+        extensionFactories: [
+          (pi) => openCandleExtension(pi, { askUserHandler: options.askUserHandler }),
+        ],
       })
     : undefined;
 

package/src/pi/setup.ts

@@ -1,8 +1,8 @@
 import type { Model } from "@earendil-works/pi-ai";
 import {
-  LoginDialogComponent,
   type ExtensionAPI,
   type ExtensionContext,
+  LoginDialogComponent,
 } from "@earendil-works/pi-coding-agent";
 
 type SetupMode = "startup" | "manual";
@@ -54,14 +54,18 @@ function getAvailableModels(ctx: ExtensionContext, preferredProvider?: string):
   return sortModels(ctx.modelRegistry.getAvailable(), preferredProvider);
 }
 
-export function getLlmSetupRequirement(ctx: Pick<ExtensionContext, "model" | "modelRegistry">): SetupRequirement {
+export function getLlmSetupRequirement(
+  ctx: Pick<ExtensionContext, "model" | "modelRegistry">,
+): SetupRequirement {
   if (ctx.model && ctx.modelRegistry.hasConfiguredAuth(ctx.model)) {
     return "ready";
   }
   return ctx.modelRegistry.getAvailable().length > 0 ? "select_model" : "connect_auth";
 }
 
-async function selectProviderForApiKey(ctx: ExtensionContext): Promise<ApiKeyProviderId | undefined> {
+async function selectProviderForApiKey(
+  ctx: ExtensionContext,
+): Promise<ApiKeyProviderId | undefined> {
   const choice = await ctx.ui.select("Connect an AI model", [
     "Google Gemini API",
     "OpenAI API",
@@ -79,7 +83,9 @@ async function selectProviderForApiKey(ctx: ExtensionContext): Promise<ApiKeyPro
   }
 }
 
-async function selectProviderForLogin(ctx: ExtensionContext): Promise<OAuthProviderChoice | undefined> {
+async function selectProviderForLogin(
+  ctx: ExtensionContext,
+): Promise<OAuthProviderChoice | undefined> {
   const choice = await ctx.ui.select("Connect an AI model", [
     "Google",
     "OpenAI",
@@ -112,7 +118,9 @@ async function selectAdvancedOAuthProvider(ctx: ExtensionContext): Promise<strin
 }
 
 async function runLoginDialog(ctx: ExtensionContext, providerId: string): Promise<boolean> {
-  const provider = ctx.modelRegistry.authStorage.getOAuthProviders().find((item) => item.id === providerId);
+  const provider = ctx.modelRegistry.authStorage
+    .getOAuthProviders()
+    .find((item) => item.id === providerId);
   const providerName = provider?.name ?? providerId;
   const usesCallbackServer = provider?.usesCallbackServer ?? false;
 
@@ -136,43 +144,49 @@ async function runLoginDialog(ctx: ExtensionContext, providerId: string): Promis
     });
 
     // Cast required: advanced providers return dynamic IDs outside the SDK's static union type
-    void ctx.modelRegistry.authStorage.login(providerId as any, {
-      onAuth: (info) => {
-        dialog.showAuth(info.url, info.instructions);
-        if (usesCallbackServer) {
-          void dialog
-            .showManualInput("Paste redirect URL below, or complete login in your browser:")
-            .then((value) => {
-              if (value && manualCodeResolve) {
-                manualCodeResolve(value);
-                manualCodeResolve = undefined;
-              }
-            })
-            .catch(() => {
-              if (manualCodeReject) {
-                manualCodeReject(new Error("Login cancelled"));
-                manualCodeReject = undefined;
-              }
-            });
-        } else if (providerId === "github-copilot") {
-          dialog.showWaiting("Waiting for browser authentication...");
-        }
-      },
-      onDeviceCode: (info) => {
-        dialog.showDeviceCode(info);
-        dialog.showWaiting("Waiting for authentication...");
-      },
-      onPrompt: async (prompt) => dialog.showPrompt(prompt.message, prompt.placeholder),
-      onProgress: (message) => dialog.showProgress(message),
-      onSelect: async (prompt) => {
-        const options = prompt.options.map((option, index) => `${index + 1}. ${option.label}`).join("\n");
-        const answer = await dialog.showPrompt(`${prompt.message}\n\n${options}`, "Enter a number");
-        const selectedIndex = Number.parseInt(answer.trim(), 10) - 1;
-        return prompt.options[selectedIndex]?.id;
-      },
-      onManualCodeInput: () => manualCodePromise,
-      signal: dialog.signal,
-    })
+    void ctx.modelRegistry.authStorage
+      .login(providerId as any, {
+        onAuth: (info) => {
+          dialog.showAuth(info.url, info.instructions);
+          if (usesCallbackServer) {
+            void dialog
+              .showManualInput("Paste redirect URL below, or complete login in your browser:")
+              .then((value) => {
+                if (value && manualCodeResolve) {
+                  manualCodeResolve(value);
+                  manualCodeResolve = undefined;
+                }
+              })
+              .catch(() => {
+                if (manualCodeReject) {
+                  manualCodeReject(new Error("Login cancelled"));
+                  manualCodeReject = undefined;
+                }
+              });
+          } else if (providerId === "github-copilot") {
+            dialog.showWaiting("Waiting for browser authentication...");
+          }
+        },
+        onDeviceCode: (info) => {
+          dialog.showDeviceCode(info);
+          dialog.showWaiting("Waiting for authentication...");
+        },
+        onPrompt: async (prompt) => dialog.showPrompt(prompt.message, prompt.placeholder),
+        onProgress: (message) => dialog.showProgress(message),
+        onSelect: async (prompt) => {
+          const options = prompt.options
+            .map((option, index) => `${index + 1}. ${option.label}`)
+            .join("\n");
+          const answer = await dialog.showPrompt(
+            `${prompt.message}\n\n${options}`,
+            "Enter a number",
+          );
+          const selectedIndex = Number.parseInt(answer.trim(), 10) - 1;
+          return prompt.options[selectedIndex]?.id;
+        },
+        onManualCodeInput: () => manualCodePromise,
+        signal: dialog.signal,
+      })
       .then(() => finish(true))
       .catch((error) => {
         const message = error instanceof Error ? error.message : String(error);
@@ -248,7 +262,11 @@ async function activateDefaultModel(
   return true;
 }
 
-async function selectModel(api: ExtensionAPI, ctx: ExtensionContext, preferredProvider?: string): Promise<boolean> {
+async function selectModel(
+  api: ExtensionAPI,
+  ctx: ExtensionContext,
+  preferredProvider?: string,
+): Promise<boolean> {
   const models = getAvailableModels(ctx, preferredProvider);
   if (models.length === 0) {
     ctx.ui.notify("No available models found yet. Connect a provider first.", "warning");

package/src/pi/tool-adapter.ts

@@ -1,9 +1,10 @@
 import type { AgentTool } from "@earendil-works/pi-agent-core";
 import type { ToolDefinition } from "@earendil-works/pi-coding-agent";
 import type { TSchema } from "@sinclair/typebox";
-import { getAllTools } from "../tools/index.js";
 import { getDefaults } from "../memory/tool-defaults.js";
 import { wrapWithDefaults } from "../runtime/tool-defaults-wrapper.js";
+import { getAllTools } from "../tools/index.js";
+import type { AskUserHandler } from "../types/index.js";
 
 export function agentToolToPiTool<TParams extends TSchema, TDetails>(
   tool: AgentTool<TParams, TDetails>,
@@ -14,17 +15,29 @@ export function agentToolToPiTool<TParams extends TSchema, TDetails>(
     description: tool.description,
     promptSnippet: `${tool.name}: ${tool.description}`,
     parameters: tool.parameters,
-    execute: async (toolCallId, params, signal, onUpdate) => {
-      return tool.execute(toolCallId, params, signal, onUpdate);
+    execute: async (toolCallId, params, signal, onUpdate, ctx) => {
+      const executeWithContext = tool.execute as unknown as (
+        id: string,
+        params: unknown,
+        signal: AbortSignal | undefined,
+        onUpdate: unknown,
+        ctx: unknown,
+      ) => ReturnType<typeof tool.execute>;
+      return executeWithContext(toolCallId, params, signal, onUpdate, ctx);
     },
   };
 }
 
-export function getOpenCandleToolDefinitions(): ToolDefinition[] {
-  return getAllTools()
+export function getOpenCandleToolDefinitions(
+  options: { askUserHandler?: AskUserHandler } = {},
+): ToolDefinition[] {
+  return getAllTools(options)
     .map((tool) => ({ tool, defaults: safeGetDefaults(tool.name) }))
     .filter(({ defaults }) => defaults.__enabled !== false)
-    .map(({ tool, defaults }) => agentToolToPiTool(wrapWithDefaults(tool, defaults)));
+    .map(({ tool, defaults }) => {
+      const { __enabled: _enabled, ...paramDefaults } = defaults;
+      return agentToolToPiTool(wrapWithDefaults(tool, paramDefaults));
+    });
 }
 
 function safeGetDefaults(toolName: string): Record<string, unknown> {

package/src/prompts/context-builder.ts

@@ -1,7 +1,7 @@
-import type { PromptSection, SectionName } from "./sections.js";
-import { SECTION_ORDER, DEFAULT_BUDGETS, truncateTobudget } from "./sections.js";
-import { renderPolicyCardForPlanning } from "./policy-cards.js";
 import type { ResolvedTurnContext } from "../routing/turn-context.js";
+import { renderPolicyCardForPlanning } from "./policy-cards.js";
+import type { PromptSection, SectionName } from "./sections.js";
+import { DEFAULT_BUDGETS, SECTION_ORDER, truncateTobudget } from "./sections.js";
 
 export interface PromptSectionReport {
   name: SectionName;
@@ -122,10 +122,7 @@ export class PromptContextBuilder {
         policyCard ? `${policyCard}\n\n${routePlaybook}` : routePlaybook,
       );
     } else if (options.fallbackContext) {
-      this.setSection(
-        "workflow-instructions",
-        buildFallbackPlaybook(options.fallbackContext),
-      );
+      this.setSection("workflow-instructions", buildFallbackPlaybook(options.fallbackContext));
     }
     if (options.memoryContext) {
       this.setSection("memory-context", formatMemorySection(options.memoryContext));
@@ -150,12 +147,26 @@ export function buildFallbackPlaybook(ctx: FallbackContext): string {
 
 export function buildRoutePlaybook(ctx: ResolvedTurnContext): string {
   const assumptionsBlock = buildResolvedAssumptionsBlock(ctx);
+  const droppedSymbols = ctx.diagnostics
+    .filter((diagnostic) => diagnostic.code === "symbol_dropped")
+    .map((diagnostic) => diagnostic.details?.token)
+    .filter((token): token is string => typeof token === "string" && token.length > 0);
+  const dropContext =
+    droppedSymbols.length > 0
+      ? `Dropped ambiguous ticker-like tokens: ${droppedSymbols.join(", ")}.`
+      : undefined;
+  const extraContext = [
+    ctx.entities.symbols.length > 0
+      ? `Router-extracted symbols: ${ctx.entities.symbols.join(", ")}. Route kind: ${ctx.routeKind}. Tool bundles: ${ctx.toolBundles.join(", ") || "(none)"}.`
+      : `Route kind: ${ctx.routeKind}. Tool bundles: ${ctx.toolBundles.join(", ") || "(none)"}.`,
+    dropContext,
+  ]
+    .filter((part): part is string => Boolean(part))
+    .join(" ");
   const fallbackContext: FallbackContext = {
     assumptionsBlock,
     missingRequired: ctx.missingRequired,
-    extraContext: ctx.entities.symbols.length > 0
-      ? `Router-extracted symbols: ${ctx.entities.symbols.join(", ")}. Route kind: ${ctx.routeKind}. Tool bundles: ${ctx.toolBundles.join(", ") || "(none)"}.`
-      : `Route kind: ${ctx.routeKind}. Tool bundles: ${ctx.toolBundles.join(", ") || "(none)"}.`,
+    extraContext,
   };
 
   if (ctx.routeKind === "clarification") {
@@ -240,7 +251,7 @@ const SAFETY_RULES = `## Guidelines
 - For crypto position-sizing prompts, start with a concrete allocation range and dollar amount, then show drawdown impact on the user's portfolio, a sleep test, dollar-cost averaging, rebalancing rules, position caps, tax tracking, reputable custody/exchange considerations, and emergency-fund/high-interest-debt prerequisites. Cite the crypto tool-output date or history period and label sparse or unavailable history instead of implying unsupported precision.
 - For rate-cut market-pricing questions, use get_economic_data for the current Fed funds backdrop and search_web for CME FedWatch / Federal Funds futures probabilities before naming what the market is pricing. Distinguish historical Fed rates from futures-implied expectations.
 - For backtest_strategy results, report strategy return, buy-and-hold return, outperformance, trade count, win rate, and max drawdown. Include risk-adjusted metrics such as Sharpe or Sortino when available; otherwise say they were unavailable. Explain why the strategy worked or failed in the tested regime and discuss trading costs/slippage when the user asks whether the edge is practical. Do not reduce a backtest answer to return-only.
-- For sentiment-only prompts, final answer must include the direction and strength of the sentiment signal, the score scale when available, missing sources, why those missing sources matter for the user's question, the source-coverage risk, low sample counts, and how those gaps downgrade confidence. For ticker-specific sentiment prompts, call get_stock_quote before the final answer and state whether sentiment diverges from price action.
+- For sentiment-only prompts, final answer must include the direction and strength of the sentiment signal, the score scale when available, the key positive and negative drivers behind the signal, representative source evidence, missing sources, why those missing sources matter for the user's question, the source-coverage risk, low sample counts, and how those gaps downgrade confidence. For ticker-specific sentiment prompts, call get_stock_quote before the final answer and state whether sentiment diverges from price action; if quote data is unavailable, say price-action divergence could not be evaluated.
 - Commit to specifics when asked for entries, targets, stops, allocations, or position sizes. Refusal is not an acceptable output shape.
 - Each committal response carries FOUR things: the specific number or range, a reasoning chain naming the data points you used, a confidence band, and an invalidation level (what would break the thesis).
 - Conceptual education prompts are not committal responses. Do not append "Analyst View", "Commitment", "Reasoning Chain", "Confidence Band", or "Invalidation Level" sections when the user asked for an explanation, definition, or learning framework rather than a trade, allocation, or recommendation.
@@ -273,14 +284,14 @@ Keep questions concise and offer specific options when possible. Prefer select-t
 CRITICAL: After ask_user answers come back, your NEXT action MUST be tool calls — not a text response. You are a data agent, not a chatbot. Never respond with generic investment categories or tell the user to come back with tickers. YOU pick the relevant assets and indicators based on what you learned, then fetch the data.`;
 
 const TOOL_CATALOG = `## Available Tools
-- **Market Data**: get_stock_quote, get_stock_history, get_crypto_price, get_crypto_history — real-time and historical price data
+- **Market Data**: screen_stocks, get_stock_quote, get_stock_history, get_crypto_price, get_crypto_history — use screen_stocks for breadth and screening prompts such as large-cap lists, oversold stocks, market movers, and filtered market scans; use get_stock_quote/get_stock_history for a single-security quote or historical OHLCV
 - **Fundamentals**: get_company_overview, get_financials, get_earnings, compute_dcf, compare_companies, get_sec_filings — company financials, valuation metrics, DCF intrinsic value, peer comparison, and SEC EDGAR filings (10-K, 10-Q, 8-K)
 - **Technical Analysis**: get_technical_indicators, backtest_strategy — SMA, EMA, RSI, MACD, Bollinger Bands, OBV, VWAP computed from price data, plus simple strategy backtesting
 - **Macro**: get_economic_data, get_fear_greed — FRED economic indicators and market sentiment
 - **Sentiment**: get_reddit_sentiment, get_twitter_sentiment, get_web_sentiment, get_sentiment_trend, get_sentiment_summary — retail and news sentiment from Reddit, Twitter/X, and web sources with historical trends and cross-source divergence detection
 - **Web Search**: search_web — breaking news, earnings context, company events, regulatory developments. Supported freshness values are hours, day, week, and month; use category general with freshness month for broad industry context; never pass unsupported values such as all, year, 3mo, quarter, or custom date ranges. When a dedicated tool can answer the question (quotes, fundamentals, earnings, macro, SEC filings, sentiment), use that tool instead — do not add search_web as a supplementary source for data available through dedicated tools
 - **Options**: get_option_chain — full options chain with strikes, bids/asks, volume, OI, IV, and computed Greeks (delta, gamma, theta, vega, rho)
-- **Portfolio**: track_portfolio, analyze_risk, manage_watchlist, analyze_correlation, analyze_holdings_overlap, track_prediction — position tracking, P&L, Sharpe ratio, VaR, watchlist with price alerts, correlation matrix, ETF/fund holdings overlap, and prediction tracking with accuracy scoring
+- **Portfolio**: track_portfolio, analyze_risk, manage_watchlist, analyze_correlation, analyze_holdings_overlap, track_prediction, manage_alerts, daily_watchlist_report, manage_notifications — position tracking, P&L, Sharpe ratio, VaR, watchlist tracking, durable local alerts, daily watchlist reports, notification history, correlation matrix, ETF/fund holdings overlap, and prediction tracking with accuracy scoring
 - **User Interaction**: ask_user — ask the user a clarification question when their request is ambiguous or missing key details`;
 
 function buildToolCatalog(addonDescriptions?: string[]): string {

package/src/prompts/policy-cards.ts

@@ -27,7 +27,7 @@ export const POLICY_CARD_IDS = [
   "general_fallback",
 ] as const;
 
-export type PromptPolicyCardId = typeof POLICY_CARD_IDS[number];
+export type PromptPolicyCardId = (typeof POLICY_CARD_IDS)[number];
 
 export interface PolicyCard {
   id: PromptPolicyCardId;
@@ -68,7 +68,7 @@ For "today", "right now", "this morning", "after close", or "why did it move" pr
     status: "implemented",
     capabilityGapIds: ["sentiment_sample_depth"],
     content: `## Sentiment Snapshot Policy
-For sentiment-only prompts, include the direction and strength of the sentiment signal, the score scale when available, missing sources, why missing sources matter for the user's question, source-coverage risk, low sample counts, and how those gaps downgrade confidence. For ticker-specific sentiment prompts, compare sentiment with fetched price action and state whether sentiment diverges from price action. Treat sentiment as supporting evidence, not a standalone buy/sell verdict. Disclose sparse source coverage, unavailable Twitter/X sessions, provider gaps, or low sample depth instead of implying full-market sentiment coverage.`,
+For sentiment-only prompts, include the direction and strength of the sentiment signal, the score scale when available, the key positive and negative drivers behind the signal, representative source evidence, missing sources, why missing sources matter for the user's question, source-coverage risk, low sample counts, and how those gaps downgrade confidence. For ticker-specific sentiment prompts, compare sentiment with fetched price action and state whether sentiment diverges from price action; if quote data is unavailable, say price-action divergence could not be evaluated. Treat sentiment as supporting evidence, not a standalone buy/sell verdict. Disclose sparse source coverage, unavailable Twitter/X sessions, provider gaps, or low sample depth instead of implying full-market sentiment coverage.`,
   },
   filing_thesis_review: {
     id: "filing_thesis_review",
@@ -133,7 +133,7 @@ For strategy backtest prompts, use backtest_strategy evidence before judging whe
     status: "implemented",
     capabilityGapIds: [],
     content: `## Stateful Tracking Update Policy
-For watchlist, portfolio tracking, prediction recording, and prediction-check prompts, use the state tool that owns the change or lookup: manage_watchlist, track_prediction, or track_portfolio. Do not confirm a saved change from prose alone. Confirm the persisted state update with the symbol, action, direction, entry price, target, stop, conviction, timeframe, or check result that the tool accepted. If required fields for a state mutation are missing, ask the smallest clarification question instead of inventing values. For check or list operations, summarize the saved state and say clearly when no records exist. Do not turn a state update into a buy/sell recommendation unless the user separately asks for market analysis.`,
+For watchlist, portfolio tracking, alert management, daily-report, prediction recording, and prediction-check prompts, use the state tool that owns the change or lookup: manage_watchlist, track_prediction, track_portfolio, manage_alerts, or daily_watchlist_report. Do not confirm a saved change from prose alone. Confirm the persisted state update with the symbol, action, direction, entry price, target, stop, conviction, timeframe, or check result that the tool accepted. If the user asks to create an alert and check it now in the same request, call manage_alerts with the matching create action and check_after_create=true. If required fields for a state mutation are missing, ask the smallest clarification question instead of inventing values. For check or list operations, summarize the saved state and say clearly when no records exist. Do not turn a state update into a buy/sell recommendation unless the user separately asks for market analysis.`,
   },
   retail_finance_tradeoff: {
     id: "retail_finance_tradeoff",

package/src/prompts/sections.ts

@@ -32,7 +32,7 @@ export const SECTION_ORDER = [
   "output-format",
 ] as const;
 
-export type SectionName = typeof SECTION_ORDER[number];
+export type SectionName = (typeof SECTION_ORDER)[number];
 
 /** Default character budgets per section. */
 export const DEFAULT_BUDGETS: Record<SectionName, number> = {

package/src/prompts/symbol-preflight.ts

@@ -0,0 +1,80 @@
+import { type InstrumentCandidate, searchYahooInstruments } from "../market-state/resolve.js";
+
+export interface SymbolValidation {
+  valid: boolean;
+  reason?: string;
+  checkedAt: number;
+}
+
+export type SymbolValidationCache = Map<string, SymbolValidation>;
+
+export interface SymbolPreflightDrop {
+  symbol: string;
+  reason: string;
+}
+
+export interface SymbolPreflightResult {
+  valid: string[];
+  dropped: SymbolPreflightDrop[];
+}
+
+export async function preflightSymbols(
+  symbols: string[],
+  options: {
+    cache?: SymbolValidationCache;
+    search?: (query: string) => Promise<InstrumentCandidate[]>;
+  } = {},
+): Promise<SymbolPreflightResult> {
+  const cache = options.cache;
+  const search = options.search ?? searchYahooInstruments;
+  const valid: string[] = [];
+  const dropped: SymbolPreflightDrop[] = [];
+
+  for (const rawSymbol of symbols) {
+    const symbol = rawSymbol.trim().toUpperCase();
+    if (!symbol) continue;
+
+    const cached = cache?.get(symbol);
+    const validation = cached ?? (await validateSymbol(symbol, search));
+    if (!cached) cache?.set(symbol, validation);
+
+    if (validation.valid) {
+      valid.push(symbol);
+    } else {
+      dropped.push({
+        symbol,
+        reason: validation.reason ?? "no matching ticker found via resolver search",
+      });
+    }
+  }
+
+  return { valid, dropped };
+}
+
+export function formatPreflightDropAnnotation(dropped: SymbolPreflightDrop[]): string {
+  const count = dropped.length;
+  const symbols = dropped.map((drop) => `${drop.symbol} (${drop.reason})`).join(", ");
+  return `[Pre-flight: dropped ${count} unknown symbol${count === 1 ? "" : "s"} - ${symbols}]`;
+}
+
+function validateSymbol(
+  symbol: string,
+  search: (query: string) => Promise<InstrumentCandidate[]>,
+): Promise<SymbolValidation> {
+  return search(symbol)
+    .then((candidates) => ({
+      valid: candidates.some((candidate) => candidate.symbol.toUpperCase() === symbol),
+      reason: candidates.some((candidate) => candidate.symbol.toUpperCase() === symbol)
+        ? undefined
+        : "no matching ticker found via resolver search",
+      checkedAt: Date.now(),
+    }))
+    .catch((error) => ({
+      valid: true,
+      reason:
+        error instanceof Error
+          ? `resolver search unavailable: ${error.message}`
+          : "resolver search unavailable",
+      checkedAt: Date.now(),
+    }));
+}