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

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

@@ -7,6 +7,27 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 
 ## [Unreleased]
 
+## [0.2.1] - 2026-10-20
+
+### Fixed
+
+- `honcho session summaries`, `honcho session inspect`, `honcho session context` and `honcho workspace queue-status` emit nested SDK objects (summaries, context messages, per-session queue status) as JSON objects instead of Python repr strings like `"content='...' message_id='...'"` (#1324)
+
+## [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.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: honcho-cli
-Version: 0.1.5
+Version: 0.2.1
 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.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "honcho-cli"
-version = "0.1.5"
+version = "0.2.1"
 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.1}/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.1}/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.1}/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.1}/src/honcho_cli/commands/session.py

@@ -27,6 +27,23 @@ app = typer.Typer(cls=HonchoTyperGroup, help="List, inspect, view, create, delet
 add_common_options(app)
 
 
+def _summary_to_dict(summary) -> dict | None:
+    """Serialize an SDK ``Summary`` model, which ``json.dumps`` would otherwise stringify."""
+    return summary.model_dump(mode="json") if summary is not None else None
+
+
+def _message_to_dict(m) -> dict:
+    """Serialize an SDK ``Message`` to the CLI's message shape."""
+    return {
+        "id": m.id,
+        "peer_id": m.peer_id,
+        "content": m.content,
+        "token_count": m.token_count,
+        "metadata": m.metadata,
+        "created_at": str(m.created_at),
+    }
+
+
 def _get_session_id(session_id: str | None) -> str:
 
     config = get_resolved_config()
@@ -132,8 +149,8 @@ def inspect(
             "peers": [{"id": p.id} for p in peers],
             "message_count": msg_page.total,
             "summaries": {
-                "short": summaries.short_summary if hasattr(summaries, "short_summary") else None,
-                "long": summaries.long_summary if hasattr(summaries, "long_summary") else None,
+                "short": _summary_to_dict(summaries.short_summary),
+                "long": _summary_to_dict(summaries.long_summary),
             },
             "configuration": _config_to_dict(sess_config) if sess_config else None,
         }
@@ -334,17 +351,7 @@ def view(
             if not reverse:
                 msgs = list(reversed(msgs))
 
-        items = [
-            {
-                "id": m.id,
-                "peer_id": m.peer_id,
-                "content": m.content,
-                "token_count": m.token_count,
-                "metadata": m.metadata,
-                "created_at": str(m.created_at),
-            }
-            for m in msgs
-        ]
+        items = [_message_to_dict(m) for m in msgs]
     except Exception as e:
         _handle_error(e, "session", sid)
         raise  # unreachable: _handle_error always exits
@@ -394,8 +401,13 @@ def context(
 
     try:
         ctx = sess.context(tokens=tokens, summary=summary)
-        result = ctx.__dict__ if hasattr(ctx, "__dict__") else ctx
-        print_result(result)
+        print_result({
+            "session_id": ctx.session_id,
+            "summary": _summary_to_dict(ctx.summary),
+            "peer_representation": ctx.peer_representation,
+            "peer_card": ctx.peer_card,
+            "messages": [_message_to_dict(m) for m in ctx.messages],
+        })
     except Exception as e:
         _handle_error(e, "session", sid)
 
@@ -418,8 +430,8 @@ def summaries(
         s = sess.summaries()
         result = {
             "session_id": sid,
-            "short_summary": s.short_summary if hasattr(s, "short_summary") else None,
-            "long_summary": s.long_summary if hasattr(s, "long_summary") else None,
+            "short_summary": _summary_to_dict(s.short_summary),
+            "long_summary": _summary_to_dict(s.long_summary),
         }
         print_result(result)
     except Exception as e:

{honcho_cli-0.1.5 → honcho_cli-0.2.1}/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.1}/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)
 
@@ -306,7 +323,7 @@ def queue_status(
 
     try:
         result = client.queue_status(observer=observer, sender=sender, session=config.session_id or None)
-        print_result(result.__dict__ if hasattr(result, "__dict__") else result)
+        print_result(result.model_dump(mode="json"))
     except Exception as e:
         _handle_error(e, "queue", "status")
 
@@ -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.1}/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.1}/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.1/src/honcho_cli/local/templates/init.sql

@@ -0,0 +1,2 @@
+CREATE EXTENSION IF NOT EXISTS vector;
+CREATE EXTENSION IF NOT EXISTS pg_trgm;

{honcho_cli-0.1.5 → honcho_cli-0.2.1}/src/honcho_cli/output.py

@@ -11,6 +11,7 @@ import sys
 from datetime import datetime, timezone
 from typing import Any
 
+from pydantic import BaseModel
 from rich.console import Console
 from rich.table import Table
 from rich.text import Text
@@ -41,9 +42,20 @@ def use_json() -> bool:
     return _force_json or os.environ.get("HONCHO_JSON", "").lower() in ("1", "true") or not is_tty()
 
 
+def _json_default(obj: Any) -> Any:
+    """Fallback for ``json.dumps``: dump pydantic models as objects, stringify the rest.
+
+    A bare ``default=str`` turns an SDK model into its repr
+    (``content='...' message_id='...'``) instead of a nested object.
+    """
+    if isinstance(obj, BaseModel):
+        return obj.model_dump(mode="json")
+    return str(obj)
+
+
 def print_json(data: Any) -> None:
     """Print a single JSON value to stdout."""
-    print(json.dumps(data, indent=2, default=str))
+    print(json.dumps(data, indent=2, default=_json_default))
 
 
 def print_table(columns: list[str], rows: list[list[str]], title: str | None = None) -> None:
@@ -76,7 +88,7 @@ def print_result(data: Any, columns: list[str] | None = None, title: str | None
             table.add_column("Field", style="bold")
             table.add_column("Value")
             for k, v in data.items():
-                val = json.dumps(v, default=str) if isinstance(v, (dict, list)) else str(v)
+                val = json.dumps(v, default=_json_default) if isinstance(v, (dict, list)) else str(v)
                 table.add_row(k, val)
             stdout_console.print(table)
         else:

{honcho_cli-0.1.5 → honcho_cli-0.2.1}/tests/test_commands.py

@@ -10,9 +10,12 @@ from __future__ import annotations
 import json
 import os
 from contextlib import ExitStack, contextmanager
+from datetime import datetime, timezone
 from unittest.mock import MagicMock, patch
 
 import pytest
+from honcho import Message, SessionContext, SessionSummaries, Summary
+from honcho.api_types import QueueStatusResponse, SessionQueueStatus
 from typer.testing import CliRunner
 
 from honcho_cli.commands.session import _next_page_command
@@ -86,6 +89,16 @@ def _patch_view(session: MagicMock, *, peer_id: str = ""):
     )
 
 
+def _summary(kind: str) -> Summary:
+    return Summary(
+        content=f"{kind} summary",
+        message_id="m1",
+        summary_type=f"honcho_chat_summary_{kind}",
+        created_at="2026-01-01T00:00:00Z",
+        token_count=3,
+    )
+
+
 @contextmanager
 def _nested(*managers):
     with ExitStack() as stack:
@@ -553,6 +566,107 @@ class TestJsonContract:
         assert payload[-1]["id"] == "m149"
         assert session.messages.call_args.kwargs["size"] == 100
 
+    def test_session_summaries_json_nests_summary_objects(self, cfg, runner):
+        """Summaries are SDK models; they were emitted as their Python repr string."""
+        cfg.write_text(json.dumps({"apiKey": "k", "environmentUrl": "http://localhost:8000"}))
+        sess = MagicMock()
+        sess.summaries.return_value = SessionSummaries(
+            id="sess1", short_summary=_summary("short"), long_summary=None
+        )
+        client = MagicMock()
+        client.session.return_value = sess
+        config = MagicMock(session_id="sess1", workspace_id="ws1")
+        with patch("honcho_cli.commands.session.get_client", return_value=(client, config)):
+            result = runner.invoke(app, ["session", "summaries", "sess1", "-w", "ws1", "--json"])
+        assert result.exit_code == 0, result.stderr
+        assert json.loads(result.stdout) == {
+            "session_id": "sess1",
+            "short_summary": _summary("short").model_dump(),
+            "long_summary": None,
+        }
+
+    def test_session_inspect_json_nests_summary_objects(self, cfg, runner):
+        cfg.write_text(json.dumps({"apiKey": "k", "environmentUrl": "http://localhost:8000"}))
+        sess = MagicMock()
+        sess.peers.return_value = []
+        sess.messages.return_value = _fake_page([], total=0)
+        sess.summaries.return_value = SessionSummaries(
+            id="sess1", short_summary=_summary("short"), long_summary=_summary("long")
+        )
+        sess.get_configuration.return_value = None
+        client = MagicMock()
+        client.session.return_value = sess
+        config = MagicMock(session_id="sess1", workspace_id="ws1")
+        with patch("honcho_cli.commands.session.get_client", return_value=(client, config)):
+            result = runner.invoke(app, ["session", "inspect", "sess1", "-w", "ws1", "--json"])
+        assert result.exit_code == 0, result.stderr
+        assert json.loads(result.stdout)["summaries"] == {
+            "short": _summary("short").model_dump(),
+            "long": _summary("long").model_dump(),
+        }
+
+    def test_session_context_json_nests_summary_and_messages(self, cfg, runner):
+        cfg.write_text(json.dumps({"apiKey": "k", "environmentUrl": "http://localhost:8000"}))
+        message = Message(
+            id="m1",
+            content="hello",
+            peer_id="alice",
+            session_id="sess1",
+            workspace_id="ws1",
+            metadata={},
+            created_at=datetime(2026, 1, 1, tzinfo=timezone.utc),
+            token_count=1,
+        )
+        sess = MagicMock()
+        sess.context.return_value = SessionContext(
+            session_id="sess1", messages=[message], summary=_summary("short")
+        )
+        client = MagicMock()
+        client.session.return_value = sess
+        config = MagicMock(session_id="sess1", workspace_id="ws1")
+        with patch("honcho_cli.commands.session.get_client", return_value=(client, config)):
+            result = runner.invoke(app, ["session", "context", "sess1", "-w", "ws1", "--json"])
+        assert result.exit_code == 0, result.stderr
+        assert json.loads(result.stdout) == {
+            "session_id": "sess1",
+            "summary": _summary("short").model_dump(),
+            "peer_representation": None,
+            "peer_card": None,
+            "messages": [{
+                "id": "m1",
+                "peer_id": "alice",
+                "content": "hello",
+                "token_count": 1,
+                "metadata": {},
+                "created_at": "2026-01-01 00:00:00+00:00",
+            }],
+        }
+
+    def test_workspace_queue_status_json_nests_session_status(self, cfg, runner):
+        cfg.write_text(json.dumps({
+            "apiKey": "k",
+            "environmentUrl": "http://localhost:8000",
+            "workspace_id": "ws1",
+        }))
+        counts = {
+            "total_work_units": 2,
+            "completed_work_units": 1,
+            "in_progress_work_units": 0,
+            "pending_work_units": 1,
+        }
+        client = MagicMock()
+        client.queue_status.return_value = QueueStatusResponse(
+            **counts, sessions={"sess1": SessionQueueStatus(session_id="sess1", **counts)}
+        )
+        config = MagicMock(workspace_id="ws1", session_id="")
+        with patch("honcho_cli.commands.workspace.get_client", return_value=(client, config)):
+            result = runner.invoke(app, ["workspace", "queue-status", "-w", "ws1", "--json"])
+        assert result.exit_code == 0, result.stderr
+        assert json.loads(result.stdout) == {
+            **counts,
+            "sessions": {"sess1": {"session_id": "sess1", **counts}},
+        }
+
 
 # --------------------------------------------------------------------------- #
 # 4. Exit codes on error

honcho_cli-0.2.1/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.1}/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__} (")

honcho_cli-0.1.5/src/honcho_cli/local/templates/init.sql

@@ -1 +0,0 @@
-CREATE EXTENSION IF NOT EXISTS vector;