Add option to run agent tasks without cli interaction

Author: nezhar

README.md

@@ -45,6 +45,16 @@ vp run codex
 vp run vibe   # alias of devstral
 ```
 
+Run in the background and retrieve collected output by task ID:
+
+```bash
+vp run <agent> --detached --prompt "Write TEST.md"
+vp logs show <task-id>
+```
+
+Use `--prompt` to run a single non-interactive task. VibePod maps it to each
+agent's documented prompt mode.
+
 Extra arguments after the agent are forwarded to the agent process. Use `--`
 before agent flags so VibePod does not parse them as its own options:
 

docs/agents/index.md

@@ -153,7 +153,24 @@ agents:
       MY_VAR: value
 ```
 
-## Passing arguments to the agent
+## Running one prompt
+
+Use `--prompt` to run a single task in the selected agent's non-interactive mode:
+
+```bash
+vp run codex --prompt "Write TEST.md"
+vp run claude --prompt "Summarize this repository"
+```
+
+Combine it with detached mode to run the same non-interactive task in the background:
+
+```bash
+vp run codex --detached --prompt "Write TEST.md"
+```
+
+VibePod maps `--prompt` to each agent's documented prompt mode (`claude -p`, `codex exec`, `opencode run`, and so on).
+
+## Passing raw arguments to the agent
 
 Any extra arguments after the agent name are appended to the agent command inside the container:
 
@@ -206,21 +223,36 @@ vp run codex --ikwid
 
 ## Detached mode
 
-Use `-d` / `--detach` to start an agent container in the background without attaching your terminal. The agent process starts immediately inside the container — `-d` only controls whether VibePod attaches your terminal to it.
+Use `-d`, `--detach`, or `--detached` to start an agent container in the background without attaching your terminal. The agent process starts immediately inside the container and VibePod returns a task ID that can be used to retrieve logs later.
 
 ### Basic usage
 
 ```bash
-vp run claude -d
-# ✓ Started vibepod-claude-a1b2c3d4
+vp run codex --detached --prompt "Write TEST.md"
+# ✓ Started vibepod-codex-a1b2c3d4
+# ✓ Task ID: 9f2c7d4e8a1b4c6f9a0d2e3f4b5c6d7e
 ```
 
-The command prints the container name and returns immediately. You can also find it later with:
+The command prints the container name and task ID, then returns immediately. You can also find running task IDs later with:
 
 ```bash
 vp list --running
 ```
 
+### Retrieving detached output
+
+Detached container output is collected in the local VibePod logs database while the task runs.
+
+```bash
+vp logs show 9f2c7d4e8a1b4c6f9a0d2e3f4b5c6d7e
+```
+
+For a still-running task, you can attach by task ID:
+
+```bash
+vp logs attach 9f2c7d4e8a1b4c6f9a0d2e3f4b5c6d7e
+```
+
 ### Interacting with a detached container
 
 The agent is already running inside the container. You can exec into it to inspect state, install extra tools, or interact with the agent alongside its running process:
@@ -254,9 +286,8 @@ vp stop --all        # stop every VibePod container
 
 ### Caveats
 
-- **`auto_remove` (default: `true`)** — By default, containers are automatically removed when they stop. This means you cannot restart a stopped detached container; you need to `vp run` again. Set `auto_remove: false` in your [configuration](../configuration.md) if you want stopped containers to persist.
-- **No built-in re-attach** — VibePod does not currently have a command to re-attach your terminal to a detached container. Use `docker attach <container>` or `docker exec -it <container> bash` directly.
-- **Session logging** — Sessions started with `--detach` are not recorded in the VibePod session log since VibePod does not capture the interactive I/O. If you need session logging, run without `--detach`.
+- **`auto_remove` (default: `true`)** — Foreground containers are automatically removed when they stop by default. Detached containers are kept so their Docker logs remain available through the task ID.
+- **Session logging disabled** — If `logging.enabled` is `false`, VibePod still starts the detached container and prints a task ID, but it does not collect detached output in SQLite.
 
 ## Connecting to a Docker Compose network
 
@@ -464,3 +495,15 @@ vp run copilot   # or: vp p
 ```bash
 vp run codex   # or: vp x
 ```
+
+For non-interactive detached tasks, use Codex's `exec` subcommand:
+
+```bash
+vp run codex --detached -- exec "Write a TEST.md file with details to our test strategy"
+```
+
+For unattended edits, combine it with IKWID mode:
+
+```bash
+vp run codex --detached --ikwid -- exec "Write a TEST.md file with details to our test strategy"
+```

docs/quickstart.md

@@ -53,15 +53,15 @@ Use `-w` / `--workspace` to target any directory:
 vp run claude -w ~/other-project
 ```
 
-## Pass arguments to the agent
+## Run one prompt
 
-Arguments after the agent name are forwarded to the agent command inside the container:
+Use `--prompt` to run a single non-interactive task. VibePod maps it to the selected agent's documented prompt mode:
 
 ```bash
-vp run <agent> <agent-args>
+vp run codex --prompt "Write TEST.md"
 ```
 
-When forwarding flags to the agent, use `--` to stop VibePod option parsing:
+For raw agent-specific arguments, use `--` to stop VibePod option parsing:
 
 ```bash
 vp run <agent> -- <agent-flag> <value>
@@ -91,10 +91,16 @@ If that agent is already configured under `agents`, the command exits without ch
 
 ## Run in the background
 
-Use `-d` / `--detach` to start the container without attaching your terminal:
+Use `-d`, `--detach`, or `--detached` to start the container without attaching your terminal:
 
 ```bash
-vp run claude -d
+vp run codex --detached --prompt "Write TEST.md"
+```
+
+Detached runs print a task ID. Use it to inspect collected output later:
+
+```bash
+vp logs show <task-id>
 ```
 
 Check which agents are running:

src/vibepod/cli.py

@@ -40,8 +40,15 @@ def _alias(
             bool, typer.Option("--pull", help="Pull latest image before run")
         ] = False,
         detach: Annotated[
-            bool, typer.Option("-d", "--detach", help="Run container in background")
+            bool, typer.Option("-d", "--detach", "--detached", help="Run container in background")
         ] = False,
+        prompt: Annotated[
+            str | None,
+            typer.Option(
+                "--prompt",
+                help="Run a single prompt in the agent's non-interactive mode",
+            ),
+        ] = None,
         env: Annotated[
             list[str] | None,
             typer.Option("-e", "--env", help="Environment variable KEY=VALUE", show_default=False),
@@ -76,6 +83,7 @@ def _alias(
             workspace=workspace,
             pull=pull,
             detach=detach,
+            prompt=prompt,
             env=env,
             name=name,
             network=network,

src/vibepod/commands/list_cmd.py

@@ -39,6 +39,7 @@ def _running_rows(containers: list[Any]) -> list[dict[str, str]]:
                 "agent": agent,
                 "container": getattr(container, "name", "-"),
                 "context": labels.get("vibepod.workspace", "-"),
+                "task_id": labels.get("vibepod.session_id", "-"),
             }
         )
     return sorted(rows, key=lambda row: (row["agent"], row["container"]))
@@ -75,11 +76,12 @@ def list_agents(
     running_table = Table(title="Running Agents", title_justify="left")
     running_table.add_column("AGENT", style="cyan")
     running_table.add_column("CONTAINER", style="magenta")
+    running_table.add_column("TASK ID")
     running_table.add_column("CONTEXT")
 
     if running_rows:
         for row in running_rows:
-            running_table.add_row(row["agent"], row["container"], row["context"])
+            running_table.add_row(row["agent"], row["container"], row["task_id"], row["context"])
         console.print(running_table)
     else:
         console.print("No running agents.")

src/vibepod/commands/logs.py

@@ -7,13 +7,14 @@
 import urllib.request
 import webbrowser
 from pathlib import Path
-from typing import Annotated
+from typing import Annotated, Any
 
 import typer
 
 from vibepod.constants import EXIT_DOCKER_NOT_RUNNING
 from vibepod.core.config import get_config
 from vibepod.core.docker import DockerClientError, DockerManager, _is_latest_tag
+from vibepod.core.session_logger import SessionLogger
 from vibepod.utils.console import error, info, success, warning
 
 app = typer.Typer(help="View logs and traffic UI")
@@ -37,6 +38,11 @@ def _wait_for_datasette(port: int) -> bool:
     return False
 
 
+def _log_db_path(config: dict[str, Any]) -> Path:
+    log_cfg = config.get("logging", {})
+    return Path(str(log_cfg.get("db_path", "~/.config/vibepod/logs.db"))).expanduser().resolve()
+
+
 @app.command("start")
 def logs_start(
     port: Annotated[int | None, typer.Option("--port", help="Datasette host port")] = None,
@@ -125,6 +131,108 @@ def logs_status() -> None:
     info(f"Datasette container: {existing.name} ({existing.status})")
 
 
+@app.command("show")
+def logs_show(
+    task_id: Annotated[str, typer.Argument(help="Task/run ID returned by `vp run --detach`")],
+) -> None:
+    """Print persisted logs for a detached task."""
+    db_path = _log_db_path(get_config())
+    session = SessionLogger.get_session(db_path, task_id)
+    if session is None:
+        error(f"Unknown task ID: {task_id}")
+        raise typer.Exit(1)
+
+    outputs = SessionLogger.get_outputs(db_path, task_id)
+    if outputs:
+        for row in outputs:
+            print(row["content"], end="")
+        return
+
+    try:
+        docker_logs = DockerManager().container_logs(str(session["container_id"]))
+    except DockerClientError as exc:
+        warning(f"No persisted output has been collected for this task: {exc}")
+        return
+
+    if docker_logs:
+        print(docker_logs, end="")
+        return
+
+    info("No output has been collected for this task yet.")
+
+
+@app.command("attach")
+def logs_attach(
+    task_id: Annotated[str, typer.Argument(help="Task/run ID returned by `vp run --detach`")],
+) -> None:
+    """Attach to a running detached task by task ID."""
+    db_path = _log_db_path(get_config())
+    session = SessionLogger.get_session(db_path, task_id)
+    if session is None:
+        error(f"Unknown task ID: {task_id}")
+        raise typer.Exit(1)
+
+    try:
+        manager = DockerManager()
+        container = manager.get_container(str(session["container_id"]))
+    except DockerClientError as exc:
+        error(str(exc))
+        raise typer.Exit(EXIT_DOCKER_NOT_RUNNING) from exc
+
+    info(f"Attached to {session['container_name']}. Use Ctrl+C to detach/stop.")
+    try:
+        manager.attach_interactive(container)
+    except KeyboardInterrupt:
+        info("Detached")
+
+
+@app.command("collect", hidden=True)
+def logs_collect(
+    task_id: Annotated[str, typer.Argument(help="Task/run ID")],
+    db_path: Annotated[Path | None, typer.Option("--db-path", help="Logs DB path")] = None,
+) -> None:
+    """Persist Docker logs for a detached task until the container exits."""
+    config = get_config()
+    resolved_db_path = (
+        db_path.expanduser().resolve() if db_path is not None else _log_db_path(config)
+    )
+    session = SessionLogger.get_session(resolved_db_path, task_id)
+    if session is None:
+        raise typer.Exit(1)
+
+    try:
+        manager = DockerManager()
+        container = manager.get_container(str(session["container_id"]))
+        for chunk in container.logs(stream=True, follow=True, stdout=True, stderr=True):
+            if isinstance(chunk, bytes):
+                content = chunk.decode("utf-8", errors="replace")
+            else:
+                content = str(chunk)
+            SessionLogger.append_output(
+                resolved_db_path,
+                session_id=task_id,
+                content=content,
+            )
+        try:
+            result = container.wait()
+            status_code = result.get("StatusCode") if isinstance(result, dict) else None
+            exit_reason = f"exit_{status_code}" if status_code is not None else "normal"
+        except Exception:
+            exit_reason = "normal"
+        SessionLogger.close_session_by_id(
+            resolved_db_path,
+            session_id=task_id,
+            exit_reason=exit_reason,
+        )
+    except Exception:
+        SessionLogger.close_session_by_id(
+            resolved_db_path,
+            session_id=task_id,
+            exit_reason="collector_error",
+        )
+        raise typer.Exit(1)
+
+
 @app.command("ui", hidden=True)
 def logs_ui(
     port: Annotated[int | None, typer.Option("--port", help="Datasette host port")] = None,