opencandle 0.5.0 → 0.7.0

package/src/runtime/prompt-step.ts

@@ -1,4 +1,4 @@
-import type { WorkflowStep, StepOutput } from "./workflow-types.js";
+import type { StepOutput, WorkflowStep } from "./workflow-types.js";
 
 /**
  * A workflow step definition that carries its prompt text.
@@ -10,7 +10,6 @@ export interface PromptStep extends Omit<WorkflowStep, "status"> {
 
 /**
  * A complete workflow definition: typed step metadata + prompt text for each step.
- * Replaces the old WorkflowPlan { initialPrompt, followUps }.
  */
 export interface WorkflowDefinition {
   workflowType: string;
@@ -59,17 +58,3 @@ export function promptStepOutput(stepIndex: number, stepType: string): StepOutpu
 export function toStepDefinitions(steps: PromptStep[]): Omit<WorkflowStep, "status">[] {
   return steps.map(({ prompt: _prompt, ...step }) => step);
 }
-
-/**
- * Convert a WorkflowDefinition to the old WorkflowPlan format for backward compatibility.
- */
-export function toWorkflowPlan(definition: WorkflowDefinition): {
-  initialPrompt: string;
-  followUps: string[];
-} {
-  const [first, ...rest] = definition.steps;
-  return {
-    initialPrompt: first?.prompt ?? "",
-    followUps: rest.map((s) => s.prompt),
-  };
-}

package/src/runtime/run-context.ts

@@ -4,16 +4,26 @@ interface RunContext {
   providerTracker: ProviderTracker;
 }
 
+export interface RunContextToken {
+  readonly id: symbol;
+}
+
 let activeContext: RunContext | null = null;
+let activeToken: RunContextToken | null = null;
 
 /** Set the active run context. Called by SessionCoordinator at workflow start. */
-export function setRunContext(ctx: RunContext): void {
+export function setRunContext(ctx: RunContext): RunContextToken {
+  const token = { id: Symbol("run-context") };
   activeContext = ctx;
+  activeToken = token;
+  return token;
 }
 
 /** Clear the active run context. Called when a workflow ends or is cancelled. */
-export function clearRunContext(): void {
+export function clearRunContext(token?: RunContextToken): void {
+  if (token && activeToken !== token) return;
   activeContext = null;
+  activeToken = null;
 }
 
 /** Get the current run's ProviderTracker, or undefined outside a workflow. */

package/src/runtime/session-coordinator.ts

@@ -1,4 +1,9 @@
-import type { ExtensionAPI, ExtensionCommandContext, ExtensionContext, SessionEntry } from "@earendil-works/pi-coding-agent";
+import type {
+  ExtensionAPI,
+  ExtensionCommandContext,
+  ExtensionContext,
+  SessionEntry,
+} from "@earendil-works/pi-coding-agent";
 import { getAllDefaults, initDefaultDatabase, MemoryStorage } from "../memory/index.js";
 
 /**
@@ -8,26 +13,34 @@ import { getAllDefaults, initDefaultDatabase, MemoryStorage } from "../memory/in
  * the shape we need from the public `ExtensionContext` type.
  */
 type ReadonlySessionManager = ExtensionContext["sessionManager"];
+
+import type Database from "better-sqlite3";
+import { MarketStateService } from "../market-state/service.js";
+import type { FilteredMemoryEntry } from "../memory/manager.js";
 import { MemoryManager } from "../memory/manager.js";
 import { extractPreferences } from "../memory/preference-extractor.js";
+import type { MemoryEntry } from "../memory/types.js";
 import { runOpenCandleSetup } from "../pi/setup.js";
-import { WorkflowEventLogger } from "./workflow-events.js";
-import { ProviderTracker } from "./provider-tracker.js";
-import { WorkflowRunner } from "./workflow-runner.js";
-import { setRunContext, clearRunContext } from "./run-context.js";
-import { PromptContextBuilder, type FallbackContext } from "../prompts/context-builder.js";
+import { type FallbackContext, PromptContextBuilder } from "../prompts/context-builder.js";
+import type { SymbolValidationCache } from "../prompts/symbol-preflight.js";
+import type { RouterRouteKind } from "../routing/router-types.js";
+import type { ResolvedTurnContext } from "../routing/turn-context.js";
 import { getAddonToolDescriptions } from "../tool-kit.js";
 import type { WorkflowDefinition } from "./prompt-step.js";
-import { toStepDefinitions, promptStepOutput } from "./prompt-step.js";
-import type { ResolvedTurnContext } from "../routing/turn-context.js";
-import type { RouterRouteKind } from "../routing/router-types.js";
-import type { MemoryEntry } from "../memory/types.js";
-import type { FilteredMemoryEntry } from "../memory/manager.js";
-import type Database from "better-sqlite3";
+import { promptStepOutput, toStepDefinitions } from "./prompt-step.js";
+import { ProviderTracker } from "./provider-tracker.js";
+import { clearRunContext, type RunContextToken, setRunContext } from "./run-context.js";
+import { WorkflowEventLogger } from "./workflow-events.js";
+import { WorkflowRunner } from "./workflow-runner.js";
 
 const PROMPT_SETTLE_POLL_MS = 25;
 const IMMEDIATE_IDLE_GRACE_MS = 100;
 
+interface ActiveWorkflowRunRef {
+  active: boolean;
+  contextToken: RunContextToken;
+}
+
 function parseMaybeJson(raw: unknown): Record<string, unknown> | undefined {
   if (typeof raw !== "string" || raw.length === 0) return undefined;
   try {
@@ -40,11 +53,13 @@ function parseMaybeJson(raw: unknown): Record<string, unknown> | undefined {
   }
 }
 
-type QueueContext = ExtensionCommandContext | {
-  isIdle(): boolean;
-  hasPendingMessages?(): boolean;
-  ui?: { notify(message: string, level?: string): void };
-};
+type QueueContext =
+  | ExtensionCommandContext
+  | {
+      isIdle(): boolean;
+      hasPendingMessages?(): boolean;
+      ui?: { notify(message: string, level?: string): void };
+    };
 
 function hasPendingMessages(ctx: QueueContext): boolean {
   return ctx.hasPendingMessages?.() ?? false;
@@ -102,6 +117,9 @@ export class SessionCoordinator {
   private eventLogger: WorkflowEventLogger | null = null;
   private runner: WorkflowRunner;
   private providerTracker: ProviderTracker;
+  private activeWorkflowRunRef: ActiveWorkflowRunRef | null = null;
+  private activeWorkflowType: string | undefined;
+  private tickerValidationCache: SymbolValidationCache = new Map();
   private sessionId = "unknown";
 
   constructor() {
@@ -118,6 +136,14 @@ export class SessionCoordinator {
     return this.runner;
   }
 
+  getTickerValidationCache(): SymbolValidationCache {
+    return this.tickerValidationCache;
+  }
+
+  clearTickerValidationCache(): void {
+    this.tickerValidationCache.clear();
+  }
+
   /** Initialize session: database, memory, event logger, workflow runner. */
   initSession(sessionId: string): void {
     this.db = initDefaultDatabase();
@@ -279,10 +305,7 @@ export class SessionCoordinator {
     overriddenSlots?: string[],
   ): { entries: MemoryEntry[]; filtered: FilteredMemoryEntry[] } {
     if (!this.memoryManager) return { entries: [], filtered: [] };
-    return this.memoryManager.retrieveDetailed(
-      workflowType ?? routeKind,
-      overriddenSlots,
-    );
+    return this.memoryManager.retrieveDetailed(workflowType ?? routeKind, overriddenSlots);
   }
 
   /** Build system prompt using composable sections. */
@@ -295,28 +318,37 @@ export class SessionCoordinator {
     const builder = new PromptContextBuilder();
 
     const addonTools = getAddonToolDescriptions();
-    const addonDescriptions = addonTools.length > 0
-      ? addonTools.map((t) => `${t.name}: ${t.description}`)
-      : undefined;
+    const addonDescriptions =
+      addonTools.length > 0 ? addonTools.map((t) => `${t.name}: ${t.description}`) : undefined;
 
     const memoryContext = this.memoryManager
       ? this.memoryManager.buildContext(
-        resolvedTurnContext?.workflow ?? workflowType ?? resolvedTurnContext?.routeKind ?? "unclassified",
-      )
+          resolvedTurnContext?.workflow ??
+            workflowType ??
+            resolvedTurnContext?.routeKind ??
+            "unclassified",
+        )
       : undefined;
+    const savedMarketStateContext =
+      this.db &&
+      shouldIncludeSavedMarketStateContext(workflowType, resolvedTurnContext, fallbackContext)
+        ? buildSavedMarketStateContext(this.db)
+        : "";
+    const combinedMemoryContext = [savedMarketStateContext, memoryContext]
+      .filter((part) => part && part.trim().length > 0)
+      .join("\n\n");
 
     builder.populateFromOptions({
       workflowType,
-      memoryContext: memoryContext || undefined,
+      memoryContext: combinedMemoryContext || undefined,
       addonToolDescriptions: addonDescriptions,
       fallbackContext,
       resolvedTurnContext,
     });
 
     const toolDefaults = formatToolDefaultsForPrompt();
-    const defaultsSection = toolDefaults.length > 0
-      ? `\n\n## User Tool Defaults\n${toolDefaults.join("\n")}`
-      : "";
+    const defaultsSection =
+      toolDefaults.length > 0 ? `\n\n## User Tool Defaults\n${toolDefaults.join("\n")}` : "";
 
     return `${basePrompt}\n\n${builder.build()}${defaultsSection}`;
   }
@@ -353,11 +385,7 @@ export class SessionCoordinator {
    * Execute a workflow definition through the WorkflowRunner,
    * sending prompts via Pi with settlement-based sequencing.
    */
-  executeWorkflow(
-    pi: ExtensionAPI,
-    definition: WorkflowDefinition,
-    ctx: QueueContext,
-  ): void {
+  executeWorkflow(pi: ExtensionAPI, definition: WorkflowDefinition, ctx: QueueContext): void {
     this.startWorkflowRun(pi, definition, ctx, "send");
   }
 
@@ -366,6 +394,11 @@ export class SessionCoordinator {
    * transform result. The current prompt becomes the first workflow prompt;
    * only later steps are sent through Pi.
    */
+  /** Workflow type of the in-flight run, for prompt context on workflow turns. */
+  getActiveWorkflowType(): string | undefined {
+    return this.activeWorkflowRunRef?.active ? this.activeWorkflowType : undefined;
+  }
+
   transformWorkflowInput(
     pi: ExtensionAPI,
     definition: WorkflowDefinition,
@@ -385,7 +418,11 @@ export class SessionCoordinator {
     if (definition.steps.length === 0) return;
 
     const runner = this.runner;
-    const runRef = { active: true };
+    if (this.activeWorkflowRunRef) {
+      this.activeWorkflowRunRef.active = false;
+    }
+    runner.cancel();
+    this.activeWorkflowType = definition.workflowType;
 
     const [firstStep] = definition.steps;
 
@@ -400,38 +437,48 @@ export class SessionCoordinator {
     }
 
     // Make the run's ProviderTracker accessible to tools during execution
-    setRunContext({ providerTracker: this.providerTracker });
+    const contextToken = setRunContext({ providerTracker: this.providerTracker });
+    const runRef: ActiveWorkflowRunRef = { active: true, contextToken };
+    this.activeWorkflowRunRef = runRef;
 
     // Start the runner in the background for state tracking
     const stepDefs = toStepDefinitions(definition.steps);
-    void runner.start(definition.workflowType, stepDefs, async (step, stepIndex) => {
-      // First step was already sent above — just wait for settlement
-      if (stepIndex > 0) {
-        const settled = await waitForPromptSettlement(ctx, () => runRef.active);
-        if (!settled || !runRef.active) {
-          throw new Error("run_cancelled");
+    void runner
+      .start(definition.workflowType, stepDefs, async (step, stepIndex) => {
+        // First step was already sent above — just wait for settlement
+        if (stepIndex > 0) {
+          const settled = await waitForPromptSettlement(ctx, () => runRef.active);
+          if (!settled || !runRef.active) {
+            throw new Error("run_cancelled");
+          }
+          pi.sendUserMessage(definition.steps[stepIndex].prompt);
+        } else {
+          // For the first step, just wait for it to settle
+          const settled = await waitForPromptSettlement(ctx, () => runRef.active, {
+            requireActivity: firstPromptMode === "transform",
+          });
+          if (!settled || !runRef.active) {
+            throw new Error("run_cancelled");
+          }
         }
-        pi.sendUserMessage(definition.steps[stepIndex].prompt);
-      } else {
-        // For the first step, just wait for it to settle
-        const settled = await waitForPromptSettlement(
-          ctx,
-          () => runRef.active,
-          { requireActivity: firstPromptMode === "transform" },
-        );
-        if (!settled || !runRef.active) {
-          throw new Error("run_cancelled");
+        return promptStepOutput(stepIndex, step.stepType);
+      })
+      .finally(() => {
+        clearRunContext(runRef.contextToken);
+        if (this.activeWorkflowRunRef === runRef) {
+          this.activeWorkflowRunRef = null;
         }
-      }
-      return promptStepOutput(stepIndex, step.stepType);
-    }).finally(() => {
-      clearRunContext();
-    });
+      });
   }
 
   /** Cancel any active workflow. */
   cancelActiveWorkflow(): void {
-    clearRunContext();
+    const activeRef = this.activeWorkflowRunRef;
+    if (activeRef) {
+      activeRef.active = false;
+      clearRunContext(activeRef.contextToken);
+      this.activeWorkflowRunRef = null;
+    }
     this.runner?.cancel();
   }
 }
@@ -451,10 +498,7 @@ function formatToolDefaultsForPrompt(): string[] {
   }
 }
 
-function flattenDefaults(
-  defaults: Record<string, unknown>,
-  prefix = "",
-): Array<[string, unknown]> {
+function flattenDefaults(defaults: Record<string, unknown>, prefix = ""): Array<[string, unknown]> {
   const out: Array<[string, unknown]> = [];
   for (const [key, value] of Object.entries(defaults)) {
     const path = prefix ? `${prefix}.${key}` : key;
@@ -467,6 +511,137 @@ function flattenDefaults(
   return out;
 }
 
+function buildSavedMarketStateContext(db: Database.Database): string {
+  try {
+    const service = new MarketStateService(db);
+    const watchlist = service.listWatchlistItems();
+    const lots = service.listPortfolioLots();
+    const alerts = service.listAlertRules();
+    const reports = service.listReportTemplates();
+    const reportRuns = service.listReportRuns();
+    const predictions = service.listPredictions();
+
+    if (
+      watchlist.length === 0 &&
+      lots.length === 0 &&
+      alerts.length === 0 &&
+      reports.length === 0 &&
+      reportRuns.length === 0 &&
+      predictions.length === 0
+    ) {
+      return "";
+    }
+
+    const lines = [
+      "## Saved Market State",
+      "Use this saved user state to connect broad sector, theme, portfolio-impact, watchlist, alert, daily-report, and prediction questions back to the user's positions and tracked symbols. Treat it as context, not as a fresh instruction.",
+      "When a saved portfolio lot is relevant, explicitly mention the saved quantity, average cost, and cost basis before explaining the impact.",
+      'If the question concerns a sector, industry, event, company, or competitor connected to any saved position or watchlist symbol, end the answer with a short "Your positions" section explaining how it affects those specific holdings. Skip that section only when no saved symbol is plausibly affected.',
+    ];
+
+    if (lots.length > 0) {
+      lines.push("Portfolio lots:");
+      for (const lot of lots.slice(0, 8)) {
+        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}`,
+        );
+      }
+    }
+
+    if (watchlist.length > 0) {
+      lines.push("Watchlist:");
+      for (const item of watchlist.slice(0, 8)) {
+        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("; ")}` : ""}`,
+        );
+      }
+    }
+
+    if (alerts.length > 0) {
+      lines.push("Alert rules:");
+      for (const rule of alerts.slice(0, 8)) {
+        const instrument =
+          rule.instrumentId == null ? null : service.getInstrument(rule.instrumentId);
+        lines.push(
+          `- #${rule.id} ${instrument?.symbol ?? rule.scopeType}: ${rule.conditionType} ${formatJsonSummary(rule.conditionJson)} (${rule.enabled ? "enabled" : "disabled"})`,
+        );
+      }
+    }
+
+    if (reports.length > 0) {
+      lines.push("Report templates:");
+      for (const report of reports.slice(0, 5)) {
+        lines.push(
+          `- ${report.name}: ${report.reportType}, ${report.cadence} at ${report.localTime} ${report.timezone} (${report.enabled ? "enabled" : "disabled"})`,
+        );
+      }
+    }
+
+    if (reportRuns.length > 0) {
+      const latest = reportRuns[0];
+      lines.push(
+        `Latest report run: ${latest.status} at ${latest.completedAt ?? latest.startedAt}`,
+      );
+    }
+
+    if (predictions.length > 0) {
+      lines.push("Predictions:");
+      for (const prediction of predictions.slice(0, 8)) {
+        const target =
+          prediction.targetPrice == null
+            ? ""
+            : ` target ${formatMoney(prediction.targetPrice, "USD")}`;
+        lines.push(
+          `- #${prediction.id} ${prediction.symbol}: ${prediction.direction} conv ${prediction.conviction}/10 from ${formatMoney(prediction.entryPrice, "USD")}${target}, status ${prediction.status}, expires ${prediction.expiresAt}`,
+        );
+      }
+    }
+
+    return lines.join("\n");
+  } catch {
+    return "";
+  }
+}
+
+function shouldIncludeSavedMarketStateContext(
+  workflowType: string | undefined,
+  resolvedTurnContext: ResolvedTurnContext | undefined,
+  fallbackContext: FallbackContext | undefined,
+): boolean {
+  if (resolvedTurnContext) {
+    return resolvedTurnContext.routeKind !== "pass_through";
+  }
+  // A pending fallback context only exists for routed finance turns (rules-mode
+  // general finance or LLM-router fallback), never for pass-through prompts.
+  return workflowType != null || fallbackContext != null;
+}
+
+function formatMoney(value: number, currency: string): string {
+  const normalized = currency.toUpperCase();
+  if (normalized === "USD") return `$${value.toFixed(2)}`;
+  return `${normalized} ${value.toFixed(2)}`;
+}
+
+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 isPlainObject(value: unknown): value is Record<string, unknown> {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }

package/src/runtime/session-title.ts

@@ -0,0 +1,60 @@
+/**
+ * LLM-summarized session titles.
+ *
+ * Builds a strict short-title prompt from the user's first message (plus an
+ * optional slice of the first assistant reply), delegates to an injected
+ * completion function, and sanitizes the result. Returns null when the model
+ * output is unusable (empty or rambling) so callers can keep the existing
+ * placeholder name. Completion errors propagate to the caller.
+ */
+
+const MAX_TITLE_CHARS = 60;
+const MAX_TITLE_WORDS = 12;
+
+export interface SessionTitleInput {
+  userText: string;
+  assistantText?: string;
+}
+
+export async function generateSessionTitle(
+  input: SessionTitleInput,
+  complete: (prompt: string) => Promise<string>,
+): Promise<string | null> {
+  const lines = [
+    "Write a 4-8 word title for this finance chat session.",
+    "No quotes, no punctuation at the end, no markdown. Return only the title.",
+    "",
+    `User: ${input.userText}`,
+  ];
+  if (input.assistantText !== undefined && input.assistantText.trim().length > 0) {
+    lines.push("", `Assistant: ${input.assistantText}`);
+  }
+  const raw = await complete(lines.join("\n"));
+  return sanitizeTitle(raw);
+}
+
+function sanitizeTitle(raw: string): string | null {
+  // First non-empty line only — discard any model commentary after a newline.
+  let title =
+    raw
+      .split("\n")
+      .map((line) => line.trim())
+      .find((line) => line.length > 0) ?? "";
+  // Strip markdown emphasis/heading/code characters.
+  title = title.replace(/[*_`#]/g, "");
+  // Strip surrounding quotes.
+  title = title.replace(/^["'“”‘’]+/, "").replace(/["'“”‘’]+$/, "");
+  // Strip trailing punctuation.
+  title = title.replace(/[.!?:;,]+$/, "");
+  // Collapse whitespace.
+  title = title.replace(/\s+/g, " ").trim();
+
+  if (title.length === 0) return null;
+  if (title.split(" ").length > MAX_TITLE_WORDS) return null;
+  if (title.length > MAX_TITLE_CHARS) {
+    const cut = title.slice(0, MAX_TITLE_CHARS);
+    const lastSpace = cut.lastIndexOf(" ");
+    title = (lastSpace > 0 ? cut.slice(0, lastSpace) : cut).trim();
+  }
+  return title;
+}

package/src/runtime/tool-defaults-wrapper.ts

@@ -7,9 +7,19 @@ export function wrapWithDefaults<TParams extends TSchema, TDetails>(
 ): AgentTool<TParams, TDetails> {
   return {
     ...tool,
-    execute: async (toolCallId, params, signal, onUpdate) => {
+    execute: async (toolCallId, params, signal, onUpdate, ctx?: unknown) => {
       const merged = mergeDefaults(defaults, params as Record<string, unknown>);
-      return tool.execute(toolCallId, merged as typeof params, signal, onUpdate);
+      const executeWithContext = tool.execute as unknown as (
+        id: string,
+        params: unknown,
+        signal?: AbortSignal,
+        onUpdate?: unknown,
+        ctx?: unknown,
+      ) => ReturnType<typeof tool.execute>;
+      if (ctx === undefined) {
+        return executeWithContext(toolCallId, merged, signal, onUpdate);
+      }
+      return executeWithContext(toolCallId, merged, signal, onUpdate, ctx);
     },
   };
 }
@@ -23,9 +33,7 @@ function mergeDefaults(
   const out: Record<string, unknown> = { ...defaults };
   for (const [key, value] of Object.entries(args)) {
     const base = out[key];
-    out[key] = isPlainObject(base) && isPlainObject(value)
-      ? mergeDefaults(base, value)
-      : value;
+    out[key] = isPlainObject(base) && isPlainObject(value) ? mergeDefaults(base, value) : value;
   }
   return out;
 }

package/src/runtime/validation.ts

@@ -41,10 +41,7 @@ export function checkTimestamps(
 }
 
 /** Check that options expiry dates are in the future. */
-export function checkOptionsExpiries(
-  evidence: EvidenceRecord[],
-  today: string,
-): ValidationEntry[] {
+export function checkOptionsExpiries(evidence: EvidenceRecord[], today: string): ValidationEntry[] {
   const failures: ValidationEntry[] = [];
   for (const record of evidence) {
     if (

package/src/runtime/workflow-events.ts

@@ -55,13 +55,13 @@ export class WorkflowEventLogger {
         "SELECT id, run_id, step_index, event_type, payload_json, timestamp FROM workflow_events WHERE run_id = ? ORDER BY id",
       )
       .all(runId) as Array<{
-        id: number;
-        run_id: string;
-        step_index: number;
-        event_type: string;
-        payload_json: string | null;
-        timestamp: string;
-      }>;
+      id: number;
+      run_id: string;
+      step_index: number;
+      event_type: string;
+      payload_json: string | null;
+      timestamp: string;
+    }>;
 
     return rows.map((r) => ({
       id: r.id,

package/src/runtime/workflow-runner.ts

@@ -1,11 +1,8 @@
-import type { WorkflowRun, StepOutput, WorkflowStep } from "./workflow-types.js";
-import {
-  createWorkflowRun,
-  transitionStepStatus,
-} from "./workflow-types.js";
-import type { WorkflowEventLogger } from "./workflow-events.js";
-import type { ProviderTracker } from "./provider-tracker.js";
 import type { EvidenceRecord } from "./evidence.js";
+import type { ProviderTracker } from "./provider-tracker.js";
+import type { WorkflowEventLogger } from "./workflow-events.js";
+import type { StepOutput, WorkflowRun, WorkflowStep } from "./workflow-types.js";
+import { createWorkflowRun, transitionStepStatus } from "./workflow-types.js";
 
 /** Function that executes a single workflow step. */
 export type StepExecutor = (
@@ -106,10 +103,7 @@ export class WorkflowRunner {
     });
   }
 
-  private async executeSteps(
-    run: WorkflowRun,
-    executor: StepExecutor,
-  ): Promise<void> {
+  private async executeSteps(run: WorkflowRun, executor: StepExecutor): Promise<void> {
     for (let i = 0; i < run.steps.length; i++) {
       // Check if run was cancelled externally
       if (run.status !== "running") return;

package/src/sentiment/adapters/finnhub.ts

@@ -1,7 +1,7 @@
 import { randomUUID } from "node:crypto";
-import type { SentinelRecord } from "../types.js";
 import type { FinnhubArticle } from "../../providers/finnhub.js";
 import { extractEntities } from "../../routing/entity-extractor.js";
+import type { SentinelRecord } from "../types.js";
 
 const MAX_TICKERS = 3;
 
@@ -31,7 +31,12 @@ export class FinnhubAdapter {
         score: 0,
         confidence: 0,
         method: "keyword" as const,
-        tickers: article.related ? article.related.split(",").map((t) => t.trim()).filter(Boolean) : [],
+        tickers: article.related
+          ? article.related
+              .split(",")
+              .map((t) => t.trim())
+              .filter(Boolean)
+          : [],
       },
       metadata: { category: article.category },
     }));

package/src/sentiment/adapters/reddit.ts

@@ -1,7 +1,7 @@
 import { randomUUID } from "node:crypto";
-import type { SentinelRecord, SentimentAdapter } from "../types.js";
-import type { RedditSentimentResult } from "../../types/sentiment.js";
 import type { RedditComment } from "../../providers/reddit.js";
+import type { RedditSentimentResult } from "../../types/sentiment.js";
+import type { SentimentAdapter, SentinelRecord } from "../types.js";
 
 export class RedditAdapter implements SentimentAdapter {
   readonly source = "reddit" as const;

package/src/sentiment/adapters/twitter.ts

@@ -1,6 +1,6 @@
 import { randomUUID } from "node:crypto";
-import type { SentinelRecord, SentimentAdapter } from "../types.js";
 import type { TwitterSentimentResult } from "../../types/sentiment.js";
+import type { SentimentAdapter, SentinelRecord } from "../types.js";
 
 export class TwitterAdapter implements SentimentAdapter {
   readonly source = "twitter" as const;