Add Hermes v0.7.0 compatibility: reasoning tokens, cost tracking, schema detection

- Auto-detect v0.7.0 database schema with backward compat for older DBs
- Surface reasoning tokens, actual cost, and billing provider from sessions
- Display model reasoning/thinking content in session message bubbles
- Add cost tracking to Dashboard, Insights, and session detail views
- Fix FTS5 search crash on dotted terms (e.g., "config.yaml", "v0.7.0")
- Add missing platforms: Home Assistant, Webhook, Matrix
- Consolidate platform icon mapping into shared KnownPlatforms.icon(for:)
- Map execute_code tool to ToolKind.execute
- Add Settings UI for reasoning effort, approval mode, show cost
- Show memory provider warning when external provider (Honcho) is active
- Replace fragile manual HermesSession init with withTitle() helper
- De-duplicate formatTokens utility function
- Bump version to 1.4.0

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

README.md

@@ -19,19 +19,19 @@
 
 ## Features
 
-- **Dashboard** — System health, token usage, recent sessions with live refresh
-- **Insights** — Usage analytics with token breakdown, model/platform stats, top tools bar chart, activity heatmaps, notable sessions, and time period filtering (7/30/90 days or all time)
-- **Sessions Browser** — Full conversation history with message rendering, tool call inspection, full-text search, rename, delete, and JSONL export
+- **Dashboard** — System health, token usage, cost tracking, recent sessions with live refresh
+- **Insights** — Usage analytics with token breakdown (including reasoning tokens), cost tracking, model/platform stats, top tools bar chart, activity heatmaps, notable sessions, and time period filtering (7/30/90 days or all time)
+- **Sessions Browser** — Full conversation history with message rendering, model reasoning/thinking display, tool call inspection, full-text search, rename, delete, and JSONL export
 - **Activity Feed** — Recent tool execution log with filtering by kind and session, detail inspector with pretty-printed arguments
 - **Live Chat** — Embedded terminal running `hermes chat` with full ANSI color and Rich formatting via [SwiftTerm](https://github.com/migueldeicaza/SwiftTerm), session persistence across navigation, resume/continue previous sessions, and voice mode controls
-- **Memory Viewer/Editor** — View and edit Hermes's MEMORY.md and USER.md with live file-watcher refresh
+- **Memory Viewer/Editor** — View and edit Hermes's MEMORY.md and USER.md with live file-watcher refresh, external memory provider awareness (Honcho, etc.)
 - **Skills Browser** — Browse all installed skills by category with file content viewer and file switcher
-- **Tools Manager** — Enable/disable toolsets per platform (CLI, Telegram, Discord, etc.) with toggle switches, MCP server status
+- **Tools Manager** — Enable/disable toolsets per platform (CLI, Telegram, Discord, Slack, WhatsApp, Signal, Email, Home Assistant, Webhook, Matrix) with toggle switches, MCP server status
 - **Gateway Control** — Start/stop/restart the messaging gateway, view platform connection status, manage user pairing (approve/revoke)
 - **Cron Manager** — View scheduled jobs, their status, prompts, and output
 - **Log Viewer** — Real-time log tailing with level filtering and text search
-- **Project Dashboards** — Custom, agent-generated dashboards for any project. Define stat boxes, charts, tables, progress bars, checklists, and rich text in a simple JSON file — Scarf renders them with live refresh. Let your Hermes agent build and maintain project-specific visualizations automatically
-- **Settings** — Structured config editor for all Hermes settings
+- **Project Dashboards** — Custom, agent-generated dashboards for any project. Define stat boxes, charts, tables, progress bars, checklists, rich text, and embedded web views in a simple JSON file — Scarf renders them with live refresh. Let your Hermes agent build and maintain project-specific visualizations automatically
+- **Settings** — Structured config editor for all Hermes settings including reasoning effort, approval mode, cost display, and more
 - **Menu Bar** — Status icon showing Hermes running state with quick actions
 
 ## Requirements
@@ -42,12 +42,12 @@
 
 ### Compatibility
 
-Scarf reads Hermes's SQLite database (schema v6) and parses CLI output from `hermes status`, `hermes doctor`, `hermes tools`, `hermes sessions`, `hermes gateway`, and `hermes pairing`. Tested and verified against:
+Scarf reads Hermes's SQLite database and parses CLI output from `hermes status`, `hermes doctor`, `hermes tools`, `hermes sessions`, `hermes gateway`, and `hermes pairing`. Automatic schema detection provides backward compatibility with older databases while supporting new features in newer Hermes versions.
 
 | Hermes Version | Status |
 |----------------|--------|
 | v0.6.0 (2026-03-30) | Verified |
-| v0.6.0 (2026-03-31, latest) | Verified |
+| v0.7.0 (2026-04-03, latest) | Verified |
 
 If a Hermes update changes the database schema or CLI output format, Scarf may need to be updated. Check the [Health](#features) view for compatibility warnings.
 
@@ -144,7 +144,7 @@ The app sandbox is disabled because Scarf needs direct access to `~/.hermes/` an
 
 ## Project Dashboards
 
-Project Dashboards turn Scarf into a customizable monitoring hub for all your projects. You define a simple JSON file in your project folder describing what to display — stat boxes, charts, tables, progress bars, checklists, and rich text — and Scarf renders it as a live-updating dashboard. Your Hermes agent can generate and maintain these dashboards automatically.
+Project Dashboards turn Scarf into a customizable monitoring hub for all your projects. You define a simple JSON file in your project folder describing what to display — stat boxes, charts, tables, progress bars, checklists, rich text, and embedded web views — and Scarf renders it as a live-updating dashboard. Your Hermes agent can generate and maintain these dashboards automatically.
 
 ### What You Can Build
 
@@ -153,6 +153,7 @@ Project Dashboards turn Scarf into a customizable monitoring hub for all your pr
 - **Deployment monitors** — deploy history tables, uptime stats, error rate charts
 - **Research dashboards** — experiment results, key findings, paper status checklists
 - **Agent activity views** — cron job results, content generation stats, task completion rates
+- **Embedded web apps** — local dev servers, HTML reports, Grafana dashboards, any web-based tool your agent generates
 - **Any project status** — if your agent can measure it, Scarf can display it
 
 ### Quick Start
@@ -227,6 +228,23 @@ Select your project in the Projects sidebar — the dashboard renders immediatel
 | `table` | Data table with headers | `columns`, `rows` |
 | `chart` | Line, bar, or pie chart | `chartType`, `series` (each with `name`, `color`, `data`) |
 | `list` | Checklist with status indicators | `items` (each with `text`, `status`: done/active/pending) |
+| `webview` | Embedded web browser | `url`, `height` (default 400) |
+
+The `webview` widget embeds a live web browser directly in your dashboard — perfect for displaying local dev servers, HTML reports, or any web-based tool your agent generates.
+
+When a dashboard includes a webview widget, Scarf adds a tabbed interface: **Dashboard** shows your normal widgets, **Site** shows the web content full-canvas with clean margins — using the entire available space in the app. This gives you the best of both worlds: compact metrics at a glance, and a full embedded browser when you need it.
+
+```json
+{
+  "type": "webview",
+  "title": "Project Report",
+  "url": "http://localhost:8000/dashboard",
+  "height": 500
+}
+```
+
+- `url`: Any URL — typically a local server (`http://localhost:...`) or file path
+- `height`: Height in points when displayed as an inline widget card (default: 400). The Site tab always uses full available space regardless of this setting.
 
 **Colors**: red, orange, yellow, green, blue, purple, pink, teal, indigo, mint, brown, gray
 
@@ -236,7 +254,7 @@ Select your project in the Projects sidebar — the dashboard renders immediatel
 
 The real power is letting your Hermes agent build and update dashboards automatically. Add instructions like this to your agent's context:
 
-> Analyze this project and create a `.scarf/dashboard.json` dashboard with relevant metrics and status. Use stat widgets for key numbers, charts for trends, tables for structured data, and lists for task tracking. Register the project in `~/.hermes/scarf/projects.json` if not already registered.
+> Analyze this project and create a `.scarf/dashboard.json` dashboard with relevant metrics and status. Use stat widgets for key numbers, charts for trends, tables for structured data, lists for task tracking, and a webview widget if the project has a local web server or HTML reports. Register the project in `~/.hermes/scarf/projects.json` if not already registered.
 
 Your agent can update the dashboard as part of cron jobs, after builds, or whenever project state changes. Since Scarf watches the file, updates appear in real-time.
 

scarf/docs/DASHBOARD_SCHEMA.md

@@ -141,13 +141,29 @@ Create `.scarf/dashboard.json` in your project root:
 
 - `status`: "done" (checkmark), "active" (filled circle), "pending" (empty circle)
 
+### webview — Embedded web browser
+
+```json
+{
+  "type": "webview",
+  "title": "Project Dashboard",
+  "url": "http://localhost:8000",
+  "height": 500
+}
+```
+
+- `url`: Any URL — local servers, file paths, or remote pages
+- `height`: Height in points (optional, default: 400)
+
+When a dashboard includes a webview widget, Scarf adds a tabbed interface: **Dashboard** shows all normal widgets, **Site** displays the web content full-canvas. The webview widget is automatically filtered out of the Dashboard tab's grid layout.
+
 ## Agent Instructions
 
 To have your Hermes agent generate a dashboard, include these instructions:
 
 > Analyze the project and create a `.scarf/dashboard.json` file with relevant metrics,
 > status indicators, and visualizations. Use the Scarf dashboard schema with sections
-> containing stat, progress, text, table, chart, and list widgets. Register the project
+> containing stat, progress, text, table, chart, list, and webview widgets. Register the project
 > in `~/.hermes/scarf/projects.json` if not already registered.
 
 The agent can update the dashboard file at any time — Scarf watches for changes and re-renders automatically.

scarf/scarf.xcodeproj/project.pbxproj

@@ -407,7 +407,7 @@
 				CODE_SIGN_ENTITLEMENTS = scarf/scarf.entitlements;
 				CODE_SIGN_STYLE = Automatic;
 				COMBINE_HIDPI_IMAGES = YES;
-				CURRENT_PROJECT_VERSION = 1;
+				CURRENT_PROJECT_VERSION = 4;
 				DEVELOPMENT_TEAM = 3Q6X2L86C4;
 				ENABLE_APP_SANDBOX = NO;
 				ENABLE_HARDENED_RUNTIME = YES;
@@ -421,7 +421,7 @@
 					"$(inherited)",
 					"@executable_path/../Frameworks",
 				);
-				MARKETING_VERSION = 1.0;
+				MARKETING_VERSION = 1.4.0;
 				PRODUCT_BUNDLE_IDENTIFIER = com.scarf;
 				PRODUCT_NAME = "$(TARGET_NAME)";
 				REGISTER_APP_GROUPS = YES;
@@ -443,7 +443,7 @@
 				CODE_SIGN_ENTITLEMENTS = scarf/scarf.entitlements;
 				CODE_SIGN_STYLE = Automatic;
 				COMBINE_HIDPI_IMAGES = YES;
-				CURRENT_PROJECT_VERSION = 1;
+				CURRENT_PROJECT_VERSION = 4;
 				DEVELOPMENT_TEAM = 3Q6X2L86C4;
 				ENABLE_APP_SANDBOX = NO;
 				ENABLE_HARDENED_RUNTIME = YES;
@@ -457,7 +457,7 @@
 					"$(inherited)",
 					"@executable_path/../Frameworks",
 				);
-				MARKETING_VERSION = 1.0;
+				MARKETING_VERSION = 1.4.0;
 				PRODUCT_BUNDLE_IDENTIFIER = com.scarf;
 				PRODUCT_NAME = "$(TARGET_NAME)";
 				REGISTER_APP_GROUPS = YES;
@@ -475,11 +475,11 @@
 			buildSettings = {
 				BUNDLE_LOADER = "$(TEST_HOST)";
 				CODE_SIGN_STYLE = Automatic;
-				CURRENT_PROJECT_VERSION = 1;
+				CURRENT_PROJECT_VERSION = 4;
 				DEVELOPMENT_TEAM = 3Q6X2L86C4;
 				GENERATE_INFOPLIST_FILE = YES;
 				MACOSX_DEPLOYMENT_TARGET = 26.2;
-				MARKETING_VERSION = 1.0;
+				MARKETING_VERSION = 1.4.0;
 				PRODUCT_BUNDLE_IDENTIFIER = com.scarfTests;
 				PRODUCT_NAME = "$(TARGET_NAME)";
 				STRING_CATALOG_GENERATE_SYMBOLS = NO;
@@ -496,11 +496,11 @@
 			buildSettings = {
 				BUNDLE_LOADER = "$(TEST_HOST)";
 				CODE_SIGN_STYLE = Automatic;
-				CURRENT_PROJECT_VERSION = 1;
+				CURRENT_PROJECT_VERSION = 4;
 				DEVELOPMENT_TEAM = 3Q6X2L86C4;
 				GENERATE_INFOPLIST_FILE = YES;
 				MACOSX_DEPLOYMENT_TARGET = 26.2;
-				MARKETING_VERSION = 1.0;
+				MARKETING_VERSION = 1.4.0;
 				PRODUCT_BUNDLE_IDENTIFIER = com.scarfTests;
 				PRODUCT_NAME = "$(TARGET_NAME)";
 				STRING_CATALOG_GENERATE_SYMBOLS = NO;
@@ -516,10 +516,10 @@
 			isa = XCBuildConfiguration;
 			buildSettings = {
 				CODE_SIGN_STYLE = Automatic;
-				CURRENT_PROJECT_VERSION = 1;
+				CURRENT_PROJECT_VERSION = 4;
 				DEVELOPMENT_TEAM = 3Q6X2L86C4;
 				GENERATE_INFOPLIST_FILE = YES;
-				MARKETING_VERSION = 1.0;
+				MARKETING_VERSION = 1.4.0;
 				PRODUCT_BUNDLE_IDENTIFIER = com.scarfUITests;
 				PRODUCT_NAME = "$(TARGET_NAME)";
 				STRING_CATALOG_GENERATE_SYMBOLS = NO;
@@ -535,10 +535,10 @@
 			isa = XCBuildConfiguration;
 			buildSettings = {
 				CODE_SIGN_STYLE = Automatic;
-				CURRENT_PROJECT_VERSION = 1;
+				CURRENT_PROJECT_VERSION = 4;
 				DEVELOPMENT_TEAM = 3Q6X2L86C4;
 				GENERATE_INFOPLIST_FILE = YES;
-				MARKETING_VERSION = 1.0;
+				MARKETING_VERSION = 1.4.0;
 				PRODUCT_BUNDLE_IDENTIFIER = com.scarfUITests;
 				PRODUCT_NAME = "$(TARGET_NAME)";
 				STRING_CATALOG_GENERATE_SYMBOLS = NO;

scarf/scarf/Core/Models/HermesConfig.swift

@@ -15,6 +15,11 @@ struct HermesConfig: Sendable {
     var verbose: Bool
     var autoTTS: Bool
     var silenceThreshold: Int
+    var reasoningEffort: String
+    var showCost: Bool
+    var approvalMode: String
+    var browserBackend: String
+    var memoryProvider: String
 
     static let empty = HermesConfig(
         model: "unknown",
@@ -30,7 +35,12 @@ struct HermesConfig: Sendable {
         showReasoning: false,
         verbose: false,
         autoTTS: true,
-        silenceThreshold: 200
+        silenceThreshold: 200,
+        reasoningEffort: "medium",
+        showCost: false,
+        approvalMode: "manual",
+        browserBackend: "",
+        memoryProvider: ""
     )
 }
 

scarf/scarf/Core/Models/HermesConstants.swift

@@ -1,8 +1,11 @@
 import Foundation
+import SQLite3
 
 enum HermesPaths: Sendable {
-    // Using ProcessInfo to avoid main-actor isolation issues with FileManager/NSHomeDirectory
-    nonisolated static let home: String = ProcessInfo.processInfo.environment["HOME"]! + "/.hermes"
+    private nonisolated static let userHome: String = ProcessInfo.processInfo.environment["HOME"]
+        ?? NSHomeDirectory()
+
+    nonisolated static let home: String = userHome + "/.hermes"
     nonisolated static let stateDB: String = home + "/state.db"
     nonisolated static let configYAML: String = home + "/config.yaml"
     nonisolated static let memoriesDir: String = home + "/memories"
@@ -15,7 +18,32 @@ enum HermesPaths: Sendable {
     nonisolated static let skillsDir: String = home + "/skills"
     nonisolated static let errorsLog: String = home + "/logs/errors.log"
     nonisolated static let gatewayLog: String = home + "/logs/gateway.log"
-    nonisolated static let hermesBinary: String = ProcessInfo.processInfo.environment["HOME"]! + "/.local/bin/hermes"
+    nonisolated static let hermesBinary: String = userHome + "/.local/bin/hermes"
     nonisolated static let scarfDir: String = home + "/scarf"
     nonisolated static let projectsRegistry: String = scarfDir + "/projects.json"
 }
+
+// MARK: - SQLite Constants
+
+/// SQLITE_TRANSIENT tells SQLite to make its own copy of bound string data.
+/// The C macro is defined as ((sqlite3_destructor_type)-1) which can't be imported directly into Swift.
+nonisolated let sqliteTransient = unsafeBitCast(-1, to: sqlite3_destructor_type.self)
+
+// MARK: - Query Defaults
+
+enum QueryDefaults: Sendable {
+    nonisolated static let sessionLimit = 100
+    nonisolated static let messageSearchLimit = 50
+    nonisolated static let toolCallLimit = 50
+    nonisolated static let sessionPreviewLimit = 10
+    nonisolated static let previewContentLength = 100
+    nonisolated static let logLineLimit = 200
+    nonisolated static let defaultSilenceThreshold = 200
+}
+
+// MARK: - File Size Formatting
+
+enum FileSizeUnit: Sendable {
+    nonisolated static let kilobyte = 1_024.0
+    nonisolated static let megabyte = 1_048_576.0
+}

scarf/scarf/Core/Models/HermesMessage.swift

@@ -11,10 +11,12 @@ struct HermesMessage: Identifiable, Sendable {
     let timestamp: Date?
     let tokenCount: Int?
     let finishReason: String?
+    let reasoning: String?
 
     var isUser: Bool { role == "user" }
     var isAssistant: Bool { role == "assistant" }
     var isToolResult: Bool { role == "tool" }
+    var hasReasoning: Bool { reasoning != nil && !(reasoning?.isEmpty ?? true) }
 }
 
 struct HermesToolCall: Identifiable, Sendable, Codable {
@@ -61,7 +63,7 @@ struct HermesToolCall: Identifiable, Sendable, Codable {
         switch functionName {
         case "read_file", "search_files", "vision_analyze": return .read
         case "write_file", "patch": return .edit
-        case "terminal": return .execute
+        case "terminal", "execute_code": return .execute
         case "web_search", "web_extract": return .fetch
         case "browser_navigate", "browser_click", "browser_screenshot": return .browser
         default: return .other

scarf/scarf/Core/Models/HermesSession.swift

@@ -17,8 +17,16 @@ struct HermesSession: Identifiable, Sendable {
     let cacheReadTokens: Int
     let cacheWriteTokens: Int
     let estimatedCostUSD: Double?
+    let reasoningTokens: Int
+    let actualCostUSD: Double?
+    let costStatus: String?
+    let billingProvider: String?
 
-    var totalTokens: Int { inputTokens + outputTokens }
+    var totalTokens: Int { inputTokens + outputTokens + reasoningTokens }
+
+    var displayCostUSD: Double? { actualCostUSD ?? estimatedCostUSD }
+
+    var costIsActual: Bool { actualCostUSD != nil }
 
     var duration: TimeInterval? {
         guard let start = startedAt, let end = endedAt else { return nil }
@@ -30,13 +38,20 @@ struct HermesSession: Identifiable, Sendable {
     }
 
     var sourceIcon: String {
-        switch source {
-        case "cli": return "terminal"
-        case "telegram": return "paperplane"
-        case "discord": return "bubble.left.and.bubble.right"
-        case "slack": return "number"
-        case "email": return "envelope"
-        default: return "bubble.left"
-        }
+        KnownPlatforms.icon(for: source)
+    }
+
+    func withTitle(_ newTitle: String) -> HermesSession {
+        HermesSession(
+            id: id, source: source, userId: userId, model: model,
+            title: newTitle, parentSessionId: parentSessionId,
+            startedAt: startedAt, endedAt: endedAt, endReason: endReason,
+            messageCount: messageCount, toolCallCount: toolCallCount,
+            inputTokens: inputTokens, outputTokens: outputTokens,
+            cacheReadTokens: cacheReadTokens, cacheWriteTokens: cacheWriteTokens,
+            estimatedCostUSD: estimatedCostUSD, reasoningTokens: reasoningTokens,
+            actualCostUSD: actualCostUSD, costStatus: costStatus,
+            billingProvider: billingProvider
+        )
     }
 }

scarf/scarf/Core/Models/HermesTool.swift

@@ -16,13 +16,33 @@ struct HermesToolPlatform: Identifiable, Sendable {
 }
 
 enum KnownPlatforms {
+    static let cli = HermesToolPlatform(name: "cli", displayName: "CLI", icon: "terminal")
     static let all: [HermesToolPlatform] = [
-        HermesToolPlatform(name: "cli", displayName: "CLI", icon: "terminal"),
+        cli,
         HermesToolPlatform(name: "telegram", displayName: "Telegram", icon: "paperplane"),
         HermesToolPlatform(name: "discord", displayName: "Discord", icon: "bubble.left.and.bubble.right"),
         HermesToolPlatform(name: "slack", displayName: "Slack", icon: "number"),
         HermesToolPlatform(name: "whatsapp", displayName: "WhatsApp", icon: "phone.bubble"),
         HermesToolPlatform(name: "signal", displayName: "Signal", icon: "lock.shield"),
         HermesToolPlatform(name: "email", displayName: "Email", icon: "envelope"),
+        HermesToolPlatform(name: "homeassistant", displayName: "Home Assistant", icon: "house"),
+        HermesToolPlatform(name: "webhook", displayName: "Webhook", icon: "arrow.up.right.square"),
+        HermesToolPlatform(name: "matrix", displayName: "Matrix", icon: "lock.rectangle.stack"),
     ]
+
+    static func icon(for platform: String) -> String {
+        switch platform {
+        case "cli": return "terminal"
+        case "telegram": return "paperplane"
+        case "discord": return "bubble.left.and.bubble.right"
+        case "slack": return "number"
+        case "whatsapp": return "phone.bubble"
+        case "signal": return "lock.shield"
+        case "email": return "envelope"
+        case "homeassistant": return "house"
+        case "webhook": return "arrow.up.right.square"
+        case "matrix": return "lock.rectangle.stack"
+        default: return "bubble.left"
+        }
+    }
 }

scarf/scarf/Core/Models/ProjectDashboard.swift

@@ -69,6 +69,10 @@ struct DashboardWidget: Codable, Sendable, Identifiable {
 
     // List
     let items: [ListItem]?
+
+    // Webview
+    let url: String?
+    let height: Double?
 }
 
 // MARK: - Widget Value (String or Number)

scarf/scarf/Core/Services/HermesDataService.swift

@@ -3,6 +3,7 @@ import SQLite3
 
 actor HermesDataService {
     private var db: OpaquePointer?
+    private var hasV07Schema = false
 
     func open() -> Bool {
         let path = HermesPaths.stateDB
@@ -14,6 +15,7 @@ actor HermesDataService {
             return false
         }
         sqlite3_exec(db, "PRAGMA journal_mode=WAL", nil, nil, nil)
+        detectSchema()
         return true
     }
 
@@ -24,17 +26,39 @@ actor HermesDataService {
         db = nil
     }
 
-    func fetchSessions(limit: Int = 100) -> [HermesSession] {
-        guard let db else { return [] }
-        let sql = """
-            SELECT id, source, user_id, model, title, parent_session_id,
-                   started_at, ended_at, end_reason, message_count, tool_call_count,
-                   input_tokens, output_tokens, cache_read_tokens, cache_write_tokens,
-                   estimated_cost_usd
-            FROM sessions
-            ORDER BY started_at DESC
-            LIMIT ?
+    // MARK: - Schema Detection
+
+    private func detectSchema() {
+        guard let db else { return }
+        var stmt: OpaquePointer?
+        guard sqlite3_prepare_v2(db, "PRAGMA table_info(sessions)", -1, &stmt, nil) == SQLITE_OK else { return }
+        defer { sqlite3_finalize(stmt) }
+        while sqlite3_step(stmt) == SQLITE_ROW {
+            if let name = sqlite3_column_text(stmt, 1), String(cString: name) == "reasoning_tokens" {
+                hasV07Schema = true
+                return
+            }
+        }
+    }
+
+    // MARK: - Session Queries
+
+    private var sessionColumns: String {
+        var cols = """
+            id, source, user_id, model, title, parent_session_id,
+            started_at, ended_at, end_reason, message_count, tool_call_count,
+            input_tokens, output_tokens, cache_read_tokens, cache_write_tokens,
+            estimated_cost_usd
             """
+        if hasV07Schema {
+            cols += ", reasoning_tokens, actual_cost_usd, cost_status, billing_provider"
+        }
+        return cols
+    }
+
+    func fetchSessions(limit: Int = QueryDefaults.sessionLimit) -> [HermesSession] {
+        guard let db else { return [] }
+        let sql = "SELECT \(sessionColumns) FROM sessions ORDER BY started_at DESC LIMIT ?"
         var stmt: OpaquePointer?
         guard sqlite3_prepare_v2(db, sql, -1, &stmt, nil) == SQLITE_OK else { return [] }
         defer { sqlite3_finalize(stmt) }
@@ -47,19 +71,41 @@ actor HermesDataService {
         return sessions
     }
 
-    func fetchMessages(sessionId: String) -> [HermesMessage] {
+    func fetchSessionsInPeriod(since: Date) -> [HermesSession] {
         guard let db else { return [] }
-        let sql = """
-            SELECT id, session_id, role, content, tool_call_id, tool_calls,
-                   tool_name, timestamp, token_count, finish_reason
-            FROM messages
-            WHERE session_id = ?
-            ORDER BY timestamp ASC
-            """
+        let sql = "SELECT \(sessionColumns) FROM sessions WHERE started_at >= ? ORDER BY started_at DESC"
         var stmt: OpaquePointer?
         guard sqlite3_prepare_v2(db, sql, -1, &stmt, nil) == SQLITE_OK else { return [] }
         defer { sqlite3_finalize(stmt) }
-        sqlite3_bind_text(stmt, 1, sessionId, -1, unsafeBitCast(-1, to: sqlite3_destructor_type.self))
+        sqlite3_bind_double(stmt, 1, since.timeIntervalSince1970)
+
+        var sessions: [HermesSession] = []
+        while sqlite3_step(stmt) == SQLITE_ROW {
+            sessions.append(sessionFromRow(stmt!))
+        }
+        return sessions
+    }
+
+    // MARK: - Message Queries
+
+    private var messageColumns: String {
+        var cols = """
+            id, session_id, role, content, tool_call_id, tool_calls,
+            tool_name, timestamp, token_count, finish_reason
+            """
+        if hasV07Schema {
+            cols += ", reasoning"
+        }
+        return cols
+    }
+
+    func fetchMessages(sessionId: String) -> [HermesMessage] {
+        guard let db else { return [] }
+        let sql = "SELECT \(messageColumns) FROM messages WHERE session_id = ? ORDER BY timestamp ASC"
+        var stmt: OpaquePointer?
+        guard sqlite3_prepare_v2(db, sql, -1, &stmt, nil) == SQLITE_OK else { return [] }
+        defer { sqlite3_finalize(stmt) }
+        sqlite3_bind_text(stmt, 1, sessionId, -1, sqliteTransient)
 
         var messages: [HermesMessage] = []
         while sqlite3_step(stmt) == SQLITE_ROW {
@@ -68,11 +114,15 @@ actor HermesDataService {
         return messages
     }
 
-    func searchMessages(query: String, limit: Int = 50) -> [HermesMessage] {
+    func searchMessages(query: String, limit: Int = QueryDefaults.messageSearchLimit) -> [HermesMessage] {
         guard let db else { return [] }
+        let sanitized = sanitizeFTSQuery(query)
+        guard !sanitized.isEmpty else { return [] }
+        let msgCols = hasV07Schema
+            ? "m.id, m.session_id, m.role, m.content, m.tool_call_id, m.tool_calls, m.tool_name, m.timestamp, m.token_count, m.finish_reason, m.reasoning"
+            : "m.id, m.session_id, m.role, m.content, m.tool_call_id, m.tool_calls, m.tool_name, m.timestamp, m.token_count, m.finish_reason"
         let sql = """
-            SELECT m.id, m.session_id, m.role, m.content, m.tool_call_id, m.tool_calls,
-                   m.tool_name, m.timestamp, m.token_count, m.finish_reason
+            SELECT \(msgCols)
             FROM messages_fts fts
             JOIN messages m ON m.id = fts.rowid
             WHERE messages_fts MATCH ?
@@ -82,7 +132,7 @@ actor HermesDataService {
         var stmt: OpaquePointer?
         guard sqlite3_prepare_v2(db, sql, -1, &stmt, nil) == SQLITE_OK else { return [] }
         defer { sqlite3_finalize(stmt) }
-        sqlite3_bind_text(stmt, 1, query, -1, unsafeBitCast(-1, to: sqlite3_destructor_type.self))
+        sqlite3_bind_text(stmt, 1, sanitized, -1, sqliteTransient)
         sqlite3_bind_int(stmt, 2, Int32(limit))
 
         var messages: [HermesMessage] = []
@@ -92,11 +142,10 @@ actor HermesDataService {
         return messages
     }
 
-    func fetchRecentToolCalls(limit: Int = 50) -> [HermesMessage] {
+    func fetchRecentToolCalls(limit: Int = QueryDefaults.toolCallLimit) -> [HermesMessage] {
         guard let db else { return [] }
         let sql = """
-            SELECT id, session_id, role, content, tool_call_id, tool_calls,
-                   tool_name, timestamp, token_count, finish_reason
+            SELECT \(messageColumns)
             FROM messages
             WHERE tool_calls IS NOT NULL AND tool_calls != '[]' AND tool_calls != ''
             ORDER BY timestamp DESC
@@ -114,10 +163,10 @@ actor HermesDataService {
         return messages
     }
 
-    func fetchSessionPreviews(limit: Int = 10) -> [String: String] {
+    func fetchSessionPreviews(limit: Int = QueryDefaults.sessionPreviewLimit) -> [String: String] {
         guard let db else { return [:] }
         let sql = """
-            SELECT m.session_id, substr(m.content, 1, 100)
+            SELECT m.session_id, substr(m.content, 1, \(QueryDefaults.previewContentLength))
             FROM messages m
             INNER JOIN (
                 SELECT session_id, MIN(id) as min_id
@@ -142,6 +191,8 @@ actor HermesDataService {
         return previews
     }
 
+    // MARK: - Stats
+
     struct SessionStats: Sendable {
         let totalSessions: Int
         let totalMessages: Int
@@ -149,65 +200,53 @@ actor HermesDataService {
         let totalInputTokens: Int
         let totalOutputTokens: Int
         let totalCostUSD: Double
+        let totalReasoningTokens: Int
+        let totalActualCostUSD: Double
+
+        static let empty = SessionStats(
+            totalSessions: 0, totalMessages: 0, totalToolCalls: 0,
+            totalInputTokens: 0, totalOutputTokens: 0, totalCostUSD: 0,
+            totalReasoningTokens: 0, totalActualCostUSD: 0
+        )
     }
 
     func fetchStats() -> SessionStats {
-        guard let db else {
-            return SessionStats(totalSessions: 0, totalMessages: 0, totalToolCalls: 0,
-                                totalInputTokens: 0, totalOutputTokens: 0, totalCostUSD: 0)
+        guard let db else { return .empty }
+        let sql: String
+        if hasV07Schema {
+            sql = """
+                SELECT COUNT(*), COALESCE(SUM(message_count),0), COALESCE(SUM(tool_call_count),0),
+                       COALESCE(SUM(input_tokens),0), COALESCE(SUM(output_tokens),0),
+                       COALESCE(SUM(estimated_cost_usd),0),
+                       COALESCE(SUM(reasoning_tokens),0), COALESCE(SUM(actual_cost_usd),0)
+                FROM sessions
+                """
+        } else {
+            sql = """
+                SELECT COUNT(*), COALESCE(SUM(message_count),0), COALESCE(SUM(tool_call_count),0),
+                       COALESCE(SUM(input_tokens),0), COALESCE(SUM(output_tokens),0),
+                       COALESCE(SUM(estimated_cost_usd),0)
+                FROM sessions
+                """
         }
-        let sql = """
-            SELECT COUNT(*), COALESCE(SUM(message_count),0), COALESCE(SUM(tool_call_count),0),
-                   COALESCE(SUM(input_tokens),0), COALESCE(SUM(output_tokens),0),
-                   COALESCE(SUM(estimated_cost_usd),0)
-            FROM sessions
-            """
         var stmt: OpaquePointer?
-        guard sqlite3_prepare_v2(db, sql, -1, &stmt, nil) == SQLITE_OK else {
-            return SessionStats(totalSessions: 0, totalMessages: 0, totalToolCalls: 0,
-                                totalInputTokens: 0, totalOutputTokens: 0, totalCostUSD: 0)
-        }
+        guard sqlite3_prepare_v2(db, sql, -1, &stmt, nil) == SQLITE_OK else { return .empty }
         defer { sqlite3_finalize(stmt) }
-
-        guard sqlite3_step(stmt) == SQLITE_ROW else {
-            return SessionStats(totalSessions: 0, totalMessages: 0, totalToolCalls: 0,
-                                totalInputTokens: 0, totalOutputTokens: 0, totalCostUSD: 0)
-        }
+        guard sqlite3_step(stmt) == SQLITE_ROW else { return .empty }
         return SessionStats(
             totalSessions: Int(sqlite3_column_int(stmt, 0)),
             totalMessages: Int(sqlite3_column_int(stmt, 1)),
             totalToolCalls: Int(sqlite3_column_int(stmt, 2)),
             totalInputTokens: Int(sqlite3_column_int(stmt, 3)),
             totalOutputTokens: Int(sqlite3_column_int(stmt, 4)),
-            totalCostUSD: sqlite3_column_double(stmt, 5)
+            totalCostUSD: sqlite3_column_double(stmt, 5),
+            totalReasoningTokens: hasV07Schema ? Int(sqlite3_column_int(stmt, 6)) : 0,
+            totalActualCostUSD: hasV07Schema ? sqlite3_column_double(stmt, 7) : 0
         )
     }
 
     // MARK: - Insights Queries
 
-    func fetchSessionsInPeriod(since: Date) -> [HermesSession] {
-        guard let db else { return [] }
-        let sql = """
-            SELECT id, source, user_id, model, title, parent_session_id,
-                   started_at, ended_at, end_reason, message_count, tool_call_count,
-                   input_tokens, output_tokens, cache_read_tokens, cache_write_tokens,
-                   estimated_cost_usd
-            FROM sessions
-            WHERE started_at >= ?
-            ORDER BY started_at DESC
-            """
-        var stmt: OpaquePointer?
-        guard sqlite3_prepare_v2(db, sql, -1, &stmt, nil) == SQLITE_OK else { return [] }
-        defer { sqlite3_finalize(stmt) }
-        sqlite3_bind_double(stmt, 1, since.timeIntervalSince1970)
-
-        var sessions: [HermesSession] = []
-        while sqlite3_step(stmt) == SQLITE_ROW {
-            sessions.append(sessionFromRow(stmt!))
-        }
-        return sessions
-    }
-
     func fetchUserMessageCount(since: Date) -> Int {
         guard let db else { return 0 }
         let sql = """
@@ -320,7 +359,11 @@ actor HermesDataService {
             outputTokens: Int(sqlite3_column_int(stmt, 12)),
             cacheReadTokens: Int(sqlite3_column_int(stmt, 13)),
             cacheWriteTokens: Int(sqlite3_column_int(stmt, 14)),
-            estimatedCostUSD: sqlite3_column_type(stmt, 15) != SQLITE_NULL ? sqlite3_column_double(stmt, 15) : nil
+            estimatedCostUSD: sqlite3_column_type(stmt, 15) != SQLITE_NULL ? sqlite3_column_double(stmt, 15) : nil,
+            reasoningTokens: hasV07Schema ? Int(sqlite3_column_int(stmt, 16)) : 0,
+            actualCostUSD: hasV07Schema && sqlite3_column_type(stmt, 17) != SQLITE_NULL ? sqlite3_column_double(stmt, 17) : nil,
+            costStatus: hasV07Schema ? columnOptionalText(stmt, 18) : nil,
+            billingProvider: hasV07Schema ? columnOptionalText(stmt, 19) : nil
         )
     }
 
@@ -337,14 +380,20 @@ actor HermesDataService {
             toolName: columnOptionalText(stmt, 6),
             timestamp: columnDate(stmt, 7),
             tokenCount: sqlite3_column_type(stmt, 8) != SQLITE_NULL ? Int(sqlite3_column_int(stmt, 8)) : nil,
-            finishReason: columnOptionalText(stmt, 9)
+            finishReason: columnOptionalText(stmt, 9),
+            reasoning: hasV07Schema ? columnOptionalText(stmt, 10) : nil
         )
     }
 
     private func parseToolCalls(_ json: String?) -> [HermesToolCall] {
         guard let json, !json.isEmpty,
               let data = json.data(using: .utf8) else { return [] }
-        return (try? JSONDecoder().decode([HermesToolCall].self, from: data)) ?? []
+        do {
+            return try JSONDecoder().decode([HermesToolCall].self, from: data)
+        } catch {
+            print("[Scarf] Failed to decode tool calls: \(error.localizedDescription)")
+            return []
+        }
     }
 
     private func columnText(_ stmt: OpaquePointer, _ col: Int32) -> String {
@@ -365,4 +414,17 @@ actor HermesDataService {
         let value = sqlite3_column_double(stmt, col)
         return Date(timeIntervalSince1970: value)
     }
+
+    /// Wraps each whitespace-delimited token in double quotes to prevent FTS5 parse errors
+    /// on terms containing dots, hyphens, or FTS5 operators (e.g., "v0.7.0", "config.yaml").
+    private func sanitizeFTSQuery(_ raw: String) -> String {
+        raw.split(separator: " ")
+            .map { token in
+                let t = String(token)
+                let stripped = t.replacingOccurrences(of: "\"", with: "")
+                return stripped.isEmpty ? nil : "\"\(stripped)\""
+            }
+            .compactMap { $0 }
+            .joined(separator: " ")
+    }
 }

scarf/scarf/Core/Services/HermesFileService.swift

@@ -44,7 +44,12 @@ struct HermesFileService: Sendable {
             showReasoning: values["display.show_reasoning"] == "true",
             verbose: values["agent.verbose"] == "true",
             autoTTS: values["voice.auto_tts"] != "false",
-            silenceThreshold: Int(values["voice.silence_threshold"] ?? "") ?? 200
+            silenceThreshold: Int(values["voice.silence_threshold"] ?? "") ?? QueryDefaults.defaultSilenceThreshold,
+            reasoningEffort: values["agent.reasoning_effort"] ?? "medium",
+            showCost: values["display.show_cost"] == "true",
+            approvalMode: values["approvals.mode"] ?? "manual",
+            browserBackend: values["browser.backend"] ?? "",
+            memoryProvider: values["memory.provider"] ?? ""
         )
     }
 
@@ -52,7 +57,12 @@ struct HermesFileService: Sendable {
 
     func loadGatewayState() -> GatewayState? {
         guard let data = readFileData(HermesPaths.gatewayStateJSON) else { return nil }
-        return try? JSONDecoder().decode(GatewayState.self, from: data)
+        do {
+            return try JSONDecoder().decode(GatewayState.self, from: data)
+        } catch {
+            print("[Scarf] Failed to decode gateway state: \(error.localizedDescription)")
+            return nil
+        }
     }
 
     // MARK: - Memory
@@ -77,8 +87,13 @@ struct HermesFileService: Sendable {
 
     func loadCronJobs() -> [HermesCronJob] {
         guard let data = readFileData(HermesPaths.cronJobsJSON) else { return [] }
-        let file = try? JSONDecoder().decode(CronJobsFile.self, from: data)
-        return file?.jobs ?? []
+        do {
+            let file = try JSONDecoder().decode(CronJobsFile.self, from: data)
+            return file.jobs
+        } catch {
+            print("[Scarf] Failed to decode cron jobs: \(error.localizedDescription)")
+            return []
+        }
     }
 
     func loadCronOutput(jobId: String) -> String? {
@@ -123,7 +138,13 @@ struct HermesFileService: Sendable {
     }
 
     func loadSkillContent(path: String) -> String {
-        readFile(path) ?? ""
+        // Validate path stays within the skills directory to prevent traversal
+        guard !path.contains(".."),
+              path.hasPrefix(HermesPaths.skillsDir) else {
+            print("[Scarf] Rejected skill path outside skills directory: \(path)")
+            return ""
+        }
+        return readFile(path) ?? ""
     }
 
     // MARK: - Hermes Process
@@ -156,6 +177,10 @@ struct HermesFileService: Sendable {
     }
 
     private func writeFile(_ path: String, content: String) {
-        try? content.write(toFile: path, atomically: true, encoding: .utf8)
+        do {
+            try content.write(toFile: path, atomically: true, encoding: .utf8)
+        } catch {
+            print("[Scarf] Failed to write \(path): \(error.localizedDescription)")
+        }
     }
 }

scarf/scarf/Core/Services/HermesLogService.swift

@@ -39,12 +39,16 @@ actor HermesLogService {
     }
 
     func closeLog() {
-        try? fileHandle?.close()
+        do {
+            try fileHandle?.close()
+        } catch {
+            print("[Scarf] Failed to close log handle: \(error.localizedDescription)")
+        }
         fileHandle = nil
         currentPath = nil
     }
 
-    func readLastLines(count: Int = 200) -> [LogEntry] {
+    func readLastLines(count: Int = QueryDefaults.logLineLimit) -> [LogEntry] {
         guard let path = currentPath,
               let data = FileManager.default.contents(atPath: path) else { return [] }
         let content = String(data: data, encoding: .utf8) ?? ""

scarf/scarf/Core/Services/ProjectDashboardService.swift

@@ -8,14 +8,23 @@ struct ProjectDashboardService: Sendable {
         guard let data = FileManager.default.contents(atPath: HermesPaths.projectsRegistry) else {
             return ProjectRegistry(projects: [])
         }
-        return (try? JSONDecoder().decode(ProjectRegistry.self, from: data))
-            ?? ProjectRegistry(projects: [])
+        do {
+            return try JSONDecoder().decode(ProjectRegistry.self, from: data)
+        } catch {
+            print("[Scarf] Failed to decode project registry: \(error.localizedDescription)")
+            return ProjectRegistry(projects: [])
+        }
     }
 
     func saveRegistry(_ registry: ProjectRegistry) {
         let dir = HermesPaths.scarfDir
         if !FileManager.default.fileExists(atPath: dir) {
-            try? FileManager.default.createDirectory(atPath: dir, withIntermediateDirectories: true)
+            do {
+                try FileManager.default.createDirectory(atPath: dir, withIntermediateDirectories: true)
+            } catch {
+                print("[Scarf] Failed to create scarf directory: \(error.localizedDescription)")
+                return
+            }
         }
         guard let data = try? JSONEncoder().encode(registry) else { return }
         // Pretty-print for readability (agents may read this file)
@@ -33,7 +42,12 @@ struct ProjectDashboardService: Sendable {
         guard let data = FileManager.default.contents(atPath: project.dashboardPath) else {
             return nil
         }
-        return try? JSONDecoder().decode(ProjectDashboard.self, from: data)
+        do {
+            return try JSONDecoder().decode(ProjectDashboard.self, from: data)
+        } catch {
+            print("[Scarf] Failed to decode dashboard for \(project.name): \(error.localizedDescription)")
+            return nil
+        }
     }
 
     func dashboardExists(for project: ProjectEntry) -> Bool {

scarf/scarf/Features/Dashboard/ViewModels/DashboardViewModel.swift

@@ -5,10 +5,7 @@ final class DashboardViewModel {
     private let dataService = HermesDataService()
     private let fileService = HermesFileService()
 
-    var stats = HermesDataService.SessionStats(
-        totalSessions: 0, totalMessages: 0, totalToolCalls: 0,
-        totalInputTokens: 0, totalOutputTokens: 0, totalCostUSD: 0
-    )
+    var stats = HermesDataService.SessionStats.empty
     var recentSessions: [HermesSession] = []
     var sessionPreviews: [String: String] = [:]
     var config = HermesConfig.empty

scarf/scarf/Features/Dashboard/Views/DashboardView.swift

@@ -60,6 +60,10 @@ struct DashboardView: View {
                 StatCard(label: "Messages", value: "\(viewModel.stats.totalMessages)")
                 StatCard(label: "Tool Calls", value: "\(viewModel.stats.totalToolCalls)")
                 StatCard(label: "Tokens", value: formatTokens(viewModel.stats.totalInputTokens + viewModel.stats.totalOutputTokens))
+                let cost = viewModel.stats.totalActualCostUSD > 0 ? viewModel.stats.totalActualCostUSD : viewModel.stats.totalCostUSD
+                if cost > 0 {
+                    StatCard(label: "Cost", value: String(format: "$%.2f", cost))
+                }
             }
         }
     }
@@ -90,14 +94,6 @@ struct DashboardView: View {
         }
     }
 
-    private func formatTokens(_ count: Int) -> String {
-        if count >= 1_000_000 {
-            return String(format: "%.1fM", Double(count) / 1_000_000)
-        } else if count >= 1_000 {
-            return String(format: "%.1fK", Double(count) / 1_000)
-        }
-        return "\(count)"
-    }
 }
 
 struct StatusCard: View {

scarf/scarf/Features/Insights/ViewModels/InsightsViewModel.swift

@@ -27,7 +27,8 @@ struct ModelUsage: Identifiable {
     let outputTokens: Int
     let cacheReadTokens: Int
     let cacheWriteTokens: Int
-    var totalTokens: Int { inputTokens + outputTokens + cacheReadTokens + cacheWriteTokens }
+    let reasoningTokens: Int
+    var totalTokens: Int { inputTokens + outputTokens + cacheReadTokens + cacheWriteTokens + reasoningTokens }
 }
 
 struct PlatformUsage: Identifiable {
@@ -69,7 +70,9 @@ final class InsightsViewModel {
     var totalOutputTokens = 0
     var totalCacheReadTokens = 0
     var totalCacheWriteTokens = 0
+    var totalReasoningTokens = 0
     var totalTokens = 0
+    var totalCost: Double = 0
     var activeTime: TimeInterval = 0
     var avgSessionDuration: TimeInterval = 0
 
@@ -119,7 +122,9 @@ final class InsightsViewModel {
         totalOutputTokens = sessions.reduce(0) { $0 + $1.outputTokens }
         totalCacheReadTokens = sessions.reduce(0) { $0 + $1.cacheReadTokens }
         totalCacheWriteTokens = sessions.reduce(0) { $0 + $1.cacheWriteTokens }
-        totalTokens = totalInputTokens + totalOutputTokens + totalCacheReadTokens + totalCacheWriteTokens
+        totalReasoningTokens = sessions.reduce(0) { $0 + $1.reasoningTokens }
+        totalTokens = totalInputTokens + totalOutputTokens + totalCacheReadTokens + totalCacheWriteTokens + totalReasoningTokens
+        totalCost = sessions.reduce(0.0) { $0 + ($1.displayCostUSD ?? 0) }
 
         var total: TimeInterval = 0
         var count = 0
@@ -134,21 +139,22 @@ final class InsightsViewModel {
     }
 
     private func computeModelBreakdown() {
-        var grouped: [String: (sessions: Int, input: Int, output: Int, cacheRead: Int, cacheWrite: Int)] = [:]
+        var grouped: [String: (sessions: Int, input: Int, output: Int, cacheRead: Int, cacheWrite: Int, reasoning: Int)] = [:]
         for s in sessions {
             let model = s.model ?? "unknown"
-            var entry = grouped[model, default: (0, 0, 0, 0, 0)]
+            var entry = grouped[model, default: (0, 0, 0, 0, 0, 0)]
             entry.sessions += 1
             entry.input += s.inputTokens
             entry.output += s.outputTokens
             entry.cacheRead += s.cacheReadTokens
             entry.cacheWrite += s.cacheWriteTokens
+            entry.reasoning += s.reasoningTokens
             grouped[model] = entry
         }
         modelUsage = grouped.map { key, val in
             ModelUsage(model: key, sessions: val.sessions, inputTokens: val.input,
                        outputTokens: val.output, cacheReadTokens: val.cacheRead,
-                       cacheWriteTokens: val.cacheWrite)
+                       cacheWriteTokens: val.cacheWrite, reasoningTokens: val.reasoning)
         }.sorted { $0.totalTokens > $1.totalTokens }
     }
 
@@ -158,7 +164,7 @@ final class InsightsViewModel {
             var entry = grouped[s.source, default: (0, 0, 0)]
             entry.sessions += 1
             entry.messages += s.messageCount
-            entry.tokens += s.inputTokens + s.outputTokens + s.cacheReadTokens + s.cacheWriteTokens
+            entry.tokens += s.inputTokens + s.outputTokens + s.cacheReadTokens + s.cacheWriteTokens + s.reasoningTokens
             grouped[s.source] = entry
         }
         platformUsage = grouped.map { key, val in

scarf/scarf/Features/Insights/Views/InsightsView.swift

@@ -50,7 +50,9 @@ struct InsightsView: View {
                 InsightCard(label: "Output Tokens", value: formatTokens(viewModel.totalOutputTokens))
                 InsightCard(label: "Cache Read", value: formatTokens(viewModel.totalCacheReadTokens))
                 InsightCard(label: "Cache Write", value: formatTokens(viewModel.totalCacheWriteTokens))
+                InsightCard(label: "Reasoning Tokens", value: formatTokens(viewModel.totalReasoningTokens))
                 InsightCard(label: "Total Tokens", value: formatTokens(viewModel.totalTokens))
+                InsightCard(label: "Total Cost", value: String(format: "$%.2f", viewModel.totalCost))
                 InsightCard(label: "Active Time", value: formatDuration(viewModel.activeTime))
                 InsightCard(label: "Avg Session", value: formatDuration(viewModel.avgSessionDuration))
                 InsightCard(label: "Avg Msgs/Session", value: viewModel.sessions.isEmpty ? "0" : String(format: "%.1f", Double(viewModel.totalMessages) / Double(viewModel.sessions.count)))
@@ -273,19 +275,12 @@ struct InsightsView: View {
     // MARK: - Helpers
 
     private func platformIcon(_ platform: String) -> String {
-        switch platform {
-        case "cli": return "terminal"
-        case "telegram": return "paperplane"
-        case "discord": return "bubble.left.and.bubble.right"
-        case "slack": return "number"
-        case "email": return "envelope"
-        default: return "bubble.left"
-        }
+        KnownPlatforms.icon(for: platform)
     }
 
     private func barColor(for toolName: String) -> Color {
         switch toolName {
-        case "terminal": return .orange
+        case "terminal", "execute_code": return .orange
         case "read_file", "search_files": return .green
         case "write_file", "patch": return .blue
         case "web_search", "web_extract": return .purple

scarf/scarf/Features/Memory/ViewModels/MemoryViewModel.swift

@@ -6,6 +6,7 @@ final class MemoryViewModel {
 
     var memoryContent = ""
     var userContent = ""
+    var memoryProvider = ""
     var isEditing = false
     var editingFile: EditTarget = .memory
     var editText = ""
@@ -17,9 +18,14 @@ final class MemoryViewModel {
     var memoryCharCount: Int { memoryContent.count }
     var userCharCount: Int { userContent.count }
 
+    var hasExternalProvider: Bool {
+        !memoryProvider.isEmpty && memoryProvider != "file"
+    }
+
     func load() {
         memoryContent = fileService.loadMemory()
         userContent = fileService.loadUserProfile()
+        memoryProvider = fileService.loadConfig().memoryProvider
     }
 
     func startEditing(_ target: EditTarget) {

scarf/scarf/Features/Memory/Views/MemoryView.swift

@@ -7,6 +7,18 @@ struct MemoryView: View {
     var body: some View {
         ScrollView {
             VStack(alignment: .leading, spacing: 20) {
+                if viewModel.hasExternalProvider {
+                    HStack(spacing: 8) {
+                        Image(systemName: "info.circle")
+                        Text("Memory is managed by \(viewModel.memoryProvider). File contents shown here may be stale.")
+                    }
+                    .font(.caption)
+                    .foregroundStyle(.orange)
+                    .padding(10)
+                    .frame(maxWidth: .infinity, alignment: .leading)
+                    .background(.orange.opacity(0.1))
+                    .clipShape(RoundedRectangle(cornerRadius: 8))
+                }
                 memorySection("Agent Memory", content: viewModel.memoryContent, charCount: viewModel.memoryCharCount, target: .memory)
                 memorySection("User Profile", content: viewModel.userContent, charCount: viewModel.userCharCount, target: .user)
             }

scarf/scarf/Features/Projects/Views/ProjectsView.swift

@@ -1,10 +1,16 @@
 import SwiftUI
 
+private enum DashboardTab: String, CaseIterable {
+    case dashboard = "Dashboard"
+    case site = "Site"
+}
+
 struct ProjectsView: View {
     @State private var viewModel = ProjectsViewModel()
     @Environment(AppCoordinator.self) private var coordinator
     @Environment(HermesFileWatcher.self) private var fileWatcher
     @State private var showingAddSheet = false
+    @State private var selectedTab: DashboardTab = .dashboard
 
     var body: some View {
         HSplitView {
@@ -76,18 +82,36 @@ struct ProjectsView: View {
 
     // MARK: - Dashboard Area
 
+    /// First webview widget found across all sections, if any.
+    private var siteWidget: DashboardWidget? {
+        viewModel.dashboard?.sections
+            .flatMap(\.widgets)
+            .first { $0.type == "webview" }
+    }
+
     @ViewBuilder
     private var dashboardArea: some View {
         if let dashboard = viewModel.dashboard {
-            ScrollView {
-                VStack(alignment: .leading, spacing: 20) {
-                    dashboardHeader(dashboard)
-                    ForEach(dashboard.sections) { section in
-                        DashboardSectionView(section: section)
+            VStack(spacing: 0) {
+                dashboardHeader(dashboard)
+                    .padding(.horizontal)
+                    .padding(.top)
+                    .padding(.bottom, 8)
+                if siteWidget != nil {
+                    tabBar
+                        .padding(.horizontal)
+                        .padding(.bottom, 8)
+                }
+                switch selectedTab {
+                case .dashboard:
+                    widgetsTab(dashboard)
+                case .site:
+                    if let widget = siteWidget {
+                        siteTab(widget)
+                    } else {
+                        widgetsTab(dashboard)
                     }
                 }
-                .padding()
-                .frame(maxWidth: .infinity, alignment: .topLeading)
             }
         } else if let error = viewModel.dashboardError {
             ContentUnavailableView {
@@ -112,6 +136,48 @@ struct ProjectsView: View {
         }
     }
 
+    private var tabBar: some View {
+        HStack(spacing: 0) {
+            ForEach(DashboardTab.allCases, id: \.self) { tab in
+                Button {
+                    selectedTab = tab
+                } label: {
+                    HStack(spacing: 4) {
+                        Image(systemName: tab == .dashboard ? "square.grid.2x2" : "globe")
+                            .font(.caption)
+                        Text(tab.rawValue)
+                            .font(.subheadline)
+                    }
+                    .padding(.horizontal, 12)
+                    .padding(.vertical, 6)
+                    .background(selectedTab == tab ? Color.accentColor.opacity(0.15) : Color.clear)
+                    .foregroundStyle(selectedTab == tab ? .primary : .secondary)
+                    .clipShape(RoundedRectangle(cornerRadius: 6))
+                }
+                .buttonStyle(.plain)
+            }
+            Spacer()
+        }
+    }
+
+    private func widgetsTab(_ dashboard: ProjectDashboard) -> some View {
+        ScrollView {
+            VStack(alignment: .leading, spacing: 20) {
+                ForEach(dashboard.sections) { section in
+                    DashboardSectionView(section: section)
+                }
+            }
+            .padding()
+            .frame(maxWidth: .infinity, alignment: .topLeading)
+        }
+    }
+
+    private func siteTab(_ widget: DashboardWidget) -> some View {
+        WebviewWidgetView(widget: widget, fullCanvas: true)
+            .padding(16)
+            .frame(maxWidth: .infinity, maxHeight: .infinity)
+    }
+
     private func dashboardHeader(_ dashboard: ProjectDashboard) -> some View {
         HStack {
             VStack(alignment: .leading, spacing: 2) {
@@ -152,16 +218,23 @@ struct ProjectsView: View {
 struct DashboardSectionView: View {
     let section: DashboardSection
 
+    /// Filter out webview widgets — those are rendered in the Site tab instead.
+    private var displayWidgets: [DashboardWidget] {
+        section.widgets.filter { $0.type != "webview" }
+    }
+
     var body: some View {
-        VStack(alignment: .leading, spacing: 8) {
-            Text(section.title)
-                .font(.headline)
-            LazyVGrid(
-                columns: Array(repeating: GridItem(.flexible(), spacing: 12), count: section.columnCount),
-                spacing: 12
-            ) {
-                ForEach(section.widgets) { widget in
-                    WidgetView(widget: widget)
+        if !displayWidgets.isEmpty {
+            VStack(alignment: .leading, spacing: 8) {
+                Text(section.title)
+                    .font(.headline)
+                LazyVGrid(
+                    columns: Array(repeating: GridItem(.flexible(), spacing: 12), count: section.columnCount),
+                    spacing: 12
+                ) {
+                    ForEach(displayWidgets) { widget in
+                        WidgetView(widget: widget)
+                    }
                 }
             }
         }
@@ -188,6 +261,8 @@ struct WidgetView: View {
                 ChartWidgetView(widget: widget)
             case "list":
                 ListWidgetView(widget: widget)
+            case "webview":
+                WebviewWidgetView(widget: widget)
             default:
                 VStack {
                     Image(systemName: "questionmark.square.dashed")

scarf/scarf/Features/Projects/Views/Widgets/WebviewWidgetView.swift

@@ -0,0 +1,116 @@
+import SwiftUI
+import WebKit
+
+struct WebviewWidgetView: View {
+    let widget: DashboardWidget
+    var fullCanvas: Bool = false
+
+    private var webURL: URL? {
+        guard let urlString = widget.url else { return nil }
+        return URL(string: urlString)
+    }
+
+    private var viewHeight: CGFloat {
+        CGFloat(widget.height ?? 400)
+    }
+
+    var body: some View {
+        if fullCanvas {
+            fullCanvasView
+        } else {
+            cardView
+        }
+    }
+
+    // MARK: - Full Canvas (Site tab)
+
+    private var fullCanvasView: some View {
+        VStack(spacing: 0) {
+            if let url = webURL {
+                WebViewRepresentable(url: url)
+                    .clipShape(RoundedRectangle(cornerRadius: 8))
+            } else {
+                ContentUnavailableView {
+                    Label("Invalid URL", systemImage: "globe")
+                } description: {
+                    Text(widget.url ?? "No URL provided")
+                }
+            }
+        }
+        .frame(maxWidth: .infinity, maxHeight: .infinity)
+    }
+
+    // MARK: - Card (inline widget)
+
+    private var cardView: some View {
+        VStack(alignment: .leading, spacing: 6) {
+            HStack {
+                if let icon = widget.icon {
+                    Image(systemName: icon)
+                        .foregroundStyle(.secondary)
+                        .font(.caption)
+                }
+                Text(widget.title)
+                    .font(.caption)
+                    .foregroundStyle(.secondary)
+                Spacer()
+                if let urlString = widget.url {
+                    Text(urlString)
+                        .font(.caption2)
+                        .foregroundStyle(.tertiary)
+                }
+            }
+            if let url = webURL {
+                WebViewRepresentable(url: url)
+                    .frame(height: viewHeight)
+                    .clipShape(RoundedRectangle(cornerRadius: 6))
+            } else {
+                ContentUnavailableView {
+                    Label("Invalid URL", systemImage: "globe")
+                } description: {
+                    Text(widget.url ?? "No URL provided")
+                }
+                .frame(height: viewHeight)
+            }
+        }
+        .frame(maxWidth: .infinity, alignment: .leading)
+        .padding(12)
+        .background(.quaternary.opacity(0.5))
+        .clipShape(RoundedRectangle(cornerRadius: 8))
+    }
+}
+
+// MARK: - WKWebView Wrapper
+
+private struct WebViewRepresentable: NSViewRepresentable {
+    let url: URL
+
+    func makeNSView(context: Context) -> WKWebView {
+        let config = WKWebViewConfiguration()
+        config.websiteDataStore = .nonPersistent()
+        let webView = WKWebView(frame: .zero, configuration: config)
+        webView.navigationDelegate = context.coordinator
+        webView.load(URLRequest(url: url))
+        return webView
+    }
+
+    func updateNSView(_ webView: WKWebView, context: Context) {
+        if webView.url != url {
+            webView.load(URLRequest(url: url))
+        }
+    }
+
+    func makeCoordinator() -> Coordinator {
+        Coordinator()
+    }
+
+    class Coordinator: NSObject, WKNavigationDelegate {
+        func webView(_ webView: WKWebView, didFail navigation: WKNavigation!, withError error: Error) {
+            print("[Scarf] WebView navigation failed: \(error.localizedDescription)")
+        }
+
+        func webView(_ webView: WKWebView, didFailProvisionalNavigation navigation: WKNavigation!, withError error: Error) {
+            print("[Scarf] WebView failed to load: \(error.localizedDescription)")
+        }
+    }
+}

scarf/scarf/Features/Sessions/ViewModels/SessionsViewModel.swift

@@ -83,17 +83,7 @@ final class SessionsViewModel {
         let result = runHermes(["sessions", "rename", sessionId, title])
         if result.exitCode == 0 {
             if let idx = sessions.firstIndex(where: { $0.id == sessionId }) {
-                let updated = HermesSession(
-                    id: sessions[idx].id, source: sessions[idx].source,
-                    userId: sessions[idx].userId, model: sessions[idx].model,
-                    title: title, parentSessionId: sessions[idx].parentSessionId,
-                    startedAt: sessions[idx].startedAt, endedAt: sessions[idx].endedAt,
-                    endReason: sessions[idx].endReason, messageCount: sessions[idx].messageCount,
-                    toolCallCount: sessions[idx].toolCallCount, inputTokens: sessions[idx].inputTokens,
-                    outputTokens: sessions[idx].outputTokens, cacheReadTokens: sessions[idx].cacheReadTokens,
-                    cacheWriteTokens: sessions[idx].cacheWriteTokens,
-                    estimatedCostUSD: sessions[idx].estimatedCostUSD
-                )
+                let updated = sessions[idx].withTitle(title)
                 sessions[idx] = updated
                 if selectedSession?.id == sessionId {
                     selectedSession = updated
@@ -158,10 +148,10 @@ final class SessionsViewModel {
         let fileSize: String
         if let attrs = try? FileManager.default.attributesOfItem(atPath: dbPath),
            let size = attrs[.size] as? Int {
-            if size >= 1_048_576 {
-                fileSize = String(format: "%.1f MB", Double(size) / 1_048_576)
+            if Double(size) >= FileSizeUnit.megabyte {
+                fileSize = String(format: "%.1f MB", Double(size) / FileSizeUnit.megabyte)
             } else {
-                fileSize = String(format: "%.0f KB", Double(size) / 1_024)
+                fileSize = String(format: "%.0f KB", Double(size) / FileSizeUnit.kilobyte)
             }
         } else {
             fileSize = "unknown"

scarf/scarf/Features/Sessions/Views/SessionDetailView.swift

@@ -44,6 +44,12 @@ struct SessionDetailView: View {
                 Label(session.model ?? "unknown", systemImage: "cpu")
                 Label("\(session.messageCount) msgs", systemImage: "bubble.left")
                 Label("\(session.toolCallCount) tools", systemImage: "wrench")
+                if session.reasoningTokens > 0 {
+                    Label("\(session.reasoningTokens) reasoning", systemImage: "brain")
+                }
+                if let cost = session.displayCostUSD {
+                    Label(String(format: "$%.4f%@", cost, session.costIsActual ? "" : " est."), systemImage: "dollarsign.circle")
+                }
                 if let date = session.startedAt {
                     Label(date.formatted(.dateTime.month().day().hour().minute()), systemImage: "calendar")
                 }
@@ -78,6 +84,16 @@ struct MessageBubble: View {
             HStack {
                 if message.isUser { Spacer(minLength: 60) }
                 VStack(alignment: .leading, spacing: 6) {
+                    if message.hasReasoning {
+                        DisclosureGroup("Reasoning") {
+                            Text(message.reasoning ?? "")
+                                .font(.caption.monospaced())
+                                .foregroundStyle(.secondary)
+                                .textSelection(.enabled)
+                        }
+                        .font(.caption.bold())
+                        .foregroundStyle(.orange)
+                    }
                     if !message.content.isEmpty {
                         Text(message.content)
                             .textSelection(.enabled)

scarf/scarf/Features/Settings/ViewModels/SettingsViewModel.swift

@@ -18,7 +18,12 @@ final class SettingsViewModel {
         config = fileService.loadConfig()
         gatewayState = fileService.loadGatewayState()
         hermesRunning = fileService.isHermesRunning()
-        rawConfigYAML = (try? String(contentsOfFile: HermesPaths.configYAML, encoding: .utf8)) ?? ""
+        do {
+            rawConfigYAML = try String(contentsOfFile: HermesPaths.configYAML, encoding: .utf8)
+        } catch {
+            print("[Scarf] Failed to read config.yaml: \(error.localizedDescription)")
+            rawConfigYAML = ""
+        }
         personalities = parsePersonalities()
     }
 
@@ -47,6 +52,9 @@ final class SettingsViewModel {
     func setVerbose(_ value: Bool) { setSetting("agent.verbose", value: value ? "true" : "false") }
     func setAutoTTS(_ value: Bool) { setSetting("voice.auto_tts", value: value ? "true" : "false") }
     func setSilenceThreshold(_ value: Int) { setSetting("voice.silence_threshold", value: String(value)) }
+    func setReasoningEffort(_ value: String) { setSetting("agent.reasoning_effort", value: value) }
+    func setShowCost(_ value: Bool) { setSetting("display.show_cost", value: value ? "true" : "false") }
+    func setApprovalMode(_ value: String) { setSetting("approvals.mode", value: value) }
 
     func openConfigInEditor() {
         NSWorkspace.shared.open(URL(fileURLWithPath: HermesPaths.configYAML))

scarf/scarf/Features/Settings/Views/SettingsView.swift

@@ -58,6 +58,7 @@ struct SettingsView: View {
             }
             ToggleRow(label: "Streaming", isOn: viewModel.config.streaming) { viewModel.setStreaming($0) }
             ToggleRow(label: "Show Reasoning", isOn: viewModel.config.showReasoning) { viewModel.setShowReasoning($0) }
+            ToggleRow(label: "Show Cost", isOn: viewModel.config.showCost) { viewModel.setShowCost($0) }
             ToggleRow(label: "Verbose", isOn: viewModel.config.verbose) { viewModel.setVerbose($0) }
         }
     }
@@ -68,6 +69,8 @@ struct SettingsView: View {
         SettingsSection(title: "Terminal", icon: "terminal") {
             PickerRow(label: "Backend", selection: viewModel.config.terminalBackend, options: viewModel.terminalBackends) { viewModel.setTerminalBackend($0) }
             StepperRow(label: "Max Turns", value: viewModel.config.maxTurns, range: 1...200) { viewModel.setMaxTurns($0) }
+            PickerRow(label: "Reasoning Effort", selection: viewModel.config.reasoningEffort, options: ["low", "medium", "high"]) { viewModel.setReasoningEffort($0) }
+            PickerRow(label: "Approval Mode", selection: viewModel.config.approvalMode, options: ["auto", "manual", "smart"]) { viewModel.setApprovalMode($0) }
         }
     }
 

scarf/scarf/Features/Tools/ViewModels/ToolsViewModel.swift

@@ -2,7 +2,7 @@ import Foundation
 
 @Observable
 final class ToolsViewModel {
-    var selectedPlatform: HermesToolPlatform = KnownPlatforms.all[0]
+    var selectedPlatform: HermesToolPlatform = KnownPlatforms.cli
     var toolsets: [HermesToolset] = []
     var mcpStatus: String = ""
     var isLoading = false
@@ -30,7 +30,13 @@ final class ToolsViewModel {
     }
 
     private func loadPlatforms() {
-        let config = (try? String(contentsOfFile: HermesPaths.configYAML, encoding: .utf8)) ?? ""
+        let config: String
+        do {
+            config = try String(contentsOfFile: HermesPaths.configYAML, encoding: .utf8)
+        } catch {
+            print("[Scarf] Failed to read config.yaml: \(error.localizedDescription)")
+            config = ""
+        }
         var platforms: [HermesToolPlatform] = []
         var inSection = false
         for line in config.components(separatedBy: "\n") {
@@ -54,9 +60,10 @@ final class ToolsViewModel {
                 }
             }
         }
-        availablePlatforms = platforms.isEmpty ? [KnownPlatforms.all[0]] : platforms
-        if !availablePlatforms.contains(where: { $0.name == selectedPlatform.name }) {
-            selectedPlatform = availablePlatforms[0]
+        availablePlatforms = platforms.isEmpty ? [KnownPlatforms.cli] : platforms
+        if !availablePlatforms.contains(where: { $0.name == selectedPlatform.name }),
+           let first = availablePlatforms.first {
+            selectedPlatform = first
         }
     }