opencandle 0.4.0 → 0.6.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,33 +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...");
-        }
-      },
-      onPrompt: async (prompt) => dialog.showPrompt(prompt.message, prompt.placeholder),
-      onProgress: (message) => dialog.showProgress(message),
-      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);
@@ -238,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,9 @@
 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";
 
 export function agentToolToPiTool<TParams extends TSchema, TDetails>(
   tool: AgentTool<TParams, TDetails>,
@@ -24,7 +24,10 @@ export function getOpenCandleToolDefinitions(): ToolDefinition[] {
   return getAllTools()
     .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,5 +1,21 @@
+import type { ResolvedTurnContext } from "../routing/turn-context.js";
+import { renderPolicyCardForPlanning } from "./policy-cards.js";
 import type { PromptSection, SectionName } from "./sections.js";
-import { SECTION_ORDER, DEFAULT_BUDGETS, truncateTobudget } from "./sections.js";
+import { DEFAULT_BUDGETS, SECTION_ORDER, truncateTobudget } from "./sections.js";
+
+export interface PromptSectionReport {
+  name: SectionName;
+  originalLength: number;
+  renderedLength: number;
+  characterBudget: number;
+  truncated: boolean;
+}
+
+export interface PromptBuildReport {
+  prompt: string;
+  sections: PromptSectionReport[];
+  truncationMarkers: number;
+}
 
 /** Options for building prompt context. */
 export interface PromptContextOptions {
@@ -15,6 +31,7 @@ export interface PromptContextOptions {
    * if both are set, `workflowInstructions` wins (rule-path compatibility).
    */
   fallbackContext?: FallbackContext;
+  resolvedTurnContext?: ResolvedTurnContext;
 }
 
 export interface FallbackContext {
@@ -51,21 +68,36 @@ export class PromptContextBuilder {
     return this;
   }
 
-  /** Get a section by name. */
-  getSection(name: SectionName): PromptSection | undefined {
-    return this.sections.get(name);
-  }
-
   /** Build the complete system prompt. */
   build(): string {
+    return this.buildWithReport().prompt;
+  }
+
+  /** Build the complete prompt and report section size/truncation metadata. */
+  buildWithReport(): PromptBuildReport {
     const parts: string[] = [];
+    const report: PromptSectionReport[] = [];
+    let truncationMarkers = 0;
     for (const name of SECTION_ORDER) {
       const section = this.sections.get(name)!;
       if (!section.content) continue;
       const truncated = truncateTobudget(section.content, section.characterBudget);
+      const wasTruncated = truncated.includes("[...truncated]");
+      if (wasTruncated) truncationMarkers += 1;
+      report.push({
+        name,
+        originalLength: section.content.length,
+        renderedLength: truncated.length,
+        characterBudget: section.characterBudget,
+        truncated: wasTruncated,
+      });
       parts.push(truncated);
     }
-    return parts.join("\n\n");
+    return {
+      prompt: parts.join("\n\n"),
+      sections: report,
+      truncationMarkers,
+    };
   }
 
   /**
@@ -74,14 +106,23 @@ export class PromptContextBuilder {
   populateFromOptions(options: PromptContextOptions): this {
     this.setSection("base-role", BASE_ROLE);
     this.setSection("safety-rules", SAFETY_RULES);
-    this.setSection("tool-catalog", buildToolCatalog(options.addonToolDescriptions));
+    this.setSection(
+      "tool-catalog",
+      options.resolvedTurnContext && options.resolvedTurnContext.activeToolNames.length === 0
+        ? "## Available Tools\nNo finance tools are needed for this turn. Answer from general finance knowledge without naming OpenCandle tool functions."
+        : buildToolCatalog(options.addonToolDescriptions),
+    );
     if (options.workflowInstructions) {
       this.setSection("workflow-instructions", options.workflowInstructions);
-    } else if (options.fallbackContext) {
+    } else if (options.resolvedTurnContext) {
+      const routePlaybook = buildRoutePlaybook(options.resolvedTurnContext);
+      const policyCard = renderPolicyCardForPlanning(options.resolvedTurnContext.planning);
       this.setSection(
         "workflow-instructions",
-        buildFallbackPlaybook(options.fallbackContext),
+        policyCard ? `${policyCard}\n\n${routePlaybook}` : routePlaybook,
       );
+    } else if (options.fallbackContext) {
+      this.setSection("workflow-instructions", buildFallbackPlaybook(options.fallbackContext));
     }
     if (options.memoryContext) {
       this.setSection("memory-context", formatMemorySection(options.memoryContext));
@@ -101,6 +142,76 @@ export class PromptContextBuilder {
  * are missing. Contains NO refusal or hedging language.
  */
 export function buildFallbackPlaybook(ctx: FallbackContext): string {
+  return buildAgentTaskPlaybook(ctx);
+}
+
+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,
+  };
+
+  if (ctx.routeKind === "clarification") {
+    return buildClarificationPlaybook(fallbackContext);
+  }
+  if (ctx.routeKind === "pass_through") {
+    return `## Pass-Through Playbook
+This turn is outside OpenCandle's finance task surface. Answer normally without invoking finance tools. If the user clarifies into an investment, trading, portfolio, macro, or market-data task, ask a concise follow-up or proceed under the analyst stance.
+
+## Assumptions Context
+${assumptionsBlock}`;
+  }
+  if (ctx.routeKind === "workflow_dispatch") {
+    return `## Workflow Dispatch Context
+The router selected workflow dispatch${ctx.workflow ? ` for ${ctx.workflow}` : ""}. Use the workflow instructions as authoritative when present, and use this context only for slot provenance and missing required fields.
+
+${ctx.missingRequired.length > 0 ? `## Missing Required Information\nThe following slots are required but not yet filled: ${ctx.missingRequired.join(", ")}. Call the \`ask_user\` tool before committing to analysis.\n\n` : ""}## Assumptions Context
+${assumptionsBlock}`;
+  }
+  return buildAgentTaskPlaybook(fallbackContext);
+}
+
+function buildClarificationPlaybook(ctx: FallbackContext): string {
+  const missing = ctx.missingRequired.join(", ") || "required information";
+  return `## Clarification Playbook
+The router found that analysis is blocked by missing required information: ${missing}. Call the \`ask_user\` tool before committing to financial analysis. Keep the question specific and collect only the missing slots.
+
+${ctx.extraContext ? `## Additional Context\n${ctx.extraContext}\n\n` : ""}## Assumptions Context
+${ctx.assumptionsBlock}`;
+}
+
+function buildResolvedAssumptionsBlock(ctx: ResolvedTurnContext): string {
+  const lines: string[] = [];
+  lines.push("Assumptions Context:");
+  if (Object.keys(ctx.slots).length === 0) {
+    lines.push("  (none)");
+    return lines.join("\n");
+  }
+  for (const [key, slot] of Object.entries(ctx.slots)) {
+    lines.push(`  ${key}: ${String(slot.value)} (${slot.source})`);
+  }
+  return lines.join("\n");
+}
+
+function buildAgentTaskPlaybook(ctx: FallbackContext): string {
   const missingLine =
     ctx.missingRequired.length > 0
       ? `\n## Missing Required Information\nThe following slots are required but not yet filled: ${ctx.missingRequired.join(", ")}. Call the \`ask_user\` tool to collect each one BEFORE committing to a final answer. Do not guess or assume these values.`
@@ -108,17 +219,21 @@ export function buildFallbackPlaybook(ctx: FallbackContext): string {
   const extraLine = ctx.extraContext ? `\n## Additional Context\n${ctx.extraContext}` : "";
 
   return `## Fallback Playbook
-This turn did not match a structured workflow, but you still commit to an answer under the analyst stance. Follow this playbook:
+This turn did not match a structured workflow, but you still answer under the analyst stance. Keep this fallback generic: task-specific behavior belongs in policy cards, workflow prompts, tool/evidence normalization, answer contracts, or structured checks. Do not add task-specific instructions here.${missingLine}${extraLine}
 
 1. Tool-first: fetch relevant data with your available tools before stating prices, levels, or metrics.
-2. Anchor on the Assumptions block below — it carries the router's best reading of what the user said and what came from saved preferences. Reproduce the block in your response exactly as written.
-3. Commit: give a concrete, specific answer (entry zone, target, allocation, recommendation, explanation — whatever the question asked for). Do not refuse. Do not hedge into vagueness. Low confidence is a legitimate answer; refusal is not.
-4. Attach reasoning, a confidence band, and an invalidation condition to every committal response.${missingLine}${extraLine}
+2. Use the Assumptions Context below only as internal routing context. Do not quote it, label it, or start the answer with it unless the user explicitly asked for assumptions.
+3. Commit to a concrete, specific answer when the user asks for a view, recommendation, allocation, target, explanation, or next step. Low confidence is valid; refusal-shaped hedging is not.
+4. Attach reasoning, a confidence band, and an invalidation condition to every committal response.
+5. Label data gaps, stale provider output, unavailable tools, and unverified current facts. If web search returns no results or a provider soft-degrades, continue with the best supported answer when the gap is not blocking, lower confidence where appropriate, and name what live fact would change the view.
+6. If required slots are missing, call ask_user before committing. Otherwise do not ask a generic follow-up instead of answering.
+7. Do not add task-specific instructions here. Add them to the selected policy card, workflow prompt, tool result normalization, answer contract, or structured check.
 
+## Assumptions Context
 ${ctx.assumptionsBlock}
 
 Response format:
-- Start with the Assumptions block above exactly as written. Do not relabel source attribution anywhere else.
+- Lead with the answer or view, not the assumptions context.
 - Commit to specifics. Present numeric data in tables when comparing multiple values.
 - Flag downside and risks loudly; never downplay them.`;
 }
@@ -128,12 +243,19 @@ Response format:
 const BASE_ROLE = `You are OpenCandle, a research analyst for investors and traders.
 
 ## Your Role
-You are an analyst, not a fiduciary advisor. When asked for entry levels, price targets, stops, position sizes, or allocations, you COMMIT to specific numbers backed by the data you fetched. Uncertainty is expressed as a confidence band and an invalidation level — never as refusal. Refusal-shaped hedges are wrong for this product; users are here for an analyst's view. Frame views as analyst opinion ("our read", "the data suggests", "analyst view"), never as personalised fiduciary guidance ("tailored to your situation", "given your full financial picture").`;
+You are an analyst, not a fiduciary advisor. When asked for entry levels, price targets, stops, position sizes, or allocations, you COMMIT to specific numbers backed by the data you fetched. Uncertainty is expressed as a confidence band and an invalidation level — never as refusal. Refusal-shaped hedges are wrong for this product; users are here for an analyst's view. For conceptual education questions, teach the concept directly, do not name tool functions, and do not append analyst-view, confidence-band, or invalidation boilerplate. For valuation-metric education, start with "Bottom line", immediately follow it with a one-sentence paragraph beginning "Core mental model:", use a heading exactly named "Practical workflow" with numbered question-driven application steps, explain where the metric misleads as common traps to avoid, include a compact cross-check table with why/when each metric helps, include relevant trailing, forward, normalized, or cyclically adjusted variants when useful, and end with a heading exactly named "Quick checklist". Frame views as analyst opinion ("our read", "the data suggests", "analyst view"), never as personalised fiduciary guidance ("tailored to your situation", "given your full financial picture").`;
 
 const SAFETY_RULES = `## Guidelines
 - Always fetch data with tools before stating prices, ratios, or metrics. Never guess financial numbers. Every substantive response should be backed by at least one tool call — if you find yourself writing a response with zero tool calls, stop and think about what data would make it better.
+- For current single-stock recommendations, state the quote or tool-output date; preserve market-closed, delayed, or last available quote notes. If DCF/fundamentals are unavailable, do not let that tool failure or missing fundamentals become the main thesis. Use available quote, earnings, technicals, sentiment/news, fallback valuation lenses, structural business risks, position sizing, and entry strategy.
+- 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.
 - 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.
+- If no active finance tool exists for brokerage, account, fund-platform, financial-product selection, or conceptual education, do not refuse or apologize for missing tools. Answer from durable public finance knowledge, name facts the user should verify, and keep any current-data caveat brief.
 - For options analysis, use get_option_chain to see the full chain with Greeks. Pay attention to put/call ratio, unusual volume, and IV levels.
 - Present numerical data in tables when comparing multiple securities.
 - Include data timestamps so users know how fresh the information is.
@@ -151,7 +273,7 @@ Use the ask_user tool BEFORE proceeding when:
 - Risk tolerance is unclear for portfolio or options recommendations
 
 Do NOT ask clarifying questions when:
-- The request is clear and specific (e.g., "get AAPL quote", "analyze BTC")
+- The request is clear and specific about the asset or market to analyze
 - You can reasonably infer the intent from context or prior conversation
 - A reasonable default exists and can be disclosed in the Assumptions block instead
 - The user explicitly asks you to use your judgment
@@ -162,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. 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
+- **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, track_prediction — position tracking, P&L, Sharpe ratio, VaR, watchlist with price alerts, correlation matrix, 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 {
@@ -201,4 +323,4 @@ Every committal response MUST carry four elements:
 - **Invalidation level** — what would change your view, stated concretely ("thesis breaks if quarterly revenue growth falls below 15%", "invalidated on a daily close below $120 with expanding volume").
 
 ## Assumption Disclosure
-Workflow prompts include a pre-rendered "Assumptions" block with correct source attribution (user-specified, saved preference, or default). Start your response with that block exactly as written. Do NOT independently relabel any value's source anywhere in your response. The assumptions block is the single authoritative provenance representation.`;
+Structured workflow prompts may include a pre-rendered "Assumptions" block with correct source attribution (user-specified, saved preference, or default). Start with that block only when the workflow instructions explicitly say to. Fallback prompts include "Assumptions Context" only for internal routing context; do not reproduce that context unless the user explicitly asks for assumptions. Do NOT independently relabel any value's source anywhere in your response. When an assumptions block is shown, it is the single authoritative provenance representation.`;

package/src/prompts/disclaimer.ts

@@ -4,6 +4,6 @@
  * longer steers model behavior but still surfaces on every assistant turn.
  */
 export const DISCLAIMER_TEXT =
-  "OpenCandle is a research and analysis tool, not a fiduciary financial advisor. " +
+  "OpenCandle is a research and analysis tool, not financial advice or a fiduciary financial advisor. " +
   "Views, targets, and allocations are informational analyst output — not personalized recommendations. " +
   "Verify independently before acting.";