honcho-cli 0.1.5__tar.gz → 0.2.0__tar.gz

{honcho_cli-0.1.5 → honcho_cli-0.2.0}/CHANGELOG.md

@@ -7,6 +7,21 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 
 ## [Unreleased]
 
+## [0.2.0] - 2026-09-21
+
+### Added
+
+- CLI requests carry `X-Honcho-Host: honcho-cli/<version> (<platform>)` so telemetry counts them as CLI traffic rather than direct SDK use (#1181)
+- Conclusion attribution on `honcho conclusion list` and `honcho conclusion search` (Honcho v3.2.0+): every row now carries `level`, `source_ids` and `times_derived`, so an extracted fact is distinguishable from a dreamed one. Table output shows a premise count; `--json` keeps the full id list, ready to pipe into `honcho conclusion get` (#952)
+- `honcho conclusion get <id>...` fetches conclusions by ID from anywhere in the workspace, with no observer/observed pair required. Feed it a conclusion's `source_ids` to walk a reasoning chain down to the explicit facts underneath it; IDs that no longer exist are reported rather than failing the command (#952)
+- `honcho conclusion derived <id>` lists what was built on top of a conclusion — the same edge walked upward. Worth checking before deleting or correcting a fact (#952)
+- `--level` on `honcho conclusion list` and `honcho conclusion search`, and `--derived-from` on `honcho conclusion list` (#952)
+- `--evidence` on `honcho peer chat` and `honcho workspace chat` (Honcho v3.2.0+): reports the conclusions and messages the dialectic read and the tools it called. Evidence is collated from what the agent accessed rather than reported by the model, so it over-reports and costs no extra model tokens. Messages are summarised per session, since evidence carries their identity but not their text (#1129)
+
+### Changed
+
+- Requires `honcho-ai` 2.5.0 (was 2.4.0), which carries the attribution fields and the evidence-bearing chat response
+
 ## [0.1.5] - 2026-09-09
 
 ### Added

{honcho_cli-0.1.5 → honcho_cli-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: honcho-cli
-Version: 0.1.5
+Version: 0.2.0
 Summary: A terminal for Honcho — memory that reasons.
 Project-URL: Homepage, https://github.com/plastic-labs/honcho
 Project-URL: Repository, https://github.com/plastic-labs/honcho
@@ -14,7 +14,7 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Topic :: Software Development :: Libraries
 Requires-Python: >=3.11
 Requires-Dist: click>=8.0.0
-Requires-Dist: honcho-ai>=2.4.0
+Requires-Dist: honcho-ai>=2.5.0
 Requires-Dist: httpx>=0.27.0
 Requires-Dist: rich>=13.0.0
 Requires-Dist: typer>=0.15.0

{honcho_cli-0.1.5 → honcho_cli-0.2.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "honcho-cli"
-version = "0.1.5"
+version = "0.2.0"
 description = "A terminal for Honcho — memory that reasons."
 readme = "README.md"
 requires-python = ">=3.11"
@@ -19,7 +19,7 @@ classifiers = [
 dependencies = [
     "click>=8.0.0",
     "typer>=0.15.0",
-    "honcho-ai>=2.4.0",
+    "honcho-ai>=2.5.0",
     "rich>=13.0.0",
     "httpx>=0.27.0",
 ]

{honcho_cli-0.1.5 → honcho_cli-0.2.0}/src/honcho_cli/__init__.py

@@ -1,3 +1,3 @@
 """Honcho CLI — a terminal for Honcho."""
 
-__version__ = "0.1.5"
+__version__ = "0.2.0"

{honcho_cli-0.1.5 → honcho_cli-0.2.0}/src/honcho_cli/commands/conclusion.py

@@ -18,6 +18,43 @@ app = typer.Typer(cls=HonchoTyperGroup, help="List, search, create, and delete p
 add_common_options(app)
 
 
+_LEVELS = ("explicit", "deductive", "inductive", "contradiction")
+
+#: Columns carrying a conclusion's attribution, shown alongside the content.
+_ATTRIBUTION_COLUMNS = ["id", "level", "source_ids", "times_derived", "content"]
+
+
+def _format_conclusion(c, workspace_id: str | None) -> dict:
+    """Shape a Conclusion for output.
+
+    ``level``, ``source_ids`` and ``times_derived`` are the attribution the
+    server started returning in Honcho v3.2.0. In table mode ``source_ids``
+    collapses to a count, since the ids are nanoids and a list of them makes
+    the row unreadable; JSON mode keeps the full list so it can be piped back
+    into ``honcho conclusion get``.
+    """
+    source_ids = c.source_ids or []
+    return {
+        "id": c.id,
+        "level": c.level,
+        "source_ids": source_ids if use_json() else len(source_ids),
+        "times_derived": c.times_derived,
+        "content": c.content if use_json() else c.content[:160],
+        "workspace_id": workspace_id,
+        "observer_id": c.observer_id,
+        "observed_id": c.observed_id,
+        "session_id": c.session_id,
+        "created_at": str(c.created_at),
+    }
+
+
+def _validate_level(level: str | None) -> str | None:
+    if level and level not in _LEVELS:
+        print_error("INVALID_LEVEL", f"--level must be one of: {', '.join(_LEVELS)}")
+        raise typer.Exit(1)
+    return level
+
+
 def _require_observer(observer: str | None) -> str:
     """Resolve observer peer ID; emit combined error if peer+workspace both missing."""
     config = get_resolved_config()
@@ -39,6 +76,16 @@ def list_conclusions(
     observer: Optional[str] = typer.Option(None, "--observer", help="Observer peer ID"),
     observed: Optional[str] = typer.Option(None, "--observed", help="Observed peer ID"),
     limit: int = typer.Option(10, "--limit", help="Max results"),
+    level: Optional[str] = typer.Option(
+        None,
+        "--level",
+        help="Only this reasoning level: explicit, deductive, inductive, contradiction",
+    ),
+    derived_from: Optional[str] = typer.Option(
+        None,
+        "--derived-from",
+        help="Only conclusions derived from this conclusion ID",
+    ),
     workspace: Optional[str] = typer.Option(None, "--workspace", "-w", help="Override workspace ID"),
     peer: Optional[str] = typer.Option(None, "--peer", "-p", help="Override peer ID"),
     json_output: bool = typer.Option(False, "--json", help="Force JSON output"),
@@ -46,31 +93,27 @@ def list_conclusions(
     """List conclusions."""
 
     handle_cmd_flags(json_output=json_output, workspace=workspace, peer=peer)
+    _validate_level(level)
     observer = _require_observer(observer)
     client, config = get_client()
 
     p = client.peer(observer)
 
+    filters: dict = {}
+    if level:
+        filters["level"] = level
+    if derived_from:
+        filters["source_ids"] = {"contains": derived_from}
+
     try:
         if observed:
             scope = p.conclusions_of(observed)
         else:
             scope = p.conclusions
 
-        conclusions = scope.list(size=limit).items
-        items = [
-            {
-                "id": c.id,
-                "content": c.content if use_json() else c.content[:200],
-                "workspace_id": config.workspace_id,
-                "observer_id": c.observer_id,
-                "observed_id": c.observed_id,
-                "session_id": c.session_id,
-                "created_at": str(c.created_at),
-            }
-            for c in conclusions
-        ]
-        print_result(items, columns=["id", "content", "workspace_id", "observer_id", "observed_id", "session_id", "created_at"], title="Conclusions")
+        conclusions = scope.list(size=limit, filters=filters or None).items
+        items = [_format_conclusion(c, config.workspace_id) for c in conclusions]
+        print_result(items, columns=_ATTRIBUTION_COLUMNS + ["observed_id", "created_at"], title="Conclusions")
     except Exception as e:
         _handle_error(e, "conclusion", "list")
 
@@ -81,6 +124,11 @@ def search(
     observer: Optional[str] = typer.Option(None, "--observer", help="Observer peer ID"),
     observed: Optional[str] = typer.Option(None, "--observed", help="Observed peer ID"),
     top_k: int = typer.Option(10, help="Max results"),
+    level: Optional[str] = typer.Option(
+        None,
+        "--level",
+        help="Only this reasoning level: explicit, deductive, inductive, contradiction",
+    ),
     workspace: Optional[str] = typer.Option(None, "--workspace", "-w", help="Override workspace ID"),
     peer: Optional[str] = typer.Option(None, "--peer", "-p", help="Override peer ID"),
     json_output: bool = typer.Option(False, "--json", help="Force JSON output"),
@@ -88,6 +136,7 @@ def search(
     """Semantic search over conclusions."""
 
     handle_cmd_flags(json_output=json_output, workspace=workspace, peer=peer)
+    _validate_level(level)
     observer = _require_observer(observer)
     client, config = get_client()
 
@@ -99,24 +148,80 @@ def search(
         else:
             scope = p.conclusions
 
-        results = scope.query(query, top_k=top_k)
-        items = [
-            {
-                "id": c.id,
-                "content": c.content if use_json() else c.content[:200],
-                "workspace_id": config.workspace_id,
-                "observer_id": c.observer_id,
-                "observed_id": c.observed_id,
-                "session_id": c.session_id,
-                "created_at": str(c.created_at),
-            }
-            for c in results
-        ]
-        print_result(items, columns=["id", "content", "workspace_id", "session_id", "created_at"], title=f"Conclusion search: {query}")
+        results = scope.query(query, top_k=top_k, filters={"level": level} if level else None)
+        items = [_format_conclusion(c, config.workspace_id) for c in results]
+        print_result(items, columns=_ATTRIBUTION_COLUMNS + ["created_at"], title=f"Conclusion search: {query}")
     except Exception as e:
         _handle_error(e, "conclusion", "search")
 
 
+@app.command()
+def get(
+    conclusion_ids: list[str] = typer.Argument(help="Conclusion IDs to fetch"),
+    workspace: Optional[str] = typer.Option(None, "--workspace", "-w", help="Override workspace ID"),
+    json_output: bool = typer.Option(False, "--json", help="Force JSON output"),
+) -> None:
+    """Fetch conclusions by ID, from anywhere in the workspace.
+
+    Pass a conclusion's source_ids to see the premises it was derived from,
+    and repeat to walk a reasoning chain down to the explicit facts it rests
+    on. IDs that no longer exist are reported rather than failing the command.
+    """
+
+    handle_cmd_flags(json_output=json_output, workspace=workspace)
+    client, config = get_client()
+
+    for cid in conclusion_ids:
+        validate_resource_id(cid, "conclusion")
+
+    try:
+        conclusions = client.conclusions.get_many(list(conclusion_ids))
+        found = {c.id for c in conclusions}
+        missing = [cid for cid in conclusion_ids if cid not in found]
+
+        items = [_format_conclusion(c, config.workspace_id) for c in conclusions]
+        print_result(items, columns=_ATTRIBUTION_COLUMNS + ["observed_id", "created_at"], title="Conclusions")
+        if missing:
+            print_error(
+                "MISSING_CONCLUSIONS",
+                f"Not in this workspace (consolidated or deleted): {', '.join(missing)}",
+            )
+    except Exception as e:
+        _handle_error(e, "conclusion", "get")
+
+
+@app.command()
+def derived(
+    conclusion_id: str = typer.Argument(help="The premise conclusion ID"),
+    limit: int = typer.Option(10, "--limit", help="Max results"),
+    workspace: Optional[str] = typer.Option(None, "--workspace", "-w", help="Override workspace ID"),
+    json_output: bool = typer.Option(False, "--json", help="Force JSON output"),
+) -> None:
+    """List the conclusions derived FROM a conclusion.
+
+    Walks the reasoning tree upward (premise -> conclusion); `conclusion get`
+    on a conclusion's source_ids walks it downward. Worth checking before
+    deleting or correcting a fact.
+    """
+
+    handle_cmd_flags(json_output=json_output, workspace=workspace)
+    validate_resource_id(conclusion_id, "conclusion")
+    client, config = get_client()
+
+    try:
+        page = client.conclusions.list(
+            size=limit, filters={"source_ids": {"contains": conclusion_id}}
+        )
+        items = [_format_conclusion(c, config.workspace_id) for c in page.items]
+        print_result(
+            items,
+            columns=_ATTRIBUTION_COLUMNS + ["observed_id", "created_at"],
+            title=f"Derived from {conclusion_id}",
+        )
+    except Exception as e:
+        _handle_error(e, "conclusion", "derived")
+
+
 @app.command()
 def create(
     content: str = typer.Argument(help="Conclusion content or JSON payload"),

{honcho_cli-0.1.5 → honcho_cli-0.2.0}/src/honcho_cli/commands/peer.py

@@ -15,7 +15,7 @@ from honcho_cli.recall import parse_csv_repeatable, reject_incompatible_recall,
 from honcho_cli.validation import validate_resource_id
 
 from honcho_cli._help import HonchoTyperGroup
-from honcho_cli.common import add_common_options, get_client, get_flag_overrides, get_resolved_config, handle_cmd_flags
+from honcho_cli.common import add_common_options, format_evidence, get_client, get_flag_overrides, get_resolved_config, handle_cmd_flags
 
 app = typer.Typer(cls=HonchoTyperGroup, help="List, create, chat with, search, and manage peers and their representations.")
 add_common_options(app)
@@ -141,6 +141,11 @@ def chat(
         "--sessions",
         help="Recall only from these session IDs (repeat or comma-separate); explicit conclusions only. Excludes -s and --scope.",
     ),
+    evidence: bool = typer.Option(
+        False,
+        "--evidence",
+        help="Also report what the answer was built from: the conclusions and messages read and the tools called.",
+    ),
     workspace: Optional[str] = typer.Option(None, "--workspace", "-w", help="Override workspace ID"),
     peer: Optional[str] = typer.Option(None, "--peer", "-p", help="Override peer ID"),
     session: Optional[str] = typer.Option(None, "--session", "-s", help="Override session ID"),
@@ -179,8 +184,19 @@ def chat(
 
     try:
         p = client.peer(pid)
-        response = p.chat(query, **chat_kwargs)
-        print_result({"peer_id": pid, "query": query, "response": response})
+        if not evidence:
+            response = p.chat(query, **chat_kwargs)
+            print_result({"peer_id": pid, "query": query, "response": response})
+            return
+        result = p.chat(query, include_evidence=True, **chat_kwargs)
+        print_result(
+            {
+                "peer_id": pid,
+                "query": query,
+                "response": result.content,
+                "evidence": format_evidence(result.evidence),
+            }
+        )
     except Exception as e:
         _handle_chat_error(e, "peer", pid)
 

{honcho_cli-0.1.5 → honcho_cli-0.2.0}/src/honcho_cli/commands/setup.py

@@ -29,6 +29,7 @@ from honcho_cli.config import (
     DEFAULT_BASE_URL,
     CLIConfig,
     OAuthTokens,
+    identity_headers,
 )
 from honcho_cli.output import print_error, print_result, set_json_mode, use_json
 
@@ -70,7 +71,8 @@ def _test_connection(base_url: str, api_key: str) -> tuple[bool, str]:
     substrings of error messages — robust to SDK message changes and locale.
     """
     try:
-        list(Honcho(base_url=base_url, api_key=api_key).workspaces())
+        client = Honcho(base_url=base_url, api_key=api_key, default_headers=identity_headers())
+        list(client.workspaces())
         return True, "OK"
     except AuthenticationError:
         return False, "Unauthorized — check your API key"
@@ -392,7 +394,12 @@ def doctor(
         try:
 
 
-            client = Honcho(base_url=config.base_url, api_key=key, workspace_id=config.workspace_id)
+            client = Honcho(
+                base_url=config.base_url,
+                api_key=key,
+                workspace_id=config.workspace_id,
+                default_headers=identity_headers(),
+            )
             client.get_configuration()
             ws_ok = True
             _add("Workspace reachable", True, config.workspace_id)

{honcho_cli-0.1.5 → honcho_cli-0.2.0}/src/honcho_cli/commands/workspace.py

@@ -16,12 +16,13 @@ from honcho import (
     ServerError,
 )
 
+from honcho_cli.config import identity_headers
 from honcho_cli.output import print_error, print_result, status, use_json
 from honcho_cli.recall import parse_csv_repeatable, reject_incompatible_recall, scope_for_sdk
 from honcho_cli.validation import validate_resource_id
 
 from honcho_cli._help import HonchoTyperGroup
-from honcho_cli.common import add_common_options, get_client, get_flag_overrides, get_resolved_config, handle_cmd_flags
+from honcho_cli.common import add_common_options, format_evidence, get_client, get_flag_overrides, get_resolved_config, handle_cmd_flags
 
 app = typer.Typer(cls=HonchoTyperGroup, help="List, create, inspect, chat, delete, and search workspaces.")
 add_common_options(app)
@@ -221,6 +222,11 @@ def chat(
         "--scope",
         help="Recall only from this scope. Repeat or comma-separate for several (explicit conclusions only). Excludes -s.",
     ),
+    evidence: bool = typer.Option(
+        False,
+        "--evidence",
+        help="Also report what the answer was built from: the conclusions and messages read and the tools called.",
+    ),
     workspace: Optional[str] = typer.Option(None, "--workspace", "-w", help="Override workspace ID"),
     session: Optional[str] = typer.Option(None, "--session", "-s", help="Override session ID"),
     json_output: bool = typer.Option(False, "--json", help="Force JSON output"),
@@ -252,8 +258,19 @@ def chat(
         chat_kwargs["scope"] = scope_arg
 
     try:
-        response = client.chat(query, **chat_kwargs)
-        print_result({"workspace_id": wid, "query": query, "response": response})
+        if not evidence:
+            response = client.chat(query, **chat_kwargs)
+            print_result({"workspace_id": wid, "query": query, "response": response})
+            return
+        result = client.chat(query, include_evidence=True, **chat_kwargs)
+        print_result(
+            {
+                "workspace_id": wid,
+                "query": query,
+                "response": result.content,
+                "evidence": format_evidence(result.evidence),
+            }
+        )
     except Exception as e:
         _handle_chat_error(e, "workspace", wid)
 
@@ -317,6 +334,7 @@ def _with_workspace(client, workspace_id: str):
         base_url=str(client.base_url),
         api_key=client._http.api_key if hasattr(client._http, "api_key") else None,
         workspace_id=workspace_id,
+        default_headers=identity_headers(),
     )
 
 

{honcho_cli-0.1.5 → honcho_cli-0.2.0}/src/honcho_cli/common.py

@@ -166,3 +166,44 @@ def add_common_options(app: typer.Typer) -> None:
 
         if ctx.invoked_subcommand is None:
             typer.echo(ctx.get_help())
+
+
+def format_evidence(evidence) -> dict:
+    """Shape a dialectic `Evidence` for output.
+
+    Evidence is collated from what the agent accessed rather than reported by
+    the model, so it over-reports: a conclusion is listed because the agent
+    read it, which is not proof the answer leaned on it. Messages carry
+    identity only -- no content -- so they are summarised per session rather
+    than listed one by one.
+    """
+    if evidence is None:
+        return {"conclusions": [], "messages": {"total": 0, "sessions": []}, "tool_calls": []}
+
+    sessions: dict[str, int] = {}
+    for m in evidence.messages:
+        sessions[m.session_id] = sessions.get(m.session_id, 0) + 1
+
+    return {
+        "conclusions": [
+            {
+                "id": c.id,
+                "level": c.level,
+                "content": c.content,
+                "source_ids": list(c.source_ids or []),
+                "session_id": c.session_id,
+                "created_at": str(c.created_at),
+            }
+            for c in evidence.conclusions
+        ],
+        "messages": {
+            "total": len(evidence.messages),
+            "sessions": [
+                {"session_id": sid, "count": n}
+                for sid, n in sorted(sessions.items(), key=lambda kv: -kv[1])
+            ],
+        },
+        "tool_calls": [
+            {"tool_name": t.tool_name, "tool_input": t.tool_input} for t in evidence.tool_calls
+        ],
+    }

{honcho_cli-0.1.5 → honcho_cli-0.2.0}/src/honcho_cli/config.py

@@ -27,11 +27,14 @@ from __future__ import annotations
 
 import json
 import os
+import sys
 import time
 from dataclasses import dataclass, fields
 from pathlib import Path
 from typing import TYPE_CHECKING
 
+from honcho_cli import __version__
+
 if TYPE_CHECKING:
     from honcho_cli.oauth import TokenResponse
 
@@ -279,9 +282,19 @@ class CLIConfig:
         return result
 
 
+def identity_headers() -> dict[str, str]:
+    """Headers identifying the CLI to Honcho's telemetry.
+
+    Overrides the Python SDK's own ``X-Honcho-Host`` default so CLI traffic is not
+    counted as direct SDK use. Follows the identity convention harness plugins use:
+    ``name/version (platform)``.
+    """
+    return {"X-Honcho-Host": f"honcho-cli/{__version__} ({sys.platform})"}
+
+
 def get_client_kwargs(config: CLIConfig) -> dict:
     """Build kwargs for Honcho client from config."""
-    kwargs: dict = {}
+    kwargs: dict = {"default_headers": identity_headers()}
     if config.base_url:
         kwargs["base_url"] = config.base_url
     api_key = config.resolved_api_key()

honcho_cli-0.2.0/tests/test_conclusion_attribution.py

@@ -0,0 +1,142 @@
+"""Conclusion attribution and dialectic evidence (Honcho v3.2.0+).
+
+Uses Typer's CliRunner against the real `app`. stdout is not a TTY under
+CliRunner, so the CLI emits JSON — which is what scripts and agents consume.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+from unittest.mock import MagicMock, patch
+
+import pytest
+from typer.testing import CliRunner
+
+from honcho_cli.main import app
+
+
+@pytest.fixture
+def cfg(tmp_path, monkeypatch):
+    f = tmp_path / "config.json"
+    monkeypatch.setattr("honcho_cli.config.CONFIG_DIR", tmp_path)
+    monkeypatch.setattr("honcho_cli.config.CONFIG_FILE", f)
+    for k in [k for k in os.environ if k.startswith("HONCHO_")]:
+        monkeypatch.delenv(k)
+    f.write_text(json.dumps({"apiKey": "k", "environmentUrl": "http://localhost:8000"}))
+    return f
+
+
+@pytest.fixture
+def runner():
+    return CliRunner()
+
+
+def _conclusion(cid: str, level: str = "inductive", source_ids: list[str] | None = None) -> MagicMock:
+    return MagicMock(
+        id=cid,
+        content=f"content for {cid}",
+        level=level,
+        source_ids=source_ids if source_ids is not None else ["p1", "p2"],
+        times_derived=3,
+        observer_id="alice",
+        observed_id="alice",
+        session_id="s1",
+        created_at="2026-09-15T00:00:00Z",
+    )
+
+
+class TestConclusionAttribution:
+    def test_list_reports_level_source_ids_and_times_derived(self, cfg, runner):
+        client = MagicMock()
+        config = MagicMock(workspace_id="ws1", peer_id="alice")
+        client.peer.return_value.conclusions.list.return_value = MagicMock(items=[_conclusion("c1")])
+
+        with patch("honcho_cli.commands.conclusion.get_client", return_value=(client, config)):
+            result = runner.invoke(app, ["conclusion", "list", "--level", "inductive", "-p", "alice"])
+
+        assert result.exit_code == 0
+        row = json.loads(result.stdout)[0]
+        assert row["level"] == "inductive"
+        assert row["source_ids"] == ["p1", "p2"]
+        assert row["times_derived"] == 3
+        # --level reaches the server as a filter rather than being applied locally
+        assert client.peer.return_value.conclusions.list.call_args.kwargs["filters"] == {"level": "inductive"}
+
+    def test_list_rejects_an_unknown_level(self, cfg, runner):
+        result = runner.invoke(app, ["conclusion", "list", "--level", "nonsense", "-p", "alice"])
+        assert result.exit_code == 1
+        assert json.loads(result.stderr)["error"]["code"] == "INVALID_LEVEL"
+
+    def test_get_reports_ids_the_server_did_not_return(self, cfg, runner):
+        client = MagicMock()
+        config = MagicMock(workspace_id="ws1", peer_id="alice")
+        client.conclusions.get_many.return_value = [_conclusion("c1", level="explicit", source_ids=[])]
+
+        with patch("honcho_cli.commands.conclusion.get_client", return_value=(client, config)):
+            result = runner.invoke(app, ["conclusion", "get", "c1", "gone"])
+
+        assert result.exit_code == 0
+        assert client.conclusions.get_many.call_args.args[0] == ["c1", "gone"]
+        err = json.loads(result.stderr)["error"]
+        assert err["code"] == "MISSING_CONCLUSIONS"
+        assert "gone" in err["message"]
+
+    def test_derived_asks_for_conclusions_containing_the_premise(self, cfg, runner):
+        client = MagicMock()
+        config = MagicMock(workspace_id="ws1", peer_id="alice")
+        client.conclusions.list.return_value = MagicMock(items=[_conclusion("c1")])
+
+        with patch("honcho_cli.commands.conclusion.get_client", return_value=(client, config)):
+            result = runner.invoke(app, ["conclusion", "derived", "p1"])
+
+        assert result.exit_code == 0
+        assert client.conclusions.list.call_args.kwargs["filters"] == {"source_ids": {"contains": "p1"}}
+
+
+class TestChatEvidence:
+    def _evidence(self) -> MagicMock:
+        return MagicMock(
+            conclusions=[_conclusion("c1", level="explicit", source_ids=[])],
+            messages=[
+                MagicMock(id="m1", session_id="s1", peer_id="alice", created_at="2026-09-15T00:00:00Z"),
+                MagicMock(id="m2", session_id="s1", peer_id="bob", created_at="2026-09-15T00:00:01Z"),
+            ],
+            tool_calls=[MagicMock(tool_name="search_memory", tool_input={"query": "q"})],
+        )
+
+    def test_peer_chat_returns_evidence_only_when_asked(self, cfg, runner):
+        client = MagicMock()
+        config = MagicMock(workspace_id="ws1", peer_id="alice", session_id=None)
+        peer = client.peer.return_value
+        peer.chat.return_value = "plain answer"
+
+        with patch("honcho_cli.commands.peer.get_client", return_value=(client, config)):
+            plain = runner.invoke(app, ["peer", "chat", "q", "-p", "alice"])
+        assert plain.exit_code == 0
+        assert json.loads(plain.stdout)["response"] == "plain answer"
+        assert "include_evidence" not in peer.chat.call_args.kwargs
+
+        peer.chat.return_value = MagicMock(content="answer", evidence=self._evidence())
+        with patch("honcho_cli.commands.peer.get_client", return_value=(client, config)):
+            result = runner.invoke(app, ["peer", "chat", "q", "-p", "alice", "--evidence"])
+
+        assert result.exit_code == 0
+        assert peer.chat.call_args.kwargs["include_evidence"] is True
+        evidence = json.loads(result.stdout)["evidence"]
+        assert evidence["conclusions"][0]["level"] == "explicit"
+        assert evidence["tool_calls"] == [{"tool_name": "search_memory", "tool_input": {"query": "q"}}]
+        # Messages carry identity only, so they collapse to per-session counts
+        assert evidence["messages"] == {"total": 2, "sessions": [{"session_id": "s1", "count": 2}]}
+
+    def test_workspace_chat_passes_the_flag_through(self, cfg, runner):
+        client = MagicMock()
+        config = MagicMock(workspace_id="ws1", session_id=None)
+        client.chat.return_value = MagicMock(content="answer", evidence=self._evidence())
+
+        with patch("honcho_cli.commands.workspace.get_client", return_value=(client, config)):
+            result = runner.invoke(app, ["workspace", "chat", "q", "-w", "ws1", "--evidence"])
+
+        assert result.exit_code == 0
+        assert client.chat.call_args.kwargs["include_evidence"] is True
+        assert json.loads(result.stdout)["evidence"]["messages"]["total"] == 2

{honcho_cli-0.1.5 → honcho_cli-0.2.0}/tests/test_config.py

@@ -6,7 +6,8 @@ import time
 from pathlib import Path
 
 import pytest
-from honcho_cli.config import CLIConfig, OAuthTokens, _config_dir
+from honcho_cli import __version__
+from honcho_cli.config import CLIConfig, OAuthTokens, _config_dir, get_client_kwargs
 from honcho_cli.oauth import TokenResponse
 
 
@@ -264,3 +265,11 @@ def test_save_sets_600_permissions(cfg_path):
     mode = stat.S_IMODE(os.stat(cfg_path).st_mode)
     # chmod(0o600) → rw- --- ---
     assert mode == 0o600, f"expected 0o600, got {oct(mode)}"
+
+
+def test_client_kwargs_identify_the_cli_as_the_host():
+    """CLI traffic overrides the SDK's own X-Honcho-Host so telemetry counts it as
+    harness traffic, not direct SDK use."""
+    kwargs = get_client_kwargs(CLIConfig(workspace_id="ws"))
+
+    assert kwargs["default_headers"]["X-Honcho-Host"].startswith(f"honcho-cli/{__version__} (")