@pi-stef/finance-api 0.1.1

package/src/ingest/normalizer.ts

@@ -0,0 +1,21 @@
+import type { RawHolding } from "./contract";
+import { canonicalSymbol } from "../store/symbols";
+import type { HoldingRow } from "../store/repo";
+
+export interface NormalizeCtx { providerId: string; accountId: string; asOf?: number }
+
+export function normalizeHolding(ctx: NormalizeCtx, raw: RawHolding): HoldingRow & { lots?: { open_date: number; qty: number; cost_basis: number }[] } {
+  if (raw.quantity < 0) throw new Error(`negative quantity for ${raw.symbol}`);
+  const rounded = Math.round(raw.quantity * 1e6) / 1e6;
+  const lots = raw.lots?.map((l) => ({ open_date: l.openDate, qty: Math.round(l.qty * 1e6) / 1e6, cost_basis: l.costBasis }));
+  return {
+    account_id: ctx.accountId,
+    symbol: canonicalSymbol(raw.symbol, raw.assetClass),
+    quantity: rounded,
+    avg_cost: raw.avgCost ?? null,
+    asset_class: raw.assetClass,
+    subclass: raw.subclass ?? null,
+    as_of: ctx.asOf ?? Date.now(),
+    lots,
+  };
+}

package/src/ingest/registry.ts

@@ -0,0 +1,99 @@
+import type Database from "better-sqlite3";
+import type { ProviderAdapter, Credentials } from "./contract";
+import { normalizeHolding } from "./normalizer";
+import { upsertAccount, upsertHolding, upsertLot, markStale, listHoldings, listAccounts } from "../store/repo";
+
+export type AdapterRegistry = Map<string, ProviderAdapter>;
+
+export interface IngestCreds { [providerId: string]: Credentials }
+
+export interface IngestResult { accounts: number; holdings: number; transactions: number; errors: number }
+
+export async function runIngest(db: Database.Database, registry: AdapterRegistry, creds: IngestCreds, log?: { warn: (m: string, ctx?: unknown) => void }): Promise<IngestResult> {
+  let accounts = 0, holdings = 0, transactions = 0, errors = 0;
+  for (const [providerId, adapter] of registry) {
+    const c = creds[providerId];
+    if (!c) continue;
+    let session;
+    try {
+      session = await adapter.authenticate(c);
+    } catch (e) {
+      // provider-level auth failure: log so the always-on daemon doesn't silently retry forever.
+      // No per-account row exists yet to mark stale; surfaced via the result + log.
+      log?.warn(`ingest auth failed`, { providerId, error: e instanceof Error ? e.message : String(e) });
+      errors++;
+      continue;
+    }
+    // Attach creds to the session so per-call methods (getHoldings/getTransactions/getBalances)
+    // receive them via `session.creds` — the agreed threading pattern for all adapters.
+    session = { ...session, creds: c };
+    try {
+      const accts = await adapter.listAccounts(session);
+      for (const acc of accts) {
+        const id = `${providerId}:${acc.providerAccountId}`;
+        upsertAccount(db, { id, provider_id: providerId, kind: acc.kind, name: acc.name, mask_last4: acc.maskLast4 ?? null, currency: acc.currency });
+        accounts++;
+        try {
+          const asOf = Date.now();
+          const raws = await adapter.getHoldings(session, acc.providerAccountId);
+          
+          // Clear existing holdings for this account before re-inserting
+          // This prevents stale holdings from accumulating when positions are sold
+          // Wrap in a transaction so either all holdings are replaced or none are
+          const replaceHoldings = db.transaction(() => {
+            // Delete existing holdings and lots for this account
+            db.prepare("DELETE FROM holdings WHERE account_id=?").run(id);
+            db.prepare("DELETE FROM lots WHERE holding_key LIKE ?").run(`${id}:%`);
+            
+            for (const raw of raws) {
+              try {
+                const n = normalizeHolding({ providerId, accountId: id, asOf }, raw);
+                const { lots, ...row } = n;
+                upsertHolding(db, row);
+                holdings++;
+                // Persist tax lots if provided
+                if (lots) {
+                  for (const lot of lots) {
+                    upsertLot(db, {
+                      id: `${id}:${n.symbol}:${lot.open_date}`,
+                      holding_key: `${id}:${n.symbol}`,
+                      ...lot,
+                    });
+                  }
+                }
+              } catch (e) {
+                // Log individual holding errors but continue with others
+                log?.warn("holding ingest failed", { accountId: id, symbol: raw.symbol, error: e instanceof Error ? e.message : String(e) });
+              }
+            }
+          });
+          replaceHoldings();
+        } catch (e) {
+          markStale(db, id, Date.now(), e instanceof Error ? e.message : String(e));
+          errors++;
+        }
+        // Exercise getTransactions/getBalances to validate the adapter contract
+        // (persistence of transactions/balances deferred to later milestones)
+        try {
+          const txns = await adapter.getTransactions(session, acc.providerAccountId);
+          transactions += txns.length;
+        } catch {
+          // Transaction fetch failures are non-fatal for ingest
+        }
+        try {
+          await adapter.getBalances(session, acc.providerAccountId);
+        } catch {
+          // Balance fetch failures are non-fatal for ingest
+        }
+      }
+    } catch (e) {
+      // listAccounts-level failure: account rows may not exist yet to mark stale; log + count.
+      log?.warn(`ingest listAccounts failed`, { providerId, error: e instanceof Error ? e.message : String(e) });
+      errors++;
+    }
+  }
+  return { accounts, holdings, transactions, errors };
+}
+
+// re-exports for convenience
+export { listHoldings, listAccounts };

package/src/ingest/secrets.ts

@@ -0,0 +1,28 @@
+import { readFileSync, writeFileSync, chmodSync } from "node:fs";
+import type { IngestCreds } from "./registry";
+
+/**
+ * Loads secrets from the secrets file. Returns empty object if file doesn't exist.
+ * When creating the file, sets permissions to 0600 for security.
+ */
+export function loadSecrets(secretsPath: string): IngestCreds {
+  try {
+    const raw = readFileSync(secretsPath, "utf8");
+    return JSON.parse(raw) as IngestCreds;
+  } catch (e) {
+    if (e instanceof Error && "code" in e && (e as { code: string }).code === "ENOENT") {
+      return {};
+    }
+    throw e;
+  }
+}
+
+/**
+ * Saves secrets to the file with 0600 permissions.
+ * If file exists with broader permissions, tightens to 0600.
+ */
+export function saveSecrets(secretsPath: string, creds: IngestCreds): void {
+  writeFileSync(secretsPath, JSON.stringify(creds, null, 2), { encoding: "utf8", mode: 0o600 });
+  // Ensure permissions are 0600 even if file already existed with broader perms
+  try { chmodSync(secretsPath, 0o600); } catch { /* best effort */ }
+}

package/src/market/prices.ts

@@ -0,0 +1,30 @@
+import { CRYPTO_PREFIX } from "../store/symbols";
+
+export interface PriceDeps { fetcher?: typeof fetch; feed?: "stooq" | "yfinance" }
+
+export async function fetchClose(symbol: string, deps: PriceDeps = {}): Promise<number> {
+  const fetcher = deps.fetcher ?? ((u: string, i?: RequestInit) => fetch(u, i));
+
+  if (symbol.startsWith(CRYPTO_PREFIX)) {
+    const coin = symbol.slice(CRYPTO_PREFIX.length);
+    const res = await fetcher(`https://api.coinbase.com/api/v3/brokerage/market/products/${coin}-USD/spot`, {});
+    if (!res.ok) throw new Error(`coinbase price ${symbol} ${res.status}`);
+    const body = (await res.json()) as { price: string };
+    return Number(body.price);
+  }
+
+  const feed = deps.feed ?? "stooq";
+  if (feed === "stooq") {
+    // Stooq requires .us suffix for US equities
+    const stooqSymbol = symbol.includes(".") ? symbol.toLowerCase() : `${symbol.toLowerCase()}.us`;
+    const res = await fetcher(`https://stooq.com/q/l/?s=${stooqSymbol}&f=sd2t2ohlcv&h&e=csv`, {});
+    if (!res.ok) throw new Error(`stooq ${symbol} ${res.status}`);
+    const text = await res.text();
+    const row = text.trim().split(/\r?\n/)[1]?.split(",") ?? [];
+    // stooq CSV layout: Symbol,Date,Time,Open,High,Low,Close,Volume
+    const close = Number(row[6]);
+    if (!Number.isFinite(close)) throw new Error(`stooq ${symbol}: no close`);
+    return close;
+  }
+  throw new Error(`yfinance feed not implemented in v1 (symbol ${symbol})`);
+}

package/src/market/session.ts

@@ -0,0 +1,37 @@
+export type Session = "pre" | "intraday" | "post" | "closed";
+
+// NYSE holiday closures, keyed "month-day". v1 hardcodes 2026 only.
+// KNOWN LIMITATION: the daemon is always-on into 2027+, so this list MUST be
+// refreshed annually or session classification will silently drift (treating
+// future holidays as trading days). Add 2027+ entries before Jan 1 each year.
+// TODO(future): fetch from a holiday-data source keyed by year. Tracked in Open Items.
+const HOLIDAYS_2026 = new Set([
+  "1-1", "1-19", "2-16", "4-3", "5-25", "6-19", "7-3", "9-7", "11-26", "12-25",
+]);
+
+function etParts(d: Date): { dow: number; month: number; day: number; minutes: number; year: number } {
+  // Convert to America/New_York via Intl (handles DST)
+  const parts = new Intl.DateTimeFormat("en-US", {
+    timeZone: "America/New_York", weekday: "short", month: "numeric", day: "numeric", year: "numeric",
+    hour: "numeric", minute: "numeric", hour12: false,
+  }).formatToParts(d);
+  const get = (t: string) => Number(parts.find((p) => p.type === t)?.value ?? "0");
+  const wd = parts.find((p) => p.type === "weekday")?.value ?? "";
+  const dow = ["Sun","Mon","Tue","Wed","Thu","Fri","Sat"].indexOf(wd);
+  return { dow, month: get("month"), day: get("day"), minutes: get("hour") * 60 + get("minute"), year: get("year") };
+}
+
+export function classifySession(d: Date): Session {
+  const { dow, month, day, minutes, year } = etParts(d);
+  if (dow === 0 || dow === 6) return "closed";
+  // Year-guard: if we're past the last year with known holidays, throw loudly
+  // so the annual-refresh regression can't pass silently.
+  // Use ET year (not UTC) for consistency with the holiday check.
+  // Callers (routes, daemon) wrap in try/catch to handle gracefully.
+  if (year > 2026) throw new Error(`session classifier has no holidays for year ${year} — refresh HOLIDAYS list annually`);
+  if (HOLIDAYS_2026.has(`${month}-${day}`)) return "closed";
+  if (minutes >= 7 * 60 && minutes < 9 * 60 + 30) return "pre";
+  if (minutes >= 9 * 60 + 30 && minutes < 16 * 60) return "intraday";
+  if (minutes >= 16 * 60 && minutes < 20 * 60) return "post";
+  return "closed";
+}

package/src/quant/dca.ts

@@ -0,0 +1,10 @@
+export interface DcaConfig { amount: number; cadence: "weekly" | "biweekly" | "monthly"; lastBuyAt?: number }
+export interface DcaResult { due: boolean; amount: number; nextDueAt: number }
+
+const MS_DAY = 86_400_000;
+export function nextDcaBuy(cfg: DcaConfig, now: number): DcaResult {
+  const interval = cfg.cadence === "weekly" ? 7 * MS_DAY : cfg.cadence === "biweekly" ? 14 * MS_DAY : 30 * MS_DAY;
+  const last = cfg.lastBuyAt ?? now - interval; // if never bought, treat as due
+  const nextDueAt = last + interval;
+  return { due: now >= nextDueAt, amount: cfg.amount, nextDueAt };
+}

package/src/quant/drift.ts

@@ -0,0 +1,18 @@
+export interface HoldingValued { symbol: string; assetClass: string; quantity: number; price: number }
+
+export interface DriftRow { class: string; currentPct: number; targetPct: number; deltaPct: number; value: number }
+
+export function computeDrift(holdings: HoldingValued[], target: { targetAllocation: Record<string, number> }): DriftRow[] {
+  const total = holdings.reduce((a, h) => a + h.quantity * h.price, 0);
+  if (total === 0) return [];
+  const byClass = new Map<string, number>();
+  for (const h of holdings) byClass.set(h.assetClass, (byClass.get(h.assetClass) ?? 0) + h.quantity * h.price);
+
+  const classes = new Set([...byClass.keys(), ...Object.keys(target.targetAllocation)]);
+  return [...classes].map((c) => {
+    const value = byClass.get(c) ?? 0;
+    const currentPct = value / total;
+    const targetPct = target.targetAllocation[c] ?? 0;
+    return { class: c, currentPct, targetPct, deltaPct: currentPct - targetPct, value };
+  });
+}

package/src/quant/limits.ts

@@ -0,0 +1,10 @@
+export interface BandInput { currentPrice: number; allowedSlippagePct: number; lowerBandPct: number }
+export interface Band { buyUpTo: number; addAtLower: number }
+
+// Target prices are LIMIT/ACCEPTANCE bands derived from the user's rules — NOT forecasts.
+export function acceptanceBand(input: BandInput): Band {
+  return {
+    buyUpTo: input.currentPrice * (1 + input.allowedSlippagePct / 100),
+    addAtLower: input.currentPrice * (1 - input.lowerBandPct / 100),
+  };
+}

package/src/quant/rebalance.ts

@@ -0,0 +1,46 @@
+import type { HoldingValued } from "./drift";
+
+export interface RebalanceInput { cashAvailable: number; minTradeDollars: number; lotPolicy?: "fifo" | "ltf" }
+export interface RebalanceOrder { symbol: string; side: "buy" | "sell"; dollars: number; estQty: number }
+
+export function computeRebalance(
+  holdings: HoldingValued[],
+  target: { targetAllocation: Record<string, number> },
+  input: RebalanceInput,
+): RebalanceOrder[] {
+  const total = holdings.reduce((a, h) => a + h.quantity * h.price, 0) + input.cashAvailable;
+  const orders: RebalanceOrder[] = [];
+
+  // per-class target dollars
+  const targetByClass = new Map<string, number>();
+  for (const [c, pct] of Object.entries(target.targetAllocation)) targetByClass.set(c, pct * total);
+
+  // current by class
+  const currentByClass = new Map<string, number>();
+  for (const h of holdings) currentByClass.set(h.assetClass, (currentByClass.get(h.assetClass) ?? 0) + h.quantity * h.price);
+  currentByClass.set("cash", input.cashAvailable);
+
+  for (const [cls, targetDollars] of targetByClass) {
+    const current = currentByClass.get(cls) ?? 0;
+    const diff = targetDollars - current;
+    if (Math.abs(diff) < input.minTradeDollars) continue;
+    if (cls === "cash") continue; // cash is the residual; not a tradable order
+    // distribute the class diff proportionally across that class's holdings
+    const classHoldings = holdings.filter((h) => h.assetClass === cls);
+    const classValue = classHoldings.reduce((a, h) => a + h.quantity * h.price, 0) || 1;
+    
+    if (classHoldings.length === 0 && diff > input.minTradeDollars) {
+      // No holdings in this class yet — emit a placeholder buy order
+      // The agent will need to recommend a specific instrument
+      orders.push({ symbol: `[${cls}]`, side: "buy", dollars: diff, estQty: 0 });
+    } else {
+      for (const h of classHoldings) {
+        const share = (h.quantity * h.price) / classValue;
+        const d = diff * share;
+        if (Math.abs(d) < input.minTradeDollars) continue;
+        orders.push({ symbol: h.symbol, side: d > 0 ? "buy" : "sell", dollars: Math.abs(d), estQty: Math.abs(d) / h.price });
+      }
+    }
+  }
+  return orders;
+}

package/src/quant/risk.ts

@@ -0,0 +1,23 @@
+import type { HoldingValued } from "./drift";
+
+export interface RiskFlag { kind: "concentration" | "cashDrag"; symbol?: string; value: number; limit: number }
+
+export function checkRisk(
+  holdings: HoldingValued[],
+  goal: { riskLimits: Record<string, number>; cashAvailable?: number },
+): RiskFlag[] {
+  const flags: RiskFlag[] = [];
+  const total = holdings.reduce((a, h) => a + h.quantity * h.price, 0) + (goal.cashAvailable ?? 0);
+  if (total === 0) return flags;
+  const maxPos = goal.riskLimits.maxSinglePosition;
+  if (maxPos) {
+    for (const h of holdings) {
+      const pct = (h.quantity * h.price) / total;
+      if (pct > maxPos) flags.push({ kind: "concentration", symbol: h.symbol, value: pct, limit: maxPos });
+    }
+  }
+  const cashPct = (goal.cashAvailable ?? 0) / total;
+  const maxCash = goal.riskLimits.maxCashDrag;
+  if (maxCash && cashPct > maxCash) flags.push({ kind: "cashDrag", value: cashPct, limit: maxCash });
+  return flags;
+}

package/src/quant/suggestions.ts

@@ -0,0 +1,27 @@
+import type { DriftRow } from "./drift";
+import type { RebalanceOrder } from "./rebalance";
+import type { RiskFlag } from "./risk";
+import type { DcaResult } from "./dca";
+import type { Session } from "../market/session";
+
+export interface SuggestionRecord {
+  id: string; createdAt: number; marketSession: Session;
+  kind: "drift" | "rebalance" | "risk" | "cashDrag" | "dca"; payload: unknown;
+}
+
+export interface SuggestionInput {
+  drift: DriftRow[]; rebalance: RebalanceOrder[]; risk: RiskFlag[]; dca: DcaResult[];
+  session: Session; now: number;
+}
+
+export function buildSuggestions(input: SuggestionInput): SuggestionRecord[] {
+  const { drift, rebalance, risk, dca, session, now } = input;
+  const recs: SuggestionRecord[] = [];
+  let n = 0;
+  const mk = (kind: SuggestionRecord["kind"], payload: unknown): SuggestionRecord => ({ id: `s-${now}-${n++}`, createdAt: now, marketSession: session, kind, payload });
+  for (const d of drift) if (Math.abs(d.deltaPct) > 0.02) recs.push(mk("drift", d));
+  for (const r of rebalance) recs.push(mk("rebalance", r));
+  for (const r of risk) recs.push(mk(r.kind === "cashDrag" ? "cashDrag" : "risk", r));
+  for (const d of dca) if (d.due) recs.push(mk("dca", d));
+  return recs;
+}

package/src/quant/validate.ts

@@ -0,0 +1,11 @@
+export interface GoalInput { targetAllocation: Record<string, number>; riskLimits: Record<string, number> }
+
+export function validateGoal(goal: GoalInput): string[] {
+  const errs: string[] = [];
+  const entries = Object.entries(goal.targetAllocation);
+  for (const [, v] of entries) if (v < 0) errs.push("targetAllocation has a negative value (must be >= 0)");
+  const sum = entries.reduce((a, [, v]) => a + v, 0);
+  // Tolerance band: ±0.01 (1 percentage point). Explicit and tested — see validate.test.ts.
+  if (Math.abs(sum - 1) > 0.01) errs.push(`targetAllocation must sum to ~1.0 within ±1pp tolerance (got ${sum.toFixed(4)})`);
+  return errs;
+}

package/src/scheduler/daemon.ts

@@ -0,0 +1,83 @@
+import type Database from "better-sqlite3";
+import type { AdapterRegistry, IngestCreds } from "../ingest/registry";
+import { runTick } from "./tick";
+import { classifySession } from "../market/session";
+import type { Logger } from "../server/logger";
+
+export interface DaemonDeps {
+  db: Database.Database;
+  registry: AdapterRegistry;
+  creds: IngestCreds;
+  fetcher?: typeof fetch;
+  log?: Logger;
+  dataFeed?: "stooq" | "yfinance";
+}
+
+export interface DaemonHandle {
+  stop: () => void;
+}
+
+const MS_MINUTE = 60_000;
+const MS_HOUR = 3_600_000;
+
+export function getNextTickDelay(session: string): number {
+  switch (session) {
+    case "pre":
+      return 30 * MS_MINUTE; // Light: every 30 min
+    case "intraday":
+      return 30 * MS_MINUTE; // Active: every 30 min
+    case "post":
+      return MS_HOUR; // Post-market: hourly
+    case "closed":
+      return 4 * MS_HOUR; // Closed: every 4 hours (crypto only)
+    default:
+      return MS_HOUR;
+  }
+}
+
+export function startDaemon(deps: DaemonDeps): DaemonHandle {
+  const { log } = deps;
+  let running = true;
+  let timeoutId: ReturnType<typeof setTimeout> | null = null;
+
+  async function tick() {
+    if (!running) return;
+
+    try {
+      const result = await runTick({ ...deps, dataFeed: deps.dataFeed });
+      log?.info("daemon tick complete", result);
+    } catch (err) {
+      log?.error("daemon tick failed", { error: err instanceof Error ? err.message : String(err) });
+    }
+
+    if (!running) return;
+
+    // Schedule next tick based on current session
+    try {
+      const session = classifySession(new Date());
+      const delay = getNextTickDelay(session);
+      log?.info("next tick scheduled", { session, delayMs: delay });
+      timeoutId = setTimeout(tick, delay);
+    } catch (err) {
+      // If session classification fails (e.g., unsupported year), fall back to hourly
+      log?.error("session classification failed, falling back to hourly", { error: err instanceof Error ? err.message : String(err) });
+      timeoutId = setTimeout(tick, MS_HOUR);
+    }
+  }
+
+  // Start first tick immediately
+  tick();
+
+  log?.info("daemon started");
+
+  return {
+    stop: () => {
+      running = false;
+      if (timeoutId) {
+        clearTimeout(timeoutId);
+        timeoutId = null;
+      }
+      log?.info("daemon stopped");
+    },
+  };
+}

package/src/scheduler/tick.ts

@@ -0,0 +1,171 @@
+import type Database from "better-sqlite3";
+import type { AdapterRegistry, IngestCreds } from "../ingest/registry";
+import { runIngest } from "../ingest/registry";
+import { classifySession, type Session } from "../market/session";
+import { fetchClose } from "../market/prices";
+import { listHoldings, listAccounts, insertSuggestion, listGoals } from "../store/repo";
+import { computeDrift, type HoldingValued } from "../quant/drift";
+import { computeRebalance } from "../quant/rebalance";
+import { checkRisk } from "../quant/risk";
+// DCA not used until config is stored in schema
+import { buildSuggestions } from "../quant/suggestions";
+import { isCrypto } from "../store/symbols";
+import type { Logger } from "../server/logger";
+
+export interface TickDeps {
+  db: Database.Database;
+  registry: AdapterRegistry;
+  creds: IngestCreds;
+  fetcher?: typeof fetch;
+  log?: Logger;
+  now?: number;
+  dataFeed?: "stooq" | "yfinance";
+}
+
+export interface TickResult {
+  session: Session;
+  accountsIngested: number;
+  holdingsIngested: number;
+  pricesUpdated: number;
+  suggestionsCreated: number;
+  errors: number;
+}
+
+export async function runTick(deps: TickDeps): Promise<TickResult> {
+  const { db, registry, creds, log } = deps;
+  const now = deps.now ?? Date.now();
+  const fetcher = deps.fetcher ?? fetch;
+
+  // Classify current market session (fall back to "closed" if year-guard throws)
+  let session: Session;
+  try {
+    session = classifySession(new Date(now));
+  } catch (err) {
+    log?.warn("session classification failed, falling back to closed", { error: err instanceof Error ? err.message : String(err) });
+    session = "closed";
+  }
+  log?.info("tick start", { session, now });
+
+  // Ingest data from providers
+  const ingestResult = await runIngest(db, registry, creds, log);
+  log?.info("ingest complete", ingestResult);
+
+  // Refresh prices for held symbols
+  let pricesUpdated = 0;
+  const accounts = listAccounts(db);
+  const symbols = new Set<string>();
+  for (const a of accounts) {
+    const holdings = listHoldings(db, a.id);
+    for (const h of holdings) {
+      symbols.add(h.symbol);
+    }
+  }
+
+  // On closed sessions, only refresh crypto prices
+  const symbolsToRefresh = session === "closed"
+    ? [...symbols].filter(isCrypto)
+    : [...symbols];
+
+  for (const symbol of symbolsToRefresh) {
+    try {
+      const close = await fetchClose(symbol, { fetcher, feed: deps.dataFeed });
+      // Store price
+      db.prepare("INSERT OR REPLACE INTO prices (symbol, date, close, source) VALUES (?, ?, ?, ?)")
+        .run(symbol, Math.floor(now / 86400000), close, "tick");
+      pricesUpdated++;
+    } catch (err) {
+      log?.warn("price fetch failed", { symbol, error: err instanceof Error ? err.message : String(err) });
+    }
+  }
+
+  // Run quant engine
+  const holdingsValued: HoldingValued[] = [];
+  for (const a of accounts) {
+    const holdings = listHoldings(db, a.id);
+    for (const h of holdings) {
+      const priceRow = db.prepare("SELECT close FROM prices WHERE symbol=? ORDER BY date DESC LIMIT 1").get(h.symbol) as { close: number } | undefined;
+      const price = priceRow?.close ?? h.avg_cost ?? 0;
+      holdingsValued.push({
+        symbol: h.symbol,
+        assetClass: h.asset_class,
+        quantity: h.quantity,
+        price,
+      });
+    }
+  }
+
+  // Get goals for target allocation
+  const goals = listGoals(db);
+  const targetAllocation = goals.length > 0 ? JSON.parse(goals[0].target_allocation) : {};
+  const riskLimits = goals.length > 0 ? JSON.parse(goals[0].risk_limits) : {};
+
+  // Compute drift
+  const drift = computeDrift(holdingsValued, { targetAllocation });
+
+  // Compute rebalance
+  const rebalance = computeRebalance(holdingsValued, { targetAllocation }, {
+    cashAvailable: 0, // TODO: get from balances
+    minTradeDollars: 10,
+  });
+
+  // Check risk
+  const risk = checkRisk(holdingsValued, { riskLimits, cashAvailable: 0 });
+
+  // Check DCA - only if goals have DCA config (skip hardcoded defaults)
+  // For now, skip DCA suggestions until DCA config is stored in the schema
+  const dcaResults: { due: boolean; amount: number; nextDueAt: number }[] = [];
+
+  // Build suggestions
+  const suggestions = buildSuggestions({
+    drift,
+    rebalance,
+    risk,
+    dca: dcaResults,
+    session,
+    now,
+  });
+
+  // Persist suggestions
+  let suggestionsCreated = 0;
+  for (const s of suggestions) {
+    insertSuggestion(db, {
+      id: s.id,
+      created_at: s.createdAt,
+      market_session: s.marketSession,
+      kind: s.kind,
+      payload: JSON.stringify(s.payload),
+      status: "pending",
+    });
+    suggestionsCreated++;
+  }
+
+  // Persist market session snapshot
+  const sessionDate = new Date(now).toISOString().split("T")[0];
+  db.prepare("INSERT OR REPLACE INTO market_sessions (date, session, snapshot) VALUES (?, ?, ?)")
+    .run(sessionDate, session, JSON.stringify({
+      timestamp: now,
+      accountsIngested: ingestResult.accounts,
+      holdingsIngested: ingestResult.holdings,
+      pricesUpdated,
+      suggestionsCreated,
+      errors: ingestResult.errors,
+    }));
+
+  log?.info("tick complete", {
+    session,
+    accountsIngested: ingestResult.accounts,
+    holdingsIngested: ingestResult.holdings,
+    pricesUpdated,
+    suggestionsCreated,
+    errors: ingestResult.errors,
+  });
+
+  return {
+    session,
+    accountsIngested: ingestResult.accounts,
+    holdingsIngested: ingestResult.holdings,
+    pricesUpdated,
+    suggestionsCreated,
+    errors: ingestResult.errors,
+  };
+}