opencandle 0.10.0 → 0.11.0

package/src/market-state/service.ts

@@ -1,8 +1,6 @@
 import type Database from "better-sqlite3";
 
 export type AssetType = "equity" | "etf" | "fund" | "crypto" | "index" | "option" | "unknown";
-export type PredictionDirection = "bullish" | "bearish" | "neutral";
-export type PredictionStatus = "open" | "resolved" | "expired" | "cancelled";
 export type AlertScopeType = "instrument" | "watchlist" | "portfolio";
 
 export interface InstrumentInput {
@@ -100,23 +98,6 @@ export interface PortfolioLotRecord {
   updatedAt: string;
 }
 
-export interface PredictionRecord {
-  id: number;
-  instrumentId: number;
-  symbol: string;
-  direction: PredictionDirection;
-  conviction: number;
-  entryPrice: number;
-  targetPrice: number | null;
-  openedAt: string;
-  expiresAt: string;
-  status: PredictionStatus;
-  resolvedAt: string | null;
-  resultJson: string | null;
-  createdAt: string;
-  updatedAt: string;
-}
-
 export interface AlertRuleRecord {
   id: number;
   scopeType: AlertScopeType;
@@ -337,23 +318,6 @@ type PortfolioLotRow = {
   updated_at: string;
 };
 
-type PredictionRow = {
-  id: number;
-  instrument_id: number;
-  symbol: string;
-  direction: PredictionDirection;
-  conviction: number;
-  entry_price: number;
-  target_price: number | null;
-  opened_at: string;
-  expires_at: string;
-  status: PredictionStatus;
-  resolved_at: string | null;
-  result_json: string | null;
-  created_at: string;
-  updated_at: string;
-};
-
 type AlertRuleRow = {
   id: number;
   scope_type: AlertScopeType;
@@ -877,75 +841,6 @@ export class MarketStateService {
     });
   }
 
-  recordPrediction(params: {
-    instrument: InstrumentInput;
-    direction: PredictionDirection;
-    conviction: number;
-    entryPrice: number;
-    targetPrice?: number;
-    timeframeDays: number;
-    now?: Date;
-  }): PredictionRecord {
-    const tx = this.db.transaction(() => {
-      const instrument = this.upsertInstrument(params.instrument);
-      const opened = params.now ?? new Date();
-      const expires = new Date(opened);
-      expires.setDate(expires.getDate() + params.timeframeDays);
-      const nowIso = opened.toISOString();
-      const result = this.db
-        .prepare(
-          `INSERT INTO prediction_records (
-             instrument_id, direction, conviction, entry_price, target_price,
-             opened_at, expires_at, status, created_at, updated_at
-           )
-           VALUES (?, ?, ?, ?, ?, ?, ?, 'open', ?, ?)`,
-        )
-        .run(
-          instrument.id,
-          params.direction,
-          params.conviction,
-          params.entryPrice,
-          params.targetPrice ?? null,
-          nowIso,
-          expires.toISOString(),
-          nowIso,
-          nowIso,
-        );
-      return Number(result.lastInsertRowid);
-    });
-
-    return this.getPrediction(tx());
-  }
-
-  listPredictions(): PredictionRecord[] {
-    const rows = this.db
-      .prepare(
-        `SELECT pr.*, i.symbol
-         FROM prediction_records pr
-         JOIN instruments i ON i.id = pr.instrument_id
-         ORDER BY pr.opened_at, pr.id`,
-      )
-      .all() as PredictionRow[];
-    return rows.map(mapPrediction);
-  }
-
-  updatePredictionOutcome(params: {
-    id: number;
-    status: Exclude<PredictionStatus, "open">;
-    resolvedAt: string;
-    result: unknown;
-  }): PredictionRecord {
-    const now = new Date().toISOString();
-    this.db
-      .prepare(
-        `UPDATE prediction_records
-         SET status = ?, resolved_at = ?, result_json = ?, updated_at = ?
-         WHERE id = ?`,
-      )
-      .run(params.status, params.resolvedAt, JSON.stringify(params.result), now, params.id);
-    return this.getPrediction(params.id);
-  }
-
   createAlertRule(params: {
     scopeType: AlertScopeType;
     scopeId?: number;
@@ -1998,18 +1893,6 @@ export class MarketStateService {
     return row == null ? null : mapPortfolioLot(row);
   }
 
-  private getPrediction(id: number): PredictionRecord {
-    const row = this.db
-      .prepare(
-        `SELECT pr.*, i.symbol
-         FROM prediction_records pr
-         JOIN instruments i ON i.id = pr.instrument_id
-         WHERE pr.id = ?`,
-      )
-      .get(id) as PredictionRow;
-    return mapPrediction(row);
-  }
-
   getAlertRule(id: number): AlertRuleRecord {
     const row = this.db.prepare("SELECT * FROM alert_rules WHERE id = ?").get(id) as AlertRuleRow;
     return mapAlertRule(row);
@@ -2118,25 +2001,6 @@ function mapPortfolioLot(row: PortfolioLotRow): PortfolioLotRecord {
   };
 }
 
-function mapPrediction(row: PredictionRow): PredictionRecord {
-  return {
-    id: row.id,
-    instrumentId: row.instrument_id,
-    symbol: row.symbol,
-    direction: row.direction,
-    conviction: row.conviction,
-    entryPrice: row.entry_price,
-    targetPrice: row.target_price,
-    openedAt: row.opened_at,
-    expiresAt: row.expires_at,
-    status: row.status,
-    resolvedAt: row.resolved_at,
-    resultJson: row.result_json,
-    createdAt: row.created_at,
-    updatedAt: row.updated_at,
-  };
-}
-
 function mapAlertRule(row: AlertRuleRow): AlertRuleRecord {
   return {
     id: row.id,

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/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,
@@ -118,9 +115,7 @@ export default function openCandleExtension(
         ctx.ui.notify("Usage: /analyze <ticker>", "warning");
         return;
       }
-      const definition = buildComprehensiveAnalysisDefinition(symbol, {
-        debate: getConfig().debate,
-      });
+      const definition = buildComprehensiveAnalysisDefinition(symbol);
       coordinator.executeWorkflow(pi, definition, ctx);
     },
   });
@@ -674,244 +669,26 @@ 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 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,
-        });
-        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 definition = buildComprehensiveAnalysisDefinition(analysis.symbol);
       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;
   });
 
   /**
@@ -1206,36 +983,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 +1183,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