diff --git a/AGENTS.md b/AGENTS.md
index 062fb22eb4..f190fd0d5a 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -55,6 +55,7 @@ Specify supports multiple AI agents by generating agent-specific command files a
 | **Gemini CLI**             | `.gemini/commands/`    | TOML     | `gemini`        | Google's Gemini CLI         |
 | **GitHub Copilot**         | `.github/agents/`      | Markdown | N/A (IDE-based) | GitHub Copilot in VS Code   |
 | **Cursor**                 | `.cursor/commands/`    | Markdown | N/A (IDE-based) | Cursor IDE (`--ai cursor-agent`) |
+| **Dev Container**          | `.devcontainer/commands/` | Markdown | `devcontainer` (optional) | VS Code Dev Containers (`--integration devcontainer`) |
 | **Qwen Code**              | `.qwen/commands/`      | Markdown | `qwen`          | Alibaba's Qwen Code CLI     |
 | **opencode**               | `.opencode/command/`   | Markdown | `opencode`      | opencode CLI                |
 | **Codex CLI**              | `.agents/skills/`      | Markdown | `codex`         | Codex CLI (`--ai codex --ai-skills`) |
@@ -288,6 +289,7 @@ Work within integrated development environments:
 
 - **GitHub Copilot**: Built into VS Code/compatible editors
 - **Cursor**: Built into Cursor IDE (`--ai cursor-agent`)
+- **Dev Container**: VS Code Dev Containers (`--integration devcontainer`)
 - **Windsurf**: Built into Windsurf IDE
 - **Kilo Code**: Built into Kilo Code IDE
 - **Roo Code**: Built into Roo Code IDE
@@ -299,7 +301,7 @@ Work within integrated development environments:
 
 ### Markdown Format
 
-Used by: Claude, Cursor, GitHub Copilot, opencode, Windsurf, Junie, Kiro CLI, Amp, SHAI, IBM Bob, Kimi Code, Qwen, Pi, Codex, Auggie, CodeBuddy, Qoder, Roo Code, Kilo Code, Trae, Antigravity, Mistral Vibe, iFlow, Forge
+Used by: Claude, Cursor, GitHub Copilot, Dev Container, opencode, Windsurf, Junie, Kiro CLI, Amp, SHAI, IBM Bob, Kimi Code, Qwen, Pi, Codex, Auggie, CodeBuddy, Qoder, Roo Code, Kilo Code, Trae, Antigravity, Mistral Vibe, iFlow, Forge
 
 **Standard format:**
 
@@ -355,6 +357,7 @@ Command content with {SCRIPT} and {{args}} placeholders.
 - **IDE agents**: Follow IDE-specific patterns:
   - Copilot: `.github/agents/`
   - Cursor: `.cursor/commands/`
+  - Dev Container: `.devcontainer/commands/`
   - Windsurf: `.windsurf/workflows/`
   - Kilo Code: `.kilocode/workflows/`
   - Roo Code: `.roo/commands/`
diff --git a/CHANGELOG.md b/CHANGELOG.md
index ee611738ba..2acbeaab3f 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -255,7 +255,22 @@ All notable changes to the Specify CLI and templates are documented here.
 
 - **Quick extension**: v1.0.3 → v1.0.4 (hook execution template improvement)
 
-# [Unreleased]
+# [0.8.7+adlc6] - 2026-05-13
+
+### Fixed
+
+- **OpenCode Docker HTTP**: Use the real OpenCode server API (`POST /session` then `POST /session/{id}/command`) instead of the non-existent `/api/execute`, map core `speckit.*` slash names to `spec.*` for the HTTP command field (with an override for `speckit.taskstoissues`), and probe **`/global/health`** (with `/health` fallback) for readiness so traffic reaches the container and can appear in **`docker compose logs`**.
+
+# [0.8.7+adlc5] - 2026-05-13
+
+### Added
+
+- **`specify integration invoke`**: Dispatch a Spec Kit command (e.g. `implement`) through the active integration, including **OpenCode Docker** HTTP mode when configured.
+- **`/speckit.implement` template**: Document that IDE-only implementation does not hit OpenCode Docker; use `specify integration invoke implement ...` from the repo root when `"mode": "docker"` in `.specify/opencode.json`.
+
+### Changed
+
+- **OpenCode Docker**: Emit `[specify][opencode-docker]` trace lines to **stderr** whenever a command (including `implement`) is dispatched via HTTP so you can confirm the container path in the terminal.
 
 ### Added
 
diff --git a/README.md b/README.md
index 68c6fb5151..6faecc03f5 100644
--- a/README.md
+++ b/README.md
@@ -349,6 +349,85 @@ Additional commands for enhanced quality and validation:
 
 For full command details, options, and examples, see the [CLI Reference](https://github.github.io/spec-kit/reference/overview.html).
 
+### 🐳 Running OpenCode in Docker
+
+You can run OpenCode async tasks in a Docker container for easier testing, CI/CD integration, or remote execution. This is useful for sandboxed execution or running on servers.
+
+**Prerequisites:**
+- Docker Desktop or Docker Engine
+- `docker-compose` CLI tool
+
+**Starting the Docker container:**
+
+```bash
+# Initialize your project (if not already done)
+specify init . --integration opencode
+
+# Start OpenCode in Docker
+spec docker-up
+
+# Output:
+# Starting OpenCode Docker container...
+# ✓ OpenCode container running at http://localhost:9000
+```
+
+**Using OpenCode from Docker:**
+
+Once the container is running, all `spec.implement` tasks and OpenCode commands automatically execute on the Docker container via HTTP API:
+
+```bash
+specify integration invoke implement "write a hello world function"
+```
+
+The CLI talks to the OpenCode HTTP server inside Docker (`POST /session` then `POST /session/{id}/command`). While that runs, **`docker compose -f .specify/docker-compose.yml logs -f`** should show server activity, and your terminal shows **`[specify][opencode-docker]`** lines on stderr when Specify is dispatching to Docker.
+
+**Checking container status:**
+
+```bash
+spec docker-status
+
+# Output:
+# ✓ OpenCode container opencode-dev is running
+# URL: http://localhost:9000
+# Recent logs:
+# ...
+```
+
+**Stopping the container:**
+
+```bash
+spec docker-down
+
+# Output:
+# Stopping OpenCode Docker container...
+# ✓ OpenCode container stopped
+```
+
+**Configuration:**
+
+Docker settings are stored in `.specify/opencode.json`:
+
+```json
+{
+  "mode": "docker",
+  "docker": {
+    "enabled": true,
+    "compose_file": "./.specify/docker-compose.yml",
+    "container_name": "opencode-dev",
+    "http_url": "http://localhost:9000",
+    "container_workspace": "/workspace"
+  }
+}
+```
+
+**Environment override:**
+
+You can also use the `OPENCODE_MODE` environment variable to temporarily enable Docker mode:
+
+```bash
+OPENCODE_MODE=docker spec.implement "write a function"
+```
+
 ## 🧩 Making Spec Kit Your Own: Extensions & Presets
 
 Spec Kit can be tailored to your needs through two complementary systems — **extensions** and **presets** — plus project-local overrides for one-off adjustments:
diff --git a/pyproject.toml b/pyproject.toml
index 5351c6744d..f4c98311bf 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -54,6 +54,9 @@ packages = ["src/specify_cli"]
 "extensions/catalog.json" = "specify_cli/core_pack/extensions/catalog.json"
 # Bundled presets (installable via `specify preset add <name>` or `specify init --preset <name>`)
 "presets/lean" = "specify_cli/core_pack/presets/lean"
+# OpenCode Docker templates
+"src/specify_cli/integrations/opencode/docker/Dockerfile" = "specify_cli/integrations/opencode/docker/Dockerfile"
+"src/specify_cli/integrations/opencode/docker/docker-compose.yml" = "specify_cli/integrations/opencode/docker/docker-compose.yml"
 
 [tool.hatch.build.targets.sdist]
 include = [
@@ -93,3 +96,10 @@ precision = 2
 show_missing = true
 skip_covered = false
 
+[dependency-groups]
+dev = [
+    "httpx>=0.28.1",
+    "pytest>=9.0.3",
+    "pytest-asyncio>=1.3.0",
+]
+
diff --git a/src/specify_cli/__init__.py b/src/specify_cli/__init__.py
index 715623edba..e454955940 100644
--- a/src/specify_cli/__init__.py
+++ b/src/specify_cli/__init__.py
@@ -38,6 +38,8 @@
 from typing import Any, Optional
 
 import typer
+from rich.console import Console
+
 from rich.panel import Panel
 from rich.live import Live
 from rich.align import Align
@@ -805,20 +807,25 @@ def init(
     if not ignore_agent_tools:
         agent_config = AGENT_CONFIG.get(selected_ai)
         if agent_config and agent_config["requires_cli"]:
-            install_url = agent_config["install_url"]
-            if not check_tool(selected_ai):
-                error_panel = Panel(
-                    f"[cyan]{selected_ai}[/cyan] not found\n"
-                    f"Install from: [cyan]{install_url}[/cyan]\n"
-                    f"{agent_config['name']} is required to continue with this project type.\n\n"
-                    "Tip: Use [cyan]--ignore-agent-tools[/cyan] to skip this check",
-                    title="[red]Agent Detection Error[/red]",
-                    border_style="red",
-                    padding=(1, 2)
-                )
-                console.print()
-                console.print(error_panel)
-                raise typer.Exit(1)
+            # Special case: opencode supports Docker mode, so don't require local CLI
+            if selected_ai == "opencode":
+                # Skip local CLI check for opencode - Docker mode will handle it
+                pass
+            else:
+                install_url = agent_config["install_url"]
+                if not check_tool(selected_ai):
+                    error_panel = Panel(
+                        f"[cyan]{selected_ai}[/cyan] not found\n"
+                        f"Install from: [cyan]{install_url}[/cyan]\n"
+                        f"{agent_config['name']} is required to continue with this project type.\n\n"
+                        "Tip: Use [cyan]--ignore-agent-tools[/cyan] to skip this check",
+                        title="[red]Agent Detection Error[/red]",
+                        border_style="red",
+                        padding=(1, 2)
+                    )
+                    console.print()
+                    console.print(error_panel)
+                    raise typer.Exit(1)
 
     if script_type:
         if script_type not in SCRIPT_TYPE_CHOICES:
@@ -1126,6 +1133,13 @@ def init(
                 tracker.skip("extensions", f"hook error: {hook_err}")
                 tracker.skip("presets", f"hook error: {hook_err}")
 
+            # After all presets/extensions are installed, re-wrap for devcontainer
+            if resolved_integration.key == "devcontainer":
+                try:
+                    resolved_integration.post_preset_install(project_path)
+                except Exception as wrap_err:
+                    print(f"[specify][devcontainer] Post-init wrap failed: {wrap_err}", file=sys.stderr)
+
             tracker.complete("final", "project ready")
         except (typer.Exit, SystemExit):
             raise
@@ -2726,6 +2740,84 @@ def integration_info(
     raise typer.Exit(1)
 
 
+@integration_app.command("invoke")
+def integration_invoke(
+    command: str = typer.Argument(
+        ...,
+        metavar="COMMAND",
+        help="Spec Kit command stem (e.g. implement, plan, tasks, specify).",
+    ),
+    agent_args: str = typer.Argument(
+        "",
+        metavar="[ARGS]",
+        help="Optional text passed to the agent after the slash command.",
+    ),
+    integration_key: str | None = typer.Option(
+        None,
+        "--integration",
+        "-I",
+        help="Integration to use (default: project's active integration).",
+    ),
+):
+    """Run a Spec Kit command through the configured agent (local CLI or OpenCode Docker HTTP)."""
+    from .integrations import get_integration
+
+    project_root = _require_specify_project()
+    current = _read_integration_json(project_root)
+    key = integration_key or _default_integration_key(current)
+    if not key:
+        console.print(
+            "[red]Error:[/red] No default integration. "
+            "Choose one with [cyan]specify integration use <id>[/cyan]."
+        )
+        raise typer.Exit(1)
+
+    impl = get_integration(key)
+    if impl is None:
+        console.print(f"[red]Error:[/red] Unknown integration {key!r}.")
+        raise typer.Exit(1)
+
+    stem = command.strip().lstrip("/")
+    if stem.startswith("speckit."):
+        stem = stem[len("speckit.") :]
+    elif stem.startswith("spec."):
+        stem = stem[len("spec.") :]
+
+    exec_args = impl.build_exec_args("test", project_root=project_root)
+    if exec_args is None:
+        console.print(
+            f"[red]Error:[/red] Integration {key!r} does not support "
+            "non-interactive command dispatch."
+        )
+        raise typer.Exit(1)
+
+    is_docker_mode = "--docker-mode" in exec_args
+    if not is_docker_mode and not shutil.which(impl.key):
+        console.print(
+            f"[red]Error:[/red] {impl.key!r} is not on PATH and OpenCode Docker mode "
+            "is not active (see .specify/opencode.json or run [cyan]specify docker-up[/cyan])."
+        )
+        raise typer.Exit(1)
+
+    try:
+        result = impl.dispatch_command(
+            stem,
+            args=agent_args,
+            project_root=project_root,
+            stream=True,
+        )
+    except NotImplementedError as exc:
+        console.print(f"[red]Error:[/red] {exc}")
+        raise typer.Exit(1)
+
+    code = result.get("exit_code", 1)
+    if code not in (0, None):
+        err = (result.get("stderr") or "").strip()
+        if err:
+            console.print(f"[red]{err}[/red]")
+        raise typer.Exit(int(code))
+
+
 @integration_catalog_app.command("list")
 def integration_catalog_list():
     """List configured integration catalog sources."""
@@ -5518,6 +5610,154 @@ def workflow_catalog_remove(
     console.print(f"[green]✓[/green] Catalog source '{removed_name}' removed")
 
 
+# docker_up and other docker commands are registered as app subcommands below
+
+
+@app.command()
+def docker_up(
+    project_root: Path | None = typer.Option(
+        None, "--project-root", help="Project root directory"
+    )
+):
+    """Start OpenCode in a Docker container.
+
+    Builds and starts the Docker container, then waits for it to be ready.
+    Configuration is stored in .specify/opencode.json.
+    """
+    from .integrations.opencode.docker_manager import DockerManager, ensure_opencode_docker_assets
+
+    _project_root = project_root or _require_specify_project()
+
+    ensure_opencode_docker_assets(_project_root)
+
+    # Load or create config
+    config_path = _project_root / ".specify" / "opencode.json"
+    config = {}
+    if config_path.exists():
+        try:
+            with open(config_path) as f:
+                config = json.load(f)
+        except (json.JSONDecodeError, IOError):
+            pass
+
+    docker_config = config.get("docker", {})
+    compose_file = docker_config.get("compose_file", "./.specify/docker-compose.yml")
+    container_name = docker_config.get("container_name", "opencode-dev")
+    http_url = docker_config.get("http_url", "http://localhost:9000")
+
+    manager = DockerManager(
+        compose_file, container_name, http_url, project_root=_project_root
+    )
+
+    console.print("[bold]Starting OpenCode Docker container...[/bold]")
+    if manager.docker_up():
+        config["mode"] = "docker"
+        container_workspace = docker_config.get("container_workspace", "/workspace")
+        config["docker"] = {
+            "enabled": True,
+            "compose_file": compose_file,
+            "container_name": container_name,
+            "http_url": http_url,
+            "container_workspace": container_workspace,
+        }
+        config_path.parent.mkdir(parents=True, exist_ok=True)
+        with open(config_path, "w") as f:
+            json.dump(config, f, indent=2)
+        console.print(f"[green]✓[/green] OpenCode container running at {http_url}")
+    else:
+        console.print("[red]✗[/red] Failed to start Docker container")
+        raise typer.Exit(1)
+
+
+@app.command()
+def docker_down(
+    project_root: Path | None = typer.Option(
+        None, "--project-root", help="Project root directory"
+    )
+):
+    """Stop the OpenCode Docker container."""
+    from .integrations.opencode.docker_manager import DockerManager
+
+    _project_root = project_root or _require_specify_project()
+
+    config_path = _project_root / ".specify" / "opencode.json"
+    config = {}
+    if config_path.exists():
+        try:
+            with open(config_path) as f:
+                config = json.load(f)
+        except (json.JSONDecodeError, IOError):
+            pass
+
+    docker_config = config.get("docker", {})
+    compose_file = docker_config.get("compose_file", "./.specify/docker-compose.yml")
+    container_name = docker_config.get("container_name", "opencode-dev")
+    http_url = docker_config.get("http_url", "http://localhost:9000")
+
+    manager = DockerManager(
+        compose_file, container_name, http_url, project_root=_project_root
+    )
+
+    console.print("[bold]Stopping OpenCode Docker container...[/bold]")
+    if manager.docker_down():
+        config["mode"] = "local"
+        config.setdefault("docker", {})
+        config["docker"]["enabled"] = False
+        with open(config_path, "w") as f:
+            json.dump(config, f, indent=2)
+        console.print(f"[green]✓[/green] OpenCode container stopped")
+    else:
+        console.print("[red]✗[/red] Failed to stop Docker container")
+        raise typer.Exit(1)
+
+
+@app.command()
+def docker_status(
+    project_root: Path | None = typer.Option(
+        None, "--project-root", help="Project root directory"
+    )
+):
+    """Show OpenCode Docker container status."""
+    from .integrations.opencode.docker_manager import DockerManager
+
+    _project_root = project_root or _require_specify_project()
+
+    config_path = _project_root / ".specify" / "opencode.json"
+    config = {}
+    if config_path.exists():
+        try:
+            with open(config_path) as f:
+                config = json.load(f)
+        except (json.JSONDecodeError, IOError):
+            pass
+
+    docker_config = config.get("docker", {})
+    compose_file = docker_config.get("compose_file", "./.specify/docker-compose.yml")
+    container_name = docker_config.get("container_name", "opencode-dev")
+    http_url = docker_config.get("http_url", "http://localhost:9000")
+
+    manager = DockerManager(
+        compose_file, container_name, http_url, project_root=_project_root
+    )
+
+    status = manager.docker_status()
+    if status is None:
+        console.print("[yellow]⚠[/yellow] Could not retrieve Docker status")
+        return
+
+    if status.get("running"):
+        console.print(f"[green]✓[/green] OpenCode container [bold]{status.get('name')}[/bold] is running")
+        console.print(f"[dim]URL: {http_url}[/dim]")
+    else:
+        console.print(f"[yellow]○[/yellow] OpenCode container is not running")
+
+    # Show recent logs
+    logs = manager.get_container_logs(lines=10)
+    if logs:
+        console.print("\n[bold]Recent logs:[/bold]")
+        console.print("[dim]" + logs + "[/dim]")
+
+
 def main():
     app()
 
diff --git a/src/specify_cli/integrations/__init__.py b/src/specify_cli/integrations/__init__.py
index 4a78e7d035..1b6da0fb17 100644
--- a/src/specify_cli/integrations/__init__.py
+++ b/src/specify_cli/integrations/__init__.py
@@ -56,6 +56,7 @@ def _register_builtins() -> None:
     from .codex import CodexIntegration
     from .copilot import CopilotIntegration
     from .cursor_agent import CursorAgentIntegration
+    from .devcontainer import DevContainerIntegration
     from .devin import DevinIntegration
     from .forge import ForgeIntegration
     from .gemini import GeminiIntegration
@@ -88,6 +89,7 @@ def _register_builtins() -> None:
     _register(CodexIntegration())
     _register(CopilotIntegration())
     _register(CursorAgentIntegration())
+    _register(DevContainerIntegration())
     _register(DevinIntegration())
     _register(ForgeIntegration())
     _register(GeminiIntegration())
diff --git a/src/specify_cli/integrations/devcontainer/__init__.py b/src/specify_cli/integrations/devcontainer/__init__.py
new file mode 100644
index 0000000000..29f383523f
--- /dev/null
+++ b/src/specify_cli/integrations/devcontainer/__init__.py
@@ -0,0 +1,788 @@
+"""Dev Container integration."""
+
+import json
+import os
+import subprocess
+import sys
+from pathlib import Path
+from typing import Any, TYPE_CHECKING
+
+from ..base import MarkdownIntegration
+
+if TYPE_CHECKING:
+    from ..manifest import IntegrationManifest
+
+
+class DevContainerIntegration(MarkdownIntegration):
+    key = "devcontainer"
+    config = {
+        "name": "Dev Container",
+        "folder": ".devcontainer/",
+        "commands_subdir": "commands",
+        "install_url": "https://code.visualstudio.com/docs/devcontainers/devcontainer-cli",
+        "requires_cli": False,  # IDE-based, but can use CLI
+    }
+    registrar_config = {
+        "dir": ".devcontainer/commands",
+        "format": "markdown",
+        "args": "$ARGUMENTS",
+        "extension": ".md",
+    }
+    context_file = ".devcontainer/devcontainer-instructions.md"
+
+    _DEVCONTAINER_LOG_PREFIX = "[specify][devcontainer]"
+
+    @classmethod
+    def _devcontainer_trace(cls, message: str) -> None:
+        """Emit a visible trace line for Dev Container routing (stderr, flushed)."""
+        print(f"{cls._DEVCONTAINER_LOG_PREFIX} {message}", file=sys.stderr, flush=True)
+
+    def build_exec_args(
+        self,
+        prompt: str,
+        *,
+        model: str | None = None,
+        output_json: bool = True,
+        project_root: Path | None = None,
+    ) -> list[str] | None:
+        # Check if Dev Container mode is enabled - if so, return synthetic args
+        # to pass the CLI check in CommandStep._try_dispatch()
+        check_path = project_root or Path.cwd()
+        if self._is_devcontainer_mode(check_path):
+            # Return synthetic args indicating Dev Container mode
+            # dispatch_command will route to devcontainer CLI instead
+            return [self.key, "--devcontainer-mode", prompt]
+
+        # No local CLI fallback for dev containers
+        return None
+
+    @staticmethod
+    def _wrap_script_path_for_devcontainer(script_path_with_args: str, shell_type: str) -> str:
+        """Wrap script path with devcontainer routing for AI agents.
+        
+        Creates a simple, clear command that AI agents can execute to run scripts
+        in the dev container.
+        
+        Args:
+            script_path_with_args: Path to the script with arguments
+            shell_type: 'bash' or 'powershell'
+            
+        Returns:
+            Direct devcontainer exec command (simple and clear for AI)
+        """
+        # Keep it simple: just wrap with devcontainer exec
+        # AI agents will see clear, direct commands
+        
+        if shell_type == 'bash':
+            # Simple, direct command that AI can easily understand and execute
+            wrapper = f'devcontainer exec --workspace-folder . bash {script_path_with_args}'
+        else:  # powershell
+            wrapper = f'devcontainer exec --workspace-folder . powershell {script_path_with_args}'
+        
+        return wrapper
+
+    def process_template(
+        self,
+        content: str,
+        agent_name: str,
+        script_type: str,
+        arg_placeholder: str = "$ARGUMENTS",
+        context_file: str = "",
+        invoke_separator: str = ".",
+        project_root: Path | None = None,
+    ) -> str:
+        """Process command template with Dev Container-specific routing.
+        
+        Wraps script invocations so they execute inside the dev container
+        when an AI agent (like Claude Code) runs commands via slash commands.
+        """
+        self._devcontainer_trace(f"Processing template for {agent_name} (script_type={script_type})")
+        
+        # First, apply standard Markdown processing
+        content = super().process_template(
+            content=content,
+            agent_name=agent_name,
+            script_type=script_type,
+            arg_placeholder=arg_placeholder,
+            context_file=context_file,
+            invoke_separator=invoke_separator,
+            project_root=project_root,
+        )
+        
+        self._devcontainer_trace("Standard processing complete, applying script wrapping...")
+
+        # After standard processing, {SCRIPT} has been replaced with actual script paths
+        # Now wrap those script invocations to route through dev container
+        # Pattern matches script paths in backticks: `.specify/scripts/bash/<script>.sh`
+        
+        import re
+        
+        # Match both with and without leading backslash escape
+        # Patterns: `.specify/...` or `\.specify/...`
+        bash_pattern = r'`(\\?\.specify/scripts/bash/[^`]+\.sh[^`]*)`'
+        bash_matches = re.findall(bash_pattern, content)
+        if bash_matches:
+            self._devcontainer_trace(f"Found {len(bash_matches)} bash script references to wrap")
+        
+        # Wrap bash script paths
+        content = re.sub(
+            bash_pattern,
+            lambda m: f'`{self._wrap_script_path_for_devcontainer(m.group(1).replace("\\", ""), "bash")}`',
+            content
+        )
+        
+        # Also match explicit bash commands if present
+        content = re.sub(
+            r'`bash (\\?\.specify/scripts/bash/[^`]+\.sh[^`]*)`',
+            lambda m: f'`{self._wrap_script_path_for_devcontainer(m.group(1).replace("\\", ""), "bash")}`',
+            content
+        )
+        
+        # Wrap PowerShell script paths
+        ps_pattern = r'`(\\?\.specify/scripts/powershell/[^`]+\.ps1[^`]*)`'
+        content = re.sub(
+            ps_pattern,
+            lambda m: f'`{self._wrap_script_path_for_devcontainer(m.group(1).replace("\\", ""), "powershell")}`',
+            content
+        )
+        
+        # Also match explicit powershell commands if present
+        content = re.sub(
+            r'`powershell (\\?\.specify/scripts/powershell/[^`]+\.ps1[^`]*)`',
+            lambda m: f'`{self._wrap_script_path_for_devcontainer(m.group(1).replace("\\", ""), "powershell")}`',
+            content
+        )
+        
+        # Debug: check if wrapping actually happened
+        if 'devcontainer exec' in content:
+            self._devcontainer_trace("✅ Script wrapping successful - devcontainer exec found in output")
+            # Show a sample of what was wrapped
+            import re
+            sample = re.search(r'`devcontainer exec[^`]{0,80}', content)
+            if sample:
+                self._devcontainer_trace(f"Sample: {sample.group()[:100]}...")
+        else:
+            self._devcontainer_trace("⚠️  Script wrapping may have failed - no devcontainer exec in output")
+
+        return content
+
+    def setup(
+        self,
+        project_root: Path,
+        manifest: "IntegrationManifest",
+        parsed_options: dict[str, Any] | None = None,
+        **opts: Any,
+    ) -> list[Path]:
+        """Set up Dev Container integration.
+
+        Creates:
+        1. .devcontainer/commands/ with devcontainer exec wrapping
+        2. Command files for ALL AI agents (opencode, claude, cursor, etc.)
+        3. Docker configuration (.devcontainer/devcontainer.json)
+        4. Context files (AGENTS.md, devcontainer-instructions.md)
+        5. .specify/devcontainer.json config
+        """
+        # Standard Markdown integration setup creates .devcontainer/commands/ files
+        created_files = super().setup(project_root, manifest, parsed_options, **opts)
+
+        # Create .specify/devcontainer.json configuration
+        self._create_devcontainer_config(project_root)
+
+        # Create .devcontainer/devcontainer.json Docker configuration if it doesn't exist
+        force = opts.get("force", False)
+        self._create_docker_config(project_root, force)
+
+        # Create context files for AI agents
+        self._create_context_file(project_root)
+        self._create_agents_md_context(project_root)
+
+        # Create wrapped command files for ALL AI agent directories
+        self._setup_all_agent_commands(project_root, manifest, parsed_options, **opts)
+
+        # Safety net: wrap any existing agent files not created by us
+        self._wrap_all_agent_commands(project_root)
+
+        return created_files
+
+    def post_preset_install(self, project_root: Path) -> None:
+        """Re-wrap agent command files after preset installation.
+
+        Presets (like agentic-sdlc) install their own command files into
+        agent directories AFTER setup() runs, overwriting our wrapped
+        versions. This method re-applies the devcontainer exec wrapping
+        to undo the overwrite.
+        """
+        self._devcontainer_trace("Re-wrapping agent files after preset installation...")
+        self._wrap_all_agent_commands(project_root)
+        self._create_agents_md_context(project_root)
+
+    def _create_devcontainer_config(self, project_root: Path) -> None:
+        """Create .specify/devcontainer.json configuration file."""
+        specify_dir = project_root / ".specify"
+        specify_dir.mkdir(parents=True, exist_ok=True)
+
+        config_path = specify_dir / "devcontainer.json"
+        config = {
+            "mode": "enabled",
+            "devcontainer": {
+                "workspace_folder": "/workspace",
+                "cli_path": "devcontainer",
+            },
+        }
+
+        with open(config_path, "w", encoding="utf-8") as f:
+            json.dump(config, f, indent=2)
+            f.write("\n")
+
+        self._devcontainer_trace(f"Created {config_path}")
+
+    def _create_docker_config(self, project_root: Path, force: bool = False) -> None:
+        """Create .devcontainer/devcontainer.json Docker configuration file."""
+        devcontainer_dir = project_root / ".devcontainer"
+        devcontainer_dir.mkdir(parents=True, exist_ok=True)
+
+        docker_config_path = devcontainer_dir / "devcontainer.json"
+        
+        # Skip if file exists and not forcing
+        if docker_config_path.exists() and not force:
+            self._devcontainer_trace(f"Docker config already exists at {docker_config_path}")
+            return
+
+        docker_config = {
+            "name": "Specify Project",
+            "image": "mcr.microsoft.com/devcontainers/python:3.11",
+            "features": {
+                "ghcr.io/devcontainers/features/common-utils:2": {
+                    "installZsh": True,
+                    "upgradePackages": True,
+                },
+                "ghcr.io/devcontainers/features/node:1": {
+                    "version": "lts"
+                },
+            },
+            "postCreateCommand": "pip install specify-cli",
+            "remoteUser": "vscode",
+        }
+
+        with open(docker_config_path, "w", encoding="utf-8") as f:
+            json.dump(docker_config, f, indent=2)
+            f.write("\n")
+
+        self._devcontainer_trace(f"Created Docker config at {docker_config_path}")
+
+    def _create_context_file(self, project_root: Path) -> None:
+        """Create .devcontainer/devcontainer-instructions.md context file."""
+        devcontainer_dir = project_root / ".devcontainer"
+        devcontainer_dir.mkdir(parents=True, exist_ok=True)
+
+        context_path = devcontainer_dir / "devcontainer-instructions.md"
+        
+        context_content = """# Dev Container Instructions
+
+## 🐳 This Project Uses Dev Containers
+
+**ALL script execution happens automatically in the dev container.**
+
+### How It Works
+
+When you see commands like this in command files:
+
+```bash
+devcontainer exec --workspace-folder . bash .specify/scripts/bash/check-prerequisites.sh --json
+```
+
+**Just run it as shown!** The command will execute inside the Linux container automatically.
+
+### Verification
+
+After running commands, verify they executed in the container:
+
+```bash
+devcontainer exec --workspace-folder . bash -c 'echo "OS: $(uname -s) | User: $(whoami)"'
+```
+
+Expected output: `OS: Linux | User: vscode`
+
+### Container Management
+
+**Start container (if not running):**
+```bash
+devcontainer up --workspace-folder .
+```
+
+**Check if running:**
+```bash
+docker ps
+```
+
+**Get shell in container:**
+```bash
+devcontainer exec --workspace-folder . bash
+```
+
+### For AI Agents
+
+When implementing features (`/spec.implement`, `/spec.plan`, etc.):
+
+1. Command files already have `devcontainer exec` commands
+2. Execute them exactly as shown
+3. Container will auto-start if needed (first time: 3-5 min)
+4. Subsequent runs are instant (container stays running)
+
+**Evidence of container execution:**
+- Scripts run with `devcontainer exec` 
+- OS shows `Linux` (not `Darwin`)
+- User shows `vscode` (not your host username)
+- Python shows `3.11.x` (container version)
+
+### More Information
+
+- Dev Containers: https://containers.dev/
+- devcontainer CLI: https://code.visualstudio.com/docs/devcontainers/devcontainer-cli
+
+<!-- SPECKIT START -->
+<!-- This section is managed by the Specify CLI -->
+<!-- SPECKIT END -->
+"""
+
+        with open(context_path, "w", encoding="utf-8") as f:
+            f.write(context_content)
+
+        self._devcontainer_trace(f"Created {context_path}")
+
+    def _setup_all_agent_commands(
+        self,
+        project_root: Path,
+        manifest: "IntegrationManifest",
+        parsed_options: dict[str, Any] | None = None,
+        **opts: Any,
+    ) -> None:
+        """Create dev-container-wrapped command files for ALL AI agent directories.
+
+        This means `specify init --integration devcontainer` sets up EVERY agent
+        (opencode, claude, cursor, windsurf, etc.) so no matter which one the user
+        opens, commands run inside the dev container automatically.
+        """
+        from .. import INTEGRATION_REGISTRY
+
+        templates = self.list_command_templates()
+        if not templates:
+            self._devcontainer_trace("No command templates found")
+            return
+
+        project_root = Path(project_root)
+        script_type = opts.get("script_type", "sh") if opts else "sh"
+        total_created = 0
+        total_agents = 0
+
+        for key, integration_cls in INTEGRATION_REGISTRY.items():
+            if key == self.key:
+                continue
+
+            # Get agent config
+            try:
+                agent_config = getattr(integration_cls, 'config', None) or {}
+            except Exception:
+                continue
+
+            folder = agent_config.get("folder", "")
+            subdir = agent_config.get("commands_subdir", "commands")
+            if not folder:
+                continue
+
+            # Determine destination directory
+            dest = (project_root / folder / subdir).resolve()
+            try:
+                dest.relative_to(project_root.resolve())
+            except ValueError:
+                continue
+            dest.mkdir(parents=True, exist_ok=True)
+
+            # Get agent-specific parameters
+            registrar_config = getattr(integration_cls, 'registrar_config', {}) or {}
+            arg_placeholder = registrar_config.get("args", "$ARGUMENTS") if registrar_config else "$ARGUMENTS"
+            agent_context_file = getattr(integration_cls, 'context_file', "") or ""
+            agent_name = agent_config.get("name", key)
+            total_agents += 1
+
+            for src_file in templates:
+                raw = src_file.read_text(encoding="utf-8")
+                processed = self.process_template(
+                    raw, agent_name, script_type, arg_placeholder,
+                    context_file=agent_context_file,
+                    project_root=project_root,
+                )
+                dst_name = integration_cls.command_filename(src_file.stem)
+                dst_file = self.write_file_and_record(
+                    processed, dest / dst_name, project_root, manifest
+                )
+                total_created += 1
+
+        self._devcontainer_trace(
+            f"Created {total_created} command files across {total_agents} AI agent directories"
+        )
+
+        # Update context file for each agent
+        for key, integration_cls in INTEGRATION_REGISTRY.items():
+            if key == self.key:
+                continue
+            try:
+                agent_config = getattr(integration_cls, 'config', None) or {}
+                if not agent_config.get("folder"):
+                    continue
+                inst = integration_cls()
+                inst.upsert_context_section(project_root)
+            except Exception:
+                pass
+
+    def _wrap_all_agent_commands(self, project_root: Path) -> None:
+        """Wrap script references in ALL AI agent command files with devcontainer exec.
+        
+        Safety net: catches any command files not created by _setup_all_agent_commands.
+        """
+        from .. import INTEGRATION_REGISTRY
+
+        project_root = Path(project_root)
+        wrapped_count = 0
+        checked_dirs = 0
+        import re
+
+        self._devcontainer_trace("Wrapping ALL agent command files for dev container execution...")
+
+        for key, integration_cls in INTEGRATION_REGISTRY.items():
+            if key == self.key:
+                continue  # Skip .devcontainer/commands/ - already processed in process_template()
+
+            # Determine command directory for this agent
+            try:
+                config = getattr(integration_cls, 'config', None) or {}
+            except Exception:
+                continue
+            folder = config.get("folder", "")
+            subdir = config.get("commands_subdir", "commands")
+            if not folder:
+                continue
+            cmd_dir = project_root / folder / subdir
+
+            if not cmd_dir.exists():
+                continue
+
+            checked_dirs += 1
+
+            files_found = list(cmd_dir.glob("*.md"))
+            if files_found:
+                self._devcontainer_trace(f"  📁 {key}: {cmd_dir.relative_to(project_root)}/ ({len(files_found)} files)")
+
+            for cmd_file in sorted(files_found):
+                content = cmd_file.read_text(encoding="utf-8")
+
+                # Skip files that already have devcontainer exec wrapping
+                if 'devcontainer exec' in content:
+                    continue
+
+                new_content = content
+
+                # Wrap bash script references: `.specify/scripts/bash/<script>.sh <args>`
+                bash_pattern = r'`(\\?\.specify/scripts/bash/[^`]+\.sh[^`]*)`'
+                new_content = re.sub(
+                    bash_pattern,
+                    lambda m: f'`{self._wrap_script_path_for_devcontainer(m.group(1).replace("\\", ""), "bash")}`',
+                    new_content
+                )
+
+                # Wrap explicit `bash .specify/scripts/...`
+                new_content = re.sub(
+                    r'`bash (\\?\.specify/scripts/bash/[^`]+\.sh[^`]*)`',
+                    lambda m: f'`{self._wrap_script_path_for_devcontainer(m.group(1).replace("\\", ""), "bash")}`',
+                    new_content
+                )
+
+                # Wrap powershell references
+                ps_pattern = r'`(\\?\.specify/scripts/powershell/[^`]+\.ps1[^`]*)`'
+                new_content = re.sub(
+                    ps_pattern,
+                    lambda m: f'`{self._wrap_script_path_for_devcontainer(m.group(1).replace("\\", ""), "powershell")}`',
+                    new_content
+                )
+
+                if new_content != content:
+                    cmd_file.write_text(new_content, encoding="utf-8")
+                    wrapped_count += 1
+                    rel_path = cmd_file.relative_to(project_root)
+                    self._devcontainer_trace(f"  ✅ Wrapped: {rel_path}")
+
+        self._devcontainer_trace(
+            f"Checked {checked_dirs} agent directories, wrapped {wrapped_count} command files"
+        )
+
+    def _create_agents_md_context(self, project_root: Path) -> None:
+        """Write dev container instructions to AGENTS.md so every AI agent reads them."""
+        agents_path = project_root / "AGENTS.md"
+        if not agents_path.exists():
+            agents_path.write_text("", encoding="utf-8")
+
+        content = agents_path.read_text(encoding="utf-8")
+
+        devcontainer_section = """
+## 🐳 Dev Container Execution
+
+**IMPORTANT: This project uses dev containers. ALL commands must run inside the container.**
+
+**How to run any command:**
+
+```bash
+devcontainer exec --workspace-folder . bash <command>
+```
+
+**Examples:**
+
+| ❌ Wrong (runs on HOST) | ✅ Correct (runs in CONTAINER) |
+|---|---|
+| `bash .specify/scripts/bash/check-prerequisites.sh --json` | `devcontainer exec --workspace-folder . bash .specify/scripts/bash/check-prerequisites.sh --json` |
+
+**Verification:**
+
+```bash
+devcontainer exec --workspace-folder . bash -c 'echo "OS: $(uname -s) | User: $(whoami)"'
+```
+Expected: `OS: Linux | User: vscode`
+
+**Container Management:**
+
+- Start: `devcontainer up --workspace-folder .` (first time: 3-5 min)
+- Check: `docker ps`
+- Shell: `devcontainer exec --workspace-folder . bash`
+
+**Command files in this project already have devcontainer exec commands. Execute them as shown.**
+<!-- SPECKIT START -->
+<!-- This section is managed by Specify CLI. Do not edit manually. -->
+<!-- SPECKIT END -->
+"""
+
+        # Replace existing dev container section if it exists
+        import re as _re
+        if _re.search(r'<!-- SPECKIT START -->.*?<!-- SPECKIT END -->', content, _re.DOTALL):
+            content = _re.sub(
+                r'<!-- SPECKIT START -->.*?<!-- SPECKIT END -->',
+                devcontainer_section.split("<!-- SPECKIT START -->")[1].split("<!-- SPECKIT END -->")[0],
+                content,
+                flags=_re.DOTALL
+            )
+        else:
+            content += devcontainer_section
+
+        agents_path.write_text(content, encoding="utf-8")
+        self._devcontainer_trace(f"Updated {agents_path} with dev container instructions")
+
+    def _is_devcontainer_mode(self, project_root: Path) -> bool:
+        """Check if Dev Container mode is enabled."""
+        # Check environment variable first
+        env_mode = os.getenv("DEVCONTAINER_MODE", "").lower()
+        if env_mode == "enabled":
+            return True
+
+        # Check config file
+        config = self._load_devcontainer_config(project_root)
+        return config.get("mode") == "enabled"
+
+    def _load_devcontainer_config(self, project_root: Path) -> dict[str, Any]:
+        """Load .specify/devcontainer.json configuration."""
+        config_path = project_root / ".specify" / "devcontainer.json"
+        if not config_path.exists():
+            return {}
+
+        try:
+            with open(config_path, "r", encoding="utf-8") as f:
+                return json.load(f)
+        except (json.JSONDecodeError, IOError):
+            return {}
+
+    def dispatch_command(
+        self,
+        command_name: str,
+        *,
+        args: str = "",
+        project_root: Path,
+        stream: bool = False,
+    ) -> dict[str, Any]:
+        """Dispatch command execution to Dev Container CLI."""
+        # Check if devcontainer mode is enabled
+        if not self._is_devcontainer_mode(project_root):
+            self._devcontainer_trace("Dev Container mode not enabled, falling back to standard dispatch")
+            return super().dispatch_command(
+                command_name, args=args, project_root=project_root, stream=stream
+            )
+
+        # Execute via devcontainer CLI
+        return self._call_devcontainer_exec(
+            command_name=command_name,
+            args=args,
+            project_root=project_root,
+            stream=stream,
+        )
+
+    def _is_container_running(self, project_root: Path, cli_path: str) -> bool:
+        """Check if the dev container is currently running."""
+        try:
+            # Try a simple exec command to check if container is running
+            result = subprocess.run(
+                [cli_path, "exec", "--workspace-folder", str(project_root), "echo", "ping"],
+                capture_output=True,
+                text=True,
+                timeout=5,
+                check=False,
+            )
+            return result.returncode == 0
+        except (subprocess.TimeoutExpired, FileNotFoundError):
+            return False
+
+    def _start_container(self, project_root: Path, cli_path: str) -> bool:
+        """Start the dev container in the background."""
+        self._devcontainer_trace("Container not running, starting it now...")
+        self._devcontainer_trace("This may take 3-5 minutes on first run (pulling image, installing deps)...")
+        
+        try:
+            # Use `devcontainer up` to start the container
+            result = subprocess.run(
+                [
+                    cli_path,
+                    "up",
+                    "--workspace-folder",
+                    str(project_root),
+                ],
+                capture_output=True,
+                text=True,
+                timeout=300,  # Give it 5 minutes to start (first run needs to pull image)
+                check=False,
+            )
+            
+            if result.returncode == 0:
+                self._devcontainer_trace("Container started successfully")
+                return True
+            else:
+                self._devcontainer_trace(f"Failed to start container: {result.stderr}")
+                # Print stdout too for debugging
+                if result.stdout:
+                    self._devcontainer_trace(f"Container startup output: {result.stdout[:500]}")
+                return False
+                
+        except subprocess.TimeoutExpired:
+            self._devcontainer_trace("Container startup timed out after 5 minutes")
+            self._devcontainer_trace("Try manually: devcontainer up --workspace-folder .")
+            return False
+        except Exception as e:
+            self._devcontainer_trace(f"Error starting container: {e}")
+            return False
+
+    def _call_devcontainer_exec(
+        self,
+        command_name: str,
+        args: str,
+        project_root: Path,
+        stream: bool,
+    ) -> dict[str, Any]:
+        """Execute command using devcontainer exec."""
+        config = self._load_devcontainer_config(project_root)
+        cli_path = config.get("devcontainer", {}).get("cli_path", "devcontainer")
+
+        # Check if container is running, start it if not
+        if not self._is_container_running(project_root, cli_path):
+            if not self._start_container(project_root, cli_path):
+                return {
+                    "exit_code": 1,
+                    "stdout": "",
+                    "stderr": "Failed to start dev container. Ensure Docker is running and .devcontainer/devcontainer.json is properly configured.",
+                }
+
+        # Build the command to execute
+        # Dev container integration is designed for AI agents to read command files,
+        # not for direct CLI invocation. For direct usage, get a shell in the container instead.
+        # However, for basic commands, we can try to execute the check-prerequisites script
+        # which is what most commands start with.
+        
+        # For now, provide a helpful error message
+        return {
+            "exit_code": 1,
+            "stdout": "",
+            "stderr": (
+                f"Dev container integration is designed for AI agents (Claude Code, Cursor, etc.), "
+                f"not direct CLI usage.\n\n"
+                f"To use the dev container:\n\n"
+                f"Option 1 - With AI Agent (Recommended):\n"
+                f"  1. Open project in Claude Code/Cursor\n"
+                f"  2. Run: /spec.{command_name} \"{args}\"\n"
+                f"  3. AI agent will execute commands in container automatically\n\n"
+                f"Option 2 - Get Shell in Container:\n"
+                f"  devcontainer exec --workspace-folder {project_root} bash\n\n"
+                f"Option 3 - Run Scripts Directly:\n"
+                f"  devcontainer exec --workspace-folder {project_root} bash .specify/scripts/bash/check-prerequisites.sh\n\n"
+                f"See: .devcontainer/commands/spec.{command_name}.md for AI agent instructions"
+            ),
+        }
+
+        # Build devcontainer exec command
+        exec_cmd = [
+            cli_path,
+            "exec",
+            "--workspace-folder",
+            str(project_root),
+            "bash",
+            "-c",
+            cmd_to_exec,
+        ]
+
+        self._devcontainer_trace(f"Executing: {' '.join(exec_cmd)}")
+
+        try:
+            if stream:
+                # Stream output in real-time
+                process = subprocess.Popen(
+                    exec_cmd,
+                    stdout=subprocess.PIPE,
+                    stderr=subprocess.STDOUT,
+                    text=True,
+                    cwd=project_root,
+                )
+
+                stdout_lines = []
+                for line in process.stdout:
+                    print(line, end="", flush=True)
+                    stdout_lines.append(line)
+
+                process.wait()
+                stdout = "".join(stdout_lines)
+                exit_code = process.returncode
+            else:
+                # Capture output
+                result = subprocess.run(
+                    exec_cmd,
+                    cwd=project_root,
+                    capture_output=True,
+                    text=True,
+                    check=False,
+                )
+                stdout = result.stdout
+                exit_code = result.returncode
+
+            return {
+                "exit_code": exit_code,
+                "stdout": stdout,
+                "stderr": "",
+            }
+
+        except FileNotFoundError:
+            error_msg = f"devcontainer CLI not found at: {cli_path}"
+            self._devcontainer_trace(f"ERROR: {error_msg}")
+            return {
+                "exit_code": 1,
+                "stdout": "",
+                "stderr": error_msg,
+            }
+        except Exception as e:
+            error_msg = f"Error executing devcontainer command: {e}"
+            self._devcontainer_trace(f"ERROR: {error_msg}")
+            return {
+                "exit_code": 1,
+                "stdout": "",
+                "stderr": error_msg,
+            }
diff --git a/src/specify_cli/integrations/opencode/__init__.py b/src/specify_cli/integrations/opencode/__init__.py
index 4fa9c724ac..bbfb6b642a 100644
--- a/src/specify_cli/integrations/opencode/__init__.py
+++ b/src/specify_cli/integrations/opencode/__init__.py
@@ -1,6 +1,16 @@
 """opencode integration."""
 
+import json
+import os
+import sys
+from pathlib import Path
+from typing import Any, TYPE_CHECKING
+
 from ..base import MarkdownIntegration
+from .docker_manager import DockerManager, ensure_opencode_docker_assets
+
+if TYPE_CHECKING:
+    from ..manifest import IntegrationManifest
 
 
 class OpencodeIntegration(MarkdownIntegration):
@@ -21,13 +31,30 @@ class OpencodeIntegration(MarkdownIntegration):
     }
     context_file = "AGENTS.md"
 
+    _DOCKER_LOG_PREFIX = "[specify][opencode-docker]"
+
+    @classmethod
+    def _docker_trace(cls, message: str) -> None:
+        """Emit a visible trace line for OpenCode Docker routing (stderr, flushed)."""
+        print(f"{cls._DOCKER_LOG_PREFIX} {message}", file=sys.stderr, flush=True)
+
     def build_exec_args(
         self,
         prompt: str,
         *,
         model: str | None = None,
         output_json: bool = True,
+        project_root: Path | None = None,
     ) -> list[str] | None:
+        # Check if Docker mode is enabled - if so, return synthetic args
+        # to pass the CLI check in CommandStep._try_dispatch()
+        check_path = project_root or Path.cwd()
+        if self._is_docker_mode(check_path):
+            # Return synthetic args indicating Docker mode
+            # dispatch_command will route to HTTP API instead
+            return [self.key, "--docker-mode", prompt]
+
+        # Fall back to local CLI args (requires opencode to be installed)
         args = [self.key, "run"]
 
         message = prompt
@@ -44,3 +71,514 @@ def build_exec_args(
         if message:
             args.append(message)
         return args
+
+    @staticmethod
+    def _wrap_script_for_docker(script_command: str) -> str:
+        """Wrap bash script with docker routing logic.
+
+        Injects a check at the beginning that routes to docker if enabled,
+        otherwise runs locally.
+        """
+        # Escape for inline shell
+        escaped = script_command.replace('"', '\\"')
+        wrapper = (
+            '[ "$OPENCODE_MODE" = "docker" ] || '
+            '([ -f .specify/opencode.json ] && grep -q \'"mode"\\s*:\\s*"docker"\' .specify/opencode.json) && '
+            'echo "Routing to OpenCode Docker..." >&2 || true; '
+            f'{escaped}'
+        )
+        return wrapper
+
+    def process_template(
+        self,
+        content: str,
+        agent_name: str,
+        script_type: str,
+        arg_placeholder: str = "$ARGUMENTS",
+        context_file: str = "",
+        invoke_separator: str = ".",
+        project_root: Path | None = None,
+    ) -> str:
+        """Process template and wrap script command with docker routing.
+
+        Calls parent process_template, then wraps any script invocations
+        with docker mode detection.
+        """
+        import re
+
+        # Call parent to get processed content
+        processed = super().process_template(
+            content,
+            agent_name,
+            script_type,
+            arg_placeholder,
+            context_file,
+            invoke_separator,
+            project_root=project_root,
+        )
+
+        # Find and wrap script invocations in code blocks
+        # Pattern: bash code block with a script path
+        script_pattern = re.compile(
+            r'(```bash\s*\n)(\.specify/scripts/\S+[^\n]*)',
+            re.MULTILINE
+        )
+
+        def replace_script(match):
+            opening = match.group(1)
+            script = match.group(2)
+            wrapped = self._wrap_script_for_docker(script)
+            return opening + wrapped
+
+        processed = script_pattern.sub(replace_script, processed)
+        return processed
+
+    def setup(
+        self,
+        project_root: Path,
+        manifest: "IntegrationManifest",
+        parsed_options: dict[str, Any] | None = None,
+        **opts: Any,
+    ) -> list[Path]:
+        """Setup opencode integration.
+
+        Calls parent setup() for command templates, then creates
+        .specify/opencode.json with docker mode enabled.
+        """
+        created = super().setup(project_root, manifest, parsed_options=parsed_options, **opts)
+
+        # Create .specify/opencode.json with docker mode config
+        specify_dir = project_root / ".specify"
+        specify_dir.mkdir(parents=True, exist_ok=True)
+
+        config_path = specify_dir / "opencode.json"
+        config_content = {
+            "mode": "docker",
+            "docker": {
+                "http_url": "http://localhost:9000",
+                "compose_file": "./.specify/docker-compose.yml",
+                "container_name": "opencode-dev",
+                "container_workspace": "/workspace",
+            },
+        }
+
+        config_text = json.dumps(config_content, indent=2)
+        config_path.write_text(config_text + "\n", encoding="utf-8")
+
+        # Record in manifest if file didn't exist
+        if config_path not in created:
+            self.record_file_in_manifest(config_path, project_root, manifest)
+            created.append(config_path)
+
+        return created
+
+    def _load_opencode_config(self, project_root: Path) -> dict[str, Any]:
+        """Load OpenCode configuration from .specify/opencode.json.
+
+        Returns dict with mode, docker, and remote settings.
+        Defaults to local subprocess mode if no config exists.
+        """
+        config_path = project_root / ".specify" / "opencode.json"
+        if config_path.exists():
+            try:
+                with open(config_path) as f:
+                    return json.load(f)
+            except (json.JSONDecodeError, IOError):
+                pass
+
+        return {"mode": "local"}
+
+    @staticmethod
+    def is_docker_mode_exec_args(args: list[str] | None) -> bool:
+        """Check if build_exec_args returned Docker mode synthetic args.
+
+        Used by CommandStep to detect when to skip local CLI checks.
+        """
+        return bool(args and "--docker-mode" in args)
+
+    def _is_docker_mode(self, project_root: Path) -> bool:
+        """Check if Docker mode is enabled.
+
+        Checks env var first, then config file.
+        """
+        env_mode = os.getenv("OPENCODE_MODE", "").lower()
+        if env_mode == "docker":
+            return True
+
+        config = self._load_opencode_config(project_root)
+        return config.get("mode") == "docker"
+
+    @staticmethod
+    def _split_opencode_slash_prompt(prompt: str) -> tuple[str, str]:
+        """Split ``/speckit.foo bar`` → (``speckit.foo``, ``bar``) for OpenCode ``POST /session/:id/command``."""
+        p = prompt.strip()
+        if not p:
+            return "help", ""
+        if p.startswith("/"):
+            p = p[1:]
+        head, _, tail = p.partition(" ")
+        cmd = head.strip() or "help"
+        return cmd, tail.strip()
+
+    @staticmethod
+    def _opencode_http_command_name(stem: str) -> str:
+        """Map slash-command stem to the name OpenCode's HTTP ``/session/.../command`` expects.
+
+        Installed markdown commands use ``/speckit.*``, while the server typically registers
+        ``spec.*`` for the core Spec Kit commands. A few commands keep the ``speckit.`` prefix.
+        """
+        overrides: dict[str, str] = {
+            "speckit.taskstoissues": "speckit.taskstoissues",
+        }
+        if stem in overrides:
+            return overrides[stem]
+        if stem.startswith("speckit."):
+            return "spec." + stem[len("speckit.") :]
+        return stem
+
+    def _call_docker_opencode(
+        self,
+        prompt: str,
+        *,
+        model: str | None = None,
+        output_json: bool = True,
+        project_root: Path | None = None,
+    ) -> dict[str, Any]:
+        """Call OpenCode via Docker HTTP API.
+
+        Returns dict with exit_code, stdout, stderr.
+        """
+        try:
+            import httpx
+        except ImportError:
+            self._docker_trace("httpx is not installed; cannot call OpenCode Docker HTTP API")
+            return {
+                "exit_code": 1,
+                "stdout": "",
+                "stderr": "httpx library required for Docker mode",
+            }
+
+        project_root = (project_root or Path.cwd()).resolve()
+        config = self._load_opencode_config(project_root)
+        docker_config = config.get("docker", {})
+        base = str(docker_config.get("http_url", "http://localhost:9000")).rstrip("/")
+        workspace = str(docker_config.get("container_workspace", "/workspace"))
+
+        cmd, arguments = self._split_opencode_slash_prompt(prompt)
+        api_cmd = self._opencode_http_command_name(cmd)
+        if api_cmd != cmd:
+            self._docker_trace(f"command stem mapped for HTTP API: {cmd!r} -> {api_cmd!r}")
+        preview = prompt if len(prompt) <= 280 else f"{prompt[:280]}…"
+        self._docker_trace(
+            f"OpenCode HTTP project={project_root} base={base} workspace={workspace!r}"
+        )
+        self._docker_trace(
+            f"session API: slash={cmd!r} http_command={api_cmd!r} arguments={arguments!r} preview={preview!r}"
+        )
+
+        timeout = httpx.Timeout(600.0)
+        try:
+            with httpx.Client(timeout=timeout) as client:
+                self._docker_trace(
+                    f"POST {base}/session?directory={workspace} (create OpenCode session)"
+                )
+                sr = client.post(
+                    f"{base}/session",
+                    params={"directory": workspace},
+                    json={"title": "Specify CLI"},
+                )
+                self._docker_trace(f"session HTTP status={sr.status_code}")
+                if sr.status_code not in (200, 201):
+                    return {
+                        "exit_code": 1,
+                        "stdout": "",
+                        "stderr": f"OpenCode session create failed: {sr.status_code} {sr.text}",
+                    }
+                try:
+                    session = sr.json()
+                except json.JSONDecodeError:
+                    return {
+                        "exit_code": 1,
+                        "stdout": "",
+                        "stderr": f"OpenCode session create returned non-JSON: {sr.text[:500]}",
+                    }
+                sid = session.get("id")
+                if not sid:
+                    return {
+                        "exit_code": 1,
+                        "stdout": "",
+                        "stderr": f"OpenCode session response missing id: {session!r}",
+                    }
+                self._docker_trace(
+                    f"session_id={sid!r} — tail container logs during the next request "
+                    f"(`docker compose -f .specify/docker-compose.yml logs -f`)"
+                )
+
+                body: dict[str, Any] = {"command": api_cmd, "arguments": arguments}
+                if model:
+                    body["model"] = model
+
+                cmd_url = f"{base}/session/{sid}/command"
+                self._docker_trace(
+                    f"POST {cmd_url}?directory={workspace} (execute slash command on server)"
+                )
+                cr = client.post(cmd_url, params={"directory": workspace}, json=body)
+                self._docker_trace(
+                    f"command HTTP status={cr.status_code} bytes={len(cr.content)}"
+                )
+
+                if cr.status_code == 200:
+                    if output_json:
+                        payload = cr.json()
+                        out = json.dumps(payload)
+                    else:
+                        out = cr.text
+                    self._docker_trace("OpenCode Docker slash command finished OK (exit_code=0)")
+                    return {"exit_code": 0, "stdout": out, "stderr": ""}
+                self._docker_trace(
+                    f"OpenCode command API error status={cr.status_code} body_snip="
+                    f"{cr.text[:400]!r}"
+                )
+                return {
+                    "exit_code": 1,
+                    "stdout": "",
+                    "stderr": f"OpenCode command failed: {cr.status_code} {cr.text}",
+                }
+        except httpx.ConnectError as e:
+            self._docker_trace(f"connect_error base={base!r} detail={e!r}")
+            return {
+                "exit_code": 1,
+                "stdout": "",
+                "stderr": f"Failed to connect to OpenCode at {base}. Is Docker running? Error: {e}",
+            }
+        except httpx.TimeoutException:
+            self._docker_trace(f"timeout base={base!r}")
+            return {
+                "exit_code": 1,
+                "stdout": "",
+                "stderr": f"Request timeout connecting to OpenCode at {base}",
+            }
+        except Exception as e:
+            self._docker_trace(f"unexpected_error type={type(e).__name__!r} detail={e!r}")
+            return {
+                "exit_code": 1,
+                "stdout": "",
+                "stderr": f"Error calling OpenCode: {e}",
+            }
+
+    def dispatch_command(
+        self,
+        command_name: str,
+        args: str = "",
+        *,
+        project_root: Path | None = None,
+        model: str | None = None,
+        timeout: int = 600,
+        stream: bool = True,
+    ) -> dict[str, Any]:
+        """Dispatch command to OpenCode.
+
+        Routes to Docker HTTP API if Docker mode is enabled,
+        otherwise uses subprocess as before.
+        """
+        project_root = project_root or Path.cwd()
+
+        # Shell commands (docker-up/down/status) must run locally — they manage the
+        # Docker container, so they bypass the HTTP API and go straight to DockerManager.
+        if command_name in ("docker-up", "docker-down", "docker-status"):
+            return self.dispatch_shell_command(command_name, project_root=project_root)
+
+        if self._is_docker_mode(project_root):
+            root = project_root.resolve()
+            prompt = self.build_command_invocation(command_name, args)
+            self._docker_trace(
+                f"Docker mode ON — dispatching speckit command={command_name!r} via HTTP "
+                f"(not local opencode CLI) project={root}"
+            )
+            if "implement" in command_name.lower():
+                self._docker_trace(
+                    "implement detected — this request is proxied to the OpenCode container "
+                    "(watch `docker compose logs` for session / command activity on the server)"
+                )
+            result = self._call_docker_opencode(
+                prompt, model=model, output_json=not stream, project_root=project_root
+            )
+
+            if stream and result.get("stdout"):
+                print(result["stdout"])
+
+            if result.get("exit_code") == 0:
+                self._docker_trace(
+                    f"dispatch_command complete command={command_name!r} exit_code=0"
+                )
+            else:
+                self._docker_trace(
+                    f"dispatch_command complete command={command_name!r} "
+                    f"exit_code={result.get('exit_code')} stderr={str(result.get('stderr', ''))[:500]!r}"
+                )
+
+            return result
+
+        # Fall back to subprocess for local mode
+        return super().dispatch_command(
+            command_name, args, project_root=project_root, model=model, timeout=timeout, stream=stream
+        )
+
+    def dispatch_shell_command(
+        self,
+        command_name: str,
+        project_root: Path | None = None,
+    ) -> dict[str, Any]:
+        """Dispatch a shell command to OpenCode.
+
+        Handles special subcommands like docker-up, docker-down, docker-status.
+        """
+        project_root = project_root or Path.cwd()
+
+        if command_name == "docker-up":
+            return self._dispatch_docker_up(project_root)
+        elif command_name == "docker-down":
+            return self._dispatch_docker_down(project_root)
+        elif command_name == "docker-status":
+            return self._dispatch_docker_status(project_root)
+        else:
+            return {"exit_code": 1, "stdout": "", "stderr": f"Unknown shell command: {command_name}"}
+
+    def _dispatch_docker_up(self, project_root: Path) -> dict[str, Any]:
+        """Dispatch the docker-up shell command."""
+        ensure_opencode_docker_assets(project_root)
+
+        config_path = project_root / ".specify" / "opencode.json"
+        full: dict[str, Any] = {}
+        if config_path.exists():
+            try:
+                full = json.loads(config_path.read_text(encoding="utf-8"))
+            except (json.JSONDecodeError, OSError):
+                full = {}
+
+        docker_inner = dict(full.get("docker") or {})
+        compose_file = docker_inner.get("compose_file", "./.specify/docker-compose.yml")
+        container_name = docker_inner.get("container_name", "opencode-dev")
+        http_url = docker_inner.get("http_url", "http://localhost:9000")
+
+        manager = DockerManager(
+            compose_file, container_name, http_url, project_root=project_root
+        )
+
+        try:
+            result: dict[str, Any] = {"exit_code": 0, "stdout": "", "stderr": ""}
+            result["stdout"] = f"Starting OpenCode Docker container at {http_url}\n"
+            if manager.docker_up():
+                full["mode"] = "docker"
+                full["docker"] = {
+                    **docker_inner,
+                    "enabled": True,
+                    "compose_file": compose_file,
+                    "container_name": container_name,
+                    "http_url": http_url,
+                }
+                config_path.parent.mkdir(parents=True, exist_ok=True)
+                config_path.write_text(
+                    json.dumps(full, indent=2) + "\n", encoding="utf-8"
+                )
+                result["stdout"] += f"✓ OpenCode container running at {http_url}\n"
+            else:
+                result["stderr"] = "Failed to start Docker container"
+                result["exit_code"] = 1
+            return result
+        except Exception as e:
+            return {
+                "exit_code": 1,
+                "stdout": "",
+                "stderr": f"Error: {str(e)}",
+            }
+
+    def _dispatch_docker_down(self, project_root: Path) -> dict[str, Any]:
+        """Dispatch the docker-down shell command."""
+        config_path = project_root / ".specify" / "opencode.json"
+        full: dict[str, Any] = {}
+        if config_path.exists():
+            try:
+                full = json.loads(config_path.read_text(encoding="utf-8"))
+            except (json.JSONDecodeError, OSError):
+                full = {}
+
+        docker_inner = dict(full.get("docker") or {})
+        compose_file = docker_inner.get("compose_file", "./.specify/docker-compose.yml")
+        container_name = docker_inner.get("container_name", "opencode-dev")
+        http_url = docker_inner.get("http_url", "http://localhost:9000")
+
+        manager = DockerManager(
+            compose_file, container_name, http_url, project_root=project_root
+        )
+
+        try:
+            result: dict[str, Any] = {"exit_code": 0, "stdout": "", "stderr": ""}
+            result["stdout"] = f"Stopping OpenCode Docker container at {http_url}\n"
+            if manager.docker_down():
+                full["mode"] = "local"
+                docker_inner["enabled"] = False
+                full["docker"] = {**docker_inner}
+                config_path.parent.mkdir(parents=True, exist_ok=True)
+                config_path.write_text(
+                    json.dumps(full, indent=2) + "\n", encoding="utf-8"
+                )
+                result["stdout"] += "✓ OpenCode container stopped\n"
+            else:
+                result["stderr"] = "Failed to stop Docker container"
+                result["exit_code"] = 1
+            return result
+        except Exception as e:
+            return {
+                "exit_code": 1,
+                "stdout": "",
+                "stderr": f"Error: {str(e)}",
+            }
+
+    def _dispatch_docker_status(self, project_root: Path) -> dict[str, Any]:
+        """Dispatch the docker-status shell command."""
+        config_path = project_root / ".specify" / "opencode.json"
+        full: dict[str, Any] = {}
+        if config_path.exists():
+            try:
+                full = json.loads(config_path.read_text(encoding="utf-8"))
+            except (json.JSONDecodeError, OSError):
+                full = {}
+
+        docker_inner = dict(full.get("docker") or {})
+        compose_file = docker_inner.get("compose_file", "./.specify/docker-compose.yml")
+        container_name = docker_inner.get("container_name", "opencode-dev")
+        http_url = docker_inner.get("http_url", "http://localhost:9000")
+
+        manager = DockerManager(
+            compose_file, container_name, http_url, project_root=project_root
+        )
+
+        try:
+            result: dict[str, Any] = {"exit_code": 0, "stdout": "", "stderr": ""}
+            status = manager.docker_status()
+            if status is None:
+                result["stderr"] = "Could not retrieve Docker status"
+                result["exit_code"] = 1
+                return result
+
+            if status.get("running"):
+                result["stdout"] = (
+                    f"✓ OpenCode container {status.get('name')} is running at {http_url}\n"
+                )
+            else:
+                result["stdout"] = (
+                    f"○ OpenCode container is not running at {http_url}\n"
+                )
+
+            logs = manager.get_container_logs(lines=10)
+            if logs:
+                result["stdout"] += f"\nRecent logs:\n{logs}\n"
+
+            return result
+        except Exception as e:
+            return {
+                "exit_code": 1,
+                "stdout": "",
+                "stderr": f"Error: {str(e)}",
+            }
diff --git a/src/specify_cli/integrations/opencode/docker/Dockerfile b/src/specify_cli/integrations/opencode/docker/Dockerfile
new file mode 100644
index 0000000000..2e7cc8b76b
--- /dev/null
+++ b/src/specify_cli/integrations/opencode/docker/Dockerfile
@@ -0,0 +1,38 @@
+FROM node:24-alpine
+
+WORKDIR /app
+
+RUN apk add --no-cache git curl python3 coreutils
+
+# Download and extract OpenCode binary for Linux
+RUN apk add --no-cache tar && \
+    OPENCODE_VERSION=1.14.37 && \
+    ARCH=$(uname -m | sed 's/x86_64/x64/;s/aarch64/arm64/') && \
+    cd /tmp && \
+    curl -L https://github.com/anomalyco/opencode/releases/download/v${OPENCODE_VERSION}/opencode-linux-${ARCH}-musl.tar.gz \
+      -o opencode.tar.gz && \
+    tar -xzf opencode.tar.gz && \
+    mv opencode /usr/local/bin/ && \
+    chmod +x /usr/local/bin/opencode && \
+    rm opencode.tar.gz
+
+RUN addgroup -g 2000 opencode && \
+    adduser -D -u 2000 -G opencode opencode
+
+RUN mkdir -p /workspace && \
+    chown -R opencode:opencode /workspace /app
+
+# Prefix each server output line with [opencode-server] so it stands out in
+# `docker compose logs`.  OPENCODE_LOG_LEVEL controls verbosity (default INFO).
+# stdbuf -oL forces line-buffered mode so lines appear in real-time.
+RUN printf '#!/bin/sh\n' > /start.sh && \
+    printf 'LOG_LEVEL="${OPENCODE_LOG_LEVEL:-INFO}"\n' >> /start.sh && \
+    printf 'exec opencode serve --hostname 0.0.0.0 --port 3000 --log-level "$LOG_LEVEL" 2>&1 |\n' >> /start.sh && \
+    printf '  stdbuf -oL sed "s/^/[opencode-server] /"\n' >> /start.sh && \
+    chmod +x /start.sh
+
+USER opencode
+
+EXPOSE 3000
+
+CMD ["/start.sh"]
\ No newline at end of file
diff --git a/src/specify_cli/integrations/opencode/docker/docker-compose.yml b/src/specify_cli/integrations/opencode/docker/docker-compose.yml
new file mode 100644
index 0000000000..6819847e68
--- /dev/null
+++ b/src/specify_cli/integrations/opencode/docker/docker-compose.yml
@@ -0,0 +1,21 @@
+services:
+  opencode:
+    build:
+      context: .
+      dockerfile: Dockerfile
+    container_name: opencode-dev
+    ports:
+      - "9000:3000"
+    volumes:
+      - ..:/workspace
+    environment:
+      - NODE_ENV=development
+      - OPENCODE_PORT=3000
+      - OPENCODE_LOG_LEVEL=${OPENCODE_LOG_LEVEL:-INFO}
+    healthcheck:
+      test: ["CMD", "curl", "-sf", "http://localhost:3000/global/health"]
+      interval: 5s
+      timeout: 3s
+      retries: 30
+      start_period: 10s
+    restart: unless-stopped
diff --git a/src/specify_cli/integrations/opencode/docker_manager.py b/src/specify_cli/integrations/opencode/docker_manager.py
new file mode 100644
index 0000000000..358ba252c0
--- /dev/null
+++ b/src/specify_cli/integrations/opencode/docker_manager.py
@@ -0,0 +1,254 @@
+"""Docker container management for OpenCode."""
+
+from __future__ import annotations
+
+import json
+import shutil
+import subprocess
+import time
+from pathlib import Path
+from typing import Any, Optional
+
+import httpx
+
+
+def ensure_opencode_docker_assets(project_root: Path) -> Path:
+    """Copy packaged Dockerfile and compose file into ``.specify/`` if missing.
+
+    Returns the absolute path to ``docker-compose.yml`` under ``.specify/``.
+    """
+    template_dir = Path(__file__).resolve().parent / "docker"
+    specify_dir = project_root / ".specify"
+    specify_dir.mkdir(parents=True, exist_ok=True)
+
+    for name in ("Dockerfile", "docker-compose.yml"):
+        src = template_dir / name
+        dst = specify_dir / name
+        if not dst.exists() and src.exists():
+            shutil.copy(src, dst)
+
+    return (specify_dir / "docker-compose.yml").resolve()
+
+
+def _resolve_compose_file(compose_file: str | Path, project_root: Path | None) -> Path:
+    p = Path(compose_file)
+    if p.is_absolute():
+        return p.resolve()
+    base = project_root if project_root is not None else Path.cwd()
+    return (base / p).resolve()
+
+
+def _parse_compose_ps_json(stdout: str) -> list[dict[str, Any]]:
+    """Parse ``docker compose ps --format json`` output (array or NDJSON)."""
+    text = stdout.strip()
+    if not text:
+        return []
+    try:
+        data = json.loads(text)
+        if isinstance(data, list):
+            return data
+        if isinstance(data, dict):
+            return [data]
+    except json.JSONDecodeError:
+        pass
+    services: list[dict[str, Any]] = []
+    for line in text.splitlines():
+        line = line.strip()
+        if not line:
+            continue
+        try:
+            row = json.loads(line)
+            if isinstance(row, dict):
+                services.append(row)
+        except json.JSONDecodeError:
+            continue
+    return services
+
+
+class DockerManager:
+    """Manage OpenCode Docker container lifecycle."""
+
+    def __init__(
+        self,
+        compose_file: str | Path = "docker-compose.yml",
+        container_name: str = "opencode-dev",
+        http_url: str = "http://localhost:9000",
+        timeout: int = 60,
+        *,
+        project_root: Path | None = None,
+    ):
+        self.compose_file = _resolve_compose_file(compose_file, project_root)
+        self.container_name = container_name
+        self.http_url = http_url.rstrip("/")
+        self.timeout = timeout
+        self._project_root = project_root
+        self._compose_prefix: list[str] | None = None
+
+    def _compose_cmd_prefix(self) -> list[str]:
+        """``docker compose -f <file>`` or legacy ``docker-compose -f <file>``."""
+        if self._compose_prefix is not None:
+            return self._compose_prefix
+        compose_arg = str(self.compose_file)
+        if shutil.which("docker"):
+            probe = subprocess.run(
+                ["docker", "compose", "version"],
+                capture_output=True,
+                text=True,
+                timeout=10,
+            )
+            if probe.returncode == 0:
+                self._compose_prefix = ["docker", "compose", "-f", compose_arg]
+                return self._compose_prefix
+        if shutil.which("docker-compose"):
+            self._compose_prefix = ["docker-compose", "-f", compose_arg]
+            return self._compose_prefix
+        raise FileNotFoundError(
+            "Neither 'docker compose' nor 'docker-compose' is available. Install Docker."
+        )
+
+    def _compose(self, *compose_args: str) -> list[str]:
+        return [*self._compose_cmd_prefix(), *compose_args]
+
+    def docker_up(self) -> bool:
+        """Start Docker container and wait until healthy.
+
+        Returns:
+            True if successful, False otherwise
+        """
+        try:
+            result = subprocess.run(
+                self._compose("up", "-d"),
+                cwd=str(self.compose_file.parent),
+                capture_output=True,
+                text=True,
+                timeout=120,
+            )
+            if result.returncode != 0:
+                print(f"Error starting Docker: {result.stderr}")
+                return False
+
+            return self.check_container_ready()
+        except subprocess.TimeoutExpired:
+            print("Timeout starting Docker container")
+            return False
+        except FileNotFoundError as e:
+            print(str(e))
+            return False
+
+    def docker_down(self) -> bool:
+        """Stop Docker container.
+
+        Returns:
+            True if successful, False otherwise
+        """
+        try:
+            result = subprocess.run(
+                self._compose("down"),
+                cwd=str(self.compose_file.parent),
+                capture_output=True,
+                text=True,
+                timeout=60,
+            )
+            if result.returncode != 0:
+                print(f"Error stopping Docker: {result.stderr}")
+                return False
+            return True
+        except subprocess.TimeoutExpired:
+            print("Timeout stopping Docker container")
+            return False
+        except FileNotFoundError as e:
+            print(str(e))
+            return False
+
+    def docker_status(self) -> Optional[dict]:
+        """Get Docker container status.
+
+        Returns:
+            dict with container info or None if error
+        """
+        try:
+            result = subprocess.run(
+                self._compose("ps", "--format", "json"),
+                cwd=str(self.compose_file.parent),
+                capture_output=True,
+                text=True,
+                timeout=15,
+            )
+            if result.returncode != 0:
+                return None
+
+            services = _parse_compose_ps_json(result.stdout)
+            if not services:
+                return {"status": "not-running", "running": False}
+
+            # Prefer the opencode service / configured container name
+            service = None
+            for row in services:
+                name = row.get("Name") or row.get("Service") or ""
+                if self.container_name in str(name) or row.get("Service") == "opencode":
+                    service = row
+                    break
+            service = service or services[0]
+
+            state = service.get("State", "unknown")
+            return {
+                "status": state,
+                "name": service.get("Service", ""),
+                "running": state == "running",
+                "url": self.http_url if state == "running" else None,
+            }
+        except (subprocess.TimeoutExpired, FileNotFoundError):
+            return None
+
+    def check_container_ready(self, timeout: Optional[int] = None) -> bool:
+        """Poll HTTP endpoint until container is ready.
+
+        Args:
+            timeout: seconds to wait (defaults to self.timeout)
+
+        Returns:
+            True if container is ready, False if timeout/error
+        """
+        timeout = timeout or self.timeout
+        start_time = time.time()
+
+        base = self.http_url.rstrip("/")
+        while time.time() - start_time < timeout:
+            ready = False
+            for path in ("/global/health", "/health"):
+                try:
+                    response = httpx.get(f"{base}{path}", timeout=2)
+                    if response.status_code == 200:
+                        ready = True
+                        break
+                except Exception:
+                    pass
+            if ready:
+                print(f"✓ OpenCode container ready at {self.http_url}")
+                return True
+
+            time.sleep(2)
+
+        print(f"Timeout waiting for OpenCode container (waited {timeout}s)")
+        return False
+
+    def get_container_logs(self, lines: int = 50) -> str:
+        """Get recent container logs.
+
+        Args:
+            lines: number of log lines to retrieve
+
+        Returns:
+            Log output as string
+        """
+        try:
+            result = subprocess.run(
+                self._compose("logs", "--tail", str(lines)),
+                cwd=str(self.compose_file.parent),
+                capture_output=True,
+                text=True,
+                timeout=15,
+            )
+            return result.stdout if result.returncode == 0 else result.stderr
+        except (subprocess.TimeoutExpired, FileNotFoundError):
+            return ""
diff --git a/src/specify_cli/workflows/steps/command/__init__.py b/src/specify_cli/workflows/steps/command/__init__.py
index 21fd4837d1..d24fa269fd 100644
--- a/src/specify_cli/workflows/steps/command/__init__.py
+++ b/src/specify_cli/workflows/steps/command/__init__.py
@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import inspect
 import shutil
 from pathlib import Path
 from typing import Any
@@ -127,15 +128,24 @@ def _try_dispatch(
             return None
 
         # Check if the integration supports CLI dispatch
-        if impl.build_exec_args("test") is None:
+        project_root = Path(context.project_root) if context.project_root else None
+        build_sig = inspect.signature(impl.build_exec_args)
+        if project_root is not None and "project_root" in build_sig.parameters:
+            exec_args = impl.build_exec_args("test", project_root=project_root)
+        else:
+            exec_args = impl.build_exec_args("test")
+        if exec_args is None:
             return None
 
-        # Check if the CLI tool is actually installed
-        if not shutil.which(impl.key):
+        # Check if the CLI tool is actually installed (skip for Docker mode)
+        # OpenCode integration uses --docker-mode sentinel for HTTP dispatch
+        is_docker_mode = (
+            hasattr(impl, "is_docker_mode_exec_args")
+            and impl.is_docker_mode_exec_args(exec_args)
+        ) or ("--docker-mode" in exec_args if exec_args else False)
+        if not is_docker_mode and not shutil.which(impl.key):
             return None
 
-        project_root = Path(context.project_root) if context.project_root else None
-
         try:
             return impl.dispatch_command(
                 command,
diff --git a/templates/commands/implement.md b/templates/commands/implement.md
index b0a26a69e6..1ba8cf99f2 100644
--- a/templates/commands/implement.md
+++ b/templates/commands/implement.md
@@ -13,6 +13,43 @@ $ARGUMENTS
 
 You **MUST** consider the user input before proceeding (if not empty).
 
+## Dev Container Mode (when `.specify/devcontainer.json` uses `"mode": "enabled"`)
+
+If this project is configured for **Dev Container** execution (`.specify/devcontainer.json` with `"mode": "enabled"`), then **doing the implementation only by editing files in this IDE does not run inside the dev container** — the commands run on the host machine instead of the containerized environment.
+
+When the user asked to **use the Dev Container** for implementation (or when the above config is present and they want execution there), you **MUST** run the Specify CLI from the **repository root** so dispatch routes to the dev container via the `devcontainer` CLI:
+
+```bash
+devcontainer up --workspace-folder .
+specify integration invoke implement --integration devcontainer "$ARGUMENTS"
+```
+
+If `devcontainer` is already the project's default integration, `--integration devcontainer` may be omitted:
+
+```bash
+specify integration invoke implement "$ARGUMENTS"
+```
+
+Use the same shell/terminal tool you use for other repo commands; do not only describe this command — **execute it** so the command runs inside the dev container. When it runs, the Specify CLI prints lines to **stderr** prefixed with `[specify][devcontainer]` — if you see those lines in the terminal, the request was routed to the dev container. If the user prefers to stay entirely in this IDE without dev container, skip this section and implement locally as usual.
+
+## OpenCode Docker (when `.specify/opencode.json` uses `"mode": "docker"`)
+
+If this project is configured for **OpenCode in Docker** (`specify docker-up`, `.specify/opencode.json` with `"mode": "docker"`), then **doing the implementation only by editing files in this chat does not run on OpenCode** — nothing is sent to the container, so Docker logs stay quiet.
+
+When the user asked to **use the OpenCode Docker container** for implementation (or when the above config is present and they want execution there), you **MUST** run the Specify CLI from the **repository root** so dispatch hits the OpenCode HTTP endpoint (after `specify docker-up` is healthy):
+
+```bash
+specify integration invoke implement --integration opencode "$ARGUMENTS"
+```
+
+If `opencode` is already the project's default integration, `--integration opencode` may be omitted:
+
+```bash
+specify integration invoke implement "$ARGUMENTS"
+```
+
+Use the same shell/terminal tool you use for other repo commands; do not only describe this command — **execute it** so the OpenCode server receives **`POST /session`** then **`POST /session/{id}/command`** (that is what makes `docker compose logs` show activity). When it runs, the Specify CLI prints lines to **stderr** prefixed with `[specify][opencode-docker]` — if you see those lines in the terminal, the request was sent to the OpenCode HTTP server inside Docker (not the local `opencode` binary). If the user prefers to stay entirely in this IDE without OpenCode, skip this section and implement locally as usual.
+
 ## Pre-Execution Checks
 
 **Check for extension hooks (before implementation)**:
diff --git a/tests/test_docker_opencode.py b/tests/test_docker_opencode.py
new file mode 100644
index 0000000000..c76a41e816
--- /dev/null
+++ b/tests/test_docker_opencode.py
@@ -0,0 +1,349 @@
+"""Tests for Docker OpenCode integration."""
+
+import json
+from pathlib import Path
+from unittest.mock import MagicMock, patch
+
+from specify_cli.integrations.opencode import OpencodeIntegration
+from specify_cli.integrations.opencode.docker_manager import DockerManager
+
+
+class TestDockerManager:
+    """Tests for DockerManager class."""
+
+    def test_docker_manager_init(self):
+        """Test DockerManager initialization."""
+        manager = DockerManager()
+        assert manager.container_name == "opencode-dev"
+        assert manager.http_url == "http://localhost:9000"
+        assert manager.timeout == 60
+
+    def test_docker_manager_custom_config(self, tmp_path, monkeypatch):
+        """Test DockerManager with custom configuration (relative compose path)."""
+        monkeypatch.chdir(tmp_path)
+        manager = DockerManager(
+            compose_file="custom.yml",
+            container_name="custom-opencode",
+            http_url="http://127.0.0.1:8000",
+        )
+        assert manager.compose_file == (tmp_path / "custom.yml").resolve()
+        assert manager.container_name == "custom-opencode"
+        assert manager.http_url == "http://127.0.0.1:8000"
+
+    @patch("specify_cli.integrations.opencode.docker_manager.subprocess.run")
+    def test_docker_up_success(self, mock_run):
+        """Test successful docker up command."""
+        mock_run.return_value = MagicMock(returncode=0)
+
+        manager = DockerManager()
+        with patch.object(manager, "check_container_ready", return_value=True):
+            result = manager.docker_up()
+            assert result is True
+
+    @patch("specify_cli.integrations.opencode.docker_manager.subprocess.run")
+    def test_docker_down_success(self, mock_run):
+        """Test successful docker down command."""
+        mock_run.return_value = MagicMock(returncode=0)
+
+        manager = DockerManager()
+        result = manager.docker_down()
+        assert result is True
+
+    @patch("specify_cli.integrations.opencode.docker_manager.subprocess.run")
+    def test_docker_status_running(self, mock_run):
+        """Test docker status when container is running."""
+        mock_run.side_effect = [
+            MagicMock(returncode=0),
+            MagicMock(
+                returncode=0,
+                stdout=json.dumps([{"Service": "opencode", "State": "running"}]),
+            ),
+        ]
+
+        manager = DockerManager()
+        status = manager.docker_status()
+        assert status is not None
+        assert status["status"] == "running"
+        assert status["running"] is True
+
+    @patch("specify_cli.integrations.opencode.docker_manager.httpx.get")
+    def test_check_container_ready_success(self, mock_get):
+        """Test container health check success."""
+        mock_get.return_value = MagicMock(status_code=200)
+
+        manager = DockerManager()
+        result = manager.check_container_ready(timeout=5)
+        assert result is True
+        mock_get.assert_called_once()
+
+    @patch("specify_cli.integrations.opencode.docker_manager.httpx.get")
+    def test_check_container_ready_timeout(self, mock_get):
+        """Test container health check timeout."""
+        mock_get.side_effect = Exception("Connection refused")
+
+        manager = DockerManager(timeout=1)  # Short timeout for testing
+        result = manager.check_container_ready(timeout=1)
+        assert result is False
+
+    @patch("specify_cli.integrations.opencode.docker_manager.subprocess.run")
+    def test_get_container_logs(self, mock_run):
+        """Test retrieving container logs."""
+        mock_run.side_effect = [
+            MagicMock(returncode=0),
+            MagicMock(
+                returncode=0,
+                stdout="log line 1\nlog line 2",
+            ),
+        ]
+
+        manager = DockerManager()
+        logs = manager.get_container_logs(lines=50)
+        assert "log line" in logs
+
+
+class TestOpencodeIntegration:
+    """Tests for OpenCode integration Docker support."""
+
+    def test_split_opencode_slash_prompt(self):
+        """Slash prompts map to OpenCode session command API fields."""
+        assert OpencodeIntegration._split_opencode_slash_prompt("") == ("help", "")
+        assert OpencodeIntegration._split_opencode_slash_prompt("/speckit.implement") == (
+            "speckit.implement",
+            "",
+        )
+        assert OpencodeIntegration._split_opencode_slash_prompt("/speckit.implement Phase 1") == (
+            "speckit.implement",
+            "Phase 1",
+        )
+
+    def test_load_opencode_config_no_file(self, tmp_path):
+        """Test loading config when file doesn't exist."""
+        integration = OpencodeIntegration()
+        project_root = tmp_path / "project"
+        project_root.mkdir()
+
+        config = integration._load_opencode_config(project_root)
+        assert config == {"mode": "local"}
+
+    def test_load_opencode_config_exists(self, tmp_path):
+        """Test loading existing config file."""
+        integration = OpencodeIntegration()
+        project_root = tmp_path / "project"
+        project_root.mkdir()
+
+        spec_dir = project_root / ".specify"
+        spec_dir.mkdir()
+
+        config_data = {
+            "mode": "docker",
+            "docker": {
+                "enabled": True,
+                "http_url": "http://localhost:9000",
+            },
+        }
+
+        config_file = spec_dir / "opencode.json"
+        with open(config_file, "w") as f:
+            json.dump(config_data, f)
+
+        loaded = integration._load_opencode_config(project_root)
+        assert loaded["mode"] == "docker"
+        assert loaded["docker"]["enabled"] is True
+
+    def test_is_docker_mode_false_by_default(self, tmp_path):
+        """Test that Docker mode is false by default."""
+        integration = OpencodeIntegration()
+        project_root = tmp_path / "project"
+        project_root.mkdir()
+        (project_root / ".specify").mkdir()
+
+        assert integration._is_docker_mode(project_root) is False
+
+    def test_is_docker_mode_enabled_in_config(self, tmp_path):
+        """Test Docker mode when enabled in config."""
+        integration = OpencodeIntegration()
+        project_root = tmp_path / "project"
+        project_root.mkdir()
+
+        spec_dir = project_root / ".specify"
+        spec_dir.mkdir()
+
+        config_file = spec_dir / "opencode.json"
+        with open(config_file, "w") as f:
+            json.dump({"mode": "docker"}, f)
+
+        assert integration._is_docker_mode(project_root) is True
+
+    @patch.dict("os.environ", {"OPENCODE_MODE": "docker"})
+    def test_is_docker_mode_from_env_var(self, tmp_path):
+        """Test Docker mode from environment variable."""
+        integration = OpencodeIntegration()
+        project_root = tmp_path / "project"
+        project_root.mkdir()
+
+        assert integration._is_docker_mode(project_root) is True
+
+    def test_opencode_http_command_name(self):
+        """HTTP /session/.../command uses spec.* for core speckit.* commands."""
+        assert OpencodeIntegration._opencode_http_command_name("speckit.implement") == "spec.implement"
+        assert OpencodeIntegration._opencode_http_command_name("speckit.specify") == "spec.specify"
+        assert OpencodeIntegration._opencode_http_command_name("speckit.taskstoissues") == (
+            "speckit.taskstoissues"
+        )
+
+    @patch("httpx.Client")
+    def test_call_docker_opencode_success(self, mock_client_class, tmp_path):
+        """Test successful Docker OpenCode API call."""
+        mock_inst = MagicMock()
+        mock_inst.__enter__ = MagicMock(return_value=mock_inst)
+        mock_inst.__exit__ = MagicMock(return_value=False)
+        mock_inst.post.side_effect = [
+            MagicMock(
+                status_code=200,
+                json=lambda: {
+                    "id": "sess-test",
+                    "title": "Specify CLI",
+                    "projectID": "p",
+                    "directory": "/workspace",
+                    "version": "1",
+                    "time": {"created": 0, "updated": 0},
+                },
+            ),
+            MagicMock(
+                status_code=200,
+                json=lambda: {"info": {"role": "assistant"}, "parts": []},
+            ),
+        ]
+        mock_client_class.return_value = mock_inst
+
+        integration = OpencodeIntegration()
+        project_root = tmp_path / "project"
+        project_root.mkdir()
+
+        spec_dir = project_root / ".specify"
+        spec_dir.mkdir()
+
+        config_file = spec_dir / "opencode.json"
+        with open(config_file, "w") as f:
+            json.dump(
+                {"mode": "docker", "docker": {"http_url": "http://localhost:9000"}},
+                f,
+            )
+
+        result = integration._call_docker_opencode(
+            "/speckit.specify hello",
+            project_root=project_root,
+        )
+
+        assert result["exit_code"] == 0
+        assert mock_inst.post.call_count == 2
+        first_url = mock_inst.post.call_args_list[0][0][0]
+        second_url = mock_inst.post.call_args_list[1][0][0]
+        assert "/session" in first_url
+        assert "/session/sess-test/command" in second_url
+        cmd_body = mock_inst.post.call_args_list[1][1]["json"]
+        assert cmd_body["command"] == "spec.specify"
+        assert cmd_body["arguments"] == "hello"
+        assert "assistant" in result["stdout"]
+
+    @patch("httpx.Client")
+    def test_call_docker_opencode_connection_error(self, mock_client_class, tmp_path):
+        """Test Docker OpenCode API connection error."""
+        import httpx
+
+        mock_inst = MagicMock()
+        mock_inst.__enter__ = MagicMock(return_value=mock_inst)
+        mock_inst.__exit__ = MagicMock(return_value=False)
+        mock_inst.post.side_effect = httpx.ConnectError("Connection failed")
+        mock_client_class.return_value = mock_inst
+
+        integration = OpencodeIntegration()
+        project_root = tmp_path / "project"
+        project_root.mkdir()
+
+        spec_dir = project_root / ".specify"
+        spec_dir.mkdir()
+
+        config_file = spec_dir / "opencode.json"
+        with open(config_file, "w") as f:
+            json.dump(
+                {"mode": "docker", "docker": {"http_url": "http://localhost:9000"}},
+                f,
+            )
+
+        result = integration._call_docker_opencode(
+            "/speckit.specify hello",
+            project_root=project_root,
+        )
+
+        assert result["exit_code"] == 1
+        assert "Docker running" in result["stderr"] or "Failed to connect" in result["stderr"]
+
+    def test_build_exec_args_docker_mode(self, tmp_path):
+        """Test build_exec_args returns synthetic args in Docker mode."""
+        integration = OpencodeIntegration()
+        project_root = tmp_path / "project"
+        project_root.mkdir()
+
+        spec_dir = project_root / ".specify"
+        spec_dir.mkdir()
+
+        config_file = spec_dir / "opencode.json"
+        with open(config_file, "w") as f:
+            json.dump({"mode": "docker"}, f)
+
+        args = integration.build_exec_args(
+            "/spec.implement test", project_root=project_root
+        )
+
+        assert args is not None
+        assert "--docker-mode" in args
+        assert args[0] == "opencode"
+        assert "/spec.implement test" in args
+
+    def test_build_exec_args_local_mode(self, tmp_path):
+        """Test build_exec_args returns local CLI args when not in Docker mode."""
+        integration = OpencodeIntegration()
+        project_root = tmp_path / "project"
+        project_root.mkdir()
+
+        # No config file = local mode
+        args = integration.build_exec_args(
+            "/spec.implement test", project_root=project_root
+        )
+
+        assert args is not None
+        assert args[0] == "opencode"
+        assert "run" in args
+        assert "--docker-mode" not in args
+
+    @patch.dict("os.environ", {"OPENCODE_MODE": "docker"})
+    def test_build_exec_args_docker_mode_from_env(self, tmp_path):
+        """Test build_exec_args detects Docker mode from env var without config file."""
+        integration = OpencodeIntegration()
+        project_root = tmp_path / "project"
+        project_root.mkdir()
+
+        # No config file, but env var set
+        args = integration.build_exec_args(
+            "/spec.implement test", project_root=project_root
+        )
+
+        assert args is not None
+        assert "--docker-mode" in args
+
+    def test_is_docker_mode_exec_args(self):
+        """Test is_docker_mode_exec_args correctly detects Docker mode."""
+        # Docker mode args
+        docker_args = ["opencode", "--docker-mode", "/spec.test"]
+        assert OpencodeIntegration.is_docker_mode_exec_args(docker_args) is True
+
+        # Local mode args
+        local_args = ["opencode", "run", "test"]
+        assert OpencodeIntegration.is_docker_mode_exec_args(local_args) is False
+
+        # None
+        assert OpencodeIntegration.is_docker_mode_exec_args(None) is False
+
+        # Empty list
+        assert OpencodeIntegration.is_docker_mode_exec_args([]) is False