opencandle 0.10.0 → 0.11.1

package/src/market-state/summaries.ts

@@ -0,0 +1,75 @@
+import type { PortfolioLotRecord, ReportRunRecord, WatchlistItemRecord } from "./service.js";
+
+export function formatPortfolioSummary(lots: PortfolioLotRecord[], limit = 8): string[] {
+  if (lots.length === 0) return [];
+  const lines = ["Portfolio lots:"];
+  for (const lot of lots.slice(0, limit)) {
+    const costBasis = formatMoney(lot.quantity * lot.avgCost, lot.currency);
+    const name = lot.name ? ` (${lot.name})` : "";
+    lines.push(
+      `- ${lot.symbol}: ${lot.quantity} @ ${formatMoney(lot.avgCost, lot.currency)}, cost basis ${costBasis}${name}`,
+    );
+  }
+  return lines;
+}
+
+export function formatWatchlistSummary(items: WatchlistItemRecord[], limit = 8): string[] {
+  if (items.length === 0) return [];
+  const lines = ["Watchlist:"];
+  for (const item of items.slice(0, limit)) {
+    const parts = [
+      item.targetPrice == null
+        ? null
+        : `target ${formatMoney(item.targetPrice, item.priceCurrency ?? item.currency ?? "USD")}`,
+      item.stopPrice == null
+        ? null
+        : `stop ${formatMoney(item.stopPrice, item.priceCurrency ?? item.currency ?? "USD")}`,
+      item.thesis ? `thesis: ${item.thesis}` : null,
+      item.tags && item.tags.length > 0 ? `tags: ${item.tags.join(", ")}` : null,
+      item.notes ? `notes: ${item.notes}` : null,
+    ].filter((part): part is string => part != null);
+    lines.push(
+      `- ${item.symbol}${item.name ? ` (${item.name})` : ""}${parts.length > 0 ? ` — ${parts.join("; ")}` : ""}`,
+    );
+  }
+  return lines;
+}
+
+export function formatLatestReportSummary(
+  report: ReportRunRecord | undefined,
+  options: { includeSummary?: boolean } = {},
+): string[] {
+  if (!report) return [];
+  const completed = report.completedAt ?? report.startedAt;
+  const summary = options.includeSummary === false ? "" : formatJsonSummary(report.summaryJson);
+  const lines = [
+    `Latest report run: ${report.status} at ${completed}${summary ? ` — ${summary}` : ""}`,
+  ];
+  const reportText = options.includeSummary === false ? "" : extractReportText(report.summaryJson);
+  if (reportText) lines.push("Report text:", truncateText(reportText, 8_000));
+  return lines;
+}
+
+export function formatMoney(value: number, currency: string): string {
+  const normalized = currency.toUpperCase();
+  if (normalized === "USD") return `$${value.toFixed(2)}`;
+  return `${normalized} ${value.toFixed(2)}`;
+}
+
+export function formatJsonSummary(value: unknown): string {
+  if (value == null) return "";
+  const json = JSON.stringify(value);
+  if (json.length <= 90) return json;
+  return `${json.slice(0, 87)}...`;
+}
+
+function extractReportText(value: unknown): string {
+  if (!value || typeof value !== "object" || !("text" in value)) return "";
+  const text = (value as { text?: unknown }).text;
+  return typeof text === "string" ? text.trim() : "";
+}
+
+function truncateText(value: string, maxLength: number): string {
+  if (value.length <= maxLength) return value;
+  return `${value.slice(0, maxLength - 3)}...`;
+}

package/src/memory/sqlite.ts

@@ -3,7 +3,7 @@ import { dirname } from "node:path";
 import Database from "better-sqlite3";
 import { ensureOpenCandleHomeDir, getStateDbPath } from "../infra/opencandle-paths.js";
 
-const CURRENT_SCHEMA_VERSION = 7;
+const CURRENT_SCHEMA_VERSION = 8;
 
 const CURRENT_SCHEMA = `
   CREATE TABLE IF NOT EXISTS schema_version (
@@ -178,23 +178,6 @@ const CURRENT_SCHEMA = `
     ON portfolio_lots(source, source_lot_id)
     WHERE source IS NOT NULL AND source_lot_id IS NOT NULL;
 
-  CREATE TABLE IF NOT EXISTS prediction_records (
-    id INTEGER PRIMARY KEY AUTOINCREMENT,
-    instrument_id INTEGER NOT NULL,
-    direction TEXT NOT NULL,
-    conviction REAL NOT NULL,
-    entry_price REAL NOT NULL,
-    target_price REAL,
-    opened_at TEXT NOT NULL,
-    expires_at TEXT NOT NULL,
-    status TEXT NOT NULL,
-    resolved_at TEXT,
-    result_json TEXT,
-    created_at TEXT NOT NULL,
-    updated_at TEXT NOT NULL,
-    FOREIGN KEY (instrument_id) REFERENCES instruments(id) ON DELETE RESTRICT
-  );
-
   CREATE TABLE IF NOT EXISTS alert_rules (
     id INTEGER PRIMARY KEY AUTOINCREMENT,
     scope_type TEXT NOT NULL,
@@ -380,14 +363,21 @@ function ensureCurrentSchema(db: Database.Database): void {
     return;
   }
 
+  if (currentVersion === 7) {
+    migrateV7ToV8(db);
+    return;
+  }
+
   if (currentVersion === 6) {
     migrateV6ToV7(db);
+    migrateV7ToV8(db);
     return;
   }
 
   if (currentVersion === 5) {
     migrateV5ToV6(db);
     migrateV6ToV7(db);
+    migrateV7ToV8(db);
     return;
   }
 
@@ -395,6 +385,7 @@ function ensureCurrentSchema(db: Database.Database): void {
     migrateV4ToV5(db);
     migrateV5ToV6(db);
     migrateV6ToV7(db);
+    migrateV7ToV8(db);
     return;
   }
 
@@ -403,16 +394,19 @@ function ensureCurrentSchema(db: Database.Database): void {
     migrateV4ToV5(db);
     migrateV5ToV6(db);
     migrateV6ToV7(db);
+    migrateV7ToV8(db);
     return;
   }
 
-  // Additive v2 → v3 → v4 → v5 → v6 migration without dropping data.
+  // Additive v2 → v3 → ... → v7 migration without dropping data (v8 drops
+  // prediction_records as the explicit removal of the predictions feature).
   if (currentVersion === 2) {
     migrateV2ToV3(db);
     migrateV3ToV4(db);
     migrateV4ToV5(db);
     migrateV5ToV6(db);
     migrateV6ToV7(db);
+    migrateV7ToV8(db);
     return;
   }
 
@@ -487,6 +481,16 @@ function migrateV6ToV7(db: Database.Database): void {
 
   db.exec(CURRENT_SCHEMA);
 
+  db.prepare("DELETE FROM schema_version").run();
+  db.prepare("INSERT INTO schema_version (version) VALUES (?)").run(7);
+}
+
+function migrateV7ToV8(db: Database.Database): void {
+  // Predictions feature removal: dropping prediction_records is the explicit,
+  // documented destructive step for this table; all other rows are preserved.
+  db.exec("DROP TABLE IF EXISTS prediction_records");
+  db.exec(CURRENT_SCHEMA);
+
   db.prepare("DELETE FROM schema_version").run();
   db.prepare("INSERT INTO schema_version (version) VALUES (?)").run(CURRENT_SCHEMA_VERSION);
 }

package/src/onboarding/providers.ts

@@ -12,7 +12,7 @@ import { getConfig, loadFileConfig } from "../config.js";
 
 export type ApiKeyProviderId = "alpha_vantage" | "fred" | "finnhub" | "brave" | "exa";
 export type ExternalToolProviderId = "twitter" | "reddit";
-export type PublicHttpProviderId = "yahoo";
+export type PublicHttpProviderId = "polymarket" | "tradingview" | "yahoo";
 export type ProviderId = ApiKeyProviderId | ExternalToolProviderId | PublicHttpProviderId;
 
 export type ProviderCategory =
@@ -201,6 +201,34 @@ export const PROVIDERS = [
     snoozeDurationDays: 7,
     instructionsHint: "No account needed; OpenCandle checks public Yahoo Finance reachability",
   },
+  {
+    id: "polymarket",
+    kind: "public-http",
+    displayName: "Polymarket",
+    category: "macro",
+    tier: "hard",
+    aliases: ["polymarket", "prediction-markets", "event-probabilities"],
+    probeUrl: "https://gamma-api.polymarket.com/public-search?q=fed%20rate%20cut&limit=1",
+    unlocks: ["market-implied event probabilities", "prediction-market resolution criteria"],
+    fallbackDescription: null,
+    snoozeDurationDays: 7,
+    instructionsHint: "No account needed; OpenCandle checks public Polymarket Gamma reachability",
+  },
+  {
+    id: "tradingview",
+    kind: "public-http",
+    displayName: "TradingView Scanner",
+    category: "market",
+    tier: "soft",
+    aliases: ["tradingview", "tradingview-scanner", "screener"],
+    probeUrl: "https://scanner.tradingview.com/america/scan2?label-product=screener-stock",
+    unlocks: ["stock screens", "ticker search fallback", "watchlist quote fallback"],
+    fallbackDescription:
+      "Core market quote/history tools continue through Yahoo and Alpha Vantage when TradingView scanner is unavailable",
+    snoozeDurationDays: 7,
+    instructionsHint:
+      "No account needed; OpenCandle checks the public TradingView scanner endpoint",
+  },
   {
     id: "twitter",
     kind: "external-tool",

package/src/pi/opencandle-extension.ts

@@ -25,15 +25,12 @@ import { formatPreflightDropAnnotation, preflightSymbols } from "../prompts/symb
 import { buildAssumptionsBlockFromRouter } from "../prompts/workflow-prompts.js";
 import {
   buildResolvedTurnContext,
-  classifyWithLegacyRules,
   createPiAiRouterClient,
-  hasFinanceSignals,
   resolveOptionsScreenerSlots,
   resolvePortfolioSlots,
   route as routeLlm,
 } from "../routing/index.js";
 import type { RouterInputContext, RouterLlmClient, RouterOutput } from "../routing/router-types.js";
-import { disambiguateSymbols } from "../routing/symbol-disambiguator.js";
 import type { ResolvedTurnContext } from "../routing/turn-context.js";
 import type {
   CompareAssetsSlots,
@@ -68,6 +65,10 @@ export interface OpenCandleExtensionOptions {
   titleCompletion?: (prompt: string) => Promise<string>;
 }
 
+interface OriginalInputMarkerContext {
+  sessionManager?: { getBranch?: () => unknown[]; getEntries?: () => unknown[] };
+}
+
 export default function openCandleExtension(
   pi: ExtensionAPI,
   options?: OpenCandleExtensionOptions,
@@ -76,10 +77,22 @@ export default function openCandleExtension(
 
   // 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: string): void => {
+  const markOriginalInput = (original: string, ctx?: OriginalInputMarkerContext): void => {
+    if (hasUnconsumedOriginalInputMarker(ctx)) return;
     pi.appendEntry("opencandle-user-input", { original });
   };
 
+  const appendComprehensiveAnalysisWorkflowEntry = (
+    symbol: string,
+    definition: ReturnType<typeof buildComprehensiveAnalysisDefinition>,
+  ): void => {
+    pi.appendEntry("opencandle-workflow", {
+      workflow: "comprehensive_analysis",
+      resolvedSlots: { symbol },
+      analystsTotal: definition.steps.filter((step) => step.stepType.startsWith("analyst_")).length,
+    });
+  };
+
   // Credential-interception state. Lifetime:
   //   `sessionPromptedSet` — cleared on session_start, persists across turns
   //      within a session so users don't get re-prompted after picking
@@ -118,9 +131,8 @@ export default function openCandleExtension(
         ctx.ui.notify("Usage: /analyze <ticker>", "warning");
         return;
       }
-      const definition = buildComprehensiveAnalysisDefinition(symbol, {
-        debate: getConfig().debate,
-      });
+      const definition = buildComprehensiveAnalysisDefinition(symbol);
+      appendComprehensiveAnalysisWorkflowEntry(symbol, definition);
       coordinator.executeWorkflow(pi, definition, ctx);
     },
   });
@@ -674,244 +686,27 @@ export default function openCandleExtension(
     return undefined;
   });
 
-  // Input handling — branches on OPENCANDLE_ROUTER_MODE.
+  // Input handling — the LLM router is the single production routing path.
   pi.on("input", async (event, ctx) => {
     if (event.source === "extension") return;
     coordinator.clearTickerValidationCache();
 
-    // Check for comprehensive analysis pattern — same in both modes.
+    // Check for comprehensive analysis pattern before routing.
     const analysis = isAnalysisRequest(event.text);
     if (analysis.match && analysis.symbol) {
-      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;
-    if (mode === "llm") {
-      const dispatched = await handleLlmRouterTurn(event.text, ctx);
-      // Dispatched a workflow → the original user turn is now represented by
-      // the workflow's queued prompts; tell Pi not to also forward it.
-      // Fallback path (no dispatch) → let Pi pass the user turn through to the
-      // main agent, which will run under the router-supplied fallback context.
-      return dispatched || undefined;
-    }
-
-    // --- explicit legacy rules mode (`OPENCANDLE_ROUTER_MODE=rules`) ---
-    // Extract and persist user preferences (legacy regex path)
-    coordinator.extractAndStorePreferences(event.text);
-    const storage = coordinator.getStorage();
-    const workflowPrefs = storage?.getWorkflowPreferences("global") ?? {};
-
-    // Classify intent
-    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: RouterOutput = {
-        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,
-      });
-      const definition = buildPortfolioWorkflowDefinition(resolution);
+      const definition = buildComprehensiveAnalysisDefinition(analysis.symbol);
+      appendComprehensiveAnalysisWorkflowEntry(analysis.symbol, definition);
       const prompt = coordinator.transformWorkflowInput(pi, definition, ctx);
-      if (prompt) markOriginalInput(event.text);
+      if (prompt) markOriginalInput(event.text, ctx);
       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,
-        });
-        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
-    ) {
-      const resolution: SlotResolution<CompareAssetsSlots> = {
-        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" as const } : {}),
-          ...(classification.entities.compareMetrics ? { metrics: "user" as const } : {}),
-          ...(classification.entities.budget !== undefined ? { budget: "user" as const } : {}),
-          ...(classification.entities.assetScope ? { assetScope: "user" as const } : {}),
-        },
-        defaultsUsed: [],
-        missingRequired: [],
-      };
-      coordinator.recordWorkflowRun(
-        "compare_assets",
-        classification.entities,
-        resolution.resolved,
-        resolution.defaultsUsed,
-      );
-      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;
+    const dispatched = await handleLlmRouterTurn(event.text, ctx);
+    // Dispatched a workflow → the original user turn is now represented by
+    // the workflow's queued prompts; tell Pi not to also forward it.
+    // Fallback path (no dispatch) → let Pi pass the user turn through to the
+    // main agent, which will run under the router-supplied fallback context.
+    return dispatched || undefined;
   });
 
   /**
@@ -1067,7 +862,7 @@ export default function openCandleExtension(
       });
       const definition = buildPortfolioWorkflowDefinition(resolution);
       const prompt = coordinator.transformWorkflowInput(pi, definition, ctx);
-      if (prompt) markOriginalInput(originalText);
+      if (prompt) markOriginalInput(originalText, ctx);
       return prompt ? { action: "transform", text: prompt } : false;
     }
     if (workflow === "options_screener") {
@@ -1092,7 +887,7 @@ export default function openCandleExtension(
         });
         const definition = buildOptionsScreenerWorkflowDefinition(resolution);
         const prompt = coordinator.transformWorkflowInput(pi, definition, ctx);
-        if (prompt) markOriginalInput(originalText);
+        if (prompt) markOriginalInput(originalText, ctx);
         return prompt ? { action: "transform", text: prompt } : false;
       }
       // Missing required symbol — treat as fallback with ask_user directive.
@@ -1150,7 +945,7 @@ export default function openCandleExtension(
       const definition = buildCompareAssetsWorkflowDefinition(preflight.resolution);
       applyPreflightAnnotation(definition, preflight.dropped);
       const prompt = coordinator.transformWorkflowInput(pi, definition, ctx);
-      if (prompt) markOriginalInput(originalText);
+      if (prompt) markOriginalInput(originalText, ctx);
       return prompt ? { action: "transform", text: prompt } : false;
     }
 
@@ -1206,36 +1001,6 @@ export default function openCandleExtension(
     }
   }
 
-  function disambiguateRulesModeSymbols(
-    text: string,
-    extractedSymbols: string[],
-  ): {
-    kept: string[];
-    dropped: Array<{ token: string; reason: string; signalsChecked: string[] }>;
-  } {
-    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: string): string[] {
-    const tokens: string[] = [];
-    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: string): boolean {
-    return /\b(?:compare|vs\.?|versus|which\s+is\s+better)\b/i.test(text);
-  }
-
   async function preflightCompareResolution(
     resolution: SlotResolution<CompareAssetsSlots>,
   ): Promise<{
@@ -1436,8 +1201,8 @@ export default function openCandleExtension(
     ctx: Parameters<Parameters<ExtensionAPI["on"]>[1]>[1],
   ): RouterLlmClient | null {
     // `ctx.model` is the currently selected pi-ai model. When unset (no auth
-    // configured yet), we skip the router and the main agent will run with
-    // its default unrouted flow (legacy rules path is the safer default).
+    // configured yet), we skip the router and the main agent runs with its
+    // default unrouted flow for the turn.
     const model = (ctx as { model?: unknown }).model;
     if (!model) return null;
     // biome-ignore lint/suspicious/noExplicitAny: Pi typings keep Model generic
@@ -1460,6 +1225,38 @@ export default function openCandleExtension(
   });
 }
 
+function hasUnconsumedOriginalInputMarker(ctx?: OriginalInputMarkerContext): boolean {
+  const manager = ctx?.sessionManager;
+  const entries =
+    typeof manager?.getBranch === "function"
+      ? manager.getBranch()
+      : typeof manager?.getEntries === "function"
+        ? manager.getEntries()
+        : [];
+  let markerAfterLastUser = false;
+  for (const entry of entries) {
+    if (!isSessionEntryRecord(entry)) continue;
+    if (entry.type === "message" && entry.message?.role === "user") {
+      markerAfterLastUser = false;
+      continue;
+    }
+    if (entry.type === "custom" && entry.customType === "opencandle-user-input") {
+      markerAfterLastUser = true;
+      continue;
+    }
+    if (markerAfterLastUser) {
+      markerAfterLastUser = false;
+    }
+  }
+  return markerAfterLastUser;
+}
+
+function isSessionEntryRecord(
+  entry: unknown,
+): entry is { type?: unknown; customType?: unknown; message?: { role?: unknown } } {
+  return typeof entry === "object" && entry !== null;
+}
+
 /** Concatenate text from a Pi message `content` (plain string or block array). */
 function extractMessageText(content: unknown): string {
   if (typeof content === "string") return content;