wicked-garden 12.27.0

package/scripts/jam/detect_clis.py

@@ -0,0 +1,409 @@
+#!/usr/bin/env python3
+"""
+detect_clis.py — detect & probe agentic LLM CLIs for the council.
+
+Reads ``agentic_cli_registry.py`` and answers two questions the council needs:
+
+  1. Which registered CLIs are INSTALLED on this machine (``shutil.which``)?
+  2. With ``--probe``: which installed CLIs are actually USABLE right now —
+     i.e. running their headless form (+ trust flags) on a trivial prompt
+     returns a sane reply — vs INSTALLED-BUT-UNUSABLE (auth revoked, no
+     provider configured, daemon down, …)?
+
+The probe is the difference between "the binary is on PATH" and "the council
+can get a real answer out of it". A CLI can be installed yet 401, or print
+"no provider configured", or fail to reach a local daemon. Those seats must
+NOT be counted toward quorum.
+
+Safety / cross-platform contract (mirrors _capability_registry.py + CLAUDE.md):
+  * stdlib only — no third-party imports.
+  * detection via ``shutil.which``.
+  * each probe runs with ``subprocess.run(..., timeout=N, stdin=DEVNULL,
+    cwd=<fresh tempdir under tempfile.gettempdir()>)`` so a hanging CLI is
+    bounded, nothing reads our stdin, and no CLI mutates the real project.
+  * never perl/bash-isms, never a bare ``/tmp``.
+
+Modes:
+  detect_clis.py                 # PATH scan, human output
+  detect_clis.py --json          # PATH scan, JSON
+  detect_clis.py --probe         # PATH scan + usability probe (JSON-capable)
+  detect_clis.py --list          # dump the registry (no detection)
+  detect_clis.py --list --json   # registry dump as JSON
+
+Output JSON shape (--probe):
+  {
+    "detected":   [ {key, display_name, binary, resolved_path, category,
+                     confidence, enabled_for_council, version}, ... ],
+    "usable":     [ "<key>", ... ],
+    "unusable":   [ {"cli": "<key>", "reason": "<class>: <detail>"}, ... ],
+    "collisions": [ {"binary": "...", "keys": [...]}, ... ]
+  }
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import re
+import subprocess
+import sys
+import tempfile
+from dataclasses import asdict
+from pathlib import Path
+
+# Import the registry. Works both when run as a file from anywhere
+# (sys.path bootstrap) and when imported as a module.
+try:
+    from agentic_cli_registry import (  # type: ignore
+        AGENTIC_CLI_REGISTRY,
+        AgenticCLI,
+        detect as registry_detect,
+    )
+except ModuleNotFoundError:  # pragma: no cover — path bootstrap for direct runs
+    sys.path.insert(0, str(Path(__file__).resolve().parent))
+    from agentic_cli_registry import (  # type: ignore
+        AGENTIC_CLI_REGISTRY,
+        AgenticCLI,
+        detect as registry_detect,
+    )
+
+
+# Trivial prompt: cheap, deterministic, and the reply is easy to sanity-check.
+PROBE_PROMPT = "Reply with the single word: pong"
+
+# Per-CLI probe timeout (seconds). Agentic coders spin up tools/MCP and can be
+# slow on a cold start; this bounds a hang (e.g. cursor-agent `-p`) without
+# starving a legitimately-slow-but-working CLI. Local runners get longer
+# because first-token latency on a cold model load is high.
+DEFAULT_TIMEOUT = 45
+LOCAL_RUNNER_TIMEOUT = 60
+
+# ---------------------------------------------------------------------------
+# Error-signature classification.
+# A CLI that is installed-but-unusable fails in a recognisable way. We match
+# stdout+stderr (lower-cased) against these signatures to label WHY a seat is
+# unusable, so the council can tell the user "codex: auth revoked" rather than
+# a generic failure. Order matters: first match wins.
+# ---------------------------------------------------------------------------
+
+_UNUSABLE_SIGNATURES: list[tuple[str, re.Pattern[str]]] = [
+    (
+        "auth",
+        re.compile(
+            r"\b(401|403|unauthor|authentication (failed|required)|not (logged|signed) in"
+            r"|please (log ?in|sign ?in|run .*login)|invalid api key|api key (not|is missing)"
+            r"|expired (token|credential)|forbidden|access denied"
+            r"|credentials? (not found|missing|expired)|re-?authenticate)\b",
+            re.IGNORECASE,
+        ),
+    ),
+    (
+        "no-provider",
+        re.compile(
+            r"\b(no (provider|model) (configured|set|selected|available)"
+            r"|no api key|set (the )?\w*_?api_key|missing .*api[_ ]?key"
+            r"|configure (a )?(provider|model|api key)|run .*configure"
+            r"|no default model|model not (found|configured))\b",
+            re.IGNORECASE,
+        ),
+    ),
+    (
+        "daemon-down",
+        re.compile(
+            r"\b(could not connect|connection refused|connection error"
+            r"|failed to connect|daemon (not|isn'?t) running|is the server running"
+            r"|ollama (server|app) (not|isn'?t) running|dial tcp|econnrefused"
+            r"|no such model|model .* not found, try pulling)\b",
+            re.IGNORECASE,
+        ),
+    ),
+    (
+        "quota",
+        re.compile(
+            r"\b(quota|rate ?limit|429|insufficient (credit|funds|balance)"
+            r"|billing|payment required|402)\b",
+            re.IGNORECASE,
+        ),
+    ),
+]
+
+# If a CLI exits non-zero with no recognised signature, we still mark it
+# unusable but with this generic label so the seat is not silently trusted.
+_GENERIC_UNUSABLE = "error"
+
+
+def _classify_failure(
+    returncode: int | None, combined: str, timed_out: bool
+) -> tuple[str, str] | None:
+    """Classify a probe run. Returns ``(reason_class, matched_line)`` for an
+    unusable run, or ``None`` if the run looks usable.
+
+    ``matched_line`` is the specific line that tripped the signature (e.g. the
+    401 line), so the human-facing reason is honest rather than echoing a
+    cosmetic banner line. A run is USABLE only when it did not time out, exited
+    0, and produced non-trivial stdout free of a failure signature (some CLIs
+    print the error to stdout yet still exit 0).
+    """
+    if timed_out:
+        return ("timeout", "")
+    lines = combined.splitlines()
+    for label, pat in _UNUSABLE_SIGNATURES:
+        for line in lines:
+            if pat.search(line):
+                return (label, line.strip())
+        # Fall back to a whole-text match (signature spanning the buffer).
+        if pat.search(combined):
+            return (label, "")
+    if returncode not in (0, None):
+        return (_GENERIC_UNUSABLE, "")
+    return None
+
+
+def _looks_like_real_reply(stdout: str) -> bool:
+    """A sane reply has some printable content beyond whitespace/banners.
+
+    We do NOT require the literal word 'pong' — models phrase things their own
+    way and some CLIs wrap output. We only require that *something* substantive
+    came back, since auth/provider/daemon failures produce either empty stdout
+    or an error string (already caught by signature matching)."""
+    stripped = stdout.strip()
+    return len(stripped) >= 2
+
+
+def _probe_version(cli: AgenticCLI, timeout: int) -> str:
+    """Capture the version string (disambiguates binary collisions like grok)."""
+    try:
+        proc = subprocess.run(
+            cli.version_probe,
+            stdin=subprocess.DEVNULL,
+            capture_output=True,
+            text=True,
+            timeout=min(timeout, 15),
+        )
+        out = (proc.stdout or proc.stderr or "").strip()
+        # Keep it to the first line — version banners can be multi-line.
+        return out.splitlines()[0].strip() if out else ""
+    except (subprocess.TimeoutExpired, OSError, ValueError):
+        return ""
+
+
+def _build_probe_argv(cli: AgenticCLI) -> list[str] | None:
+    """Build the headless argv for a probe run: rendered template + trust flags.
+
+    Returns None for CLIs that cannot be safely auto-probed with a trivial
+    prompt (e.g. ollama needs a model name we don't know). Those are reported
+    as detected but skipped by the probe with an explicit reason.
+    """
+    if cli.key == "ollama" or "{MODEL}" in cli.headless_invocation:
+        # Local runners need a concrete pulled model; we won't guess one.
+        return None
+
+    rendered = cli.render(PROBE_PROMPT)
+    try:
+        import shlex
+
+        argv = shlex.split(rendered, posix=(sys.platform != "win32"))
+    except ValueError:
+        return None
+    if not argv:
+        return None
+    # Append trust flags AFTER the template so headless runs don't block on a
+    # permission / trust / git-repo prompt.
+    argv.extend(cli.trust_flags)
+    return argv
+
+
+def _probe_one(cli: AgenticCLI) -> dict:
+    """Probe a single detected CLI. Returns {usable: bool, reason, version}."""
+    timeout = LOCAL_RUNNER_TIMEOUT if cli.category == "local-runner" else DEFAULT_TIMEOUT
+    version = _probe_version(cli, timeout)
+
+    argv = _build_probe_argv(cli)
+    if argv is None:
+        return {
+            "usable": False,
+            "reason": "skipped: requires a model/daemon not auto-probeable (e.g. ollama needs a pulled model + running daemon)",
+            "version": version,
+        }
+
+    tmpdir = tempfile.mkdtemp(prefix="wg-council-probe-")
+    timed_out = False
+    returncode: int | None = None
+    stdout = ""
+    stderr = ""
+    try:
+        proc = subprocess.run(
+            argv,
+            stdin=subprocess.DEVNULL,
+            capture_output=True,
+            text=True,
+            timeout=timeout,
+            cwd=tmpdir,
+        )
+        returncode = proc.returncode
+        stdout = proc.stdout or ""
+        stderr = proc.stderr or ""
+    except subprocess.TimeoutExpired as exc:
+        timed_out = True
+        stdout = (exc.stdout or b"").decode("utf-8", "replace") if isinstance(exc.stdout, bytes) else (exc.stdout or "")
+        stderr = (exc.stderr or b"").decode("utf-8", "replace") if isinstance(exc.stderr, bytes) else (exc.stderr or "")
+    except (OSError, ValueError) as exc:
+        return {"usable": False, "reason": f"error: could not launch ({exc})", "version": version}
+    finally:
+        # Best-effort cleanup of the scratch cwd (aider et al. drop cache files).
+        try:
+            import shutil as _sh
+
+            _sh.rmtree(tmpdir, ignore_errors=True)
+        except Exception:
+            pass
+
+    combined = f"{stdout}\n{stderr}"
+    classified = _classify_failure(returncode, combined, timed_out)
+    if classified is None and _looks_like_real_reply(stdout):
+        return {"usable": True, "reason": None, "version": version}
+
+    if classified is None:
+        # Exited 0 but produced nothing substantive — treat as unusable so the
+        # council does not seat an empty responder.
+        reason, matched = "empty-response", ""
+    else:
+        reason, matched = classified
+
+    # Prefer the line that actually matched the failure signature (e.g. the
+    # 401 line); fall back to the first non-empty line if nothing matched
+    # (timeout / generic non-zero exit).
+    detail = matched
+    if not detail:
+        for line in combined.splitlines():
+            s = line.strip()
+            if s:
+                detail = s
+                break
+    detail = detail[:160]
+    full = f"{reason}: {detail}" if detail else reason
+    return {"usable": False, "reason": full, "version": version}
+
+
+def run_detect(probe: bool) -> dict:
+    """Detect installed CLIs and, if ``probe``, classify usable vs unusable."""
+    base = registry_detect(probe=False)
+    detected = base["detected"]
+    collisions = base["collisions"]
+
+    if not probe:
+        return {"detected": detected, "collisions": collisions}
+
+    usable: list[str] = []
+    unusable: list[dict] = []
+    for entry in detected:
+        key = entry["key"]
+        if key == "claude":
+            # Claude is the in-process host, not an external seat. Record its
+            # version for collision/audit purposes but don't probe it as a CLI.
+            cli = AGENTIC_CLI_REGISTRY[key]
+            entry["version"] = _probe_version(cli, DEFAULT_TIMEOUT)
+            continue
+        cli = AGENTIC_CLI_REGISTRY[key]
+        result = _probe_one(cli)
+        entry["version"] = result["version"]
+        if result["usable"]:
+            usable.append(key)
+        else:
+            unusable.append({"cli": key, "reason": result["reason"]})
+
+    return {
+        "detected": detected,
+        "usable": usable,
+        "unusable": unusable,
+        "collisions": collisions,
+    }
+
+
+def list_registry() -> dict:
+    """Dump the full registry as plain dicts (for --list)."""
+    return {
+        "clis": [asdict(cli) for cli in AGENTIC_CLI_REGISTRY.values()],
+        "count": len(AGENTIC_CLI_REGISTRY),
+    }
+
+
+# ---------------------------------------------------------------------------
+# Human-readable rendering
+# ---------------------------------------------------------------------------
+
+def _emit_human_list(reg: dict) -> None:
+    sys.stdout.write(f"agentic CLI registry — {reg['count']} entries\n")
+    for cli in reg["clis"]:
+        flag = "" if cli["enabled_for_council"] else " [council-disabled]"
+        conf = "" if cli["confidence"] == "verified" else f" ({cli['confidence']})"
+        sys.stdout.write(
+            f"  {cli['key']:<14} {cli['category']:<14} {cli['vendor']}{conf}{flag}\n"
+        )
+
+
+def _emit_human_detect(result: dict, probed: bool) -> None:
+    detected = result["detected"]
+    sys.stdout.write(f"detected {len(detected)} installed CLI(s):\n")
+    usable = set(result.get("usable", []))
+    unusable_map = {u["cli"]: u["reason"] for u in result.get("unusable", [])}
+    for entry in detected:
+        key = entry["key"]
+        ver = entry.get("version", "")
+        ver_s = f"  v={ver}" if ver else ""
+        if not probed:
+            status = ""
+        elif key == "claude":
+            status = "  [in-process host]"
+        elif key in usable:
+            status = "  USABLE"
+        elif key in unusable_map:
+            status = f"  UNUSABLE — {unusable_map[key]}"
+        else:
+            status = ""
+        sys.stdout.write(f"  {key:<14} {entry['resolved_path']}{ver_s}{status}\n")
+
+    if probed:
+        sys.stdout.write(
+            f"\nquorum: {len(usable)} usable external CLI(s)"
+            + (
+                " — full council"
+                if len(usable) >= 2
+                else " — below quorum (fallback to Task() subagent seats)"
+            )
+            + "\n"
+        )
+
+    if result.get("collisions"):
+        sys.stdout.write("\nbinary collisions (disambiguate by version):\n")
+        for c in result["collisions"]:
+            sys.stdout.write(f"  {c['binary']}: {', '.join(c['keys'])}\n")
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(
+        description="Detect & probe agentic LLM CLIs for the wicked-garden council."
+    )
+    parser.add_argument("--probe", action="store_true", help="run headless usability probe")
+    parser.add_argument("--list", action="store_true", help="dump the registry and exit")
+    parser.add_argument("--json", action="store_true", help="emit JSON instead of human text")
+    args = parser.parse_args(argv)
+
+    if args.list:
+        reg = list_registry()
+        if args.json:
+            sys.stdout.write(json.dumps(reg, indent=2) + "\n")
+        else:
+            _emit_human_list(reg)
+        return 0
+
+    result = run_detect(probe=args.probe)
+    if args.json:
+        sys.stdout.write(json.dumps(result, indent=2) + "\n")
+    else:
+        _emit_human_detect(result, probed=args.probe)
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/scripts/jam/jam.py

@@ -0,0 +1,283 @@
+#!/usr/bin/env python3
+"""
+wicked-jam query CLI -- exposes session data for cross-plugin access.
+
+All data flows through DomainStore("wicked-jam") which routes to MCP
+integrations when available and falls back to local JSON files.
+
+Usage:
+    jam.py list-sessions [--query Q] [--limit N] [--json] [--project P]
+    jam.py transcript [--session-id ID] [--json]
+    jam.py persona <name> [--session-id ID] [--json]
+    jam.py thinking [--session-id ID] [--json]
+
+Transcript entry schema:
+    {
+        "session_id": "...",
+        "round": 1,
+        "persona_name": "Technical Architect",
+        "persona_type": "technical",   # technical | user | business | process | council
+        "raw_text": "...",
+        "thinking": "...",             # optional: pre-synthesis deliberation (alternatives, trade-offs)
+        "timestamp": "...",
+        "entry_type": "perspective"    # perspective | synthesis | council_response
+    }
+"""
+
+import argparse
+import json
+import sys
+from pathlib import Path
+
+# Resolve _domain_store from the parent scripts/ directory
+sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
+from _domain_store import DomainStore
+
+_sm = DomainStore("wicked-jam")
+
+
+def list_sessions(query: str = None, limit: int = 10, project: str = None) -> dict:
+    """List recent brainstorming sessions, optionally filtered by query."""
+    params = {}
+    if query:
+        params["q"] = query
+    if project:
+        params["project"] = project
+
+    records = _sm.list("sessions", **params)
+
+    results = []
+    query_lower = query.lower() if query else None
+
+    for session in records:
+        topic = session.get("topic", "")
+        summary = session.get("synthesis", {}).get("summary", "")
+        perspectives = session.get("perspectives", [])
+        created = session.get("created", "")
+        session_project = session.get("project", "")
+
+        # Filter by project if specified (in case local fallback doesn't filter)
+        if project and session_project and session_project != project:
+            continue
+
+        # Filter by query if specified (in case local fallback doesn't filter)
+        if query_lower:
+            text = f"{topic} {summary}".lower()
+            if not any(word in text for word in query_lower.split() if len(word) > 2):
+                continue
+
+        results.append({
+            "id": session.get("id", ""),
+            "topic": topic,
+            "summary": summary[:300] if summary else "",
+            "perspectives_count": len(perspectives) if isinstance(perspectives, list) else 0,
+            "created": created,
+        })
+
+        if len(results) >= limit:
+            break
+
+    return {"sessions": results}
+
+
+def _resolve_session_id(session_id: str = None) -> str:
+    """Return the given session_id or derive the most recent one from stored sessions."""
+    if session_id:
+        return session_id
+    records = _sm.list("sessions")
+    if not records:
+        return None
+    # Sessions are expected to be in insertion order; take the last one.
+    latest = records[-1]
+    return latest.get("id", "")
+
+
+def get_transcript(session_id: str = None) -> dict:
+    """Return the full transcript (all entries) for a session, in chronological order."""
+    sid = _resolve_session_id(session_id)
+    if not sid:
+        return {"session_id": None, "entries": [], "error": "No sessions found."}
+
+    data = _sm.get("transcripts", sid)
+    if not data:
+        return {
+            "session_id": sid,
+            "entries": [],
+            "error": f"No transcript found for session: {sid}",
+        }
+
+    entries = data.get("entries", [])
+    return {"session_id": sid, "entries": entries}
+
+
+def get_persona(name: str, session_id: str = None) -> dict:
+    """Return all transcript entries from a specific persona (case-insensitive match)."""
+    sid = _resolve_session_id(session_id)
+    if not sid:
+        return {"session_id": None, "persona": name, "entries": [], "error": "No sessions found."}
+
+    data = _sm.get("transcripts", sid)
+    if not data:
+        return {
+            "session_id": sid,
+            "persona": name,
+            "entries": [],
+            "error": f"No transcript found for session: {sid}",
+        }
+
+    name_lower = name.lower()
+    entries = [
+        e for e in data.get("entries", [])
+        if e.get("persona_name", "").lower() == name_lower
+    ]
+
+    if not entries:
+        return {
+            "session_id": sid,
+            "persona": name,
+            "entries": [],
+            "error": f"No contributions found for persona: {name}",
+        }
+
+    return {"session_id": sid, "persona": name, "entries": entries}
+
+
+def get_thinking(session_id: str = None) -> dict:
+    """Return all pre-synthesis perspective entries for a session."""
+    sid = _resolve_session_id(session_id)
+    if not sid:
+        return {"session_id": None, "entries": [], "error": "No sessions found."}
+
+    data = _sm.get("transcripts", sid)
+    if not data:
+        return {
+            "session_id": sid,
+            "entries": [],
+            "error": f"No transcript found for session: {sid}",
+        }
+
+    entries = [
+        e for e in data.get("entries", [])
+        if e.get("entry_type") == "perspective"
+    ]
+    return {"session_id": sid, "entries": entries}
+
+
+def _print_entry(entry: dict, index: int = None) -> None:
+    """Pretty-print a single transcript entry."""
+    prefix = f"[{index}] " if index is not None else ""
+    round_num = entry.get("round", "?")
+    persona = entry.get("persona_name", "Unknown")
+    ptype = entry.get("persona_type", "")
+    etype = entry.get("entry_type", "")
+    timestamp = entry.get("timestamp", "")
+
+    type_label = f"  ({etype})" if etype else ""
+    ptype_label = f" [{ptype}]" if ptype else ""
+    ts_label = f"  {timestamp}" if timestamp else ""
+
+    print(f"\n{prefix}Round {round_num} — {persona}{ptype_label}{type_label}{ts_label}")
+    print("-" * 60)
+    thinking = entry.get("thinking", "").strip()
+    if thinking:
+        print(f"[thinking]\n{thinking}\n")
+    print(entry.get("raw_text", "").strip())
+
+
+def main():
+    parser = argparse.ArgumentParser(description="wicked-jam query CLI")
+    subparsers = parser.add_subparsers(dest="command")
+
+    ls_parser = subparsers.add_parser("list-sessions", help="List brainstorming sessions")
+    ls_parser.add_argument("--query", "-q", help="Filter by topic/summary text")
+    ls_parser.add_argument("--limit", "-n", type=int, default=10, help="Max results")
+    ls_parser.add_argument("--json", action="store_true", help="Output as JSON")
+    ls_parser.add_argument("--project", "-p", help="Filter by project")
+
+    tr_parser = subparsers.add_parser("transcript", help="Full conversation transcript")
+    tr_parser.add_argument("--session-id", help="Session ID (defaults to most recent)")
+    tr_parser.add_argument("--json", action="store_true", help="Output as JSON")
+
+    pe_parser = subparsers.add_parser("persona", help="Specific persona's contributions")
+    pe_parser.add_argument("name", help="Persona name (case-insensitive)")
+    pe_parser.add_argument("--session-id", help="Session ID (defaults to most recent)")
+    pe_parser.add_argument("--json", action="store_true", help="Output as JSON")
+
+    th_parser = subparsers.add_parser("thinking", help="All pre-synthesis perspectives")
+    th_parser.add_argument("--session-id", help="Session ID (defaults to most recent)")
+    th_parser.add_argument("--json", action="store_true", help="Output as JSON")
+
+    args = parser.parse_args()
+
+    if not args.command:
+        parser.print_help()
+        sys.exit(1)
+
+    if args.command == "list-sessions":
+        result = list_sessions(
+            query=args.query,
+            limit=args.limit,
+            project=args.project,
+        )
+        if getattr(args, "json", False):
+            print(json.dumps(result, indent=2))
+        else:
+            sessions = result["sessions"]
+            if not sessions:
+                print("No sessions found.")
+                return
+            for s in sessions:
+                print(f"  {s['id']}: {s['topic']} ({s['perspectives_count']} perspectives)")
+
+    elif args.command == "transcript":
+        result = get_transcript(session_id=getattr(args, "session_id", None))
+        if getattr(args, "json", False):
+            print(json.dumps(result, indent=2))
+        else:
+            error = result.get("error")
+            if error and not result["entries"]:
+                print(error)
+                return
+            sid = result.get("session_id", "")
+            entries = result["entries"]
+            print(f"Transcript — session: {sid}  ({len(entries)} entries)")
+            for i, entry in enumerate(entries, start=1):
+                _print_entry(entry, index=i)
+
+    elif args.command == "persona":
+        result = get_persona(name=args.name, session_id=getattr(args, "session_id", None))
+        if getattr(args, "json", False):
+            print(json.dumps(result, indent=2))
+        else:
+            error = result.get("error")
+            if error and not result["entries"]:
+                print(error)
+                return
+            sid = result.get("session_id", "")
+            entries = result["entries"]
+            persona = result.get("persona", args.name)
+            print(f"Contributions from: {persona}  |  session: {sid}  ({len(entries)} entries)")
+            for i, entry in enumerate(entries, start=1):
+                _print_entry(entry, index=i)
+
+    elif args.command == "thinking":
+        result = get_thinking(session_id=getattr(args, "session_id", None))
+        if getattr(args, "json", False):
+            print(json.dumps(result, indent=2))
+        else:
+            error = result.get("error")
+            if error and not result["entries"]:
+                print(error)
+                return
+            sid = result.get("session_id", "")
+            entries = result["entries"]
+            print(f"Pre-synthesis perspectives — session: {sid}  ({len(entries)} entries)")
+            entries_with_thinking = [e for e in entries if e.get("thinking", "").strip()]
+            if entries and not entries_with_thinking:
+                print("No thinking data available for this session.")
+            for i, entry in enumerate(entries, start=1):
+                _print_entry(entry, index=i)
+
+
+if __name__ == "__main__":
+    main()