@@ -0,0 +1,86 @@
+import * as path from "node:path";
+import * as fs from "node:fs";
+import { app, BrowserWindow } from "electron";
+import * as settingsStore from "./settings-store";
+import type * as localServers from "./local-server-manager";
+import type { EnergyMonitorSettings } from "./energy-types";
+import type { ProviderId } from "./providers/types";
+
+export const PROVIDER_SECRET_KEYS: Record<Exclude<ProviderId, "ollama" | "llamacpp" | "custom" | "mlx" | "rocm" | "vllm">, string> = {
+    openai: "openai_api_key",
+    anthropic: "anthropic_api_key",
+    gemini: "gemini_api_key",
+};
+
+export function customProviderSecretKey(customProviderId: string): string {
+    return `custom_${customProviderId}_api_key`;
+}
+
+export const activeChatRequests = new Map<string, AbortController>();
+export const activeBenchmarkRequests = new Map<string, AbortController>();
+
+let isBusy = false;
+export function getIsBusy(): boolean {
+    return isBusy;
+}
+export function setIsBusy(value: boolean): void {
+    isBusy = value;
+}
+
+let forceClose = false;
+export function getForceClose(): boolean {
+    return forceClose;
+}
+export function setForceClose(value: boolean): void {
+    forceClose = value;
+}
+
+// Every ipcMain.handle callback below is only reachable from this app's own
+// preload-bridged renderer (contextIsolation is on, nodeIntegration is off),
+// so this isn't a hostile-input boundary in the way a public API would be.
+// Still, a malformed/undefined argument reaching a store function as `id`
+// would throw a raw TypeError several layers deep — validating up front
+// turns that into one clear, loggable error instead.
+export function requireString(value: unknown, label: string): string {
+    if (typeof value !== "string" || !value) {
+        throw new Error(`Invalid ${label}: expected a non-empty string`);
+    }
+    return value;
+}
+
+export function getLlamaCppModelsDir(): string {
+    const configured = settingsStore.getSettings().llamaCppModelsDir;
+    const dir = configured || path.join(app.getPath("userData"), "llamacpp-models");
+    fs.mkdirSync(dir, { recursive: true });
+    return dir;
+}
+
+export function getLocalRuntimeConfig(): localServers.LocalBackendConfig {
+    const settings = settingsStore.getSettings();
+    return { mlxPythonPath: settings.mlxPythonPath, rocmServerPath: settings.rocmServerPath, vllmCommand: settings.vllmCommand };
+}
+
+export function getEnergyMonitorSettings(): EnergyMonitorSettings {
+    const settings = settingsStore.getSettings();
+    return {
+        enabled: settings.energyMonitoringEnabled ?? false,
+        electricityPricePerKwh: Math.max(0, settings.electricityPricePerKwh ?? 0.2),
+        currency: settings.energyCurrency?.trim() || "USD",
+        timeOfUseTariffs: settings.timeOfUseTariffs ?? [],
+        manualCpuWatts: settings.manualCpuWatts,
+        manualGpuWatts: settings.manualGpuWatts,
+        manualSystemIdleWatts: settings.manualSystemIdleWatts,
+        includeIdleSystemConsumption: settings.includeIdleSystemConsumption ?? true,
+        retentionDays: Math.max(1, settings.energyUsageRetentionDays ?? 365),
+        sampleIntervalSeconds: Math.max(1, Math.min(5, settings.energySampleIntervalSeconds ?? 2)),
+        gridIntensityGCo2PerKwh: settings.gridIntensityGCo2PerKwh,
+    };
+}
+
+let mainWindow: BrowserWindow | null = null;
+export function getMainWindow(): BrowserWindow | null {
+    return mainWindow;
+}
+export function setMainWindow(win: BrowserWindow | null): void {
+    mainWindow = win;
+}
@@ -0,0 +1,78 @@
+import * as path from "node:path";
+import * as fs from "node:fs";
+import { app, dialog } from "electron";
+import * as systemSpecs from "./system-specs";
+import * as localServers from "./local-server-manager";
+import * as powerMonitor from "./power-monitor";
+import { getLogTail } from "./logger";
+import type * as benchmarkRunner from "./benchmark-runner";
+import { getMainWindow, getEnergyMonitorSettings, getLocalRuntimeConfig } from "./app-state";
+
+function benchmarkResultPath(): string {
+    const dir = path.join(app.getPath("userData"), "benchmarks");
+    fs.mkdirSync(dir, { recursive: true });
+    return path.join(dir, "latest.json");
+}
+
+function benchmarkHistoryPath(): string { return path.join(path.dirname(benchmarkResultPath()), "history.json"); }
+
+export function saveBenchmarkResult(result: benchmarkRunner.BenchmarkResult): void {
+    const destination = benchmarkResultPath();
+    const temporary = `${destination}.tmp`;
+    fs.writeFileSync(temporary, JSON.stringify(result, null, 2));
+    fs.renameSync(temporary, destination);
+    let history: benchmarkRunner.BenchmarkResult[] = [];
+    try { history = JSON.parse(fs.readFileSync(benchmarkHistoryPath(), "utf-8")); } catch { /* first benchmark */ }
+    history.push(result);
+    fs.writeFileSync(benchmarkHistoryPath(), JSON.stringify(history.slice(-100), null, 2));
+}
+
+export function getBenchmarkObservations(): systemSpecs.BenchmarkObservation[] {
+    try {
+        const history = JSON.parse(fs.readFileSync(benchmarkHistoryPath(), "utf-8")) as benchmarkRunner.BenchmarkResult[];
+        return history.flatMap((result) => result.primary ? [{ model: result.model, tokensPerSecond: result.primary.tokensPerSecond, promptTokensPerSecond: result.primary.promptTokensPerSecond, timeToFirstTokenMs: result.primary.timeToFirstTokenMs }] : []);
+    } catch {
+        const latest = getLastBenchmarkResult();
+        return latest?.primary ? [{ model: latest.model, tokensPerSecond: latest.primary.tokensPerSecond, promptTokensPerSecond: latest.primary.promptTokensPerSecond, timeToFirstTokenMs: latest.primary.timeToFirstTokenMs }] : [];
+    }
+}
+
+export function getLastBenchmarkResult(): benchmarkRunner.BenchmarkResult | null {
+    try {
+        return JSON.parse(fs.readFileSync(benchmarkResultPath(), "utf-8")) as benchmarkRunner.BenchmarkResult;
+    } catch {
+        return null;
+    }
+}
+
+export async function exportDiagnosticReport(result: benchmarkRunner.BenchmarkResult): Promise<{ success: boolean }> {
+    const specs = await systemSpecs.getSpecs();
+    const runtimes = await localServers.getRuntimeStatuses(getLocalRuntimeConfig());
+    const report = {
+        schemaVersion: 1,
+        exportedAt: new Date().toISOString(),
+        application: {
+            version: app.getVersion(),
+            electron: process.versions.electron,
+            chrome: process.versions.chrome,
+            node: process.versions.node,
+            platform: process.platform,
+            arch: process.arch,
+        },
+        system: specs,
+        runtimeHealth: runtimes,
+        benchmark: result,
+        energyUsage: powerMonitor.getDashboard(getEnergyMonitorSettings()),
+        recentLogs: getLogTail(),
+    };
+    const date = new Date().toISOString().replace(/[:.]/g, "-");
+    const options = {
+        defaultPath: `modelforge-diagnostic-${date}.json`,
+        filters: [{ name: "JSON", extensions: ["json"] }],
+    };
+    const mainWindow = getMainWindow();
+    const dialogResult = mainWindow ? await dialog.showSaveDialog(mainWindow, options) : await dialog.showSaveDialog(options);
+    if (dialogResult.canceled || !dialogResult.filePath) return { success: false };
+    fs.writeFileSync(dialogResult.filePath, JSON.stringify(report, null, 2));
+    return { success: true };
+}
@@ -0,0 +1,138 @@
+import * as path from "node:path";
+import * as ollama from "./ollama-manager";
+import * as settingsStore from "./settings-store";
+import * as secretsStore from "./secrets-store";
+import * as llamacpp from "./llamacpp-manager";
+import * as localServers from "./local-server-manager";
+import * as powerMonitor from "./power-monitor";
+import * as openaiProvider from "./providers/openai";
+import * as anthropicProvider from "./providers/anthropic";
+import * as geminiProvider from "./providers/gemini";
+import { createOpenAiCompatibleChat } from "./providers/openai-compatible";
+import type { ChatMessage, ChatChunk, ChatOptions, ProviderId, ToolDefinition } from "./providers/types";
+import { PROVIDER_SECRET_KEYS, customProviderSecretKey, getLlamaCppModelsDir, getEnergyMonitorSettings } from "./app-state";
+
+// Shared by chat:send (renderer-driven, streams tokens back over IPC) and
+// the scheduled-task runner (background, wants the full text once done) —
+// same provider dispatch and error handling either way.
+export async function dispatchChat(
+    provider: ProviderId,
+    model: string,
+    messages: ChatMessage[],
+    options: ChatOptions | undefined,
+    onToken: (chunk: ChatChunk) => void,
+    signal?: AbortSignal,
+    tools?: ToolDefinition[]
+): Promise<void> {
+    const currentSettings = settingsStore.getSettings();
+    const customLocal = provider === "custom"
+        && currentSettings.customProviders?.find((item) => model.startsWith(`${item.id}::`))?.localGpuBackend;
+    const localProvider = ["ollama", "llamacpp", "mlx", "rocm", "vllm"].includes(provider) || !!customLocal;
+    const energySettings = getEnergyMonitorSettings();
+    energySettings.enabled = energySettings.enabled && localProvider;
+    const backend = provider === "llamacpp"
+        ? currentSettings.llamaCppGpuBackend ?? "auto"
+        : provider === "rocm" ? "rocm" : provider;
+    const initialPromptTokens = Math.max(1, Math.ceil(messages.reduce((sum, message) => sum + message.content.length, 0) / 4));
+    const activity = powerMonitor.beginRequest(provider, model, backend, energySettings, initialPromptTokens);
+    const downstreamToken = onToken;
+    onToken = (chunk) => {
+        activity.onChunk(chunk);
+        downstreamToken(chunk);
+    };
+    try {
+    if (provider === "ollama") {
+        await ollama.chat(model, messages, options, onToken, signal, tools);
+    } else if (provider === "llamacpp") {
+        // Same containment rule as the rocm branch below: the model ref is a
+        // renderer-supplied relative path (may include subfolders), and
+        // path.join would happily walk ".." segments out of the models dir.
+        const root = path.resolve(getLlamaCppModelsDir());
+        const modelPath = path.resolve(root, model);
+        if (modelPath === root || !modelPath.startsWith(root + path.sep)) {
+            throw new Error(`Model file "${model}" is outside the models directory.`);
+        }
+        await llamacpp.chat(modelPath, messages, options, onToken, signal, tools);
+    } else if (provider === "mlx" || provider === "rocm" || provider === "vllm") {
+        const settings = settingsStore.getSettings();
+        // ROCm serves the same GGUF files as the llama.cpp backend, so the
+        // model ref is a filename that must stay inside the models dir; MLX
+        // models are HF repo ids the server resolves itself.
+        let serverModel = model;
+        if (provider === "rocm") {
+            const root = path.resolve(getLlamaCppModelsDir());
+            const resolved = path.resolve(root, model);
+            // Was `resolved !== root && !startsWith(...)` (AND) — that only
+            // threw when BOTH conditions held, so a ref resolving to exactly
+            // the models dir itself (e.g. "rocm:.") satisfied neither and
+            // slipped through, handing the whole directory to llama-server
+            // -m as if it were a single model file.
+            if (resolved === root || !resolved.startsWith(root + path.sep)) {
+                throw new Error(`Model file "${model}" is outside the models directory.`);
+            }
+            serverModel = resolved;
+        }
+        const lease = await localServers.acquireServer(provider, serverModel, {
+            mlxPythonPath: settings.mlxPythonPath,
+            rocmServerPath: settings.rocmServerPath,
+            vllmCommand: settings.vllmCommand,
+        });
+        try {
+            // Managed runtimes are local and unauthenticated; the key is a
+            // compatibility placeholder for their OpenAI-shaped APIs.
+            const providerLabel = provider === "mlx" ? "MLX" : provider === "vllm" ? "vLLM" : "ROCm llama-server";
+            await createOpenAiCompatibleChat(`${lease.baseUrl}/v1`, providerLabel)(
+                "local",
+                model,
+                messages,
+                options,
+                onToken,
+                signal,
+                tools
+            );
+        } finally {
+            lease.release();
+        }
+    } else if (provider === "custom") {
+        // model is "<customProviderId>::<actual model id>" — see
+        // frontend/src/lib/providers.ts's formatCustomModelRef.
+        const sep = model.indexOf("::");
+        if (sep === -1) throw new Error(`Malformed custom model reference: ${model}`);
+        const customProviderId = model.slice(0, sep);
+        const actualModel = model.slice(sep + 2);
+        const config = settingsStore.getSettings().customProviders?.find((p) => p.id === customProviderId);
+        if (!config) throw new Error(`Custom provider "${customProviderId}" is no longer configured.`);
+        const apiKey = secretsStore.getSecret(customProviderSecretKey(customProviderId));
+        if (!apiKey && !config.localGpuBackend) throw new Error(`No API key set for ${config.name}. Add one in Settings.`);
+        await createOpenAiCompatibleChat(config.baseUrl, config.name)(
+            apiKey ?? "local-gpu-backend",
+            actualModel,
+            messages,
+            options,
+            onToken,
+            signal,
+            tools
+        );
+    } else {
+        const secretKey = PROVIDER_SECRET_KEYS[provider];
+        const apiKey = secretsStore.getSecret(secretKey);
+        if (!apiKey) throw new Error(`No API key set for ${provider}. Add one in Settings.`);
+        const providerFn =
+            provider === "openai" ? openaiProvider.chat : provider === "anthropic" ? anthropicProvider.chat : geminiProvider.chat;
+        await providerFn(apiKey, model, messages, options, onToken, signal, tools);
+    }
+    } finally {
+        await activity.finish();
+    }
+}
+
+// Runs a single-turn prompt to completion and returns the full text —
+// what the scheduled-task runner needs, as opposed to chat:send's
+// token-by-token streaming back to the renderer.
+export async function completePrompt(provider: ProviderId, model: string, prompt: string): Promise<string> {
+    let text = "";
+    await dispatchChat(provider, model, [{ role: "user", content: prompt }], undefined, (chunk) => {
+        text += chunk.message?.content ?? "";
+    });
+    return text;
+}