opencode-bridge 0.1.5__tar.gz → 0.3.0__tar.gz

{opencode_bridge-0.1.5 → opencode_bridge-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: opencode-bridge
-Version: 0.1.5
+Version: 0.3.0
 Summary: MCP server for continuous OpenCode discussion sessions
 Project-URL: Repository, https://github.com/genomewalker/opencode-bridge
 Author: Antonio Fernandez-Guerra

{opencode_bridge-0.1.5 → opencode_bridge-0.3.0}/opencode_bridge/server.py

@@ -30,6 +30,280 @@ from mcp.server.stdio import stdio_server
 from mcp.types import Tool, TextContent, ServerCapabilities, ToolsCapability
 
 
+# File size thresholds
+SMALL_FILE = 500        # lines
+MEDIUM_FILE = 1500      # lines
+LARGE_FILE = 5000       # lines
+
+# Language detection by extension
+LANG_MAP = {
+    ".py": "Python", ".js": "JavaScript", ".ts": "TypeScript", ".tsx": "TypeScript/React",
+    ".jsx": "JavaScript/React", ".go": "Go", ".rs": "Rust", ".java": "Java",
+    ".c": "C", ".cpp": "C++", ".h": "C/C++ Header", ".hpp": "C++ Header",
+    ".cs": "C#", ".rb": "Ruby", ".php": "PHP", ".swift": "Swift",
+    ".kt": "Kotlin", ".scala": "Scala", ".sh": "Shell", ".bash": "Bash",
+    ".sql": "SQL", ".html": "HTML", ".css": "CSS", ".scss": "SCSS",
+    ".yaml": "YAML", ".yml": "YAML", ".json": "JSON", ".toml": "TOML",
+    ".xml": "XML", ".md": "Markdown", ".r": "R", ".lua": "Lua",
+    ".zig": "Zig", ".nim": "Nim", ".ex": "Elixir", ".erl": "Erlang",
+    ".clj": "Clojure", ".hs": "Haskell", ".ml": "OCaml", ".vue": "Vue",
+    ".svelte": "Svelte", ".dart": "Dart", ".proto": "Protocol Buffers",
+}
+
+
+_file_info_cache: dict[str, dict] = {}
+
+MAX_READ_SIZE = 10 * 1024 * 1024  # 10MB - above this, estimate lines from size
+
+
+def get_file_info(filepath: str) -> dict:
+    """Get metadata about a file: size, lines, language, etc. Results are cached per path."""
+    filepath = str(Path(filepath).resolve())
+    if filepath in _file_info_cache:
+        return _file_info_cache[filepath]
+
+    p = Path(filepath)
+    if not p.is_file():
+        return {}
+    try:
+        stat = p.stat()
+        ext = p.suffix.lower()
+
+        # Count lines efficiently: stream for large files, estimate for huge ones
+        if stat.st_size > MAX_READ_SIZE:
+            # Estimate: ~40 bytes per line for code files
+            line_count = stat.st_size // 40
+        else:
+            # Stream line counting without loading full content into memory
+            line_count = 0
+            with open(p, "r", errors="replace") as f:
+                for _ in f:
+                    line_count += 1
+
+        result = {
+            "path": filepath,
+            "name": p.name,
+            "size_bytes": stat.st_size,
+            "size_human": _human_size(stat.st_size),
+            "lines": line_count,
+            "language": LANG_MAP.get(ext, ext.lstrip(".").upper() if ext else "Unknown"),
+            "ext": ext,
+            "category": (
+                "small" if line_count <= SMALL_FILE
+                else "medium" if line_count <= MEDIUM_FILE
+                else "large" if line_count <= LARGE_FILE
+                else "very large"
+            ),
+        }
+        _file_info_cache[filepath] = result
+        return result
+    except Exception:
+        return {"path": filepath, "name": p.name}
+
+
+def _human_size(size_bytes: int) -> str:
+    """Convert bytes to human-readable size."""
+    for unit in ("B", "KB", "MB", "GB"):
+        if size_bytes < 1024:
+            return f"{size_bytes:.0f}{unit}" if unit == "B" else f"{size_bytes:.1f}{unit}"
+        size_bytes /= 1024
+    return f"{size_bytes:.1f}TB"
+
+
+def build_file_context(file_paths: list[str]) -> str:
+    """Build a context block describing attached files."""
+    if not file_paths:
+        return ""
+    infos = [info for f in file_paths if (info := get_file_info(f))]
+    if not infos:
+        return ""
+
+    parts = ["## Attached Files\n"]
+    for info in infos:
+        line = f"- **{info.get('name', '?')}**"
+        details = []
+        if "language" in info:
+            details.append(info["language"])
+        if "lines" in info:
+            details.append(f"{info['lines']} lines")
+        if "size_human" in info:
+            details.append(info["size_human"])
+        if "category" in info:
+            details.append(info["category"])
+        if details:
+            line += f" ({', '.join(details)})"
+        parts.append(line)
+
+    total_lines = sum(i.get("lines", 0) for i in infos)
+    if total_lines > LARGE_FILE:
+        parts.append(f"\n> Total: {total_lines} lines across {len(infos)} file(s) — this is a large review.")
+        parts.append("> Focus on the most critical issues first. Use a structured, section-by-section approach.")
+
+    return "\n".join(parts)
+
+
+def build_review_prompt(file_infos: list[dict], focus: str) -> str:
+    """Build an adaptive review prompt based on file size and type."""
+    total_lines = sum(i.get("lines", 0) for i in file_infos)
+
+    # Base review instructions
+    prompt_parts = [f"Please review the attached code, focusing on: **{focus}**\n"]
+
+    # Add file context
+    if file_infos:
+        prompt_parts.append("### Files to review:")
+        for info in file_infos:
+            prompt_parts.append(f"- {info.get('name', '?')} ({info.get('language', '?')}, {info.get('lines', '?')} lines)")
+        prompt_parts.append("")
+
+    # Adapt strategy to file size
+    if total_lines > LARGE_FILE:
+        prompt_parts.append("""### Review Strategy (Large File)
+This is a large codebase review. Use this structured approach:
+
+1. **Architecture Overview**: Describe the overall structure, main components, and data flow
+2. **Critical Issues**: Security vulnerabilities, bugs, race conditions, memory leaks
+3. **Design Concerns**: Architectural problems, tight coupling, missing abstractions
+4. **Code Quality**: Naming, duplication, complexity hotspots (focus on the worst areas)
+5. **Key Recommendations**: Top 5 most impactful improvements, prioritized
+
+Do NOT try to comment on every line. Focus on patterns and the most impactful findings.""")
+    elif total_lines > MEDIUM_FILE:
+        prompt_parts.append("""### Review Strategy (Medium File)
+Provide a structured review:
+
+1. **Summary**: What does this code do? Overall assessment
+2. **Issues Found**: Bugs, security concerns, edge cases, error handling gaps
+3. **Design Feedback**: Structure, patterns, abstractions
+4. **Specific Suggestions**: Concrete improvements with code examples where helpful""")
+    else:
+        prompt_parts.append("""### Review Guidelines
+Provide a thorough review covering:
+- Correctness and edge cases
+- Error handling
+- Code clarity and naming
+- Any security concerns
+- Concrete suggestions for improvement""")
+
+    return "\n".join(prompt_parts)
+
+
+def build_message_prompt(message: str, file_paths: list[str]) -> str:
+    """Build a smart prompt that includes file context and instructions."""
+    parts = []
+
+    # Add file context if files are attached
+    user_files = [f for f in file_paths if not Path(f).name.startswith("opencode_msg_")]
+    if user_files:
+        file_context = build_file_context(user_files)
+        if file_context:
+            parts.append(file_context)
+            parts.append("")
+
+        total_lines = sum(get_file_info(f).get("lines", 0) for f in user_files)
+        if total_lines > LARGE_FILE:
+            parts.append("**Note:** Large file(s) attached. Read through the full content carefully before responding. "
+                         "If asked to analyze or review, use a structured section-by-section approach.")
+            parts.append("")
+
+    parts.append("## Request")
+    parts.append("Respond to the user's request in the attached message file. "
+                 "Read all attached files completely before responding.")
+
+    return "\n".join(parts)
+
+
+# ---------------------------------------------------------------------------
+# Companion System — Auto-Framing
+# ---------------------------------------------------------------------------
+
+
+def build_companion_prompt(
+    message: str,
+    files: Optional[list[str]] = None,
+    domain_override: Optional[str] = None,
+    is_followup: bool = False,
+) -> str:
+    """Assemble a companion prompt that auto-detects the domain.
+
+    The LLM identifies the domain and adopts an appropriate expert persona.
+    An optional *domain_override* hint biases the framing toward a specific field.
+    """
+    # Follow-up: lightweight prompt
+    if is_followup:
+        return "\n".join([
+            "## Continuing Our Discussion",
+            "",
+            message,
+            "",
+            "Remember: challenge assumptions, consider alternatives, be explicit about trade-offs.",
+        ])
+
+    # --- Full initial prompt ---
+    parts = []
+
+    # File context
+    user_files = [f for f in (files or []) if not Path(f).name.startswith("opencode_msg_")]
+    if user_files:
+        file_context = build_file_context(user_files)
+        if file_context:
+            parts.append("## Context")
+            parts.append(file_context)
+            parts.append("")
+
+    # Domain hint
+    domain_hint = ""
+    if domain_override:
+        domain_hint = (
+            f"\n\nNote: the user has indicated this is about **{domain_override}** — "
+            "frame your expertise accordingly."
+        )
+
+    parts.append("## Discussion Setup")
+    parts.append(
+        "Determine the **specific domain of expertise** this question belongs to "
+        "(e.g., distributed systems, metagenomics, compiler design, quantitative finance, "
+        "DevOps, security, database design, or any other field).\n"
+        "\n"
+        "Then adopt the persona of a **senior practitioner with deep, hands-on "
+        "experience** in that domain. You have:\n"
+        "- Years of practical experience solving real problems in this field\n"
+        "- Deep knowledge of the key frameworks, methods, and trade-offs\n"
+        "- Strong opinions loosely held — you recommend but explain why\n"
+        "\n"
+        "Briefly state what domain you identified and what expert lens you're "
+        f"applying (one line at the top is enough).{domain_hint}"
+    )
+    parts.append("")
+
+    parts.append("## Collaborative Ground Rules")
+    parts.append("- Think out loud, share your reasoning step by step")
+    parts.append("- Challenge questionable assumptions — including mine")
+    parts.append("- Lay out trade-offs explicitly: what we gain, what we lose")
+    parts.append("- Name the key analytical frameworks or methods relevant to this domain")
+    parts.append("- Propose at least one alternative I haven't considered")
+    parts.append("")
+
+    parts.append("## Your Approach")
+    parts.append("1. Identify the domain and the core question")
+    parts.append("2. Apply domain-specific frameworks and best practices")
+    parts.append("3. Analyze trade-offs with concrete reasoning")
+    parts.append("4. Provide a clear recommendation")
+    parts.append("")
+
+    parts.append("## The Question")
+    parts.append(message)
+    parts.append("")
+
+    parts.append("## Synthesize")
+    parts.append("1. Your recommendation with rationale")
+    parts.append("2. Key trade-offs")
+    parts.append("3. Risks or blind spots")
+    parts.append("4. Open questions worth exploring")
+
+    return "\n".join(parts)
+
+
 # Default configuration
 DEFAULT_MODEL = "openai/gpt-5.2-codex"
 DEFAULT_AGENT = "plan"
@@ -163,6 +437,10 @@ class OpenCodeBridge:
 
     async def _run_opencode(self, *args, timeout: int = 300) -> tuple[str, int]:
         """Run opencode CLI command and return output (async)."""
+        global OPENCODE_BIN
+        # Lazy retry: if binary wasn't found at startup, try again
+        if not OPENCODE_BIN:
+            OPENCODE_BIN = find_opencode()
         if not OPENCODE_BIN:
             return "OpenCode not installed. Install from: https://opencode.ai", 1
 
@@ -177,12 +455,18 @@ class OpenCodeBridge:
                 proc.communicate(input=b''),
                 timeout=timeout
             )
-            output = stdout.decode() or stderr.decode()
-            return output.strip(), proc.returncode or 0
+            # Combine stdout+stderr so errors aren't silently lost
+            out = stdout.decode(errors="replace").strip()
+            err = stderr.decode(errors="replace").strip()
+            output = out if out else err
+            # If both exist and return code indicates error, include stderr
+            if out and err and proc.returncode:
+                output = f"{out}\n\nStderr:\n{err}"
+            return output, proc.returncode or 0
         except asyncio.TimeoutError:
             proc.kill()
             await proc.wait()
-            return "Command timed out", 1
+            return f"Command timed out after {timeout}s", 1
         except Exception as e:
             return f"Error: {e}", 1
 
@@ -294,7 +578,9 @@ Set via:
         self,
         message: str,
         session_id: Optional[str] = None,
-        files: Optional[list[str]] = None
+        files: Optional[list[str]] = None,
+        domain_override: Optional[str] = None,
+        _raw: bool = False,
     ) -> str:
         sid = session_id or self.active_session
         if not sid or sid not in self.sessions:
@@ -302,6 +588,8 @@ Set via:
 
         session = self.sessions[sid]
         session.add_message("user", message)
+        # Save immediately so user messages aren't lost if OpenCode fails
+        session.save(self.sessions_dir / f"{sid}.json")
 
         # Always write message to temp file to avoid shell escaping issues
         temp_file = tempfile.NamedTemporaryFile(
@@ -309,9 +597,20 @@ Set via:
         )
         temp_file.write(message)
         temp_file.close()
-        args = ["run", "Respond to the request in the attached message file."]
         files = (files or []) + [temp_file.name]
 
+        # Build prompt: companion system unless _raw is set
+        if _raw:
+            run_prompt = build_message_prompt(message, files)
+        else:
+            is_followup = len(session.messages) > 1
+            run_prompt = build_companion_prompt(
+                message, files, domain_override=domain_override,
+                is_followup=is_followup,
+            )
+
+        args = ["run", run_prompt]
+
         args.extend(["--model", session.model])
         args.extend(["--agent", session.agent])
 
@@ -331,7 +630,13 @@ Set via:
         # Use JSON format to get session ID
         args.extend(["--format", "json"])
 
-        output, code = await self._run_opencode(*args)
+        # Scale timeout based on attached file size
+        user_files = [f for f in files if not Path(f).name.startswith("opencode_msg_")]
+        total_lines = sum(get_file_info(f).get("lines", 0) for f in user_files)
+        # Base 300s, +60s per 1000 lines above threshold, capped at 900s
+        timeout = min(900, 300 + max(0, (total_lines - MEDIUM_FILE) * 60 // 1000))
+
+        output, code = await self._run_opencode(*args, timeout=timeout)
 
         # Cleanup temp file
         if temp_file:
@@ -396,22 +701,14 @@ Set via:
         topic: str,
         session_id: Optional[str] = None
     ) -> str:
-        """Open-ended brainstorming discussion."""
+        """Open-ended brainstorming discussion — routes through companion system."""
         sid = session_id or self.active_session
 
         if not sid or sid not in self.sessions:
             sid = f"brainstorm-{datetime.now().strftime('%Y%m%d-%H%M%S')}"
             await self.start_session(sid, agent="build")
 
-        prompt = f"""Let's brainstorm about: {topic}
-
-Please provide:
-1. Key considerations and trade-offs
-2. Multiple approaches or solutions
-3. Pros and cons of each approach
-4. Your recommended approach and why"""
-
-        return await self.send_message(prompt, sid)
+        return await self.send_message(f"Let's brainstorm about: {topic}", sid)
 
     async def review_code(
         self,
@@ -426,19 +723,43 @@ Please provide:
             sid = f"review-{datetime.now().strftime('%Y%m%d-%H%M%S')}"
             await self.start_session(sid, agent="build")
 
-        # Check if it's a file path
+        # Check if it's a file path (could be multiple, comma or space separated)
         files = None
-        if Path(code_or_file).is_file():
-            files = [code_or_file]
-            prompt = f"Please review the attached code file, focusing on: {focus}"
+        file_paths = []
+
+        # Try splitting by comma first, then check each part
+        candidates = [c.strip() for c in code_or_file.replace(",", " ").split() if c.strip()]
+        for candidate in candidates:
+            if Path(candidate).is_file():
+                file_paths.append(candidate)
+
+        if file_paths:
+            files = file_paths
+            file_infos = [get_file_info(f) for f in file_paths]
+            file_infos = [i for i in file_infos if i]
+            prompt = build_review_prompt(file_infos, focus)
+
+            # Increase timeout for large files
+            total_lines = sum(i.get("lines", 0) for i in file_infos)
+            if total_lines > LARGE_FILE:
+                # Use variant=high for large reviews if not already high+
+                session = self.sessions[sid]
+                if session.variant in ("minimal", "low", "medium"):
+                    prompt += "\n\n> *Auto-escalated to thorough review due to file size.*"
         else:
-            prompt = f"""Please review this code, focusing on: {focus}
+            # Inline code snippet
+            prompt = f"""Please review this code, focusing on: **{focus}**
 
 ```
 {code_or_file}
-```"""
+```
+
+Provide:
+- Issues found (bugs, edge cases, security)
+- Design feedback
+- Concrete improvement suggestions"""
 
-        return await self.send_message(prompt, sid, files)
+        return await self.send_message(prompt, sid, files, _raw=True)
 
     def list_sessions(self) -> str:
         if not self.sessions:
@@ -527,6 +848,44 @@ Please provide:
 
         return f"Session '{sid}' ended."
 
+    def export_session(self, session_id: Optional[str] = None, format: str = "markdown") -> str:
+        """Export a session as markdown or JSON."""
+        sid = session_id or self.active_session
+        if not sid or sid not in self.sessions:
+            return "No active session to export."
+
+        session = self.sessions[sid]
+
+        if format == "json":
+            data = {
+                "id": session.id,
+                "model": session.model,
+                "agent": session.agent,
+                "variant": session.variant,
+                "created": session.created,
+                "messages": [asdict(m) for m in session.messages]
+            }
+            return json.dumps(data, indent=2)
+
+        # Markdown format
+        lines = [
+            f"# Session: {session.id}",
+            f"**Model:** {session.model} | **Agent:** {session.agent} | **Variant:** {session.variant}",
+            f"**Created:** {session.created}",
+            f"**Messages:** {len(session.messages)}",
+            "",
+            "---",
+            "",
+        ]
+        for msg in session.messages:
+            role = "User" if msg.role == "user" else "OpenCode"
+            lines.append(f"## {role}")
+            lines.append(f"*{msg.timestamp}*\n")
+            lines.append(msg.content)
+            lines.append("\n---\n")
+
+        return "\n".join(lines)
+
     def health_check(self) -> dict:
         """Return server health status."""
         uptime_seconds = int((datetime.now() - self.start_time).total_seconds())
@@ -591,7 +950,9 @@ async def list_tools():
         ),
         Tool(
             name="opencode_discuss",
-            description="Send a message to OpenCode. Use for code review, architecture, brainstorming.",
+            description="Send a message to OpenCode. Use for code review, architecture, brainstorming. "
+                        "Auto-detects discussion domain and frames OpenCode as a specialized expert. "
+                        "Use 'domain' to override detection.",
             inputSchema={
                 "type": "object",
                 "properties": {
@@ -603,6 +964,10 @@ async def list_tools():
                         "type": "array",
                         "items": {"type": "string"},
                         "description": "File paths to attach for context"
+                    },
+                    "domain": {
+                        "type": "string",
+                        "description": "Hint the domain of expertise (e.g., 'security', 'metagenomics', 'quantitative finance')"
                     }
                 },
                 "required": ["message"]
@@ -643,13 +1008,13 @@ async def list_tools():
         ),
         Tool(
             name="opencode_review",
-            description="Review code for issues and improvements",
+            description="Review code for issues and improvements. Supports large files with adaptive review strategies. Can accept multiple file paths (space or comma separated).",
             inputSchema={
                 "type": "object",
                 "properties": {
                     "code_or_file": {
                         "type": "string",
-                        "description": "Code snippet or file path"
+                        "description": "Code snippet, file path, or multiple file paths (space/comma separated)"
                     },
                     "focus": {
                         "type": "string",
@@ -698,6 +1063,7 @@ async def list_tools():
             inputSchema={
                 "type": "object",
                 "properties": {
+                    "session_id": {"type": "string", "description": "Session ID (default: active session)"},
                     "last_n": {"type": "integer", "description": "Number of messages (default: 20)"}
                 }
             }
@@ -740,6 +1106,17 @@ async def list_tools():
                 }
             }
         ),
+        Tool(
+            name="opencode_export",
+            description="Export a session transcript as markdown or JSON",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "session_id": {"type": "string", "description": "Session to export (default: active)"},
+                    "format": {"type": "string", "description": "Export format: markdown or json (default: markdown)", "enum": ["markdown", "json"]}
+                }
+            }
+        ),
         Tool(
             name="opencode_health",
             description="Health check: returns server status, session count, and uptime",
@@ -765,7 +1142,8 @@ async def call_tool(name: str, arguments: dict):
         elif name == "opencode_discuss":
             result = await bridge.send_message(
                 message=arguments["message"],
-                files=arguments.get("files")
+                files=arguments.get("files"),
+                domain_override=arguments.get("domain"),
             )
         elif name == "opencode_plan":
             result = await bridge.plan(
@@ -786,7 +1164,10 @@ async def call_tool(name: str, arguments: dict):
         elif name == "opencode_variant":
             result = bridge.set_variant(arguments["variant"])
         elif name == "opencode_history":
-            result = bridge.get_history(last_n=arguments.get("last_n", 20))
+            result = bridge.get_history(
+                session_id=arguments.get("session_id"),
+                last_n=arguments.get("last_n", 20)
+            )
         elif name == "opencode_sessions":
             result = bridge.list_sessions()
         elif name == "opencode_switch":
@@ -801,6 +1182,11 @@ async def call_tool(name: str, arguments: dict):
                 agent=arguments.get("agent"),
                 variant=arguments.get("variant")
             )
+        elif name == "opencode_export":
+            result = bridge.export_session(
+                session_id=arguments.get("session_id"),
+                format=arguments.get("format", "markdown")
+            )
         elif name == "opencode_health":
             health = bridge.health_check()
             result = f"Status: {health['status']}\nSessions: {health['sessions']}\nUptime: {health['uptime']}s"

{opencode_bridge-0.1.5 → opencode_bridge-0.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "opencode-bridge"
-version = "0.1.5"
+version = "0.3.0"
 description = "MCP server for continuous OpenCode discussion sessions"
 readme = "README.md"
 license = "MIT"

{opencode_bridge-0.1.5 → opencode_bridge-0.3.0}/skills/opencode.md

@@ -1,6 +1,6 @@
 # OpenCode Discussion
 
-Collaborative discussion with OpenCode models (GPT-5, Claude, Gemini). Sessions persist across messages.
+Collaborative discussion with OpenCode models (GPT-5, Claude, Gemini). Sessions persist across messages. Auto-detects discussion domains and frames OpenCode as a specialized expert.
 
 ## Usage
 
@@ -14,7 +14,7 @@ Collaborative discussion with OpenCode models (GPT-5, Claude, Gemini). Sessions
 |---------|-------------|
 | `/opencode` | Start/continue session |
 | `/opencode plan <task>` | Plan with plan agent |
-| `/opencode ask <question>` | Ask anything |
+| `/opencode ask <question>` | Ask anything (auto-detects domain) |
 | `/opencode review <file>` | Review code |
 | `/opencode models` | List models |
 | `/opencode model <name>` | Switch model |
@@ -24,6 +24,21 @@ Collaborative discussion with OpenCode models (GPT-5, Claude, Gemini). Sessions
 | `/opencode set agent <name>` | Set default agent |
 | `/opencode end` | End session |
 
+## Auto-Framing Companion
+
+When you send a message via `opencode_discuss`, the system automatically frames OpenCode as a domain expert. Rather than relying on hardcoded domain lists, the companion prompt instructs the LLM to:
+
+1. **Self-identify the domain** from the question content
+2. **Adopt a senior practitioner persona** with deep, hands-on experience
+3. **Apply relevant analytical frameworks** for that domain
+4. **Engage collaboratively** — challenging assumptions, proposing alternatives, laying out trade-offs
+
+This works for any domain — software architecture, metagenomics, quantitative finance, linguistics, or anything else.
+
+Optionally provide a `domain` hint to steer the framing: `opencode_discuss(message="...", domain="security")`.
+
+Follow-up messages in an existing session get a lighter prompt that preserves the collaborative framing without repeating the full setup.
+
 ## Instructions
 
 ### Starting a Session
@@ -44,12 +59,16 @@ When user says `/opencode ask <question>`:
 1. Call `opencode_discuss(message=<question>)`
 2. Relay the response
 
+To hint a specific domain: `opencode_discuss(message=<question>, domain="security")`
+
 ### Code Review
 
 When user says `/opencode review <file>`:
 1. Call `opencode_review(code_or_file=<file>)`
 2. Relay the findings
 
+Note: Code review bypasses the companion system and uses specialized review prompts.
+
 ### Configuration
 
 When user says `/opencode config`:
@@ -71,7 +90,7 @@ After initial connection, messages like these should be sent as follow-ups:
 - "how would you implement..."
 - "can you explain..."
 
-Call `opencode_discuss(message=<user message>)` and relay response.
+Call `opencode_discuss(message=<user message>)` and relay response. Follow-ups automatically get a lighter prompt.
 
 ### Session Management
 
@@ -86,17 +105,12 @@ Call `opencode_discuss(message=<user message>)` and relay response.
 User: /opencode
 Claude: Connected to OpenCode (openai/gpt-5.2-codex, plan agent). Ready.
 
-User: Let's plan an RLM-inspired hierarchical retrieval system
-Claude: [calls opencode_plan, relays response]
-
-User: What about the filtering stage?
-Claude: [calls opencode_discuss, relays response]
-
-User: /opencode model github-copilot/claude-opus-4.5
-Claude: Model changed to github-copilot/claude-opus-4.5
+User: Should we use event sourcing for our order system?
+Claude: [calls opencode_discuss]
+       [OpenCode responds as a distributed systems architect]
 
-User: /opencode set model openai/gpt-5.2-codex
-Claude: Default model set to openai/gpt-5.2-codex (persisted)
+User: What about the security implications?
+Claude: [calls opencode_discuss — follow-up, lighter prompt]
 
 User: /opencode end
 Claude: Session ended.

opencode_bridge-0.3.0/tests/test_companion.py

@@ -0,0 +1,114 @@
+"""Tests for the auto-framing companion prompt system."""
+
+from opencode_bridge.server import build_companion_prompt
+
+
+# ---------------------------------------------------------------------------
+# Initial prompt structure
+# ---------------------------------------------------------------------------
+
+class TestInitialPrompt:
+    def test_has_all_sections(self):
+        prompt = build_companion_prompt("How should we handle auth?")
+        assert "## Discussion Setup" in prompt
+        assert "## Collaborative Ground Rules" in prompt
+        assert "## Your Approach" in prompt
+        assert "## The Question" in prompt
+        assert "## Synthesize" in prompt
+
+    def test_contains_message(self):
+        msg = "Should we use event sourcing for orders?"
+        prompt = build_companion_prompt(msg)
+        assert msg in prompt
+
+    def test_instructs_domain_identification(self):
+        prompt = build_companion_prompt("How do we price a barrier option?")
+        assert "specific domain of expertise" in prompt
+        assert "senior practitioner" in prompt
+
+    def test_instructs_trade_off_analysis(self):
+        prompt = build_companion_prompt("Should we use Redis or Memcached?")
+        assert "trade-offs" in prompt.lower()
+        assert "challenge" in prompt.lower()
+
+    def test_works_for_software_topics(self):
+        prompt = build_companion_prompt("Should we use microservices or a monolith?")
+        assert "## The Question" in prompt
+        assert "microservices" in prompt
+
+    def test_works_for_science_topics(self):
+        prompt = build_companion_prompt(
+            "Should we use co-assembly or per-sample binning for ancient DNA metagenomes?"
+        )
+        assert "## The Question" in prompt
+        assert "co-assembly" in prompt
+
+    def test_works_for_finance_topics(self):
+        prompt = build_companion_prompt(
+            "How should we price a European barrier option with jump diffusion?"
+        )
+        assert "## The Question" in prompt
+        assert "barrier option" in prompt
+
+
+# ---------------------------------------------------------------------------
+# Domain override hint
+# ---------------------------------------------------------------------------
+
+class TestDomainOverride:
+    def test_override_included_in_prompt(self):
+        prompt = build_companion_prompt("Tell me about caching", domain_override="security")
+        assert "security" in prompt.lower()
+
+    def test_override_free_form(self):
+        prompt = build_companion_prompt(
+            "How do we handle this?", domain_override="metagenomics"
+        )
+        assert "metagenomics" in prompt
+
+    def test_no_override_no_hint(self):
+        prompt = build_companion_prompt("Tell me about caching")
+        assert "user has indicated" not in prompt
+
+
+# ---------------------------------------------------------------------------
+# Follow-up prompts
+# ---------------------------------------------------------------------------
+
+class TestFollowup:
+    def test_followup_is_lightweight(self):
+        full = build_companion_prompt("How should we handle auth?")
+        followup = build_companion_prompt("What about JWT?", is_followup=True)
+        assert "Continuing Our Discussion" in followup
+        assert len(followup) < len(full)
+
+    def test_followup_does_not_have_full_sections(self):
+        followup = build_companion_prompt("What about JWT?", is_followup=True)
+        assert "## Discussion Setup" not in followup
+        assert "## Your Approach" not in followup
+
+    def test_followup_contains_message(self):
+        msg = "What about JWT vs sessions?"
+        followup = build_companion_prompt(msg, is_followup=True)
+        assert msg in followup
+
+    def test_followup_has_collaborative_reminder(self):
+        followup = build_companion_prompt("What next?", is_followup=True)
+        assert "challenge assumptions" in followup
+
+
+# ---------------------------------------------------------------------------
+# File context
+# ---------------------------------------------------------------------------
+
+class TestFileContext:
+    def test_no_crash_with_files(self):
+        prompt = build_companion_prompt("Review this", files=["/tmp/test.py"])
+        assert "## The Question" in prompt
+
+    def test_temp_files_excluded_from_context(self):
+        prompt = build_companion_prompt(
+            "Review this", files=["/tmp/opencode_msg_abc.md"]
+        )
+        # Temp message files should not appear in file context
+        assert "opencode_msg" not in prompt.split("## The Question")[0]