Prepare Hermes Desktop v0.9.1

Author: itsdodobitch

Sources/HermesDesktop/Models/KanbanModels.swift

@@ -182,6 +182,7 @@ struct KanbanBoard: Codable, Hashable, Sendable {
     let hasHermesCLI: Bool
     let dispatcher: KanbanDispatcherStatus?
     let latestEventID: Int?
+    let warning: String?
     let tasks: [KanbanTask]
     let assignees: [KanbanAssignee]
     let tenants: [String]
@@ -195,6 +196,7 @@ struct KanbanBoard: Codable, Hashable, Sendable {
         case hasHermesCLI = "has_hermes_cli"
         case dispatcher
         case latestEventID = "latest_event_id"
+        case warning
         case tasks
         case assignees
         case tenants
@@ -209,6 +211,7 @@ struct KanbanBoard: Codable, Hashable, Sendable {
         hasHermesCLI: false,
         dispatcher: nil,
         latestEventID: nil,
+        warning: nil,
         tasks: [],
         assignees: [],
         tenants: [],

Sources/HermesDesktop/Models/SessionModels.swift

@@ -204,7 +204,7 @@ struct SessionMessageDisplay: Identifiable, Hashable, Sendable {
     init(message: SessionMessage) {
         id = message.id
         role = message.role
-        content = message.content
+        content = message.content?.strippingTerminalControlArtifacts
         timestampText = message.timestamp?.dateValue.map(DateFormatters.shortDateTimeString(from:))
 
         let displayMetadata = message.displayMetadata ?? [:]
@@ -223,6 +223,35 @@ struct SessionMessageDisplay: Identifiable, Hashable, Sendable {
     }
 }
 
+private extension String {
+    var strippingTerminalControlArtifacts: String {
+        var cleaned = self
+        let escape = "\u{001B}"
+        let bell = "\u{0007}"
+        cleaned = cleaned.replacingOccurrences(
+            of: "\(escape)\\][^\(bell)\(escape)]*(?:\(bell)|\(escape)\\\\)",
+            with: "",
+            options: .regularExpression
+        )
+        cleaned = cleaned.replacingOccurrences(
+            of: "\(escape)\\[[0-?]*[ -/]*[@-~]",
+            with: "",
+            options: .regularExpression
+        )
+        cleaned = cleaned.replacingOccurrences(
+            of: "(?m)(^|\\s)(?:\\d{1,3}m;?){2,}(?:\\s+|(?=[.,:!?)]|$))",
+            with: "$1",
+            options: .regularExpression
+        )
+        cleaned = cleaned.replacingOccurrences(
+            of: "(?m)(^|\\s)(?:\\d{1,3};){1,8}\\d{1,3}m(?:\\s+|(?=[.,:!?)]|$))",
+            with: "$1",
+            options: .regularExpression
+        )
+        return cleaned
+    }
+}
+
 struct SessionMetadataDisplayItem: Identifiable, Hashable, Sendable {
     let key: String
     let value: JSONValue

Sources/HermesDesktop/Services/KanbanBrowserService.swift

@@ -2164,6 +2164,7 @@ final class KanbanBrowserService: @unchecked Sendable {
                 "has_hermes_cli": has_cli,
                 "dispatcher": dispatcher_status(),
                 "latest_event_id": None,
+                "warning": None,
                 "tasks": [],
                 "assignees": [],
                 "tenants": [],
@@ -2175,18 +2176,35 @@ final class KanbanBrowserService: @unchecked Sendable {
             conn = None
             try:
                 if kb is not None:
-                    conn = connect_for_board(kb, board_slug, writable=False)
-                    tasks = [
-                        task_object_to_dict(task, conn)
-                        for task in kb.list_tasks(conn, include_archived=include_archived)
-                    ]
                     try:
-                        assignees = kb.known_assignees(conn)
-                    except Exception:
+                        conn = connect_for_board(kb, board_slug, writable=False)
+                        tasks = [
+                            task_object_to_dict(task, conn)
+                            for task in kb.list_tasks(conn, include_archived=include_archived)
+                        ]
+                        try:
+                            assignees = kb.known_assignees(conn)
+                        except Exception:
+                            assignees = direct_assignees(conn)
+                        try:
+                            stats = kb.board_stats(conn)
+                        except Exception:
+                            stats = direct_stats(conn)
+                    except Exception as exc:
+                        try:
+                            if conn is not None:
+                                conn.close()
+                        finally:
+                            conn = None
+                        base["warning"] = (
+                            "The remote Hermes Kanban module could not read this board "
+                            f"({exc}). Showing a direct database view instead. "
+                            "Some Kanban actions may still fail until Hermes Agent and the board database schema are in sync on the host."
+                        )
+                        conn = connect_sqlite_readonly(db_path)
+                        conn.row_factory = sqlite3.Row
+                        tasks = direct_tasks(conn, include_archived)
                         assignees = direct_assignees(conn)
-                    try:
-                        stats = kb.board_stats(conn)
-                    except Exception:
                         stats = direct_stats(conn)
                 else:
                     conn = connect_sqlite_readonly(db_path)
@@ -2250,33 +2268,40 @@ final class KanbanBrowserService: @unchecked Sendable {
             conn = None
             try:
                 if kb is not None:
-                    conn = connect_for_board(kb, board_slug, writable=False)
-                    task = kb.get_task(conn, task_id)
-                    if task is None:
-                        return None
-                    parent_ids = kb.parent_ids(conn, task_id)
-                    child_ids = kb.child_ids(conn, task_id)
-                    comments = [comment_to_dict(item) for item in kb.list_comments(conn, task_id)]
-                    events = [event_to_dict(item) for item in kb.list_events(conn, task_id)]
-                    runs = [run_to_dict(item) for item in kb.list_runs(conn, task_id)]
-                    worker_log = None
                     try:
-                        if supports_keyword(kb.read_worker_log, "board"):
-                            worker_log = kb.read_worker_log(task_id, tail_bytes=65536, board=board_slug)
-                        else:
-                            worker_log = kb.read_worker_log(task_id, tail_bytes=65536)
-                    except Exception:
+                        conn = connect_for_board(kb, board_slug, writable=False)
+                        task = kb.get_task(conn, task_id)
+                        if task is None:
+                            return None
+                        parent_ids = kb.parent_ids(conn, task_id)
+                        child_ids = kb.child_ids(conn, task_id)
+                        comments = [comment_to_dict(item) for item in kb.list_comments(conn, task_id)]
+                        events = [event_to_dict(item) for item in kb.list_events(conn, task_id)]
+                        runs = [run_to_dict(item) for item in kb.list_runs(conn, task_id)]
                         worker_log = None
-                    return {
-                        "task": task_object_to_dict(task, conn),
-                        "parent_ids": parent_ids,
-                        "child_ids": child_ids,
-                        "comments": comments,
-                        "events": events,
-                        "runs": runs,
-                        "worker_log": worker_log,
-                        "home_channels": home_channels_for_task(conn, task_id),
-                    }
+                        try:
+                            if supports_keyword(kb.read_worker_log, "board"):
+                                worker_log = kb.read_worker_log(task_id, tail_bytes=65536, board=board_slug)
+                            else:
+                                worker_log = kb.read_worker_log(task_id, tail_bytes=65536)
+                        except Exception:
+                            worker_log = None
+                        return {
+                            "task": task_object_to_dict(task, conn),
+                            "parent_ids": parent_ids,
+                            "child_ids": child_ids,
+                            "comments": comments,
+                            "events": events,
+                            "runs": runs,
+                            "worker_log": worker_log,
+                            "home_channels": home_channels_for_task(conn, task_id),
+                        }
+                    except Exception:
+                        try:
+                            if conn is not None:
+                                conn.close()
+                        finally:
+                            conn = None
 
                 conn = connect_sqlite_readonly(db_path)
                 conn.row_factory = sqlite3.Row
@@ -2316,23 +2341,37 @@ final class KanbanBrowserService: @unchecked Sendable {
                         })
                 runs = []
                 if table_exists(conn, "task_runs"):
-                    for item in conn.execute(
-                        "SELECT * FROM task_runs WHERE task_id = ? ORDER BY started_at ASC, id ASC",
-                        (task_id,),
-                    ).fetchall():
+                    run_columns = table_columns(conn, "task_runs")
+                    if "task_id" in run_columns:
+                        order_columns = []
+                        if "started_at" in run_columns:
+                            order_columns.append("started_at ASC")
+                        if "id" in run_columns:
+                            order_columns.append("id ASC")
+                        order_sql = ", ".join(order_columns) if order_columns else "rowid ASC"
+                        run_rows = conn.execute(
+                            f"SELECT * FROM task_runs WHERE task_id = ? ORDER BY {order_sql}",
+                            (task_id,),
+                        ).fetchall()
+                    else:
+                        run_rows = []
+                    for item in run_rows:
+                        keys = set(item.keys())
+                        def get(name, default=None):
+                            return item[name] if name in keys else default
                         runs.append({
-                            "id": int_value(item["id"], 0),
-                            "task_id": item["task_id"],
-                            "profile": item["profile"],
-                            "step_key": item["step_key"],
-                            "status": item["status"],
-                            "outcome": item["outcome"],
-                            "summary": item["summary"],
-                            "error": item["error"],
-                            "metadata": parse_json_object(item["metadata"]),
-                            "worker_pid": int_value(item["worker_pid"]),
-                            "started_at": int_value(item["started_at"], 0),
-                            "ended_at": int_value(item["ended_at"]),
+                            "id": int_value(get("id"), 0),
+                            "task_id": get("task_id"),
+                            "profile": get("profile"),
+                            "step_key": get("step_key"),
+                            "status": get("status", ""),
+                            "outcome": get("outcome"),
+                            "summary": get("summary"),
+                            "error": get("error"),
+                            "metadata": parse_json_object(get("metadata")),
+                            "worker_pid": int_value(get("worker_pid")),
+                            "started_at": int_value(get("started_at"), 0),
+                            "ended_at": int_value(get("ended_at")),
                         })
                 log_path = worker_log_path(task_id, board_slug)
                 worker_log = None

Sources/HermesDesktop/Services/SSH/SSHTransport.swift

@@ -39,6 +39,7 @@ final class SSHTransport: @unchecked Sendable {
 
     private enum ConnectionPurpose {
         case service
+        case serviceWithoutMultiplexing
         case terminalShell
     }
 
@@ -70,11 +71,29 @@ final class SSHTransport: @unchecked Sendable {
             purpose: .service
         )
 
-        return try await processRunner.run(
+        let result = try await processRunner.run(
             executableURL: URL(fileURLWithPath: "/usr/bin/ssh"),
             arguments: arguments,
             standardInput: standardInput
         )
+
+        guard result.exitCode != 0,
+              shouldRetryWithoutMultiplexing(result) else {
+            return result
+        }
+
+        let retryArguments = sshArguments(
+            for: connection,
+            remoteCommand: remoteCommand,
+            allocateTTY: allocateTTY,
+            purpose: .serviceWithoutMultiplexing
+        )
+
+        return try await processRunner.run(
+            executableURL: URL(fileURLWithPath: "/usr/bin/ssh"),
+            arguments: retryArguments,
+            standardInput: standardInput
+        )
     }
 
     func executeJSON<Response: Decodable>(
@@ -177,9 +196,9 @@ final class SSHTransport: @unchecked Sendable {
                 "-o", "ControlPersist=300",
                 "-o", "ControlPath=\(paths.controlPath(for: connection))"
             ])
-        case .terminalShell:
-            // Keep interactive terminal shells isolated from background RPC-style
-            // requests so an open PTY session cannot destabilize profile reloads.
+        case .serviceWithoutMultiplexing, .terminalShell:
+            // Keep direct sessions isolated when multiplexing could be stale or
+            // when an open PTY should not share the background RPC connection.
             arguments.append(contentsOf: [
                 "-o", "ControlMaster=no",
                 "-S", "none"
@@ -279,6 +298,23 @@ final class SSHTransport: @unchecked Sendable {
         return "SSH command failed with exit code \(exitCode)."
     }
 
+    private func shouldRetryWithoutMultiplexing(_ result: SSHCommandResult) -> Bool {
+        let message = [result.stderr, result.stdout]
+            .map { $0.lowercased() }
+            .joined(separator: "\n")
+
+        return message.contains("no route to host") ||
+            message.contains("network is unreachable") ||
+            message.contains("connection timed out") ||
+            message.contains("operation timed out") ||
+            message.contains("connection refused") ||
+            message.contains("connection reset") ||
+            message.contains("connection closed") ||
+            message.contains("broken pipe") ||
+            message.contains("mux_client") ||
+            message.contains("control socket")
+    }
+
     private func isLoopbackTarget(_ target: String?) -> Bool {
         guard let target else { return false }
         let normalized = target.trimmingCharacters(in: .whitespacesAndNewlines).lowercased()

Sources/HermesDesktop/Services/SessionBrowserService.swift

@@ -153,6 +153,7 @@ final class SessionBrowserService: @unchecked Sendable {
                     model = None
                     if context["session_model_column"]:
                         model = sanitize_model(record.get(context["session_model_column"]))
+                    model = latest_model_for_session(context, session_id, model)
 
                     items.append({
                         "id": session_id,
@@ -522,17 +523,47 @@ final class SessionBrowserService: @unchecked Sendable {
                 return direct
 
             metadata = record.get("metadata")
+            if not isinstance(metadata, dict):
+                metadata_text = stringify(metadata)
+                if metadata_text:
+                    try:
+                        parsed_metadata = json.loads(metadata_text)
+                        if isinstance(parsed_metadata, dict):
+                            metadata = parsed_metadata
+                    except Exception:
+                        pass
             if isinstance(metadata, dict):
                 nested = sanitize_model(
                     metadata.get("model") or
                     metadata.get("model_name") or
-                    metadata.get("default_model")
+                    metadata.get("default_model") or
+                    metadata.get("active_model")
                 )
                 if nested:
                     return nested
 
             return None
 
+        def latest_model_for_session(context, session_id, fallback=None):
+            query = (
+                f"SELECT * FROM {quote_ident(context['message_table'])} "
+                f"WHERE {quote_ident(context['message_session_id_column'])} = ? "
+                "ORDER BY "
+            )
+            if context["message_timestamp_column"]:
+                query += f"{quote_ident(context['message_timestamp_column'])} DESC, "
+            query += f"{quote_ident(context['message_id_column'])} DESC LIMIT 80"
+            try:
+                rows = context["connection"].execute(query, (session_id,)).fetchall()
+            except Exception:
+                return fallback
+            for row in rows:
+                record = dict(zip(context["message_columns"], row))
+                model = extract_model_from_record(record)
+                if model:
+                    return model
+            return fallback
+
         def parse_timestamp_value(value):
             if value is None:
                 return None

Sources/HermesDesktop/Services/Terminal/TerminalViewHost.swift

@@ -218,7 +218,6 @@ final class TerminalViewHost: NSObject, LocalProcessTerminalViewDelegate {
             }
 
             self.hostView.submit(initialInput)
-            hostView.submit(initialInput)
         }
     }
 }

Sources/HermesDesktop/Views/Kanban/KanbanView.swift

@@ -351,6 +351,10 @@ struct KanbanView: View {
                 subtitle: boardSubtitle(board)
             ) {
                 VStack(alignment: .leading, spacing: 12) {
+                    if let warning = board.warning {
+                        KanbanWarningBanner(message: warning)
+                    }
+
                     if let warning = dispatcherWarning(for: board) {
                         KanbanWarningBanner(message: warning)
                     }