opencandle 0.5.0 → 0.7.0

package/dist/pi/opencandle-extension.js

@@ -1,23 +1,29 @@
-import { isAnalysisRequest, normalizeSymbol, } from "../analysts/orchestrator.js";
-import { buildComprehensiveAnalysisDefinition } from "../analysts/orchestrator.js";
+import { buildComprehensiveAnalysisDefinition, isAnalysisRequest, normalizeSymbol, } from "../analysts/orchestrator.js";
 import { getConfig } from "../config.js";
-import { classifyWithLegacyRules, createPiAiRouterClient, resolveOptionsScreenerSlots, resolvePortfolioSlots, route as routeLlm, buildResolvedTurnContext, } from "../routing/index.js";
-import { buildAssumptionsBlockFromRouter } from "../prompts/workflow-prompts.js";
-import { buildPortfolioWorkflowDefinition, buildOptionsScreenerWorkflowDefinition, buildCompareAssetsWorkflowDefinition, } from "../workflows/index.js";
-import { getOpenCandleToolDefinitions } from "./tool-adapter.js";
-import { registerAskUserTool } from "../tools/interaction/ask-user.js";
-import { registerTwitterLoginTool } from "../tools/interaction/twitter-login.js";
-import { SessionCoordinator } from "../runtime/session-coordinator.js";
-import { getProvider, } from "../onboarding/providers.js";
-import { loadOnboardingState, saveOnboardingState, markProviderSnoozed, markProviderNeverAsk, markWelcomeShown, shouldShowWelcome, } from "../onboarding/state.js";
-import { parseToolTag, buildSkippedTag, buildConnectedTag } from "../onboarding/tool-tags.js";
+import { runProviderConnect } from "../onboarding/connect.js";
 import { resolveCredentialRequired } from "../onboarding/credential-interceptor.js";
 import { createDegradationAccumulator } from "../onboarding/degradation-accumulator.js";
 import { promptUser } from "../onboarding/prompt-user.js";
-import { runProviderConnect } from "../onboarding/connect.js";
+import { getProvider } from "../onboarding/providers.js";
+import { loadOnboardingState, markProviderNeverAsk, markProviderSnoozed, markWelcomeShown, saveOnboardingState, shouldShowWelcome, } from "../onboarding/state.js";
+import { buildConnectedTag, buildSkippedTag, parseToolTag } from "../onboarding/tool-tags.js";
 import { DISCLAIMER_TEXT } from "../prompts/disclaimer.js";
+import { formatPreflightDropAnnotation, preflightSymbols } from "../prompts/symbol-preflight.js";
+import { buildAssumptionsBlockFromRouter } from "../prompts/workflow-prompts.js";
+import { buildResolvedTurnContext, classifyWithLegacyRules, createPiAiRouterClient, hasFinanceSignals, resolveOptionsScreenerSlots, resolvePortfolioSlots, route as routeLlm, } from "../routing/index.js";
+import { disambiguateSymbols } from "../routing/symbol-disambiguator.js";
+import { SessionCoordinator } from "../runtime/session-coordinator.js";
+import { generateSessionTitle } from "../runtime/session-title.js";
+import { registerAskUserTool } from "../tools/interaction/ask-user.js";
+import { buildCompareAssetsWorkflowDefinition, buildOptionsScreenerWorkflowDefinition, buildPortfolioWorkflowDefinition, } from "../workflows/index.js";
+import { getOpenCandleToolDefinitions } from "./tool-adapter.js";
 export default function openCandleExtension(pi, options) {
     const coordinator = new SessionCoordinator();
+    // Workflow transforms replace the user's turn with the expanded prompt; this
+    // marker lets the GUI render the user's original words instead.
+    const markOriginalInput = (original) => {
+        pi.appendEntry("opencandle-user-input", { original });
+    };
     // Credential-interception state. Lifetime:
     //   `sessionPromptedSet` — cleared on session_start, persists across turns
     //      within a session so users don't get re-prompted after picking
@@ -36,12 +42,15 @@ export default function openCandleExtension(pi, options) {
     const degradationAccumulator = createDegradationAccumulator();
     let activeToolSnapshot = null;
     let currentRouteToolContext = null;
+    // LLM session-title state: one title attempt per session per process.
+    // Reset on session_start; set before the (async) title call fires so
+    // overlapping turn_end events cannot double-title.
+    let sessionTitleAttempted = false;
     // Register tools
-    for (const tool of getOpenCandleToolDefinitions()) {
+    for (const tool of getOpenCandleToolDefinitions({ askUserHandler: options?.askUserHandler })) {
         pi.registerTool(tool);
     }
     registerAskUserTool(pi, options?.askUserHandler);
-    registerTwitterLoginTool(pi);
     // /analyze command
     pi.registerCommand("analyze", {
         description: "Run the multi-analyst OpenCandle workflow for a ticker symbol",
@@ -51,7 +60,9 @@ export default function openCandleExtension(pi, options) {
                 ctx.ui.notify("Usage: /analyze <ticker>", "warning");
                 return;
             }
-            const definition = buildComprehensiveAnalysisDefinition(symbol, { debate: getConfig().debate });
+            const definition = buildComprehensiveAnalysisDefinition(symbol, {
+                debate: getConfig().debate,
+            });
             coordinator.executeWorkflow(pi, definition, ctx);
         },
     });
@@ -71,9 +82,9 @@ export default function openCandleExtension(pi, options) {
     // `/connect <alias|id|category>` routes to a specific provider (or a
     // sub-picker for multi-provider categories like "search").
     pi.registerCommand("connect", {
-        description: "Connect a data provider (Alpha Vantage, FRED, Finnhub, Brave, Exa)",
+        description: "Connect an API-key data provider (Alpha Vantage, FRED, Finnhub, Brave, Exa)",
         handler: async (args, ctx) => {
-            const { listAllProviders, resolveProviderFromArgument, hasCredential } = await import("../onboarding/providers.js");
+            const { listApiKeyProviders, resolveProviderFromArgument, hasCredential, isApiKeyProvider } = await import("../onboarding/providers.js");
             const formatState = (id) => {
                 const state = loadOnboardingState().providers[id];
                 if (state?.status === "completed")
@@ -99,12 +110,12 @@ export default function openCandleExtension(pi, options) {
             let targetId;
             if (trimmed === "") {
                 // Bare /connect → full picker.
-                targetId = await pickProvider(listAllProviders());
+                targetId = await pickProvider(listApiKeyProviders());
             }
             else {
                 const resolved = resolveProviderFromArgument(trimmed);
                 if (!resolved) {
-                    const all = listAllProviders()
+                    const all = listApiKeyProviders()
                         .map((p) => `  ${p.displayName} (${p.aliases.join(", ")})`)
                         .join("\n");
                     ctx.ui.notify(`Unknown provider: "${trimmed}". Available:\n${all}`, "warning");
@@ -112,10 +123,20 @@ export default function openCandleExtension(pi, options) {
                 }
                 if (Array.isArray(resolved)) {
                     // Multi-provider category — show a sub-picker.
-                    targetId = await pickProvider(resolved);
+                    const apiKeyProviders = resolved.filter(isApiKeyProvider);
+                    if (apiKeyProviders.length === 0) {
+                        ctx.ui.notify(`"${trimmed}" does not use API-key setup. Run opencandle doctor for setup status.`, "warning");
+                        return;
+                    }
+                    targetId = await pickProvider(apiKeyProviders);
                 }
                 else {
-                    targetId = resolved.id;
+                    const descriptor = resolved;
+                    if (!isApiKeyProvider(descriptor)) {
+                        ctx.ui.notify(`${descriptor.displayName} does not use API-key setup. Run opencandle doctor for setup status.`, "warning");
+                        return;
+                    }
+                    targetId = descriptor.id;
                 }
             }
             if (!targetId) {
@@ -137,6 +158,7 @@ export default function openCandleExtension(pi, options) {
         coordinator.initSession(ctx.sessionManager.getSessionId());
         sessionPromptedSet.clear();
         hardPromptFiredInWorkflow = false;
+        sessionTitleAttempted = false;
         if (!ctx.hasUI)
             return;
         // Pin the user-facing disclaimer in the UI footer for the entire session.
@@ -210,6 +232,83 @@ export default function openCandleExtension(pi, options) {
         }
         degradationAccumulator.reset();
     });
+    // LLM session titles. After the first completed user↔assistant exchange,
+    // replace the placeholder session name (the raw first prompt, set by the
+    // GUI server / Pi's firstMessage fallback) with a short model-written
+    // summary. Manual renames are left alone, and each session is attempted at
+    // most once per process. Model failures are swallowed (placeholder stays)
+    // but recorded as an `opencandle-title-error` entry for observability.
+    pi.on("turn_end", async (event, ctx) => {
+        if (sessionTitleAttempted)
+            return;
+        const msg = event.message;
+        if (msg?.role !== "assistant" || msg?.stopReason !== "stop")
+            return;
+        const sessionManager = ctx?.sessionManager;
+        if (typeof sessionManager?.getBranch !== "function")
+            return;
+        const branch = sessionManager.getBranch();
+        let firstUserText = null;
+        let firstAssistantText = null;
+        let originalInput = null;
+        for (const entry of branch) {
+            if (originalInput === null &&
+                entry.type === "custom" &&
+                entry.customType === "opencandle-user-input") {
+                const original = entry.data?.original;
+                if (typeof original === "string" && original.trim().length > 0) {
+                    originalInput = original;
+                }
+                continue;
+            }
+            if (entry.type !== "message")
+                continue;
+            const message = entry.message;
+            const text = extractMessageText(message?.content);
+            if (text.trim().length === 0)
+                continue;
+            if (firstUserText === null && message?.role === "user")
+                firstUserText = text;
+            if (firstAssistantText === null && message?.role === "assistant") {
+                firstAssistantText = text;
+            }
+            if (firstUserText !== null && firstAssistantText !== null)
+                break;
+        }
+        // Fall back to the just-finished assistant message when the branch has
+        // not surfaced it yet at turn_end time.
+        if (firstAssistantText === null) {
+            const eventText = extractMessageText(msg.content);
+            if (eventText.trim().length > 0)
+                firstAssistantText = eventText;
+        }
+        if (firstUserText === null || firstAssistantText === null)
+            return;
+        const userText = originalInput ?? firstUserText;
+        // A manual rename must be left alone — only replace the placeholder
+        // (unset, the raw first prompt, or the GUI's "first 77 chars + ..." form).
+        if (!isPlaceholderSessionName(pi.getSessionName(), [userText, firstUserText]))
+            return;
+        const completion = options?.titleCompletion ??
+            (() => {
+                const client = options?.routerLlmClient ?? resolveRouterLlmClient(ctx);
+                return client ? (prompt) => client.complete(prompt) : null;
+            })();
+        if (!completion)
+            return;
+        sessionTitleAttempted = true;
+        try {
+            const title = await generateSessionTitle({ userText, assistantText: firstAssistantText.slice(0, 500) }, completion);
+            if (title !== null) {
+                pi.setSessionName(title);
+            }
+        }
+        catch (err) {
+            pi.appendEntry("opencandle-title-error", {
+                message: err instanceof Error ? err.message : String(err),
+            });
+        }
+    });
     // Intercept tool results for credential-required and soft-degraded tags.
     pi.on("tool_result", async (event, ctx) => {
         // First pass: record any soft-degradation tags in the per-turn accumulator
@@ -224,17 +323,85 @@ export default function openCandleExtension(pi, options) {
                 degradationAccumulator.record(parsed.provider);
             }
         }
-        // Second pass: look for a credential-required tag; on match, run the
-        // interception decision and either replace the tool result or prompt
-        // the user. Only the first credential_required tag in the content list
-        // is acted on — subsequent hard-tier prompts are silenced by the
-        // per-workflow cap at the decision-function level.
+        // Second pass: look for setup-required tags; on match, run the interception
+        // decision and either replace the tool result or prompt the user. Only the
+        // first setup tag in the content list is acted on.
         for (const block of event.content) {
             if (block.type !== "text")
                 continue;
             const parsed = parseToolTag(block.text);
-            if (!parsed || parsed.kind !== "credential_required")
+            if (!parsed ||
+                (parsed.kind !== "credential_required" && parsed.kind !== "external_tool_required")) {
                 continue;
+            }
+            if (parsed.kind === "external_tool_required") {
+                const state = loadOnboardingState();
+                const descriptor = getProvider(parsed.provider);
+                if (state.providers[parsed.provider]?.status === "never_ask") {
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `${buildSkippedTag({
+                                    provider: parsed.provider,
+                                    reason: "credential_not_provided",
+                                    remediation: `run ${parsed.installCmd} and ${parsed.loginCmd ?? "rdt login"} to enable ${descriptor.displayName} (silenced)`,
+                                    silenced: true,
+                                })}\n\n` +
+                                    `${descriptor.displayName} data was not fetched because you previously asked not to be reminded about this provider.`,
+                            },
+                        ],
+                    };
+                }
+                const setupLabel = parsed.reason === "not_installed"
+                    ? `Continue after installing ${descriptor.displayName}`
+                    : `Continue after logging in to ${descriptor.displayName}`;
+                const skipLabel = `Skip ${descriptor.displayName} once`;
+                const neverLabel = `Always skip ${descriptor.displayName}`;
+                const installOrLogin = parsed.reason === "not_installed"
+                    ? `Install command: ${parsed.installCmd}.`
+                    : `Login command: ${parsed.loginCmd ?? "rdt login"}.`;
+                const questionBody = `${descriptor.displayName} requires a local external tool before this data can be fetched. ` +
+                    `${installOrLogin} How would you like to proceed?`;
+                sessionPromptedSet.add(parsed.provider);
+                const promptResult = await promptUser(ctx, {
+                    question: questionBody,
+                    questionType: "select",
+                    options: [setupLabel, skipLabel, neverLabel],
+                }, options?.askUserHandler);
+                const answer = promptResult.cancelled ? skipLabel : (promptResult.answer ?? skipLabel);
+                if (answer.startsWith("Always")) {
+                    saveOnboardingState(markProviderNeverAsk(state, parsed.provider));
+                }
+                if (answer.startsWith("Continue")) {
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `${buildConnectedTag({ provider: parsed.provider })}\n\n` +
+                                    `${descriptor.displayName} setup was acknowledged. Re-run the original ${descriptor.displayName} request now; if setup is still unavailable, continue without ${descriptor.displayName} and disclose the source gap.`,
+                            },
+                        ],
+                    };
+                }
+                const silenced = answer.startsWith("Always");
+                const remediation = silenced
+                    ? `run ${parsed.installCmd} and ${parsed.loginCmd ?? "rdt login"} to enable ${descriptor.displayName} (silenced)`
+                    : `run ${parsed.installCmd} and ${parsed.loginCmd ?? "rdt login"} to enable ${descriptor.displayName}`;
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `${buildSkippedTag({
+                                provider: parsed.provider,
+                                reason: "credential_not_provided",
+                                remediation,
+                                silenced,
+                            })}\n\n${descriptor.displayName} data was omitted per your choice.`,
+                        },
+                    ],
+                };
+            }
             const state = loadOnboardingState();
             const action = resolveCredentialRequired({
                 provider: parsed.provider,
@@ -396,11 +563,16 @@ export default function openCandleExtension(pi, options) {
     pi.on("input", async (event, ctx) => {
         if (event.source === "extension")
             return;
+        coordinator.clearTickerValidationCache();
         // Check for comprehensive analysis pattern — same in both modes.
         const analysis = isAnalysisRequest(event.text);
         if (analysis.match && analysis.symbol) {
-            const definition = buildComprehensiveAnalysisDefinition(analysis.symbol, { debate: getConfig().debate });
+            const definition = buildComprehensiveAnalysisDefinition(analysis.symbol, {
+                debate: getConfig().debate,
+            });
             const prompt = coordinator.transformWorkflowInput(pi, definition, ctx);
+            if (prompt)
+                markOriginalInput(event.text);
             return prompt ? { action: "transform", text: prompt } : { action: "handled" };
         }
         const mode = getConfig().routerMode;
@@ -418,46 +590,177 @@ export default function openCandleExtension(pi, options) {
         const storage = coordinator.getStorage();
         const workflowPrefs = storage?.getWorkflowPreferences("global") ?? {};
         // Classify intent
-        const classification = classifyWithLegacyRules(event.text);
+        let classification = classifyWithLegacyRules(event.text);
+        const ruleModeDisambiguation = disambiguateRulesModeSymbols(event.text, classification.entities.symbols);
+        appendSymbolDropEntries(ruleModeDisambiguation.dropped, "rules");
+        classification = {
+            ...classification,
+            entities: {
+                ...classification.entities,
+                symbols: ruleModeDisambiguation.kept,
+            },
+        };
+        if (isComparePrompt(event.text) &&
+            ruleModeDisambiguation.dropped.length > 0 &&
+            classification.entities.symbols.length < 2) {
+            pi.appendEntry("opencandle-workflow-aborted", {
+                reason: "symbol-disambiguation-insufficient-symbols",
+                dropped: ruleModeDisambiguation.dropped,
+                validSymbols: classification.entities.symbols,
+            });
+            const base = coordinator.buildRouterContextBase(ctx.sessionManager);
+            const output = {
+                routeKind: "clarification",
+                route: "fallback",
+                workflow: "compare_assets",
+                entities: classification.entities,
+                slots: {},
+                preference_updates: [],
+                missing_required: ["symbols"],
+                tool_bundles: ["clarification"],
+                diagnostics: ruleModeDisambiguation.dropped.map((drop) => ({
+                    code: "symbol_dropped",
+                    message: `${drop.token} dropped: ${drop.reason}`,
+                    details: {
+                        token: drop.token,
+                        reason: drop.reason,
+                        signalsChecked: drop.signalsChecked,
+                        source: "rules",
+                    },
+                })),
+                reasoning: "rules-mode acronym disambiguation left fewer than two symbols for comparison",
+            };
+            const resolvedTurnContext = buildResolvedTurnContext({ text: event.text, ...base }, output, {
+                availableToolNames: safeGetAllToolNames(),
+                planning: {
+                    migrationStatuses: getConfig().planningMigrationStatuses,
+                },
+            });
+            coordinator.setPendingResolvedTurnContext({
+                ...resolvedTurnContext,
+                diagnostics: [
+                    ...resolvedTurnContext.diagnostics,
+                    {
+                        code: "compare_workflow_aborted",
+                        message: "compare workflow needs at least two validated symbols after acronym disambiguation",
+                    },
+                ],
+            });
+            coordinator.setPendingFallbackContext({
+                assumptionsBlock: [
+                    "Assumptions Context:",
+                    classification.entities.symbols.length > 0
+                        ? `  valid symbols: ${classification.entities.symbols.join(", ")} (user)`
+                        : "  valid symbols: (none)",
+                    `  dropped ambiguous ticker-like tokens: ${ruleModeDisambiguation.dropped.map((d) => d.token).join(", ")} (no positive ticker signal)`,
+                ].join("\n"),
+                missingRequired: ["symbols"],
+                extraContext: "Dropped ambiguous ticker-like tokens: " +
+                    `${ruleModeDisambiguation.dropped.map((d) => d.token).join(", ")}. ` +
+                    "Ask the user which ticker symbols they want compared before calling comparison tools.",
+            });
+            applyRouteToolScope(resolvedTurnContext);
+            return undefined;
+        }
         if (classification.workflow === "portfolio_builder") {
             const resolution = resolvePortfolioSlots(classification.entities, workflowPrefs);
             coordinator.recordWorkflowRun("portfolio_builder", classification.entities, resolution.resolved, resolution.defaultsUsed);
-            pi.appendEntry("opencandle-workflow", { workflow: "portfolio_builder", entities: classification.entities, resolved: resolution.resolved });
+            pi.appendEntry("opencandle-workflow", {
+                workflow: "portfolio_builder",
+                entities: classification.entities,
+                resolved: resolution.resolved,
+            });
             const definition = buildPortfolioWorkflowDefinition(resolution);
             const prompt = coordinator.transformWorkflowInput(pi, definition, ctx);
+            if (prompt)
+                markOriginalInput(event.text);
             return prompt ? { action: "transform", text: prompt } : { action: "handled" };
         }
         if (classification.workflow === "options_screener") {
             const resolution = resolveOptionsScreenerSlots(classification.entities, workflowPrefs);
             if (resolution.missingRequired.length === 0) {
                 coordinator.recordWorkflowRun("options_screener", classification.entities, resolution.resolved, resolution.defaultsUsed);
-                pi.appendEntry("opencandle-workflow", { workflow: "options_screener", entities: classification.entities, resolved: resolution.resolved });
+                pi.appendEntry("opencandle-workflow", {
+                    workflow: "options_screener",
+                    entities: classification.entities,
+                    resolved: resolution.resolved,
+                });
                 const definition = buildOptionsScreenerWorkflowDefinition(resolution);
                 const prompt = coordinator.transformWorkflowInput(pi, definition, ctx);
+                if (prompt)
+                    markOriginalInput(event.text);
                 return prompt ? { action: "transform", text: prompt } : { action: "handled" };
             }
         }
-        if (classification.workflow === "compare_assets" && classification.entities.symbols.length >= 2) {
+        if (classification.workflow === "compare_assets" &&
+            classification.entities.symbols.length >= 2) {
             const resolution = {
                 resolved: {
                     symbols: classification.entities.symbols,
                     metrics: classification.entities.compareMetrics,
                     timeHorizon: classification.entities.timeHorizon,
+                    budget: classification.entities.budget,
+                    assetScope: classification.entities.assetScope,
                 },
                 sources: {
                     symbols: "user",
                     ...(classification.entities.timeHorizon ? { timeHorizon: "user" } : {}),
                     ...(classification.entities.compareMetrics ? { metrics: "user" } : {}),
+                    ...(classification.entities.budget !== undefined ? { budget: "user" } : {}),
+                    ...(classification.entities.assetScope ? { assetScope: "user" } : {}),
                 },
                 defaultsUsed: [],
                 missingRequired: [],
             };
             coordinator.recordWorkflowRun("compare_assets", classification.entities, resolution.resolved, resolution.defaultsUsed);
-            pi.appendEntry("opencandle-workflow", { workflow: "compare_assets", symbols: classification.entities.symbols });
-            const definition = buildCompareAssetsWorkflowDefinition(resolution);
+            pi.appendEntry("opencandle-workflow", {
+                workflow: "compare_assets",
+                symbols: classification.entities.symbols,
+            });
+            const preflight = await preflightCompareResolution(resolution);
+            if (!preflight) {
+                coordinator.recordWorkflowRun("fallback", classification.entities, resolution.resolved, [], "clarification");
+                coordinator.setPendingFallbackContext({
+                    assumptionsBlock: [
+                        "Assumptions Context:",
+                        `  original symbols: ${classification.entities.symbols.join(", ")} (user)`,
+                    ].join("\n"),
+                    missingRequired: ["symbols"],
+                    extraContext: "Compare workflow aborted because ticker preflight left fewer than two valid symbols. Ask the user to clarify the intended tickers before calling comparison tools.",
+                });
+                return undefined;
+            }
+            const definition = buildCompareAssetsWorkflowDefinition(preflight.resolution);
+            applyPreflightAnnotation(definition, preflight.dropped);
             const prompt = coordinator.transformWorkflowInput(pi, definition, ctx);
+            if (prompt)
+                markOriginalInput(event.text);
             return prompt ? { action: "transform", text: prompt } : { action: "handled" };
         }
+        // Rules-mode finance fallback: no workflow dispatched, but the turn is
+        // finance-shaped (classified finance intent, extracted symbols, or finance
+        // vocabulary). Record the fallback turn and stash a fallback context so
+        // the system prompt carries saved market state for this turn; non-finance
+        // prompts stay untouched.
+        const isFinanceFallback = classification.workflow !== "unclassified" ||
+            classification.entities.symbols.length > 0 ||
+            hasFinanceSignals(event.text);
+        if (isFinanceFallback) {
+            coordinator.recordWorkflowRun("fallback", classification.entities, {}, [], "agent_task");
+            coordinator.setPendingFallbackContext({
+                assumptionsBlock: "",
+                missingRequired: [],
+                extraContext: classification.entities.symbols.length > 0
+                    ? `Rules-router extracted symbols: ${classification.entities.symbols.join(", ")}.`
+                    : undefined,
+            });
+            pi.appendEntry("opencandle-fallback-context", {
+                mode: "rules",
+                classifiedWorkflow: classification.workflow,
+                symbols: classification.entities.symbols,
+            });
+        }
+        return undefined;
     });
     /**
      * LLM-mode input handler. In this mode `classifyIntent` and
@@ -515,6 +818,7 @@ export default function openCandleExtension(pi, options) {
             },
         });
         pi.appendEntry("opencandle-router", { output });
+        appendRouterSymbolDropEntries(output);
         pi.appendEntry("opencandle-route-context", resolvedTurnContext);
         coordinator.setPendingResolvedTurnContext(resolvedTurnContext);
         applyRouteToolScope(resolvedTurnContext);
@@ -539,7 +843,7 @@ export default function openCandleExtension(pi, options) {
         }
         // Workflow dispatch for recognised workflows.
         if (output.routeKind === "workflow_dispatch" && output.workflow) {
-            return dispatchRouterWorkflow(output, ctx);
+            return dispatchRouterWorkflow(output, ctx, text);
         }
         if (output.routeKind === "pass_through") {
             return false;
@@ -552,13 +856,13 @@ export default function openCandleExtension(pi, options) {
             assumptionsBlock,
             missingRequired: output.missing_required,
             extraContext: output.entities.symbols.length > 0
-                ? `Router-extracted symbols: ${output.entities.symbols.join(", ")}.`
-                    + ` Route kind: ${output.routeKind}. Tool bundles: ${output.tool_bundles.join(", ") || "(none)"}.`
+                ? `Router-extracted symbols: ${output.entities.symbols.join(", ")}.` +
+                    ` Route kind: ${output.routeKind}. Tool bundles: ${output.tool_bundles.join(", ") || "(none)"}.`
                 : undefined,
         });
         return false;
     }
-    function dispatchRouterWorkflow(output, ctx) {
+    async function dispatchRouterWorkflow(output, ctx, originalText) {
         const workflow = output.workflow;
         const storage = coordinator.getStorage();
         const workflowPrefs = storage?.getWorkflowPreferences("global") ?? {};
@@ -573,6 +877,8 @@ export default function openCandleExtension(pi, options) {
             });
             const definition = buildPortfolioWorkflowDefinition(resolution);
             const prompt = coordinator.transformWorkflowInput(pi, definition, ctx);
+            if (prompt)
+                markOriginalInput(originalText);
             return prompt ? { action: "transform", text: prompt } : false;
         }
         if (workflow === "options_screener") {
@@ -588,6 +894,8 @@ export default function openCandleExtension(pi, options) {
                 });
                 const definition = buildOptionsScreenerWorkflowDefinition(resolution);
                 const prompt = coordinator.transformWorkflowInput(pi, definition, ctx);
+                if (prompt)
+                    markOriginalInput(originalText);
                 return prompt ? { action: "transform", text: prompt } : false;
             }
             // Missing required symbol — treat as fallback with ask_user directive.
@@ -598,11 +906,17 @@ export default function openCandleExtension(pi, options) {
                     symbols: entities.symbols,
                     metrics: entities.compareMetrics,
                     timeHorizon: entities.timeHorizon,
+                    budget: entities.budget,
+                    assetScope: entities.assetScope,
                 },
                 sources: {
                     symbols: sourceForRouterSlot(output, "symbols", "user"),
                     ...(entities.timeHorizon ? { timeHorizon: "user" } : {}),
                     ...(entities.compareMetrics ? { metrics: "user" } : {}),
+                    ...(entities.budget !== undefined
+                        ? { budget: sourceForRouterSlot(output, "budget", "user") }
+                        : {}),
+                    ...(entities.assetScope ? { assetScope: "user" } : {}),
                 },
                 defaultsUsed: [],
                 missingRequired: [],
@@ -612,8 +926,22 @@ export default function openCandleExtension(pi, options) {
                 workflow: "compare_assets",
                 symbols: entities.symbols,
             });
-            const definition = buildCompareAssetsWorkflowDefinition(resolution);
+            const preflight = await preflightCompareResolution(resolution);
+            if (!preflight) {
+                coordinator.recordWorkflowRun("fallback", output.entities, Object.fromEntries(Object.entries(output.slots).map(([k, v]) => [k, v.value])), [], output.routeKind);
+                coordinator.setPendingResolvedTurnContext(null);
+                coordinator.setPendingFallbackContext({
+                    assumptionsBlock: buildAssumptionsBlockFromRouter(output.slots),
+                    missingRequired: ["symbols"],
+                    extraContext: "Compare workflow aborted because ticker preflight left fewer than two valid symbols. Ask the user to clarify the intended tickers.",
+                });
+                return false;
+            }
+            const definition = buildCompareAssetsWorkflowDefinition(preflight.resolution);
+            applyPreflightAnnotation(definition, preflight.dropped);
             const prompt = coordinator.transformWorkflowInput(pi, definition, ctx);
+            if (prompt)
+                markOriginalInput(originalText);
             return prompt ? { action: "transform", text: prompt } : false;
         }
         // single_asset_analysis / watchlist / general_qa + any workflow with
@@ -628,6 +956,89 @@ export default function openCandleExtension(pi, options) {
         });
         return false;
     }
+    function appendRouterSymbolDropEntries(output) {
+        for (const diagnostic of output.diagnostics) {
+            if (diagnostic.code !== "symbol_dropped")
+                continue;
+            const details = diagnostic.details ?? {};
+            appendSymbolDropEntries([
+                {
+                    token: String(details.token ?? ""),
+                    reason: String(details.reason ?? ""),
+                    signalsChecked: Array.isArray(details.signalsChecked)
+                        ? details.signalsChecked.map(String)
+                        : [],
+                },
+            ], String(details.source ?? "llm"));
+        }
+    }
+    function appendSymbolDropEntries(dropped, source) {
+        for (const drop of dropped) {
+            pi.appendEntry("opencandle-symbol-dropped", {
+                token: drop.token,
+                reason: drop.reason,
+                signalsChecked: drop.signalsChecked,
+                source,
+            });
+        }
+    }
+    function disambiguateRulesModeSymbols(text, extractedSymbols) {
+        const candidates = mergeSymbols(extractedSymbols, rawTickerLikeTokens(text));
+        const disambiguated = disambiguateSymbols(candidates, text);
+        return {
+            kept: disambiguated.kept.filter((symbol) => extractedSymbols.includes(symbol)),
+            dropped: disambiguated.dropped,
+        };
+    }
+    function rawTickerLikeTokens(text) {
+        const tokens = [];
+        for (const match of text.matchAll(/\$?([A-Za-z]{1,5})\b/g)) {
+            const raw = match[1];
+            if (raw !== raw.toUpperCase())
+                continue;
+            const token = raw.toUpperCase();
+            if (!tokens.includes(token))
+                tokens.push(token);
+        }
+        return tokens;
+    }
+    function isComparePrompt(text) {
+        return /\b(?:compare|vs\.?|versus|which\s+is\s+better)\b/i.test(text);
+    }
+    async function preflightCompareResolution(resolution) {
+        const result = await preflightSymbols(resolution.resolved.symbols, {
+            cache: coordinator.getTickerValidationCache(),
+            search: options?.symbolSearch,
+        });
+        for (const drop of result.dropped) {
+            pi.appendEntry("opencandle-symbol-preflight-dropped", drop);
+        }
+        if (result.valid.length < 2) {
+            pi.appendEntry("opencandle-workflow-aborted", {
+                reason: "preflight-insufficient-symbols",
+                dropped: result.dropped,
+            });
+            return null;
+        }
+        return {
+            resolution: {
+                ...resolution,
+                resolved: {
+                    ...resolution.resolved,
+                    symbols: result.valid,
+                },
+            },
+            dropped: result.dropped,
+        };
+    }
+    function applyPreflightAnnotation(definition, dropped) {
+        if (dropped.length === 0 || definition.steps.length === 0)
+            return;
+        definition.steps[0] = {
+            ...definition.steps[0],
+            prompt: `${formatPreflightDropAnnotation(dropped)}\n\n${definition.steps[0].prompt}`,
+        };
+    }
     function mergeRouterSlotsIntoEntities(output) {
         const entities = {
             ...output.entities,
@@ -636,12 +1047,25 @@ export default function openCandleExtension(pi, options) {
         if (entities.budget === undefined && typeof output.slots.budget?.value === "number") {
             entities.budget = output.slots.budget.value;
         }
-        const slotSymbols = symbolsFromRouterSlots(output);
+        const droppedSymbols = droppedSymbolsFromDiagnostics(output);
+        const slotSymbols = symbolsFromRouterSlots(output).filter((symbol) => !droppedSymbols.has(symbol));
         if (slotSymbols.length > 0 && slotSymbols.length > entities.symbols.length) {
             entities.symbols = mergeSymbols(slotSymbols, entities.symbols);
         }
         return entities;
     }
+    function droppedSymbolsFromDiagnostics(output) {
+        const dropped = new Set();
+        for (const diagnostic of output.diagnostics) {
+            if (diagnostic.code !== "symbol_dropped")
+                continue;
+            const token = diagnostic.details?.token;
+            if (typeof token === "string" && token.trim() !== "") {
+                dropped.add(token.toUpperCase());
+            }
+        }
+        return dropped;
+    }
     function withRouterSlotSources(resolution, output) {
         const sources = { ...resolution.sources };
         if (output.entities.budget === undefined && output.slots.budget) {
@@ -770,8 +1194,44 @@ export default function openCandleExtension(pi, options) {
         const fallbackContext = coordinator.consumePendingFallbackContext() ?? undefined;
         const resolvedTurnContext = coordinator.consumePendingResolvedTurnContext() ?? undefined;
         return {
-            systemPrompt: coordinator.buildSystemPrompt(event.systemPrompt, undefined, fallbackContext, resolvedTurnContext),
+            systemPrompt: coordinator.buildSystemPrompt(event.systemPrompt, coordinator.getActiveWorkflowType(), fallbackContext, resolvedTurnContext),
         };
     });
 }
+/** Concatenate text from a Pi message `content` (plain string or block array). */
+function extractMessageText(content) {
+    if (typeof content === "string")
+        return content;
+    if (!Array.isArray(content))
+        return "";
+    let text = "";
+    for (const block of content) {
+        if (block &&
+            typeof block === "object" &&
+            block.type === "text" &&
+            typeof block.text === "string") {
+            text += block.text;
+        }
+    }
+    return text;
+}
+/**
+ * True when the session name is still an auto-set placeholder that the LLM
+ * title may replace: unset, exactly one of the candidate user texts, or the
+ * GUI server's truncated "first 77 chars + ..." form of one of them.
+ */
+function isPlaceholderSessionName(name, candidates) {
+    if (name === undefined || name.trim().length === 0)
+        return true;
+    const trimmed = name.trim();
+    for (const candidate of candidates) {
+        const candidateTrimmed = candidate.trim();
+        if (trimmed === candidateTrimmed)
+            return true;
+        if (trimmed.endsWith("...") && candidateTrimmed.startsWith(trimmed.slice(0, -3))) {
+            return true;
+        }
+    }
+    return false;
+}
 //# sourceMappingURL=opencandle-extension.js.map