sbxloop 0.3.0__tar.gz → 0.4.1__tar.gz

{sbxloop-0.3.0 → sbxloop-0.4.1}/.gitignore

@@ -221,3 +221,7 @@ __marimo__/
 .sbxloop/
 .sdxloop/
 packages/sbxloop/src/sbxloop/_vendor/
+
+# written at build time by hatch-vcs
+packages/sbxloop/src/sbxloop/_version.py
+packages/sbxloop-worker/src/sbxloop_worker/_version.py

{sbxloop-0.3.0 → sbxloop-0.4.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sbxloop
-Version: 0.3.0
+Version: 0.4.1
 Summary: Agentic loop orchestration on Docker Sandboxes (sbx) with isolated credential domains
 Project-URL: Homepage, https://github.com/brettbergin/sbxloop
 Project-URL: Repository, https://github.com/brettbergin/sbxloop
@@ -19,7 +19,7 @@ Requires-Python: >=3.11
 Requires-Dist: pydantic>=2.7
 Requires-Dist: python-dotenv>=1.0
 Requires-Dist: rich>=13.7
-Requires-Dist: sbxloop-worker==0.3.0
+Requires-Dist: sbxloop-worker
 Requires-Dist: typer>=0.12
 Description-Content-Type: text/markdown
 

{sbxloop-0.3.0 → sbxloop-0.4.1}/hatch_build.py

@@ -29,6 +29,12 @@ class VendorWorkerWheelHook(BuildHookInterface):  # type: ignore[type-arg]
         host_version = self.metadata.version
         expected = f"sbxloop_worker-{host_version}-py3-none-any.whl"
 
+        # The static dependency list can't carry an exact pin now that versions
+        # come from git tags (hatch-vcs), so add the lockstep pin to the wheel
+        # metadata here.
+        if self.target_name == "wheel":
+            build_data.setdefault("dependencies", []).append(f"sbxloop-worker=={host_version}")
+
         if (vendor_dir / expected).is_file():
             return
 

{sbxloop-0.3.0 → sbxloop-0.4.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "sbxloop"
-version = "0.3.0"
+dynamic = ["version"]  # derived from git tags by hatch-vcs (see [tool.hatch.version])
 description = "Agentic loop orchestration on Docker Sandboxes (sbx) with isolated credential domains"
 readme = "README.md"
 requires-python = ">=3.11"
@@ -21,7 +21,10 @@ dependencies = [
     "python-dotenv>=1.0",
     "typer>=0.12",
     "rich>=13.7",
-    "sbxloop-worker==0.3.0",
+    # Unpinned here because the version is dynamic; the build hook
+    # (hatch_build.py) adds the exact lockstep pin `sbxloop-worker==X.Y.Z`
+    # to the wheel metadata at build time.
+    "sbxloop-worker",
 ]
 
 [project.scripts]
@@ -36,9 +39,21 @@ Issues = "https://github.com/brettbergin/sbxloop/issues"
 sbxloop-worker = { workspace = true }
 
 [build-system]
-requires = ["hatchling>=1.27"]
+requires = ["hatchling>=1.27", "hatch-vcs"]
 build-backend = "hatchling.build"
 
+# Both workspace packages version from the same repo-root git tag, keeping the
+# lockstep invariant by construction. `fallback_root` lets a wheel built from
+# an extracted sdist (no git) pick the version up from the sdist's PKG-INFO.
+[tool.hatch.version]
+source = "vcs"
+raw-options = { root = "../..", fallback_root = ".", local_scheme = "no-local-version", fallback_version = "0.0.0" }
+
+# Write the resolved version into the package so `sbxloop.__version__` and
+# `sbxloop --version` report it at runtime.
+[tool.hatch.build.hooks.vcs]
+version-file = "src/sbxloop/_version.py"
+
 [tool.hatch.build.targets.wheel]
 packages = ["src/sbxloop"]
 artifacts = ["src/sbxloop/_vendor/*.whl"]

{sbxloop-0.3.0 → sbxloop-0.4.1}/src/sbxloop/__init__.py

@@ -6,7 +6,16 @@ agentic layer, and a GitHub-ops sandbox holding only ``GH_TOKEN`` for
 user-facing GitHub interactions. The balanced network policy is the default.
 """
 
-__version__ = "0.3.0"
+try:
+    # written at build time by hatch-vcs (see pyproject [tool.hatch.build.hooks.vcs])
+    from sbxloop._version import __version__
+except ImportError:  # pragma: no cover - raw source tree that was never built
+    try:
+        from importlib.metadata import version as _pkg_version
+
+        __version__ = _pkg_version("sbxloop")
+    except Exception:
+        __version__ = "0.0.0"
 
 from sbxloop.config import Budgets, Config, load_config
 from sbxloop.engine import LoopEngine, RunResult, run_outcome

sbxloop-0.4.1/src/sbxloop/_version.py

@@ -0,0 +1,24 @@
+# file generated by vcs-versioning
+# don't change, don't track in version control
+from __future__ import annotations
+
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
+
+version: str
+__version__: str
+__version_tuple__: tuple[int | str, ...]
+version_tuple: tuple[int | str, ...]
+commit_id: str | None
+__commit_id__: str | None
+
+__version__ = version = '0.4.1'
+__version_tuple__ = version_tuple = (0, 4, 1)
+
+__commit_id__ = commit_id = None

{sbxloop-0.3.0 → sbxloop-0.4.1}/src/sbxloop/cli/app.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import queue
 import threading
 import time
 from pathlib import Path
@@ -15,12 +16,13 @@ from rich.tree import Tree
 
 import sbxloop
 from sbxloop.cli.doctor import run_doctor
-from sbxloop.cli.tui import Dashboard, format_event, plain_printer
+from sbxloop.cli.tui import Dashboard, format_event, plain_printer, render_event
 from sbxloop.config import Config, load_config, load_config_with_sources, load_dotenv_file
 from sbxloop.engine.engine import LoopEngine
-from sbxloop.engine.model import RunResult, artifacts_dir
+from sbxloop.engine.model import RunResult, artifact_files, artifacts_dir
 from sbxloop.engine.store import StateStore
 from sbxloop.errors import SdxloopError
+from sbxloop.events import Event
 from sbxloop.sbx.cli import SbxCLI
 from sbxloop.sbx.provision import sandbox_name
 
@@ -67,13 +69,23 @@ def _store(config: Config) -> StateStore:
 
 
 def _drive_with_ui(engine: LoopEngine, *, tui: bool, action: Any) -> RunResult:
-    """Run start/resume with either the live dashboard or plain event logs."""
+    """Run start/resume with the scrollback transcript + pinned status, or
+    plain event logs (--no-tui).
+
+    Transcript entries print permanently to the terminal's scrollback (via
+    ``live.console.print``, which renders above the live region), so the
+    full conversation history survives; only the compact status panel at
+    the bottom is redrawn in place. Events arrive on the engine thread but
+    every terminal write happens here on the main thread, via a queue —
+    ordering stays deterministic and rich's Live never interleaves.
+    """
     if not tui:
         engine.bus.subscribe(plain_printer(console))
         return action()  # type: ignore[no-any-return]
 
     dashboard = Dashboard()
-    engine.bus.subscribe(dashboard.on_event)
+    pending: queue.SimpleQueue[Event] = queue.SimpleQueue()
+    engine.bus.subscribe(pending.put)
     outcome: dict[str, Any] = {}
 
     def target() -> None:
@@ -84,10 +96,24 @@ def _drive_with_ui(engine: LoopEngine, *, tui: bool, action: Any) -> RunResult:
 
     thread = threading.Thread(target=target, daemon=True)
     with Live(dashboard.renderable(), console=console, refresh_per_second=8) as live:
+
+        def drain() -> None:
+            while True:
+                try:
+                    event = pending.get_nowait()
+                except queue.Empty:
+                    return
+                dashboard.on_event(event)
+                rendered = render_event(event)
+                if rendered is not None:
+                    live.console.print(rendered)
+
         thread.start()
         while thread.is_alive():
+            drain()
             live.update(dashboard.renderable())
             time.sleep(0.15)
+        drain()
         live.update(dashboard.renderable())
     if "error" in outcome:
         raise outcome["error"]
@@ -106,16 +132,6 @@ def _human_size(size: int) -> str:
     raise AssertionError("unreachable")  # pragma: no cover
 
 
-def _artifact_files(root: Path) -> list[Path]:
-    """Regular files under root, hidden files/dirs excluded (an agent's .git
-    would otherwise swamp the listing), sorted for stable output."""
-    return sorted(
-        p
-        for p in root.rglob("*")
-        if p.is_file() and not any(part.startswith(".") for part in p.relative_to(root).parts)
-    )
-
-
 def _artifacts_tree(root: Path, files: list[Path], cap: int = _TREE_MAX_FILES) -> Tree:
     tree = Tree(f"[bold]{root}[/]")
     nodes: dict[Path, Tree] = {root: tree}
@@ -137,7 +153,7 @@ def _print_artifacts_summary(result: RunResult, config: Config) -> None:
     target = artifacts_dir(result, config.state_dir)
     if target is None or not target.is_dir():
         return
-    files = _artifact_files(target)
+    files = artifact_files(target)
     if not files:
         console.print(f"\nartifacts: none produced (workspace: {target})")
         return
@@ -158,8 +174,19 @@ def _finish(result: RunResult, config: Config) -> None:
 @app.command()
 def run(
     outcome: Annotated[str, typer.Argument(help="The outcome to achieve.")],
-    repo: Annotated[
-        str | None, typer.Option("--repo", help="owner/repo for GitHub progress reporting.")
+    report: Annotated[
+        bool | None,
+        typer.Option(
+            "--report/--no-report",
+            help="Post run progress to the configured [github].repo.",
+        ),
+    ] = None,
+    deliver: Annotated[
+        bool | None,
+        typer.Option(
+            "--deliver/--no-deliver",
+            help="Publish the completed run's artifacts as a PR to the configured [github].repo.",
+        ),
     ] = None,
     model: Annotated[str | None, typer.Option("--model", help="Copilot model id.")] = None,
     keep_sandboxes: Annotated[
@@ -169,10 +196,29 @@ def run(
 ) -> None:
     """Run an agentic loop for OUTCOME in a fresh sandbox pair."""
     config = _config_with_overrides(model=model, keep_sandboxes=keep_sandboxes or None)
-    if repo:
+    if report is not None:
         config = config.model_copy(
-            update={"github": config.github.model_copy(update={"report_repo": repo})}
+            update={"github": config.github.model_copy(update={"report": report})}
         )
+    if deliver is not None:
+        config = config.model_copy(
+            update={"github": config.github.model_copy(update={"deliver": deliver})}
+        )
+    wanted = [
+        feature
+        for feature, enabled in (
+            ("progress reporting (--report)", config.github.report),
+            ("PR delivery (--deliver)", config.github.deliver),
+        )
+        if enabled
+    ]
+    if wanted and not config.github.enabled:
+        console.print(
+            f"[bold red]GitHub integration is not configured.[/] {', '.join(wanted)} "
+            'needs a repository: set [cyan]\\[github] repo = "owner/repo"[/] in '
+            "sbxloop.toml (see `sbxloop init`), then re-run."
+        )
+        raise typer.Exit(2)
     engine = LoopEngine(config)
     try:
         result = _drive_with_ui(engine, tui=tui, action=lambda: engine.start(outcome))
@@ -316,7 +362,7 @@ def artifacts(
     if not target.is_dir():
         console.print(f"[bold red]artifacts directory is gone:[/] {target}")
         raise typer.Exit(2)
-    files = _artifact_files(target)
+    files = artifact_files(target)
     via = "live workspace mount" if record.mounted else "harvested copy"
     console.print(f"run [bold cyan]{run_id}[/]: {len(files)} file(s) ({via}) in [bold]{target}[/]")
     if tree:
@@ -443,8 +489,18 @@ secret_strategy = "proxy"
 extra_allow_domains = []
 
 [github]
-# Report run progress to a GitHub repo ("owner/repo"); empty disables.
-# report_repo = "you/your-repo"
+# The GitHub integration. Unset (the default) disables GitHub entirely:
+# no github sandbox is provisioned, GH_TOKEN is not required, and
+# repo-facing features refuse to run. Set `repo` to the ONE repository
+# sbxloop may work with; the toggles below act on it.
+# repo = "you/your-repo"
+# Post run progress (issues/comments) to the configured repo.
+# report = false
+# Open a PR with the run's artifacts when a run completes (or `--deliver`).
+# GH_TOKEN needs contents:write + pull_requests:write on the repo.
+# deliver = false
+# deliver_base = "main"   # base branch; unset uses the repo's default
+# deliver_draft = false
 
 [budgets]
 max_revisions_per_task = 2

{sbxloop-0.3.0 → sbxloop-0.4.1}/src/sbxloop/cli/doctor.py

@@ -109,17 +109,31 @@ def collect_checks(
             f"permission and export {COPILOT_TOKEN_ENV}",
         )
     )
-    gh_set = any(env.get(name) for name in GH_TOKEN_ENVS)
-    checks.append(
-        Check(
-            "/".join(GH_TOKEN_ENVS),
-            gh_set,
-            "set"
-            if gh_set
-            else "not set — create a fine-grained PAT (issues:write, contents:read, ...) "
-            "and export GH_TOKEN",
+    # GH_TOKEN matters only when the GitHub integration is configured; an
+    # unconfigured integration is a valid (GitHub-less) setup, not a failure.
+    if config.github.enabled:
+        gh_set = any(env.get(name) for name in GH_TOKEN_ENVS)
+        checks.append(
+            Check(
+                "/".join(GH_TOKEN_ENVS),
+                gh_set,
+                f"set (github integration: {config.github.repo})"
+                if gh_set
+                else f"not set but [github].repo = {config.github.repo!r} is configured — "
+                "create a fine-grained PAT (issues:write, contents:read, ...) "
+                "and export GH_TOKEN",
+            )
+        )
+    else:
+        checks.append(
+            Check(
+                "github integration",
+                True,
+                'not configured — GitHub features disabled (set [github] repo = "owner/repo" '
+                "in sbxloop.toml to enable)",
+                hard=False,
+            )
         )
-    )
 
     # worker wheel
     wheel = resolve_worker_wheel()

{sbxloop-0.3.0 → sbxloop-0.4.1}/src/sbxloop/cli/tui.py

@@ -1,16 +1,20 @@
-"""Rich rendering for runs: a chat-style live transcript and plain logging.
-
-Agent output is conversational (markdown, fenced code blocks), so the live
-view renders it as a chat thread — markdown panels with syntax-highlighted
-code — rather than truncated log lines. Host lifecycle events stay compact
-one-liners. ``format_event`` remains the dense single-line form used by
+"""Rich rendering for runs: a permanent scrollback transcript plus a small
+pinned status region.
+
+Agent output is conversational (markdown, fenced code blocks), so the
+transcript renders it as a chat thread — markdown panels with
+syntax-highlighted code — rather than truncated log lines. Transcript
+entries are printed to the terminal's normal scrollback as they happen and
+are never rewritten or dropped: the full history of a run stays scrollable.
+Only the compact status region (run state + task table) is live-updated in
+place at the bottom. Host lifecycle events stay compact one-liners.
+``format_event`` remains the dense single-line form used by
 ``sbxloop logs``.
 """
 
 from __future__ import annotations
 
 import datetime
-from collections import deque
 from typing import Any
 
 from rich.console import Console, Group, RenderableType
@@ -50,12 +54,24 @@ _TRANSCRIPT_SKIP = {
 }
 
 AGENT_MESSAGE_CLIP = 4000
+# One-line clip for tool arguments; output tail lines shown on tool failure.
+TOOL_ARGS_LINE_CLIP = 160
+TOOL_FAIL_TAIL_LINES = 6
 
 
 def _stamp(event: Event) -> str:
     return datetime.datetime.fromtimestamp(event.ts).strftime("%H:%M:%S")
 
 
+def _one_line(text: str, limit: int = TOOL_ARGS_LINE_CLIP) -> str:
+    """Collapse to a single display line, eliding the middle beyond limit."""
+    flat = " ".join(text.split())
+    if len(flat) <= limit:
+        return flat
+    keep = (limit - 1) // 2
+    return f"{flat[:keep]}…{flat[-keep:]}"
+
+
 def render_event(event: Event) -> RenderableType | None:
     """One transcript entry for an event, or None when it should be skipped."""
     if event.type in _TRANSCRIPT_SKIP:
@@ -88,10 +104,36 @@ def render_event(event: Event) -> RenderableType | None:
 
     if event.type == EventTypes.AGENT_TOOL_START:
         tool = data.get("tool") or "tool"
-        return Text(f"{_stamp(event)}  ⚙ {tool}", style="yellow", overflow="fold")
+        start = Text(f"{_stamp(event)}  ⚙ {tool}", style="yellow")
+        args = _one_line(str(data.get("args") or ""))
+        if args:
+            start.append(" $ ", style="bold yellow")
+            start.append(args, style="yellow dim")
+        start.overflow = "fold"
+        return start
 
     if event.type == EventTypes.AGENT_TOOL_END:
-        return None  # start lines carry enough signal for the transcript
+        tool = data.get("tool") or "tool"
+        success = data.get("success")
+        exit_code = data.get("exit_code")
+        if success is None and exit_code is None:
+            return None  # nothing informative beyond the start line
+        if success or (success is None and exit_code == 0):
+            suffix = " exit 0" if exit_code == 0 else ""
+            return Text(f"{_stamp(event)}  ✓ {tool}{suffix}", style="green dim")
+        suffix = f" exit {exit_code}" if exit_code is not None else ""
+        failure = Text(f"{_stamp(event)}  ✗ {tool}{suffix}", style="red")
+        tail = str(data.get("output") or "").strip()
+        if tail:
+            return Group(
+                failure,
+                Text(
+                    "\n".join(tail.splitlines()[-TOOL_FAIL_TAIL_LINES:]),
+                    style="red dim",
+                    overflow="fold",
+                ),
+            )
+        return failure
 
     if event.type.startswith(_LIFECYCLE_PREFIXES):
         line = format_event(event)
@@ -106,14 +148,16 @@ def render_event(event: Event) -> RenderableType | None:
 
 
 class Dashboard:
-    """Accumulates run state from the event stream and renders it."""
+    """Accumulates run status from the event stream and renders the pinned
+    region. Transcript entries are NOT kept here — the drive loop prints
+    them straight to scrollback via ``render_event`` so history is never
+    truncated or rewritten."""
 
-    def __init__(self, max_entries: int = 6) -> None:
+    def __init__(self) -> None:
         self.run_id: str | None = None
         self.run_state: str = "starting"
         self.outcome: str = ""
         self.tasks: dict[str, dict[str, Any]] = {}
-        self.transcript: deque[RenderableType] = deque(maxlen=max_entries)
 
     # -- event intake ------------------------------------------------------
 
@@ -139,9 +183,6 @@ class Dashboard:
             if data.get("title"):
                 entry["title"] = str(data["title"])
             entry["state"] = str(data.get("state", entry["state"]))
-        rendered = render_event(event)
-        if rendered is not None:
-            self.transcript.append(rendered)
 
     # -- rendering ---------------------------------------------------------
 
@@ -170,15 +211,10 @@ class Dashboard:
         if not self.tasks:
             table.add_row("…", "decomposing outcome", Text("pending", style="dim"), "")
 
-        transcript: RenderableType
-        if self.transcript:
-            transcript = Group(*self.transcript)
-        else:
-            transcript = Text("waiting for events…", style="dim")
-        return Group(
-            Panel(Group(header, outcome), border_style="cyan"),
-            table,
-            transcript,
+        return Panel(
+            Group(header, outcome, table),
+            border_style="cyan",
+            padding=(0, 1),
         )
 
 
@@ -187,11 +223,14 @@ def format_event(event: Event) -> str:
     parts = [_stamp(event), event.type]
     if event.data.get("task_id"):
         parts.append(f"[{event.data['task_id']}]")
-    for key in ("state", "content", "tool", "op", "line", "message", "outcome", "path"):
+    keys = ("state", "content", "tool", "op", "line", "message", "outcome", "error", "url", "path")
+    for key in keys:
         if event.data.get(key):
             value = str(event.data[key]).replace("\n", " ")
             parts.append(value[:160])
             break
+    if event.data.get("args"):
+        parts.append(_one_line(str(event.data["args"]), 120))
     return " ".join(parts)
 
 

{sbxloop-0.3.0 → sbxloop-0.4.1}/src/sbxloop/config.py

@@ -12,12 +12,13 @@ strings.
 from __future__ import annotations
 
 import os
+import re
 import tomllib
 from collections.abc import Mapping
 from pathlib import Path
 from typing import Any, Literal
 
-from pydantic import BaseModel, ConfigDict, Field, ValidationError
+from pydantic import BaseModel, ConfigDict, Field, ValidationError, field_validator
 
 from sbxloop.errors import ConfigError
 
@@ -42,7 +43,29 @@ class SandboxConfig(_ConfigModel):
 
 
 class GithubConfig(_ConfigModel):
-    report_repo: str | None = None
+    """The GitHub integration. ``repo`` is the gate: unset (the default)
+    disables GitHub entirely — no github sandbox is provisioned, no GH_TOKEN
+    is required, and repo-facing features (progress reporting, delivery)
+    refuse to run. Setting it makes ``repo`` the one repository sbxloop is
+    allowed to work with; behavior toggles like ``report`` act on it."""
+
+    repo: str | None = None
+    report: bool = False
+    # Publish a completed run's artifacts as a PR to `repo`.
+    deliver: bool = False
+    deliver_base: str | None = None  # base branch; None → the repo's default
+    deliver_draft: bool = False
+
+    @field_validator("repo")
+    @classmethod
+    def _check_repo(cls, value: str | None) -> str | None:
+        if value is not None and not re.fullmatch(r"[\w.-]+/[\w.-]+", value):
+            raise ValueError(f"github.repo must be owner/name, got {value!r}")
+        return value
+
+    @property
+    def enabled(self) -> bool:
+        return self.repo is not None
 
 
 class Budgets(_ConfigModel):

sbxloop-0.4.1/src/sbxloop/deliver.py

@@ -0,0 +1,144 @@
+"""Deliver a completed run's artifacts as a GitHub pull request.
+
+Everything goes through the :class:`GithubOps` facade, i.e. runs as
+``github.op`` jobs inside the github-ops sandbox — the only environment
+holding ``GH_TOKEN``; the credential split is preserved. Files are committed
+atomically through the git data API (blobs → tree → commit → ref) rather
+than per-file contents PUTs: one commit regardless of file count, and
+base64 blobs carry binary content.
+
+Scaffold status: this is a real, unit-tested code path (stubbed GithubOps),
+but per the project pattern — unverified external behaviors get a seam and
+an e2e check, never a confident default — it is NOT field-proven until the
+real-sbx e2e workflow exercises it. Known e2e-validation items:
+
+- TODO(e2e): branch-name collisions (re-delivering the same run id — the
+  refs POST will 422; decide between force-update and suffixing)
+- TODO(e2e): large workspaces (one blob POST per file; may need chunking
+  or a tarball-artifact fallback beyond a few hundred files)
+- TODO(e2e): executable permission bits (every file is committed 100644)
+- TODO(e2e): empty repositories (no base ref to branch from)
+"""
+
+from __future__ import annotations
+
+import base64
+from pathlib import Path
+from typing import Any
+
+from sbxloop.engine.model import artifact_files
+from sbxloop.errors import DeliveryError
+from sbxloop.gh.ops import GithubOps, PrRef
+
+FILE_MODE = "100644"
+BODY_FILE_LIST_CAP = 50
+TITLE_CLIP = 72
+
+
+def branch_name(run_id: str) -> str:
+    return f"sbxloop/{run_id}"
+
+
+def deliver_workspace(
+    ops: GithubOps,
+    repo: str,
+    *,
+    run_id: str,
+    outcome: str,
+    source_dir: Path,
+    base: str | None = None,
+    draft: bool = False,
+) -> PrRef:
+    """Publish source_dir as one commit on a new branch and open a PR."""
+    files = artifact_files(source_dir)
+    if not files:
+        raise DeliveryError(f"nothing to deliver: no files in {source_dir}")
+
+    if base is None:
+        base = str(ops.repo_get(repo).get("default_branch") or "main")
+    base_sha = _base_commit_sha(ops, repo, base)
+    base_tree = _commit_tree_sha(ops, repo, base_sha)
+
+    entries = [
+        {
+            "path": file.relative_to(source_dir).as_posix(),
+            "mode": FILE_MODE,
+            "type": "blob",
+            "sha": _create_blob(ops, repo, file),
+        }
+        for file in files
+    ]
+    tree = _sha(
+        ops.raw("POST", f"/repos/{repo}/git/trees", {"base_tree": base_tree, "tree": entries}),
+        f"tree for {repo}",
+    )
+    commit = _sha(
+        ops.raw(
+            "POST",
+            f"/repos/{repo}/git/commits",
+            {
+                "message": f"sbxloop run {run_id}: deliver artifacts\n\nOutcome: {outcome}",
+                "tree": tree,
+                "parents": [base_sha],
+            },
+        ),
+        f"commit for {repo}",
+    )
+    branch = branch_name(run_id)
+    ops.raw("POST", f"/repos/{repo}/git/refs", {"ref": f"refs/heads/{branch}", "sha": commit})
+
+    return ops.pr_create(
+        repo,
+        base=base,
+        head=branch,
+        title=_title(outcome),
+        body=_body(run_id, outcome, source_dir, files),
+        draft=draft,
+    )
+
+
+def _base_commit_sha(ops: GithubOps, repo: str, base: str) -> str:
+    ref = ops.raw("GET", f"/repos/{repo}/git/ref/heads/{base}")
+    try:
+        return str(ref["object"]["sha"])
+    except (TypeError, KeyError) as exc:
+        raise DeliveryError(f"cannot resolve base branch {base!r} of {repo}") from exc
+
+
+def _commit_tree_sha(ops: GithubOps, repo: str, commit_sha: str) -> str:
+    commit = ops.raw("GET", f"/repos/{repo}/git/commits/{commit_sha}")
+    try:
+        return str(commit["tree"]["sha"])
+    except (TypeError, KeyError) as exc:
+        raise DeliveryError(f"cannot read base commit {commit_sha} of {repo}") from exc
+
+
+def _create_blob(ops: GithubOps, repo: str, file: Path) -> str:
+    content = base64.b64encode(file.read_bytes()).decode("ascii")
+    return _sha(
+        ops.raw("POST", f"/repos/{repo}/git/blobs", {"content": content, "encoding": "base64"}),
+        f"blob for {file.name}",
+    )
+
+
+def _sha(response: Any, what: str) -> str:
+    sha = response.get("sha") if isinstance(response, dict) else None
+    if not sha:
+        raise DeliveryError(f"GitHub returned no sha creating {what}: {response!r}")
+    return str(sha)
+
+
+def _title(outcome: str) -> str:
+    title = f"sbxloop: {outcome}"
+    return title if len(title) <= TITLE_CLIP else title[: TITLE_CLIP - 1] + "…"
+
+
+def _body(run_id: str, outcome: str, source_dir: Path, files: list[Path]) -> str:
+    listed = [f"- `{f.relative_to(source_dir).as_posix()}`" for f in files[:BODY_FILE_LIST_CAP]]
+    if len(files) > BODY_FILE_LIST_CAP:
+        listed.append(f"- … +{len(files) - BODY_FILE_LIST_CAP} more")
+    return (
+        f"Artifacts produced by sbxloop run `{run_id}`.\n\n"
+        f"**Outcome:** {outcome}\n\n"
+        f"**Files ({len(files)}):**\n" + "\n".join(listed) + "\n"
+    )

{sbxloop-0.3.0 → sbxloop-0.4.1}/src/sbxloop/engine/engine.py

@@ -20,6 +20,7 @@ import time
 from collections.abc import Callable, Sequence
 
 from sbxloop.config import Config, load_config, load_dotenv_file
+from sbxloop.deliver import deliver_workspace
 from sbxloop.engine.model import (
     RESUMABLE_RUN_STATES,
     RunResult,
@@ -29,7 +30,14 @@ from sbxloop.engine.model import (
 )
 from sbxloop.engine.phases import PhaseRunner, clip
 from sbxloop.engine.store import StateStore
-from sbxloop.errors import BudgetExceededError, SbxError, SdxloopError, StateError
+from sbxloop.errors import (
+    BudgetExceededError,
+    DeliveryError,
+    GithubOpsError,
+    SbxError,
+    SdxloopError,
+    StateError,
+)
 from sbxloop.events import EventBus, Hook, HostEventTypes
 from sbxloop.gh.ops import GithubOps
 from sbxloop.gh.reporter import GithubReporterHook
@@ -115,15 +123,20 @@ class LoopEngine:
                     transport=self.config.worker_transport,
                     python=self.worker_python,
                 )
-                github = WorkerClient(
-                    pair.github,
-                    self.bus,
-                    transport=self.config.worker_transport,
-                    python=self.worker_python,
+                github = (
+                    WorkerClient(
+                        pair.github,
+                        self.bus,
+                        transport=self.config.worker_transport,
+                        python=self.worker_python,
+                    )
+                    if pair.github is not None
+                    else None
                 )
                 if self.install_workers:
                     agent.install(extras="copilot")
-                    github.install(extras="")
+                    if github is not None:
+                        github.install(extras="")
                 detach = self._attach_reporter(github, run_id)
                 try:
                     phases = PhaseRunner(
@@ -136,6 +149,8 @@ class LoopEngine:
                     # alive here, and partial artifacts beat none.
                     self._harvest(run_id, pair)
                     self._report_artifacts(run_id, pair)
+                if state == "completed":
+                    self._deliver(run_id, outcome, pair, github)
         except SdxloopError:
             # State is already persisted; the exception is the kill signal.
             raise
@@ -150,11 +165,12 @@ class LoopEngine:
             mounted=pair.mounted,
         )
 
-    def _attach_reporter(self, github: WorkerClient, run_id: str) -> Callable[[], None]:
-        repo = self.config.github.report_repo
-        if not repo:
+    def _attach_reporter(self, github: WorkerClient | None, run_id: str) -> Callable[[], None]:
+        gh = self.config.github
+        if not gh.report or github is None:
             return lambda: None
-        hook = GithubReporterHook(GithubOps(github, run_id), repo)
+        assert gh.repo is not None  # report=True without a repo cannot provision a github worker
+        hook = GithubReporterHook(GithubOps(github, run_id), gh.repo)
         return self.bus.attach_hook(hook)
 
     def _harvest(self, run_id: str, pair: SandboxPair) -> None:
@@ -190,6 +206,44 @@ class LoopEngine:
             mounted=pair.mounted,
         )
 
+    def _deliver(
+        self, run_id: str, outcome: str, pair: SandboxPair, github: WorkerClient | None
+    ) -> None:
+        """Publish the completed run's artifacts as a PR to the configured
+        [github].repo when delivery is enabled. The run has already
+        succeeded — delivery failure is loud (run.deliver event with the
+        error) but never changes the run state.
+        """
+        gh = self.config.github
+        repo = gh.repo
+        if not gh.deliver or not repo or github is None:
+            return
+        source = (
+            pair.workspace
+            if pair.mounted
+            else self.config.state_dir / "runs" / run_id / "artifacts"
+        )
+        if source is None or not source.is_dir():
+            self.bus.emit(
+                HostEventTypes.RUN_DELIVER, run_id, repo=repo, error="no artifacts directory"
+            )
+            return
+        try:
+            pr = deliver_workspace(
+                GithubOps(github, run_id),
+                repo,
+                run_id=run_id,
+                outcome=outcome,
+                source_dir=source,
+                base=gh.deliver_base,
+                draft=gh.deliver_draft,
+            )
+        except (DeliveryError, GithubOpsError) as exc:
+            logger.warning("delivery to %s failed for run %s", repo, run_id, exc_info=True)
+            self.bus.emit(HostEventTypes.RUN_DELIVER, run_id, repo=repo, error=str(exc))
+            return
+        self.bus.emit(HostEventTypes.RUN_DELIVER, run_id, repo=repo, pr=pr.number, url=pr.url)
+
     def _run_phases(
         self, run_id: str, phases: PhaseRunner, deadline: float, pair: SandboxPair
     ) -> RunState:

{sbxloop-0.3.0 → sbxloop-0.4.1}/src/sbxloop/engine/model.py

@@ -158,6 +158,16 @@ class RunResult(_Model):
         return self.state == "completed"
 
 
+def artifact_files(root: Path) -> list[Path]:
+    """Regular files under root, hidden files/dirs excluded (an agent's .git
+    would otherwise swamp listings and deliveries), sorted for stable output."""
+    return sorted(
+        p
+        for p in root.rglob("*")
+        if p.is_file() and not any(part.startswith(".") for part in p.relative_to(root).parts)
+    )
+
+
 def artifacts_dir(run: RunRecord | RunResult, state_dir: Path) -> Path | None:
     """The single host directory holding a run's artifacts.
 

{sbxloop-0.3.0 → sbxloop-0.4.1}/src/sbxloop/errors.py

@@ -65,6 +65,10 @@ class GithubOpsError(SdxloopError):
     """A GitHub operation failed in the github-ops sandbox."""
 
 
+class DeliveryError(SdxloopError):
+    """Delivering a run's workspace as a GitHub PR failed."""
+
+
 class BudgetExceededError(SdxloopError):
     """A run or task exhausted one of its budgets."""
 

{sbxloop-0.3.0 → sbxloop-0.4.1}/src/sbxloop/events.py

@@ -74,6 +74,7 @@ class HostEventTypes:
     RUN_START = "run.start"
     RUN_STATE = "run.state"
     RUN_ARTIFACTS = "run.artifacts"
+    RUN_DELIVER = "run.deliver"
     RUN_END = "run.end"
     TASK_START = "task.start"
     TASK_STATE = "task.state"

{sbxloop-0.3.0 → sbxloop-0.4.1}/src/sbxloop/gh/reporter.py

@@ -1,7 +1,8 @@
 """GithubReporterHook: mirrors run progress to a GitHub tracking issue.
 
-The default consumer of the github-ops sandbox. When ``github.report_repo``
-is configured, the hook opens a tracking issue at run start, comments as
+The default consumer of the github-ops sandbox. When the GitHub integration
+is configured (``[github].repo``) and reporting is enabled (``report = true``
+or ``--report``), the hook opens a tracking issue at run start, comments as
 tasks finish, and posts a final summary at run end. It never raises — a
 reporting failure must not fail a run — and the EventBus isolates it anyway.
 """

{sbxloop-0.3.0 → sbxloop-0.4.1}/src/sbxloop/sbx/pair.py

@@ -1,7 +1,10 @@
 """SandboxPair — the core sbxloop primitive — and its cleanup guarantees.
 
-A run's pair consists of the agent sandbox (COPILOT_GITHUB_TOKEN only) and
-the github-ops sandbox (GH_TOKEN only). The pair is a context manager whose
+A run's pair consists of the agent sandbox (COPILOT_GITHUB_TOKEN only) and,
+when the GitHub integration is configured (``[github].repo``), the
+github-ops sandbox (GH_TOKEN only) — otherwise ``pair.github`` is None and
+no GitHub capability exists anywhere in the run. The pair is a context
+manager whose
 exit stops and removes both sandboxes unless ``keep`` is set; a process-wide
 registry additionally cleans up on interpreter exit and on SIGINT/SIGTERM,
 so aborted runs do not leak microVMs.
@@ -28,7 +31,7 @@ class SandboxPair:
         self,
         run_id: str,
         agent: Sandbox,
-        github: Sandbox,
+        github: Sandbox | None = None,
         *,
         keep: bool = False,
         workspace: Path | None = None,
@@ -64,12 +67,14 @@ class SandboxPair:
             self.cleanup()
 
     def cleanup(self) -> None:
-        """Stop and remove both sandboxes. Idempotent, best-effort per sandbox."""
+        """Stop and remove the pair's sandboxes. Idempotent, best-effort each."""
         if self._cleaned:
             return
         self._cleaned = True
         cleanup_registry.unregister(self)
         for sandbox in (self.agent, self.github):
+            if sandbox is None:
+                continue
             try:
                 sandbox.stop()
             except Exception:

{sbxloop-0.3.0 → sbxloop-0.4.1}/src/sbxloop/sbx/provision.py

@@ -7,7 +7,9 @@ The credential split is enforced here:
   token-exchange host — the value never enters the VM under the default
   ``proxy`` strategy.
 - **github sandbox** gets only ``GH_TOKEN`` via sbx's built-in ``github``
-  secret service (scoped to github.com hosts).
+  secret service (scoped to github.com hosts). It is provisioned only when
+  the GitHub integration is configured (``[github].repo``); otherwise runs
+  have no GitHub capability and GH_TOKEN is not required.
 
 The ``plain-env`` fallback strategy writes tokens to ``~/.sbxloop/env.sh``
 inside the sandbox (weaker: the value is visible in the VM) for environments
@@ -145,17 +147,22 @@ class Provisioner:
         workspace = workspace.resolve()
         workspace.mkdir(parents=True, exist_ok=True)
 
+        # The github sandbox (and its token requirement) exists only when the
+        # GitHub integration is configured; without [github].repo a run has
+        # no GitHub capability at all — and one less microVM to boot.
+        github_enabled = self.config.github.enabled
+
         # Fail fast on missing tokens before creating any microVM.
-        tokens: dict[SandboxRole, str] = {
-            "agent": self.copilot_token(),
-            "github": self.gh_token(),
-        }
+        tokens: dict[SandboxRole, str] = {"agent": self.copilot_token()}
+        if github_enabled:
+            tokens["github"] = self.gh_token()
 
         agent_spec, github_spec = self.build_specs(run_id, workspace)
+        specs = (agent_spec, github_spec) if github_enabled else (agent_spec,)
         created: list[Sandbox] = []
         try:
             sandboxes: dict[SandboxRole, Sandbox] = {}
-            for spec in (agent_spec, github_spec):
+            for spec in specs:
                 self.bus.emit("sandbox.provision_start", run_id, name=spec.name, role=spec.role)
                 self.cli.create(spec)
                 sandbox = Sandbox(self.cli, spec.name)
@@ -176,7 +183,7 @@ class Provisioner:
             return SandboxPair(
                 run_id,
                 agent=sandboxes["agent"],
-                github=sandboxes["github"],
+                github=sandboxes.get("github"),
                 keep=self.config.keep_sandboxes,
                 workspace=workspace,
                 agent_workdir=agent_workdir,