feat(chat): port desktop tool display engine (ToolResultSummary + ToolViewBuilder) (#763)

* feat(chat): port desktop heuristic JSON summarizer engine

New com.m57.hermescontrol.ui.chat.tool.ToolResultSummary — a faithful
Kotlin port of the desktop app's lib/tool-result-summary.ts (verified
against its vitest suite, ported 1:1 to JUnit):

- formatToolResultSummary: wrapper unwrap (data/result/output/response/
  payload, up to 4 levels), priority-key ordering, array/record block
  formatting with depth caps, noise filtering (success:true etc.)
- extractToolErrorMessage: cycle-safe nested hunt for real error text
  through wrappers, with placeholder filtering (error:'none' ignored)
  and stderr deliberately excluded as an error signal

Also handles stringified-JSON payloads (re-parse on demand) like the
desktop's tryJson/norm layer.

Ported contract tests: ToolResultSummaryTest (10 cases).

* feat(chat): port desktop per-tool display engine (ToolViewBuilder)

Second half of the desktop engine port, in the new ui.chat.tool package:

- ToolView: the render model the builder produces — status/title/subtitle/
  detail/count/duration/stdout/stderr/exitCode/diff/searchHits/imageUrl —
  no raw JSON in UI code
- ToolViewBuilder: port of the desktop buildToolView (fallback-model):
  status heuristics (explicit success wins; non-zero exit alone is NOT an
  error), dynamic titles (Read/Searched/Ran with summarized commands),
  per-tool subtitle/detail (browser snapshot stats, terminal output
  preview, memory message, cron job counts), count-label cascade,
  web_search hit parsing, inline diff + stats, stdout/stderr split,
  duration formatting, redundant-detail suppression
- Mobile-specific tool cases carried into the builder: todo, fact_store,
  session_search, skills_list/view, skill_manage, process, x_search,
  vision_analyze, tool_search, image_generate, project_*, read_terminal,
  computer_use
- CommandSummarizer: port of the desktop summarize-command.ts (quote-aware
  compound split, pipe-tail strip, redirect/env cleanup)
- Terminal stdout reads the gateway's canonical merged `output` key with
  stdout/stderr fallback (mobile terminal_tool contract differs from
  desktop)

Tests: ToolViewBuilderTest (18), CommandSummarizerTest (8), all ported
or derived from the desktop suite. Full suite green: 655 tests.

---------

Co-authored-by: hy4ri <hy4ri@users.noreply.github.com>

app/src/main/java/com/m57/hermescontrol/ui/chat/tool/CommandSummarizer.kt

@@ -0,0 +1,215 @@
+package com.m57.hermescontrol.ui.chat.tool
+
+/**
+ * Reduce a verbose shell command to the "main" command, for display only.
+ *
+ * Ported from the desktop app's `lib/summarize-command.ts`. Agents wrap real
+ * work in plumbing — `cd <dir> && <cmd> 2>&1 | tail -N; echo "x_exit=..."` —
+ * which buries the command the user actually cares about. This peels that
+ * wrapper off using small head-word allowlists instead of one giant regex:
+ *
+ * 1. split into segments on top-level `&&` `||` `;` (quote-aware)
+ * 2. strip trailing pipe tails (`| head`, `| tail`, `| wc`, ...)
+ * 3. clean env var prefixes / redirects
+ * 4. drop setup/banner/status segments
+ *
+ * If one real command survives, show it. If multiple real commands survive,
+ * show a short `first command + N commands` label instead of flooding the row
+ * with every probe. The full command is always still available via Copy.
+ */
+object CommandSummarizer {
+    private val SILENT_HEADS =
+        setOf("cd", "pushd", "popd", "export", "set", "unset", "source", ".", "true", "false", ":")
+    private val PIPE_TAIL_HEADS = setOf("head", "tail", "wc", "sort", "uniq")
+
+    private fun basename(head: String): String = head.substringAfterLast('/').ifEmpty { head }
+
+    /** Split on command-chain separators, but NOT pipe. */
+    private fun splitCompoundCommand(input: String): List<String> {
+        val segments = mutableListOf<String>()
+        val buf = StringBuilder()
+        var quote: Char? = null
+
+        var i = 0
+        while (i < input.length) {
+            val ch = input[i]
+
+            if (quote != null) {
+                buf.append(ch)
+                if (ch == quote && input.getOrNull(i - 1) != '\\') {
+                    quote = null
+                }
+                i += 1
+                continue
+            }
+
+            if (ch == '"' || ch == '\'') {
+                quote = ch
+                buf.append(ch)
+                i += 1
+                continue
+            }
+
+            val op =
+                when {
+                    input.startsWith("&&", i) || input.startsWith("||", i) -> input.substring(i, i + 2)
+                    ch == ';' || ch == '\n' -> ch.toString()
+                    else -> ""
+                }
+
+            if (op.isNotEmpty()) {
+                segments += buf.toString()
+                buf.clear()
+                i += op.length
+                continue
+            }
+
+            buf.append(ch)
+            i += 1
+        }
+
+        segments += buf.toString()
+
+        return segments.map { stripPipeTail(it.trim()) }.filter { it.isNotEmpty() }
+    }
+
+    private fun splitWords(segment: String): List<String> {
+        val words = mutableListOf<String>()
+        val buf = StringBuilder()
+        var quote: Char? = null
+
+        for ((idx, ch) in segment.withIndex()) {
+            if (quote != null) {
+                buf.append(ch)
+                if (ch == quote && segment.getOrNull(idx - 1) != '\\') {
+                    quote = null
+                }
+                continue
+            }
+
+            if (ch == '"' || ch == '\'') {
+                quote = ch
+                buf.append(ch)
+                continue
+            }
+
+            if (ch.isWhitespace()) {
+                if (buf.isNotEmpty()) {
+                    words += buf.toString()
+                    buf.clear()
+                }
+                continue
+            }
+
+            buf.append(ch)
+        }
+
+        if (buf.isNotEmpty()) {
+            words += buf.toString()
+        }
+
+        return words
+    }
+
+    /** The command word of a segment, skipping any `FOO=bar` env assignments. */
+    private fun headWord(segment: String): String {
+        val tokens = splitWords(segment)
+        var index = 0
+
+        while (index < tokens.size && Regex("^[A-Za-z_]\\w*=").containsMatchIn(tokens[index])) {
+            index += 1
+        }
+
+        return basename(tokens.getOrNull(index) ?: "")
+    }
+
+    private fun stripPipeTail(segment: String): String {
+        val words = splitWords(segment)
+        val out = mutableListOf<String>()
+
+        for (i in words.indices) {
+            val word = words[i]
+
+            if (word == "|" && basename(words.getOrNull(i + 1) ?: "") in PIPE_TAIL_HEADS) {
+                break
+            }
+
+            out += word
+        }
+
+        return out.joinToString(" ").trim()
+    }
+
+    private fun cleanSegment(segment: String): String {
+        val words = splitWords(segment)
+        val out = mutableListOf<String>()
+
+        var i = 0
+        while (i < words.size) {
+            val word = words[i]
+
+            // `> file`, `2> file`, `>> file`, `2>&1` — drop the operator + its target.
+            if (Regex("^\\d*(?:>>?|<)$").matches(word)) {
+                i += 2
+                continue
+            }
+
+            if (Regex("^\\d*(?:>&|<&)\\d+$").matches(word)) {
+                i += 1
+                continue
+            }
+
+            out += word
+            i += 1
+        }
+
+        return out.joinToString(" ").trim()
+    }
+
+    private fun isBoundaryEcho(segment: String): Boolean {
+        val words = splitWords(segment)
+
+        if (basename(words.firstOrNull() ?: "") != "echo") {
+            return false
+        }
+
+        // Banner/status echoes are UI plumbing. Do not treat arbitrary
+        // `echo $VALUE` as noise; it may be the command's actual output.
+        val rest = words.drop(1).joinToString(" ")
+
+        return Regex("-{2,}|_exit=|(?:^|\\s|=)\\$[?{]|PIPESTATUS").containsMatchIn(rest)
+    }
+
+    fun summarizeShellCommand(raw: String?): String {
+        val original = (raw ?: "").trim()
+
+        if (original.isEmpty()) {
+            return ""
+        }
+
+        val segments = splitCompoundCommand(original)
+
+        if (segments.size <= 1) {
+            return cleanSegment(original).ifEmpty { original }
+        }
+
+        val core =
+            segments
+                .map { cleanSegment(it) }
+                .filter { segment ->
+                    val head = headWord(segment)
+
+                    segment.isNotEmpty() && head !in SILENT_HEADS && !isBoundaryEcho(segment)
+                }
+
+        if (core.isEmpty()) {
+            return original
+        }
+
+        if (core.size == 1) {
+            return core[0]
+        }
+
+        return "${core[0]} + ${core.size - 1} ${if (core.size == 2) "command" else "commands"}"
+    }
+}

app/src/main/java/com/m57/hermescontrol/ui/chat/tool/ToolResultSummary.kt

@@ -0,0 +1,567 @@
+package com.m57.hermescontrol.ui.chat.tool
+
+import kotlinx.serialization.json.Json
+import kotlinx.serialization.json.JsonArray
+import kotlinx.serialization.json.JsonElement
+import kotlinx.serialization.json.JsonNull
+import kotlinx.serialization.json.JsonObject
+import kotlinx.serialization.json.JsonPrimitive
+
+/**
+ * Heuristic JSON → human summary engine for tool results.
+ *
+ * Ported from the Hermes desktop app's `lib/tool-result-summary.ts`
+ * (verified against its vitest suite). Pure functions over a parsed
+ * [JsonElement] — no UI deps, fully unit-testable.
+ *
+ * Two exports:
+ * - [formatToolResultSummary]: best-effort one-line/block human summary of
+ *   any tool result payload (wrapper unwrap, priority keys, depth caps).
+ * - [extractToolErrorMessage]: deep hunt for a real error message through
+ *   nested wrappers, with placeholder-value filtering.
+ */
+object ToolResultSummary {
+    private val WRAPPER_KEYS = listOf("data", "result", "output", "response", "payload")
+
+    private val PRIORITY_KEYS =
+        listOf(
+            "title",
+            "name",
+            "path",
+            "file",
+            "filepath",
+            "url",
+            "href",
+            "link",
+            "status",
+            "id",
+            "message",
+            "summary",
+            "description",
+        )
+
+    private val ERROR_KEYS = listOf("error", "errors", "failure", "exception")
+
+    // 'stderr' deliberately excluded: many CLIs emit informational lines on
+    // stderr (npm progress, git's hint:, gcc's `In file included from`) that
+    // aren't errors. Treating those as error signal flipped tool cards into
+    // destructive styling for healthy commands.
+    private val ERROR_MSG_KEYS = listOf("message", "reason", "detail")
+    private val NON_ERROR_TEXT = setOf("", "0", "false", "none", "null", "nil", "ok", "success", "n/a", "na")
+
+    // ── helpers ──────────────────────────────────────────────────────────
+
+    private fun normalize(value: String): String = value.lowercase().trim()
+
+    private fun capitalize(value: String): String =
+        value.replaceFirstChar { if (it.isLowerCase()) it.titlecase() else it.toString() }
+
+    private fun titleCase(key: String): String =
+        key
+            .split(Regex("[_\\-.]+"))
+            .filter { it.isNotEmpty() }
+            .joinToString(" ") { capitalize(it) }
+
+    private fun pluralize(
+        n: Int,
+        noun: String,
+    ): String = "$n $noun${if (n == 1) "" else "s"}"
+
+    /** Trim + collapse whitespace, truncate with ellipsis. */
+    private fun clipInline(
+        value: String,
+        max: Int = 180,
+    ): String {
+        val c = value.replace(Regex("\\s+"), " ").trim()
+
+        return if (c.length > max) "${c.take(max - 1)}…" else c
+    }
+
+    /** First N lines + char cap, with a trailing ellipsis when clipped. */
+    private fun clipBlock(
+        value: String,
+        maxChars: Int = 1800,
+        maxLines: Int = 18,
+    ): String {
+        val t = value.trim()
+
+        if (t.isEmpty()) {
+            return ""
+        }
+
+        val lines = t.split("\n")
+        var text = lines.take(maxLines).joinToString("\n")
+        val clipped = lines.size > maxLines || text.length > maxChars
+
+        if (text.length > maxChars) {
+            text = text.take(maxChars - 1).trimEnd()
+        }
+
+        return if (clipped && !text.endsWith("…")) "$text…" else text
+    }
+
+    private fun firstString(
+        record: JsonObject,
+        keys: List<String>,
+    ): String {
+        for (k in keys) {
+            val v = record[k] ?: continue
+            if (v is JsonPrimitive && v.isString && v.content.trim().isNotEmpty()) {
+                return v.content.trim()
+            }
+        }
+
+        return ""
+    }
+
+    /** Re-parse stringified JSON payloads; everything else passes through. */
+    private fun norm(value: JsonElement?): JsonElement? {
+        val v = value ?: return null
+        if (v is JsonNull) {
+            return null
+        }
+        if (v !is JsonPrimitive || !v.isString) {
+            return v
+        }
+        val t = v.content.trim()
+        if (t.isEmpty() || !(t.startsWith("{") || t.startsWith("[") || t.startsWith("\""))) {
+            return v
+        }
+
+        return try {
+            Json.parseToJsonElement(t)
+        } catch (_: Exception) {
+            v
+        }
+    }
+
+    private fun isWrapperKey(k: String): Boolean = k in WRAPPER_KEYS
+
+    /** `success: true` / `ok: true` are noise — never rendered. */
+    private fun skipField(
+        k: String,
+        v: JsonElement?,
+    ): Boolean {
+        if (isWrapperKey(k)) {
+            return true
+        }
+
+        if ((k == "success" || k == "ok") && v is JsonPrimitive && !v.isString && v.content == "true") {
+            return true
+        }
+
+        return false
+    }
+
+    private fun scalarString(v: JsonElement?): String? {
+        if (v is JsonPrimitive && v.isString) {
+            return v.content
+        }
+
+        if (v is JsonPrimitive && !v.isString) {
+            val c = v.content
+            if (c == "true" || c == "false" || c.toDoubleOrNull() != null) {
+                return c
+            }
+        }
+
+        return null
+    }
+
+    private fun summarizeScalar(v: JsonElement?): String {
+        if (v is JsonPrimitive && v.isString) {
+            return clipInline(v.content)
+        }
+
+        if (v is JsonPrimitive && !v.isString) {
+            return v.content
+        }
+
+        return ""
+    }
+
+    private fun orderedKeys(keys: List<String>): List<String> {
+        val priority = PRIORITY_KEYS.filter { it in keys }
+        val rest = keys.filter { it !in PRIORITY_KEYS }
+
+        return priority + rest
+    }
+
+    private fun summarizeRecordInline(
+        record: JsonObject,
+        depth: Int,
+    ): String {
+        if (depth > 3) {
+            return pluralize(record.keys.size, "field")
+        }
+
+        val title =
+            firstString(record, listOf("title", "name", "path", "file", "filepath", "url", "href", "link", "id"))
+        val status = firstString(record, listOf("status", "category", "type"))
+        val message = firstString(record, listOf("snippet", "summary", "description", "message"))
+
+        if (title.isNotEmpty() && status.isNotEmpty()) {
+            return "${clipInline(title, 110)} (${clipInline(status, 54)})"
+        }
+
+        if (title.isNotEmpty() && message.isNotEmpty() && title != message) {
+            return "${clipInline(title, 90)} - ${clipInline(message, 84)}"
+        }
+
+        if (title.isNotEmpty()) {
+            return clipInline(title, 150)
+        }
+
+        val pairs =
+            orderedKeys(record.keys.toList())
+                .filter { k -> !skipField(k, record[k]) }
+                .mapNotNull { k ->
+                    val s = summarizeScalar(record[k])
+                    if (s.isEmpty()) null else "${titleCase(k)}: $s"
+                }
+                .take(2)
+
+        return if (pairs.isNotEmpty()) pairs.joinToString(" · ") else pluralize(record.keys.size, "field")
+    }
+
+    private fun summarizeListItem(
+        item: JsonElement?,
+        depth: Int,
+    ): String {
+        val v = norm(item)
+        if (v is JsonNull || v == null) {
+            return ""
+        }
+
+        val scalar = scalarString(v)
+        if (scalar != null) {
+            return clipInline(scalar)
+        }
+
+        if (v is JsonArray) {
+            return pluralize(v.size, "item")
+        }
+
+        if (v is JsonObject) {
+            return summarizeRecordInline(v, depth + 1)
+        }
+
+        return clipInline(v.toString())
+    }
+
+    private fun formatFieldValue(
+        value: JsonElement?,
+        depth: Int,
+    ): String {
+        val v = norm(value)
+        val scalar = summarizeScalar(v)
+
+        if (scalar.isNotEmpty()) {
+            return scalar
+        }
+
+        if (v == null || v is JsonNull) {
+            return ""
+        }
+
+        if (v is JsonArray) {
+            if (v.isEmpty()) {
+                return ""
+            }
+
+            val scalars = v.mapNotNull { summarizeScalar(it).takeIf { s -> s.isNotEmpty() } }
+
+            if (scalars.size == v.size && v.size <= 4) {
+                return clipInline(scalars.joinToString(", "))
+            }
+
+            val first = summarizeListItem(v.firstOrNull(), depth + 1)
+
+            return if (first.isNotEmpty()) "${pluralize(v.size, "item")} ($first)" else pluralize(v.size, "item")
+        }
+
+        if (v is JsonObject) {
+            return summarizeRecordInline(v, depth + 1)
+        }
+
+        return clipInline(v.toString())
+    }
+
+    /**
+     * "Returned N items" / "0 items" / "Returned an empty object" are all
+     * noise — better to render nothing and let the title carry the signal.
+     */
+    private fun formatArraySummary(
+        value: JsonArray,
+        depth: Int,
+    ): String {
+        if (value.isEmpty()) {
+            return ""
+        }
+
+        val max = 6
+        val lines =
+            value
+                .take(max)
+                .mapNotNull { item -> summarizeListItem(item, depth + 1).takeIf { it.isNotEmpty() } }
+                .map { "- $it" }
+                .toMutableList()
+
+        if (lines.isEmpty()) {
+            return ""
+        }
+
+        if (value.size > max) {
+            val remaining = value.size - max
+            lines += "- … $remaining more ${if (remaining == 1) "item" else "items"}"
+        }
+
+        return lines.joinToString("\n")
+    }
+
+    private fun formatRecordSummary(
+        record: JsonObject,
+        depth: Int,
+    ): String {
+        val keys = record.keys.toList()
+
+        if (keys.isEmpty()) {
+            return ""
+        }
+
+        if (depth <= 2) {
+            val direct = firstString(record, listOf("message", "summary", "description", "preview", "text", "content"))
+            val meaningful = keys.filter { k -> !skipField(k, record[k]) && !isWrapperKey(k) }
+
+            if (direct.isNotEmpty() && meaningful.size <= 1) {
+                return clipBlock(direct)
+            }
+        }
+
+        val candidates = orderedKeys(keys).filter { k -> !skipField(k, record[k]) }
+        val max = 8
+        val lines = mutableListOf<String>()
+
+        for (k in candidates) {
+            val v = formatFieldValue(record[k], depth + 1)
+
+            if (v.isEmpty()) {
+                continue
+            }
+
+            lines += "- ${titleCase(k)}: $v"
+
+            if (lines.size >= max) {
+                break
+            }
+        }
+
+        if (lines.isEmpty()) {
+            return ""
+        }
+
+        if (candidates.size > lines.size) {
+            val remaining = candidates.size - lines.size
+            lines += "- … ${pluralize(remaining, "field")}"
+        }
+
+        return lines.joinToString("\n")
+    }
+
+    private fun formatSummaryValue(
+        value: JsonElement?,
+        depth: Int,
+    ): String {
+        if (depth > 4) {
+            return ""
+        }
+
+        val v = norm(value)
+
+        if (v is JsonPrimitive && v.isString) {
+            return clipBlock(v.content)
+        }
+
+        if (v is JsonPrimitive && !v.isString) {
+            return v.content
+        }
+
+        if (v == null || v is JsonNull) {
+            return ""
+        }
+
+        if (v is JsonArray) {
+            return formatArraySummary(v, depth + 1)
+        }
+
+        if (v is JsonObject) {
+            return formatRecordSummary(v, depth + 1)
+        }
+
+        return clipInline(v.toString())
+    }
+
+    /** Peel up to 4 wrapper layers (`data` / `result` / `output` / …). */
+    private fun unwrapPayload(value: JsonElement?): JsonElement? {
+        var cur: JsonElement? = norm(value)
+
+        for (i in 0 until 4) {
+            val record = cur as? JsonObject ?: return cur
+            val key = WRAPPER_KEYS.firstOrNull { k -> record[k] != null && record[k] !is JsonNull } ?: return record
+
+            cur = norm(record[key])
+        }
+
+        return cur
+    }
+
+    // ── public API ───────────────────────────────────────────────────────
+
+    fun formatToolResultSummary(value: JsonElement?): String {
+        val unwrapped = formatSummaryValue(unwrapPayload(value), 0)
+
+        return if (unwrapped.isNotEmpty()) unwrapped else formatSummaryValue(value, 0)
+    }
+
+    // ── error extraction ─────────────────────────────────────────────────
+
+    private fun hasMeaningfulErrorValue(value: JsonElement?): Boolean {
+        val v = norm(value)
+
+        if (v == null || v is JsonNull) {
+            return false
+        }
+
+        if (v is JsonPrimitive) {
+            if (v.isString) {
+                return normalize(v.content) !in NON_ERROR_TEXT
+            }
+
+            return v.content != "0" && v.content != "false"
+        }
+
+        if (v is JsonArray) {
+            return v.any { hasMeaningfulErrorValue(it) }
+        }
+
+        if (v is JsonObject) {
+            return v.keys.isNotEmpty()
+        }
+
+        return true
+    }
+
+    private fun hasErrorSignal(record: JsonObject): Boolean {
+        val status = (record["status"] as? JsonPrimitive)?.takeIf { it.isString }?.content ?: ""
+
+        return (
+            (record["success"] as? JsonPrimitive)?.let { !it.isString && it.content == "false" } == true ||
+                (record["ok"] as? JsonPrimitive)?.let { !it.isString && it.content == "false" } == true ||
+                Regex(
+                    "\\b(error|failed|failure|fatal|exception)\\b",
+                    RegexOption.IGNORE_CASE,
+                ).containsMatchIn(status) ||
+                ERROR_KEYS.any { k -> hasMeaningfulErrorValue(record[k]) }
+        )
+    }
+
+    private fun valueErrorText(value: JsonElement?): String {
+        val v = norm(value)
+
+        if (v is JsonPrimitive && v.isString) {
+            return if (hasMeaningfulErrorValue(v)) clipBlock(v.content, 700, 12) else ""
+        }
+
+        if (v is JsonArray) {
+            return clipBlock(
+                v.mapNotNull {
+                    valueErrorText(it).takeIf {
+                            s ->
+                        s.isNotEmpty()
+                    }
+                }.take(3).joinToString("; "),
+                700,
+                12,
+            )
+        }
+
+        if (v is JsonObject) {
+            val direct = firstString(v, ERROR_MSG_KEYS)
+
+            if (direct.isNotEmpty()) {
+                return clipBlock(direct, 700, 12)
+            }
+        }
+
+        return ""
+    }
+
+    private fun findNestedError(
+        value: JsonElement?,
+        depth: Int,
+        seen: MutableSet<JsonElement>,
+    ): String {
+        if (depth > 5) {
+            return ""
+        }
+
+        val v = norm(value) ?: return ""
+
+        if (v is JsonNull) {
+            return ""
+        }
+
+        if (v in seen) {
+            return ""
+        }
+        seen.add(v)
+
+        if (v is JsonArray) {
+            for (item in v) {
+                val nested = findNestedError(item, depth + 1, seen)
+
+                if (nested.isNotEmpty()) {
+                    return nested
+                }
+            }
+
+            return ""
+        }
+
+        if (v !is JsonObject) {
+            return ""
+        }
+
+        for (k in ERROR_KEYS) {
+            if (!hasMeaningfulErrorValue(v[k])) {
+                continue
+            }
+
+            val text = valueErrorText(v[k])
+
+            if (text.isNotEmpty()) {
+                return text
+            }
+        }
+
+        if (hasErrorSignal(v)) {
+            val direct = firstString(v, ERROR_MSG_KEYS)
+
+            if (direct.isNotEmpty()) {
+                return clipBlock(direct, 700, 12)
+            }
+        }
+
+        for (k in ERROR_KEYS + WRAPPER_KEYS + listOf("details", "meta")) {
+            val nested = findNestedError(v[k], depth + 1, seen)
+
+            if (nested.isNotEmpty()) {
+                return nested
+            }
+        }
+
+        return ""
+    }
+
+    fun extractToolErrorMessage(value: JsonElement?): String = findNestedError(value, 0, mutableSetOf())
+}

app/src/main/java/com/m57/hermescontrol/ui/chat/tool/ToolView.kt

@@ -0,0 +1,62 @@
+package com.m57.hermescontrol.ui.chat.tool
+
+/** Render state of a tool call row. */
+enum class ToolViewStatus {
+    RUNNING,
+    SUCCESS,
+    ERROR,
+    WARNING,
+}
+
+data class SearchHit(
+    val title: String,
+    val url: String,
+    val snippet: String,
+)
+
+data class DiffStats(
+    val added: Int,
+    val removed: Int,
+)
+
+/**
+ * The full display model for one tool call, produced by [ToolViewBuilder].
+ *
+ * Ported shape from the desktop app's `ToolView` (fallback-model): the
+ * renderer reads only these fields — no raw JSON spelunking in UI code.
+ */
+data class ToolView(
+    val status: ToolViewStatus,
+    /** One-line headline: "Read /tmp/x", "Ran sleep 10 + 2 commands". */
+    val title: String,
+    /** Secondary line naming what was acted on (path, hostname, query…). */
+    val subtitle: String = "",
+    /** Expanded body text. */
+    val detail: String = "",
+    /** Optional section label above [detail] (e.g. "Search results"). */
+    val detailLabel: String? = null,
+    /** Compact count, e.g. "3 results". */
+    val countLabel: String? = null,
+    /** Human duration, e.g. "1.2s". */
+    val durationLabel: String? = null,
+    /** Terminal tools: stdout stream when the backend split streams. */
+    val stdout: String? = null,
+    /** Terminal tools: stderr stream when the backend split streams. */
+    val stderr: String? = null,
+    /** Terminal tools: numeric exit code. */
+    val exitCode: Int? = null,
+    /** Terminal tools: the command that actually ran (for the `$` line). */
+    val terminalCommand: String? = null,
+    /** File-edit tools: the diff to render. */
+    val inlineDiff: String? = null,
+    /** File-edit tools: the file the diff applies to. */
+    val diffPath: String? = null,
+    val diffStats: DiffStats? = null,
+    /** Image-producing tools: renderable URL (data: or http(s) image). */
+    val imageUrl: String? = null,
+    /** web_search: parsed result rows. */
+    val searchHits: List<SearchHit>? = null,
+    val searchQuery: String? = null,
+    /** Detected error text (destructive styling in the view). */
+    val error: String? = null,
+)

app/src/test/java/com/m57/hermescontrol/ui/chat/tool/CommandSummarizerTest.kt

@@ -0,0 +1,71 @@
+package com.m57.hermescontrol.ui.chat.tool
+
+import org.junit.Assert.assertEquals
+import org.junit.Test
+
+class CommandSummarizerTest {
+    @Test
+    fun `simple command passes through`() {
+        assertEquals("ls -la", CommandSummarizer.summarizeShellCommand("ls -la"))
+    }
+
+    @Test
+    fun `plumbing wrapper peels to the real command`() {
+        val summarized =
+            CommandSummarizer.summarizeShellCommand(
+                """cd /tmp && sleep 70 2>&1 | tail -5; echo "x_exit=${'$'}{PIPESTATUS[0]}"""",
+            )
+
+        assertEquals("sleep 70", summarized)
+    }
+
+    @Test
+    fun `multiple real commands become first plus count`() {
+        // Faithful to the TS port: the FIRST surviving segment leads the
+        // count line — echo is not a silent head, so it leads here.
+        assertEquals("echo hi + 2 commands", CommandSummarizer.summarizeShellCommand("echo hi && sleep 2 && ls"))
+    }
+
+    @Test
+    fun `redirects are cleaned`() {
+        // Env-prefix removal happens in headWord (classification only), so
+        // the output keeps FOO=bar — mirrors the TS behavior exactly.
+        assertEquals(
+            "FOO=bar python run.py",
+            CommandSummarizer.summarizeShellCommand("FOO=bar python run.py > /tmp/out.log 2>&1"),
+        )
+    }
+
+    @Test
+    fun `single-segment commands keep their pipe tail`() {
+        // Faithful to the TS port: the single-segment path re-cleans the
+        // ORIGINAL command (redirects only, no pipe handling) — pipe-tail
+        // stripping applies in the multi-segment path below.
+        assertEquals(
+            "grep foo bar.txt | tail -20",
+            CommandSummarizer.summarizeShellCommand("grep foo bar.txt | tail -20"),
+        )
+    }
+
+    @Test
+    fun `multi-segment commands strip pipe tails`() {
+        assertEquals(
+            "grep foo bar.txt + 1 command",
+            CommandSummarizer.summarizeShellCommand("cd /tmp && grep foo bar.txt | tail -20 && echo done"),
+        )
+    }
+
+    @Test
+    fun `quote-aware compound split keeps echo arguments intact`() {
+        // The `&&` inside quotes is not a separator, so this is two segments
+        // and echo (not silent) leads the count line.
+        val summarized = CommandSummarizer.summarizeShellCommand("""echo "a && b" && git status""")
+
+        assertEquals("""echo "a && b" + 1 command""", summarized)
+    }
+
+    @Test
+    fun `empty input stays empty`() {
+        assertEquals("", CommandSummarizer.summarizeShellCommand("  "))
+    }
+}

app/src/test/java/com/m57/hermescontrol/ui/chat/tool/ToolResultSummaryTest.kt

@@ -0,0 +1,141 @@
+package com.m57.hermescontrol.ui.chat.tool
+
+import kotlinx.serialization.json.Json
+import kotlinx.serialization.json.JsonPrimitive
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+/**
+ * Ported contract tests from the desktop app's
+ * `lib/tool-result-summary.test.ts` (vitest) — the engine must satisfy the
+ * same cases here.
+ */
+class ToolResultSummaryTest {
+    private fun parse(json: String) = Json.parseToJsonElement(json)
+
+    // ── formatToolResultSummary ─────────────────────────────────────────
+
+    @Test
+    fun `unwraps wrapper payloads into structured key-value lines`() {
+        val summary =
+            ToolResultSummary.formatToolResultSummary(
+                parse(
+                    """{"success":true,"result":{"data":{"path":"/tmp/demo.txt","status":"ok",""" +
+                        """"lines_written":12,"checksum":"abc123"}}}""",
+                ),
+            )
+
+        assertTrue(summary.contains("- Path: /tmp/demo.txt"))
+        assertTrue(summary.contains("- Status: ok"))
+        assertTrue(summary.contains("- Lines Written: 12"))
+        assertFalse(summary.contains("\"path\""))
+    }
+
+    @Test
+    fun `summarizes object arrays as readable list items`() {
+        val json =
+            """[
+                {"title":"First result","snippet":"alpha preview text"},
+                {"title":"Second result","status":"cached"},
+                {"title":"Third result","summary":"more details"},
+                {"title":"Fourth result","summary":"line 4"},
+                {"title":"Fifth result","summary":"line 5"},
+                {"title":"Sixth result","summary":"line 6"},
+                {"title":"Seventh result","summary":"line 7"}
+            ]"""
+        val summary = ToolResultSummary.formatToolResultSummary(parse(json))
+
+        assertTrue("got:\n$summary", summary.contains("- First result - alpha preview text"))
+        assertTrue(summary.contains("- Second result (cached)"))
+        assertTrue("got:\n$summary", summary.contains("- … 1 more item"))
+    }
+
+    @Test
+    fun `truncates long field values for compact display`() {
+        val summary =
+            ToolResultSummary.formatToolResultSummary(
+                parse("""{"message":"ok","details":"prefix ${"x".repeat(500)}"}"""),
+            )
+        val detailsLine = summary.split("\n").firstOrNull { it.startsWith("- Details:") }
+
+        assertTrue(detailsLine != null)
+        assertTrue(detailsLine!!.length < 230)
+        assertTrue(detailsLine.contains("…"))
+    }
+
+    @Test
+    fun `formats stringified json payloads without raw dumps`() {
+        val summary =
+            ToolResultSummary.formatToolResultSummary(
+                JsonPrimitive("""{"data":{"title":"Build report","completed":true}}"""),
+            )
+
+        assertTrue(summary.contains("- Title: Build report"))
+        assertTrue(summary.contains("- Completed: true"))
+    }
+
+    // ── extractToolErrorMessage ─────────────────────────────────────────
+
+    @Test
+    fun `finds nested error messages through wrappers`() {
+        val error =
+            ToolResultSummary.extractToolErrorMessage(
+                parse(
+                    """{"success":false,"result":{"output":{"error":{"message":""" +
+                        """"Permission denied writing /tmp/demo.txt"}}}}""",
+                ),
+            )
+
+        assertEquals("Permission denied writing /tmp/demo.txt", error)
+    }
+
+    @Test
+    fun `does not treat successful payload messages as errors`() {
+        val error =
+            ToolResultSummary.extractToolErrorMessage(
+                parse("""{"success":true,"message":"Completed successfully","data":{"count":3}}"""),
+            )
+
+        assertEquals("", error)
+    }
+
+    @Test
+    fun `ignores placeholder error fields in successful payloads`() {
+        val error =
+            ToolResultSummary.extractToolErrorMessage(
+                parse("""{"success":true,"data":{"error":"none","status":"ok"}}"""),
+            )
+
+        assertEquals("", error)
+    }
+
+    // ── extra edge cases beyond the desktop suite ───────────────────────
+
+    @Test
+    fun `empty array renders nothing instead of noise`() {
+        val summary = ToolResultSummary.formatToolResultSummary(parse("""{"results":[]}"""))
+
+        assertEquals("", summary)
+    }
+
+    @Test
+    fun `unwraps up to four wrapper levels`() {
+        val summary =
+            ToolResultSummary.formatToolResultSummary(
+                parse(
+                    """{"data":{"result":{"output":{"response":{"title":"deep","count":2}}}}}""",
+                ),
+            )
+
+        assertTrue(summary.contains("- Title: deep"))
+        assertTrue(summary.contains("- Count: 2"))
+    }
+
+    @Test
+    fun `scalar results pass through`() {
+        assertEquals("hello", ToolResultSummary.formatToolResultSummary(JsonPrimitive("hello")))
+        assertEquals("42", ToolResultSummary.formatToolResultSummary(JsonPrimitive(42)))
+    }
+}

app/src/test/java/com/m57/hermescontrol/ui/chat/tool/ToolViewBuilderTest.kt

@@ -0,0 +1,268 @@
+package com.m57.hermescontrol.ui.chat.tool
+
+import kotlinx.serialization.json.Json
+import kotlinx.serialization.json.JsonObject
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertNotNull
+import org.junit.Assert.assertNull
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+class ToolViewBuilderTest {
+    private fun parse(json: String): JsonObject? = Json.parseToJsonElement(json) as? JsonObject
+
+    private fun build(
+        tool: String,
+        args: String,
+        result: String,
+        isError: Boolean = false,
+        running: Boolean = false,
+    ) = ToolViewBuilder.build(tool, parse(args), parse(result), isError, running)
+
+    // ── status heuristics ────────────────────────────────────────────────
+
+    @Test
+    fun `terminal success with exit zero is success`() {
+        val view = build("terminal", """{"command":"ls -la"}""", """{"output":"wiring.tsx","exit_code":0}""")
+
+        assertEquals(ToolViewStatus.SUCCESS, view.status)
+        assertNull(view.error)
+        assertEquals("wiring.tsx", view.stdout)
+        assertEquals(0, view.exitCode)
+    }
+
+    @Test
+    fun `terminal non-zero exit without output is an error`() {
+        val view = build("terminal", """{"command":"exit 1"}""", """{"exit_code":1}""")
+
+        assertEquals(ToolViewStatus.ERROR, view.status)
+        assertEquals("Command failed with exit code 1.", view.error)
+    }
+
+    @Test
+    fun `terminal non-zero exit with output is not an error`() {
+        val view = build("terminal", """{"command":"grep foo bar"}""", """{"exit_code":1,"output":"nothing"}""")
+
+        assertEquals(ToolViewStatus.SUCCESS, view.status)
+        assertNull(view.error)
+        assertEquals("nothing", view.stdout)
+    }
+
+    @Test
+    fun `explicit success wins over stale isError envelope`() {
+        val view = build("memory", """{"action":"add","target":"user"}""", """{"success":true}""", isError = true)
+
+        assertEquals(ToolViewStatus.SUCCESS, view.status)
+    }
+
+    @Test
+    fun `rejected memory write is a warning not an error`() {
+        val view = build("memory", """{"action":"add"}""", """{"success":false,"message":"over budget"}""")
+
+        assertEquals(ToolViewStatus.WARNING, view.status)
+        assertEquals("over budget", view.error)
+    }
+
+    @Test
+    fun `running tool gets running status and pending title`() {
+        val view = build("terminal", """{"command":"sleep 10"}""", """{}""", running = true)
+
+        assertEquals(ToolViewStatus.RUNNING, view.status)
+        assertTrue(view.title.startsWith("Running"))
+    }
+
+    // ── titles / subtitles ───────────────────────────────────────────────
+
+    @Test
+    fun `read_file title names the target with line range`() {
+        val view =
+            build("read_file", """{"path":"/repo/src/a.kt","offset":10,"limit":5}""", """{"content":"10|a\n11|b"}""")
+
+        assertEquals("Read a.kt L10-14", view.title)
+        assertEquals("/repo/src/a.kt", view.subtitle)
+    }
+
+    @Test
+    fun `terminal title uses summarized command`() {
+        val view =
+            build(
+                "terminal",
+                """{"command":"cd /tmp && sleep 70 2>&1 | tail -5; echo \"x_exit=${'$'}{PIPESTATUS[0]}\""}""",
+                """{"output":"done"}""",
+            )
+
+        assertEquals(ToolViewStatus.SUCCESS, view.status)
+        assertTrue(view.title, view.title.startsWith("Ran "))
+        assertTrue(view.title, view.title.contains("sleep 70"))
+        assertFalse(view.title.contains("tail"))
+    }
+
+    @Test
+    fun `web_search parses hits and count`() {
+        val view =
+            build(
+                "web_search",
+                """{"search_term":"cats"}""",
+                """{"data":{"web":[
+                    {"title":"Cat Facts","url":"https://cats.example/1","description":"all about cats"},
+                    {"title":"More Cats","url":"https://cats.example/2","description":"even more"},
+                    {"title":"Cat Videos","url":"https://cats.example/3","description":"videos"}
+                ]}}""",
+            )
+
+        assertEquals("Searched \"cats\"", view.title)
+        assertEquals("3 results", view.countLabel)
+        assertEquals(3, view.searchHits?.size)
+        assertEquals("Cat Facts", view.searchHits?.first()?.title)
+        assertEquals("cats", view.searchQuery)
+        assertEquals("Search results", view.detailLabel)
+    }
+
+    @Test
+    fun `patch extracts inline diff with stats`() {
+        val view =
+            build(
+                "patch",
+                """{"path":"/repo/src/wiring.tsx"}""",
+                """{"inline_diff":"--- a/wiring.tsx\n+++ b/wiring.tsx\n@@ -1,1 +1,1 @@\n-old\n+new"}""",
+            )
+
+        assertNotNull(view.inlineDiff)
+        assertEquals("/repo/src/wiring.tsx", view.diffPath)
+        assertEquals(1, view.diffStats?.added)
+        assertEquals(1, view.diffStats?.removed)
+        assertEquals("wiring.tsx", view.title)
+    }
+
+    @Test
+    fun `browser_snapshot subtitle summarizes accessibility stats`() {
+        val view =
+            build(
+                "browser_snapshot",
+                """{}""",
+                """{"snapshot":"button \"Save\"\nbutton \"Cancel\"\nlink \"Docs\"\ntextbox \"Name\""}""",
+            )
+
+        assertTrue(view.subtitle, view.subtitle.contains("2 buttons"))
+        assertTrue(view.subtitle.contains("1 links"))
+        assertTrue(view.subtitle.contains("Top controls: Save, Cancel"))
+    }
+
+    // ── mobile-specific tools ────────────────────────────────────────────
+
+    @Test
+    fun `fact_store added fact gets clean summary and detail`() {
+        val view =
+            build(
+                "fact_store",
+                """{"action":"add"}""",
+                """{"status":"added","fact_id":42}""",
+            )
+
+        assertEquals("Fact added (ID: 42)", view.subtitle)
+    }
+
+    @Test
+    fun `fact_store list renders facts with trust scores`() {
+        val view =
+            build(
+                "fact_store",
+                """{"action":"search","query":"x"}""",
+                """{"count":1,"results":[{"fact_id":7,"content":"user likes tea",""" +
+                    """"category":"user_pref","trust_score":0.8}]}""",
+            )
+
+        assertEquals("1 facts (search: x)", view.subtitle)
+        assertTrue(view.detail, view.detail.contains("#7  user likes tea"))
+        assertTrue(view.detail.contains("trust: 0.80"))
+    }
+
+    @Test
+    fun `todo gets count subtitle and markers`() {
+        val view =
+            build(
+                "todo",
+                """{"action":"create"}""",
+                """{"summary":{"total":2,"pending":1,"completed":1},"todos":[
+                    {"id":"1","content":"one","status":"pending"},
+                    {"id":"2","content":"two","status":"completed"}
+                ]}""",
+            )
+
+        assertEquals("2 items (1 pending, 1 completed)", view.subtitle)
+        assertTrue(view.detail, view.detail.contains("[ ] 1. one"))
+        assertTrue(view.detail.contains("[x] 2. two"))
+    }
+
+    @Test
+    fun `cronjob list subtitle counts jobs`() {
+        val view =
+            build(
+                "cronjob",
+                """{"action":"list"}""",
+                """{"jobs":[{"name":"daily","schedule":"0 9 * * *"},{"name":"hourly","schedule":"0 * * * *"}]}""",
+            )
+
+        assertEquals("2 cron jobs", view.subtitle)
+        assertTrue(view.detail, view.detail.contains("- daily · 0 9 * * *"))
+    }
+
+    @Test
+    fun `session_search discover mode`() {
+        val view =
+            build(
+                "session_search",
+                """{"query":"auth"}""",
+                """{"mode":"discover","count":2,"results":[{"title":"Auth refactor",""" +
+                    """"when":"2026-07-01","snippet":"..."}]}""",
+            )
+
+        assertTrue(view.subtitle, view.subtitle.startsWith("2 sessions"))
+        assertTrue(view.detail, view.detail.contains("Auth refactor"))
+    }
+
+    @Test
+    fun `read_terminal custom detail`() {
+        val view =
+            build(
+                "read_terminal",
+                """{"session_id":"s1"}""",
+                """{"total_lines":50,"start":1,"end":20,"text":"line one","cursor_row":5}""",
+            )
+
+        assertEquals("Lines 1-20 of 50, cursor at row 5", view.subtitle)
+        assertTrue(view.detail, view.detail.contains("━━━ Terminal ━━━"))
+        assertTrue(view.detail.contains("line one"))
+    }
+
+    // ── unknown tools fall back to the generic engine ────────────────────
+
+    @Test
+    fun `unknown tool gets a heuristic summary not raw json`() {
+        val view =
+            build(
+                "weird_tool",
+                """{}""",
+                """{"result":{"data":{"title":"Build report","completed":true}}}""",
+            )
+
+        assertEquals("Weird Tool", view.title)
+        assertTrue(view.detail, view.detail.contains("Title: Build report"))
+        assertTrue(view.detail.contains("Completed: true"))
+        assertFalse(view.detail.contains("\"data\""))
+    }
+
+    @Test
+    fun `unknown tool error surfaces through the generic engine`() {
+        val view =
+            build(
+                "weird_tool",
+                """{}""",
+                """{"success":false,"error":{"message":"Permission denied"}}""",
+            )
+
+        assertEquals(ToolViewStatus.ERROR, view.status)
+        assertTrue(view.error?.contains("Permission denied") == true)
+    }
+}