titan-cli 0.7.0__tar.gz → 0.7.2__tar.gz

{titan_cli-0.7.0 → titan_cli-0.7.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: titan-cli
-Version: 0.7.0
+Version: 0.7.2
 Summary: Modular development tools orchestrator - Streamline your workflows with AI integration and intuitive terminal UI
 License: MIT
 License-File: LICENSE

{titan_cli-0.7.0 → titan_cli-0.7.2}/plugins/titan-plugin-github/titan_plugin_github/clients/github_client.py

@@ -14,7 +14,7 @@ from titan_cli.core.plugins.models import GitHubPluginConfig
 from titan_plugin_git.clients.git_client import GitClient
 
 from .network import GHNetwork, GraphQLNetwork
-from .services import PRService, ReviewService, IssueService, TeamService, ReleaseService
+from .services import PRService, ReviewService, IssueService, TeamService, ReleaseService, ContentsService
 from ..models.review_models import ReferencedCommitContext
 from ..models.view import UIPullRequest, UICommentThread, UIIssue, UIPRMergeResult, UIReview, UIFileChange, UIPRCreated, UIRelease
 
@@ -77,6 +77,7 @@ class GitHubClient:
         self._issue_service = IssueService(self._gh_network)
         self._team_service = TeamService(self._gh_network)
         self._release_service = ReleaseService(self._gh_network)
+        self._contents_service = ContentsService(self._gh_network)
 
     def get_pr_template(self) -> Optional[str]:
         """Get the PR template if available."""
@@ -315,6 +316,46 @@ class GitHubClient:
         """Get a single GitHub release, including its full notes body."""
         return self._release_service.get_release(tag_name)
 
+    # ============================================================================
+    # Contents Operations
+    # ============================================================================
+
+    def list_repository_directory(
+        self,
+        path: str,
+        ref: Optional[str] = None,
+        *,
+        repo_owner: Optional[str] = None,
+        repo_name: Optional[str] = None,
+    ) -> ClientResult[List[Dict[str, Any]]]:
+        """
+        List the entries of a directory in a repository.
+
+        Defaults to this client's own repo; pass repo_owner/repo_name to read
+        from a different repository without instantiating a new client.
+        """
+        return self._contents_service.list_directory(
+            path, ref, repo_owner=repo_owner, repo_name=repo_name
+        )
+
+    def path_exists(
+        self,
+        path: str,
+        ref: Optional[str] = None,
+        *,
+        repo_owner: Optional[str] = None,
+        repo_name: Optional[str] = None,
+    ) -> ClientResult[bool]:
+        """
+        Check whether a path exists in a repository.
+
+        Defaults to this client's own repo; pass repo_owner/repo_name to check
+        against a different repository without instantiating a new client.
+        """
+        return self._contents_service.path_exists(
+            path, ref, repo_owner=repo_owner, repo_name=repo_name
+        )
+
     # ============================================================================
     # Team Operations
     # ============================================================================

{titan_cli-0.7.0 → titan_cli-0.7.2}/plugins/titan-plugin-github/titan_plugin_github/clients/services/__init__.py

@@ -10,6 +10,7 @@ from .review_service import ReviewService
 from .issue_service import IssueService
 from .team_service import TeamService
 from .release_service import ReleaseService
+from .contents_service import ContentsService
 
 __all__ = [
     "PRService",
@@ -17,4 +18,5 @@ __all__ = [
     "IssueService",
     "TeamService",
     "ReleaseService",
+    "ContentsService",
 ]

titan_cli-0.7.2/plugins/titan-plugin-github/titan_plugin_github/clients/services/contents_service.py

@@ -0,0 +1,144 @@
+# plugins/titan-plugin-github/titan_plugin_github/clients/services/contents_service.py
+"""
+Contents Service
+
+Business logic for navigating a GitHub repository's contents (Contents API).
+Uses gh CLI through the network layer.
+"""
+
+import json
+from typing import List, Optional
+from urllib.parse import quote, urlencode
+
+from titan_cli.core.result import ClientResult, ClientSuccess, ClientError
+from titan_cli.core.logging import log_client_operation
+
+from ..network import GHNetwork
+from ...exceptions import GitHubAPIError
+
+
+class ContentsService:
+    """
+    Service for GitHub repository contents operations.
+
+    Lets callers navigate a repository's tree (list a directory, check whether
+    a path exists) without cloning it locally.
+    """
+
+    def __init__(self, gh_network: GHNetwork):
+        """
+        Initialize contents service.
+
+        Args:
+            gh_network: GHNetwork instance for REST/CLI operations
+        """
+        self.gh = gh_network
+
+    def _contents_endpoint(
+        self,
+        path: str,
+        ref: Optional[str],
+        repo_owner: Optional[str],
+        repo_name: Optional[str],
+    ) -> List[str]:
+        owner = repo_owner or self.gh.repo_owner
+        name = repo_name or self.gh.repo_name
+        clean_path = "/".join(quote(segment) for segment in path.strip("/").split("/") if segment)
+
+        endpoint = f"repos/{owner}/{name}/contents"
+        if clean_path:
+            endpoint = f"{endpoint}/{clean_path}"
+        if ref:
+            endpoint = f"{endpoint}?{urlencode({'ref': ref})}"
+
+        return ["api", endpoint]
+
+    @staticmethod
+    def _is_not_found(error: GitHubAPIError) -> bool:
+        return "404" in (error.stderr or "")
+
+    @log_client_operation()
+    def list_directory(
+        self,
+        path: str,
+        ref: Optional[str] = None,
+        *,
+        repo_owner: Optional[str] = None,
+        repo_name: Optional[str] = None,
+    ) -> ClientResult[List[dict]]:
+        """
+        List the entries of a directory in a repository.
+
+        Args:
+            path: Directory path relative to the repo root ("" for repo root)
+            ref: Optional branch/tag/commit SHA to read from (defaults to the repo's default branch)
+            repo_owner: Optional owner override (defaults to the client's configured repo)
+            repo_name: Optional repo name override (defaults to the client's configured repo)
+
+        Returns:
+            ClientResult[List[dict]] with entries shaped like
+            {"name": str, "path": str, "type": "dir" | "file"}
+        """
+        try:
+            args = self._contents_endpoint(path, ref, repo_owner, repo_name)
+            output = self.gh.run_command(args)
+            data = json.loads(output)
+
+            if isinstance(data, dict):
+                return ClientError(
+                    error_message=f"'{path}' is a file, not a directory",
+                    error_code="NOT_A_DIRECTORY",
+                )
+
+            entries = [
+                {"name": item["name"], "path": item["path"], "type": item["type"]}
+                for item in data
+            ]
+
+            return ClientSuccess(
+                data=entries,
+                message=f"Retrieved {len(entries)} entries from '{path or '/'}'"
+            )
+
+        except json.JSONDecodeError as e:
+            return ClientError(
+                error_message=f"Failed to parse contents data: {e}",
+                error_code="JSON_PARSE_ERROR",
+            )
+        except GitHubAPIError as e:
+            if self._is_not_found(e):
+                return ClientError(
+                    error_message=f"Path '{path}' not found",
+                    error_code="NOT_FOUND",
+                )
+            return ClientError(error_message=str(e), error_code="API_ERROR")
+
+    @log_client_operation()
+    def path_exists(
+        self,
+        path: str,
+        ref: Optional[str] = None,
+        *,
+        repo_owner: Optional[str] = None,
+        repo_name: Optional[str] = None,
+    ) -> ClientResult[bool]:
+        """
+        Check whether a path exists in a repository.
+
+        Args:
+            path: Path relative to the repo root
+            ref: Optional branch/tag/commit SHA to check against (defaults to the repo's default branch)
+            repo_owner: Optional owner override (defaults to the client's configured repo)
+            repo_name: Optional repo name override (defaults to the client's configured repo)
+
+        Returns:
+            ClientResult[bool]
+        """
+        try:
+            args = self._contents_endpoint(path, ref, repo_owner, repo_name)
+            self.gh.run_command(args)
+            return ClientSuccess(data=True, message=f"'{path}' exists")
+        except GitHubAPIError as e:
+            if self._is_not_found(e):
+                return ClientSuccess(data=False, message=f"'{path}' does not exist")
+            return ClientError(error_message=str(e), error_code="API_ERROR")

{titan_cli-0.7.0 → titan_cli-0.7.2}/plugins/titan-plugin-github/titan_plugin_github/clients/services/pr_service.py

@@ -56,7 +56,7 @@ class PRService:
                 "baseRefName", "headRefName", "additions", "deletions",
                 "changedFiles", "mergeable", "isDraft", "createdAt",
                 "updatedAt", "mergedAt", "reviews", "labels",
-                "statusCheckRollup", "reviewDecision",
+                "statusCheckRollup", "reviewDecision", "reviewRequests",
                 "isCrossRepository", "headRepositoryOwner", "headRepository",
             ]
 

{titan_cli-0.7.0 → titan_cli-0.7.2}/plugins/titan-plugin-github/titan_plugin_github/models/mappers/pr_mapper.py

@@ -35,6 +35,13 @@ def from_rest_pr(rest_pr: NetworkPullRequest) -> UIPullRequest:
     # Extract label names from label objects
     label_names = [label.get("name", "") for label in rest_pr.labels]
 
+    # Extract requested reviewers
+    requested_reviewers = [user.login for user in rest_pr.requestedReviewers]
+
+    # Calculate pending reviewers (requested but not yet reviewed)
+    reviewed_logins = {review.user.login for review in rest_pr.reviews if review.state != "PENDING"}
+    pending_reviewers = [login for login in requested_reviewers if login not in reviewed_logins]
+
     return UIPullRequest(
         number=rest_pr.number,
         title=rest_pr.title,
@@ -58,6 +65,8 @@ def from_rest_pr(rest_pr: NetworkPullRequest) -> UIPullRequest:
         is_cross_repository=rest_pr.isCrossRepository,
         head_repository_owner=rest_pr.headRepositoryOwnerLogin,
         head_repository_name=rest_pr.headRepositoryName,
+        requested_reviewers=requested_reviewers,
+        pending_reviewers=pending_reviewers,
     )
 
 

{titan_cli-0.7.0 → titan_cli-0.7.2}/plugins/titan-plugin-github/titan_plugin_github/models/network/rest/pull_request.py

@@ -48,6 +48,7 @@ class NetworkPullRequest:
         mergedAt: Merge timestamp if merged (ISO 8601, camelCase as in API)
         reviews: List of reviews
         labels: List of label objects with 'name' field
+        requestedReviewers: List of users requested to review the PR
     """
     number: int
     title: str
@@ -71,6 +72,7 @@ class NetworkPullRequest:
     isCrossRepository: bool = False
     headRepositoryOwnerLogin: Optional[str] = None
     headRepositoryName: Optional[str] = None
+    requestedReviewers: List[NetworkUser] = field(default_factory=list)  # Users requested to review
 
     @classmethod
     def from_json(cls, data: Dict[str, Any]) -> 'NetworkPullRequest':
@@ -97,6 +99,10 @@ class NetworkPullRequest:
         reviews_data = data.get("reviews", [])
         reviews = [NetworkReview.from_json(r) for r in reviews_data]
 
+        # Parse requested reviewers (gh CLI JSON field is "reviewRequests")
+        requested_reviewers_data = data.get("reviewRequests", [])
+        requested_reviewers = [NetworkUser.from_json(r) for r in requested_reviewers_data]
+
         return cls(
             number=data.get("number", 0),
             title=data.get("title", ""),
@@ -128,6 +134,7 @@ class NetworkPullRequest:
             isCrossRepository=data.get("isCrossRepository", False),
             headRepositoryOwnerLogin=(data.get("headRepositoryOwner") or {}).get("login"),
             headRepositoryName=(data.get("headRepository") or {}).get("name"),
+            requestedReviewers=requested_reviewers,
         )
 
 

{titan_cli-0.7.0 → titan_cli-0.7.2}/plugins/titan-plugin-github/titan_plugin_github/models/view.py

@@ -10,7 +10,7 @@ Network models contain raw API data; view models contain UI-ready data.
 These models are GitHub-specific and live in the GitHub plugin, not in the core.
 """
 
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from typing import Any, List, Optional
 
 from .pr_enums import PRState
@@ -137,6 +137,10 @@ class UIPullRequest:
 
     All fields are pre-formatted and ready for widget rendering.
     Computed/derived fields are calculated once during construction.
+
+    Fields:
+        requested_reviewers: All GitHub logins of users requested to review
+        pending_reviewers: Logins of reviewers who haven't submitted a review yet
     """
     number: int
     title: str
@@ -160,6 +164,8 @@ class UIPullRequest:
     is_cross_repository: bool = False
     head_repository_owner: Optional[str] = None
     head_repository_name: Optional[str] = None
+    requested_reviewers: List[str] = field(default_factory=list)  # All requested reviewer logins
+    pending_reviewers: List[str] = field(default_factory=list)  # Reviewers who haven't reviewed yet
 
 
 @dataclass

{titan_cli-0.7.0 → titan_cli-0.7.2}/plugins/titan-plugin-github/titan_plugin_github/operations/thread_resolution_operations.py

@@ -218,6 +218,57 @@ Respond ONLY with a valid JSON array matching this exact schema for each element
 Return ONLY the JSON array. No explanation, no markdown fences."""
 
 
+DEFAULT_THREAD_BATCH_MAX_PROMPT_CHARS = 20_000
+DEFAULT_THREAD_BATCH_MAX_THREADS = 8
+
+
+def batch_thread_review_contexts(
+    contexts: list[ThreadReviewContext],
+    max_prompt_chars: int = DEFAULT_THREAD_BATCH_MAX_PROMPT_CHARS,
+    max_threads_per_batch: int = DEFAULT_THREAD_BATCH_MAX_THREADS,
+) -> list[list[ThreadReviewContext]]:
+    """
+    Split thread contexts into batches that keep each AI call within a prompt budget.
+
+    Each thread keeps its full conversation, code hunk, and referenced commit
+    context untouched — batching only controls how many threads share one AI
+    call, so no per-thread content is trimmed. A thread that alone exceeds the
+    budget is still sent by itself rather than being degraded.
+
+    Args:
+        contexts: Enriched thread contexts from build_thread_review_contexts
+        max_prompt_chars: Target prompt size per batch (soft budget)
+        max_threads_per_batch: Upper bound on threads per batch regardless of size
+
+    Returns:
+        List of thread-context batches, each safe to pass to build_thread_resolution_prompt
+    """
+    if not contexts:
+        return []
+
+    queue = [
+        contexts[i : i + max_threads_per_batch]
+        for i in range(0, len(contexts), max_threads_per_batch)
+    ]
+    batches: list[list[ThreadReviewContext]] = []
+
+    while queue:
+        batch = queue.pop(0)
+        if len(batch) == 1:
+            batches.append(batch)
+            continue
+
+        if len(build_thread_resolution_prompt(batch)) <= max_prompt_chars:
+            batches.append(batch)
+            continue
+
+        midpoint = max(1, len(batch) // 2)
+        queue.insert(0, batch[midpoint:])
+        queue.insert(0, batch[:midpoint])
+
+    return batches
+
+
 def _threads_to_text(contexts: list[ThreadReviewContext]) -> str:
     if not contexts:
         return "(no threads to review)"

{titan_cli-0.7.0 → titan_cli-0.7.2}/plugins/titan-plugin-github/titan_plugin_github/steps/code_review_steps.py

@@ -43,6 +43,7 @@ from ..operations.review_action_operations import (
     resolve_action_anchors,
 )
 from ..operations.thread_resolution_operations import (
+    batch_thread_review_contexts,
     build_thread_review_candidates as build_thread_review_candidates_operation,
     build_thread_review_contexts as build_thread_review_contexts_operation,
     build_thread_resolution_prompt,
@@ -2741,18 +2742,23 @@ def ai_thread_resolution(ctx: WorkflowContext) -> WorkflowResult:
     """
     AI call: decide what to do with each open thread.
 
-    Sends thread contexts (original comment + replies + current code) to the
+    Splits thread contexts into prompt-budget-bound batches (see
+    batch_thread_review_contexts) and sends each batch — original comment +
+    replies + current code + referenced commits, all untouched — to the
     selected headless CLI. The AI decides per thread: resolved / insist /
-    reply / skip.
+    reply / skip. Batches run sequentially and their decisions are aggregated;
+    a batch that fails (CLI error or parse error) is skipped without aborting
+    the remaining batches.
 
-    On CLI failure or parse failure, falls back to empty decisions (no actions).
+    On total failure (no batch produced usable output), falls back to empty
+    decisions (no actions).
 
     Requires (from ctx.data):
         thread_review_contexts (List[ThreadReviewContext])
         cli_preference (str): "claude" | "gemini" | "codex" | "auto"
 
     Outputs (saved to ctx.data):
-        raw_thread_decisions (list): Raw AI output before normalization
+        raw_thread_decisions (list): Raw AI output aggregated across batches, before normalization
 
     Returns:
         Success or Error
@@ -2779,46 +2785,90 @@ def ai_thread_resolution(ctx: WorkflowContext) -> WorkflowResult:
         ctx.textual.end_step("success")
         return Success("No decisions (no CLI available)", metadata={"raw_thread_decisions": []})
 
-    prompt = build_thread_resolution_prompt(contexts)
-
+    # Split into batches so one call never has to carry every open thread at
+    # once — each thread's full conversation/hunk/commit context stays intact,
+    # only the number of threads sharing a single AI call is bounded.
+    batches = batch_thread_review_contexts(contexts)
     cli_display = adapter.cli_name.value.capitalize()
-    thread_count = len(contexts)
-    adapter_started_at = time.monotonic()
-    with ctx.textual.loading(f"Asking {cli_display} to analyse {thread_count} thread(s)…"):
-        response = adapter.execute(prompt, cwd=project_root, timeout=300)
-    adapter_duration_seconds = time.monotonic() - adapter_started_at
-    logger.info(
-        "thread_resolution_adapter_call",
-        cli=adapter.cli_name.value,
-        thread_count=thread_count,
-        prompt_actual_chars=len(prompt),
-        duration_seconds=round(adapter_duration_seconds, 3),
-        exit_code=response.exit_code,
-        timed_out=response.exit_code == 124,
+    ctx.textual.dim_text(
+        f"Reviewing {len(contexts)} thread(s) in {len(batches)} batch(es) with {cli_display}"
     )
 
-    if not response.succeeded:
-        ctx.textual.warning_text(f"CLI call failed (exit {response.exit_code}) — no thread decisions")
-        if response.stderr:
-            ctx.textual.dim_text(response.stderr[:200])
-        ctx.data["raw_thread_decisions"] = []
-        ctx.textual.end_step("success")
-        return Success("No decisions (CLI error)", metadata={"raw_thread_decisions": []})
+    aggregated_raw: list = []
+    any_batch_failed = False
 
-    # Parse JSON array response
-    match extract_json_payload(response.stdout, kind="array"):
-        case ClientError(error_message=err):
-            ctx.textual.warning_text(f"Thread decisions parsing failed ({err}) — no decisions")
-            ctx.data["raw_thread_decisions"] = []
-            ctx.textual.end_step("success")
-            return Success("No decisions (parse error)", metadata={"raw_thread_decisions": []})
-        case ClientSuccess(data=raw):
-            pass
+    for batch_index, batch in enumerate(batches, start=1):
+        batch_label = f"batch {batch_index}/{len(batches)}"
+        prompt = build_thread_resolution_prompt(batch)
 
-    ctx.data["raw_thread_decisions"] = raw
-    ctx.textual.success_text(f"✓ AI returned {len(raw)} thread decision(s)")
+        _log_ai_prompt(
+            step_name="ai_thread_resolution",
+            cli_name=adapter.cli_name.value,
+            prompt=prompt,
+            batch_index=batch_index,
+            batch_count=len(batches),
+            thread_count=len(batch),
+        )
+
+        adapter_started_at = time.monotonic()
+        with ctx.textual.loading(
+            f"Asking {cli_display} to analyse {batch_label} ({len(batch)} thread(s))…"
+        ):
+            response = adapter.execute(prompt, cwd=project_root, timeout=300)
+        adapter_duration_seconds = time.monotonic() - adapter_started_at
+        logger.info(
+            "thread_resolution_adapter_call",
+            cli=adapter.cli_name.value,
+            batch_index=batch_index,
+            batch_count=len(batches),
+            thread_count=len(batch),
+            prompt_actual_chars=len(prompt),
+            duration_seconds=round(adapter_duration_seconds, 3),
+            exit_code=response.exit_code,
+            timed_out=response.exit_code == 124,
+        )
+        _log_ai_response(
+            step_name="ai_thread_resolution",
+            cli_name=adapter.cli_name.value,
+            stdout=response.stdout,
+            stderr=response.stderr,
+            exit_code=response.exit_code,
+            batch_index=batch_index,
+            batch_count=len(batches),
+        )
+
+        if not response.succeeded:
+            any_batch_failed = True
+            ctx.textual.warning_text(f"{batch_label}: CLI call failed (exit {response.exit_code}) — skipped")
+            if response.stderr:
+                ctx.textual.dim_text(response.stderr[:200])
+            continue
+
+        match extract_json_payload(response.stdout, kind="array"):
+            case ClientError(error_message=err):
+                any_batch_failed = True
+                ctx.textual.warning_text(f"{batch_label}: decisions parsing failed ({err}) — skipped")
+                continue
+            case ClientSuccess(data=raw):
+                aggregated_raw.extend(raw)
+
+    ctx.data["raw_thread_decisions"] = aggregated_raw
+
+    if not aggregated_raw:
+        status = "No decisions (all batches failed)" if any_batch_failed else "No decisions"
+        ctx.textual.warning_text(status)
+        ctx.textual.end_step("success")
+        return Success(status, metadata={"raw_thread_decisions": []})
+
+    summary = f"✓ AI returned {len(aggregated_raw)} thread decision(s)"
+    if any_batch_failed:
+        summary += " (some batches failed — partial results)"
+    ctx.textual.success_text(summary)
     ctx.textual.end_step("success")
-    return Success("AI thread decisions retrieved", metadata={"raw_thread_decisions_count": len(raw)})
+    return Success(
+        "AI thread decisions retrieved",
+        metadata={"raw_thread_decisions_count": len(aggregated_raw)},
+    )
 
 
 def normalize_thread_decisions(ctx: WorkflowContext) -> WorkflowResult:

{titan_cli-0.7.0 → titan_cli-0.7.2}/plugins/titan-plugin-github/titan_plugin_github/workflows/review-pr-thread-resolution.yaml

@@ -1,4 +1,4 @@
-name: "Review PR (Thread Resolution)"
+name: "Thread Resolution"
 description: "AI-powered analysis of open PR threads: resolve, insist, or reply"
 
 steps:

{titan_cli-0.7.0 → titan_cli-0.7.2}/plugins/titan-plugin-slack/titan_plugin_slack/clients/services/auth_service.py

@@ -41,9 +41,11 @@ class AuthService:
             )
 
         if not response.get("ok", False):
+            error_code = response.get("error", "unknown_error")
             return ClientError(
-                error_message=f"Slack auth failed: {response.get('error', 'unknown_error')}",
+                error_message=f"Slack auth failed: {error_code}",
                 error_code="AUTH_ERROR",
+                details={"slack_error": error_code},
             )
 
         return ClientSuccess(

{titan_cli-0.7.0 → titan_cli-0.7.2}/plugins/titan-plugin-slack/titan_plugin_slack/clients/services/conversation_service.py

@@ -104,14 +104,17 @@ class ConversationService:
         if not response.get("ok", False):
             needed = response.get("needed")
             provided = response.get("provided")
-            message = f"Slack read_channel failed: {response.get('error', 'unknown_error')}"
-            details = None
-            if response.get("error") == "missing_scope" and needed:
+            slack_error = response.get("error", "unknown_error")
+            message = f"Slack read_channel failed: {slack_error}"
+            details = {"slack_error": slack_error}
+            if slack_error == "missing_scope" and needed:
                 message += (
                     f". Missing scopes: {needed}. "
                     "Reconnect Slack configuration to grant the required scopes."
                 )
-                details = {"needed_scopes": needed, "provided_scopes": provided}
+                details["needed_scopes"] = needed
+                if provided:
+                    details["provided_scopes"] = provided
             return ClientError(
                 error_message=message,
                 error_code="READ_CHANNEL_ERROR",
@@ -154,16 +157,17 @@ class ConversationService:
         if not response.get("ok", False):
             needed = response.get("needed")
             provided = response.get("provided")
-            message = (
-                f"Slack open_direct_message failed: {response.get('error', 'unknown_error')}"
-            )
-            details = None
-            if response.get("error") == "missing_scope" and needed:
+            slack_error = response.get("error", "unknown_error")
+            message = f"Slack open_direct_message failed: {slack_error}"
+            details = {"slack_error": slack_error}
+            if slack_error == "missing_scope" and needed:
                 message += (
                     f". Missing scopes: {needed}. "
                     "Reconnect Slack configuration to grant the required scopes."
                 )
-                details = {"needed_scopes": needed, "provided_scopes": provided}
+                details["needed_scopes"] = needed
+                if provided:
+                    details["provided_scopes"] = provided
             return ClientError(
                 error_message=message,
                 error_code="OPEN_DIRECT_MESSAGE_ERROR",

{titan_cli-0.7.0 → titan_cli-0.7.2}/plugins/titan-plugin-slack/titan_plugin_slack/clients/services/directory_service.py

@@ -149,9 +149,11 @@ class DirectoryService:
             )
 
         if not response.get("ok", False):
+            error_code = response.get("error", "unknown_error")
             return ClientError(
-                error_message=f"Slack list_users failed: {response.get('error', 'unknown_error')}",
+                error_message=f"Slack list_users failed: {error_code}",
                 error_code="LIST_USERS_ERROR",
+                details={"slack_error": error_code},
             )
 
         members = [self._map_user(member) for member in response.get("members", [])]
@@ -195,12 +197,11 @@ class DirectoryService:
             )
 
         if not response.get("ok", False):
+            error_code = response.get("error", "unknown_error")
             return ClientError(
-                error_message=(
-                    "Slack list_public_channels failed: "
-                    f"{response.get('error', 'unknown_error')}"
-                ),
+                error_message=f"Slack list_public_channels failed: {error_code}",
                 error_code="LIST_PUBLIC_CHANNELS_ERROR",
+                details={"slack_error": error_code},
             )
 
         channels = [self._map_channel(channel) for channel in response.get("channels", [])]
@@ -353,11 +354,11 @@ class DirectoryService:
                 )
 
             if not response.get("ok", False):
+                error_code = response.get("error", "unknown_error")
                 return ClientError(
-                    error_message=(
-                        f"Slack search_channels failed: {response.get('error', 'unknown_error')}"
-                    ),
+                    error_message=f"Slack search_channels failed: {error_code}",
                     error_code="SEARCH_CHANNELS_ERROR",
+                    details={"slack_error": error_code},
                 )
 
             channels = [self._map_channel(channel) for channel in response.get("channels", [])]