flywheel-bootstrap 0.1.9.202601271702__tar.gz → 0.1.9.202601272108__tar.gz

{flywheel_bootstrap-0.1.9.202601271702 → flywheel_bootstrap-0.1.9.202601272108}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flywheel-bootstrap
-Version: 0.1.9.202601271702
+Version: 0.1.9.202601272108
 Summary: Bootstrap runner for Flywheel provisioned GPU instances
 Project-URL: Homepage, http://paradigma.inc/
 Author: Paradigma Labs

flywheel_bootstrap-0.1.9.202601272108/bootstrap/artifacts.py

@@ -0,0 +1,101 @@
+"""Artifact manifest helpers."""
+
+from __future__ import annotations
+
+import json
+import logging
+from dataclasses import dataclass
+from enum import Enum
+from pathlib import Path
+from typing import Mapping, Sequence
+
+logger = logging.getLogger(__name__)
+
+
+class ManifestStatus(Enum):
+    """Outcome of reading the artifact manifest."""
+
+    MISSING = "missing"
+    VALID = "valid"
+    MALFORMED = "malformed"
+
+
+@dataclass
+class ManifestResult:
+    """Result of reading the artifact manifest, with diagnostic info."""
+
+    status: ManifestStatus
+    artifacts: Sequence[Mapping[str, object]]
+    error: str | None = None
+
+
+def read_manifest(manifest_path: Path) -> ManifestResult:
+    """Load artifact entries from the manifest path.
+
+    Tolerant of common LLM output variations:
+    - A well-formed JSON list is returned as-is.
+    - A dict wrapping a list (e.g. ``{"artifacts": [...]}``) is unwrapped.
+    - A single artifact dict is wrapped in a list.
+    - Truncated / invalid JSON is reported as malformed.
+    - Non-dict, non-list scalars are reported as malformed.
+
+    Returns a ``ManifestResult`` carrying the parsed artifacts, the outcome
+    status, and an optional human-readable error description for feedback.
+    """
+    if not manifest_path.exists():
+        return ManifestResult(status=ManifestStatus.MISSING, artifacts=[])
+    raw = manifest_path.read_text(encoding="utf-8")
+    if not raw.strip():
+        msg = "artifact manifest file is empty"
+        logger.warning("%s: %s", msg, manifest_path)
+        return ManifestResult(status=ManifestStatus.MALFORMED, artifacts=[], error=msg)
+    try:
+        data = json.loads(raw)
+    except json.JSONDecodeError as exc:
+        msg = f"artifact manifest contains invalid JSON: {exc}"
+        logger.warning("%s: %s", msg, manifest_path)
+        return ManifestResult(status=ManifestStatus.MALFORMED, artifacts=[], error=msg)
+    return _coerce_manifest(data, manifest_path)
+
+
+def _coerce_manifest(data: object, manifest_path: Path) -> ManifestResult:
+    """Best-effort coercion of parsed JSON into a list of artifact dicts."""
+    if isinstance(data, list):
+        return ManifestResult(status=ManifestStatus.VALID, artifacts=data)
+    if isinstance(data, dict):
+        return _unwrap_dict(data, manifest_path)
+    msg = f"artifact manifest is a {type(data).__name__}, expected a JSON list"
+    logger.warning("%s: %s", msg, manifest_path)
+    return ManifestResult(status=ManifestStatus.MALFORMED, artifacts=[], error=msg)
+
+
+def _unwrap_dict(data: dict[str, object], manifest_path: Path) -> ManifestResult:
+    """Extract an artifact list from a dict, or treat it as a single artifact."""
+    # If the dict itself looks like an artifact, treat it as one.
+    # Check this BEFORE scanning for nested lists — a single artifact dict
+    # like {"artifact_type": "text", "payload": {"items": [...]}} must not
+    # have its nested list mistakenly extracted.
+    if "artifact_type" in data:
+        msg = "artifact manifest is a single artifact dict, wrapping in list"
+        logger.warning("%s: %s", msg, manifest_path)
+        return ManifestResult(
+            status=ManifestStatus.MALFORMED, artifacts=[data], error=msg
+        )
+    # Prefer the "artifacts" key if present and is a list.
+    if "artifacts" in data and isinstance(data["artifacts"], list):
+        msg = "artifact manifest wrapped in dict with 'artifacts' key, unwrapping"
+        logger.warning("%s: %s", msg, manifest_path)
+        return ManifestResult(
+            status=ManifestStatus.MALFORMED, artifacts=data["artifacts"], error=msg
+        )
+    # Fall back to the first value that is a list.
+    for key, value in data.items():
+        if isinstance(value, list):
+            msg = f"artifact manifest wrapped in dict with '{key}' key, unwrapping"
+            logger.warning("%s: %s", msg, manifest_path)
+            return ManifestResult(
+                status=ManifestStatus.MALFORMED, artifacts=value, error=msg
+            )
+    msg = "artifact manifest is a dict with no recognisable artifact data"
+    logger.warning("%s: %s", msg, manifest_path)
+    return ManifestResult(status=ManifestStatus.MALFORMED, artifacts=[], error=msg)

{flywheel_bootstrap-0.1.9.202601271702 → flywheel_bootstrap-0.1.9.202601272108}/bootstrap/constants.py

@@ -8,6 +8,7 @@ DEFAULT_SERVER_URL = "http://localhost:8000"
 DEFAULT_RUN_ROOT = Path.home() / ".flywheel" / "runs"
 DEFAULT_ARTIFACT_MANIFEST = "flywheel_artifacts.json"
 HEARTBEAT_INTERVAL_SECONDS = 30
+MAX_ARTIFACT_RETRIES = 2
 
 # Environment variables that let the backend command override defaults.
 ENV_SERVER_URL = "FLYWHEEL_SERVER"

{flywheel_bootstrap-0.1.9.202601271702 → flywheel_bootstrap-0.1.9.202601272108}/bootstrap/orchestrator.py

@@ -23,6 +23,7 @@ from bootstrap.constants import (
     ENV_RUN_TOKEN,
     ENV_SERVER_URL,
     HEARTBEAT_INTERVAL_SECONDS,
+    MAX_ARTIFACT_RETRIES,
 )
 from bootstrap.config_loader import UserConfig, load_codex_config
 from bootstrap.git_ops import GitConfig, initialize_repo, finalize_repo
@@ -30,7 +31,6 @@ from bootstrap.install import codex_login_status_ok, codex_on_path, ensure_codex
 from bootstrap.payload import BootstrapPayload, fetch_bootstrap_payload
 from bootstrap.prompts import build_prompt_text
 from bootstrap.runner import (
-    CodexInvocation,
     CodexEvent,
     build_invocation,
     run_and_stream,
@@ -42,7 +42,7 @@ from bootstrap.telemetry import (
     post_heartbeat,
     post_log,
 )
-from bootstrap.artifacts import read_manifest
+from bootstrap.artifacts import ManifestResult, ManifestStatus, read_manifest
 
 
 @dataclass
@@ -416,15 +416,20 @@ class BootstrapOrchestrator:
         return exit_code
 
     def _collect_and_post_artifacts(self, exit_code: int) -> None:
-        """Read manifest (and optional resume attempt) then POST /artifacts/complete/error."""
+        """Read manifest (and optional resume attempts) then POST /artifacts/complete/error."""
         assert self.workspace is not None
         manifest_path = self.workspace / self.config.artifact_manifest
-        artifacts = self._load_artifacts_with_content(manifest_path)
-
-        # Optional auto-resume once if missing
-        if not artifacts and self.codex_run_id:
-            self._attempt_resume(manifest_path)
-            artifacts = self._load_artifacts_with_content(manifest_path)
+        manifest_result, artifacts = self._load_artifacts_with_content(manifest_path)
+
+        # Auto-resume up to MAX_ARTIFACT_RETRIES times if artifacts are
+        # missing or the manifest was malformed.
+        retries = 0
+        while not artifacts and self.codex_run_id and retries < MAX_ARTIFACT_RETRIES:
+            retries += 1
+            self._attempt_artifact_retry(manifest_path, manifest_result)
+            manifest_result, artifacts = self._load_artifacts_with_content(
+                manifest_path
+            )
 
         if artifacts:
             post_artifacts(
@@ -461,7 +466,7 @@ class BootstrapOrchestrator:
 
     def _load_artifacts_with_content(
         self, manifest_path: Path
-    ) -> list[dict[str, object]]:
+    ) -> tuple[ManifestResult, list[dict[str, object]]]:
         """Load artifacts and inline content when a path is provided.
 
         For text/html artifacts, if payload includes a "path" (or "file") inside the workspace,
@@ -471,6 +476,8 @@ class BootstrapOrchestrator:
         Best-effort; failures are logged and skipped.
 
         Size limit: 2MB per artifact to prevent huge payloads.
+
+        Returns a tuple of (ManifestResult, enriched artifacts list).
         """
         import base64
         import mimetypes
@@ -478,7 +485,8 @@ class BootstrapOrchestrator:
         MAX_ARTIFACT_SIZE = 25 * 1024 * 1024  # 25MB
 
         assert self.workspace is not None
-        artifacts = read_manifest(manifest_path)
+        manifest_result = read_manifest(manifest_path)
+        artifacts = manifest_result.artifacts
         enriched: list[dict[str, object]] = []
 
         # Checkpoint file extensions (model weights, etc.)
@@ -609,7 +617,7 @@ class BootstrapOrchestrator:
             except Exception as exc:  # pragma: no cover - defensive
                 self._log(f"artifact enrichment error: {exc}", level="warning")
             enriched.append(dict(artifact))
-        return enriched
+        return manifest_result, enriched
 
     def _resolve_artifact_path(self, path_str: str) -> Path | None:
         """Resolve artifact path within workspace, returning None if invalid."""
@@ -649,34 +657,95 @@ class BootstrapOrchestrator:
             if isinstance(run_id, str):
                 self.codex_run_id = run_id
 
-    def _attempt_resume(self, manifest_path: Path) -> None:
+    def _attempt_artifact_retry(
+        self, manifest_path: Path, manifest_result: ManifestResult
+    ) -> None:
+        """Retry artifact collection via ``codex exec`` with a feedback prompt.
+
+        Both MISSING and MALFORMED manifests are handled by launching a new
+        Codex exec with a targeted prompt describing the problem and telling
+        Codex exactly what to do.  This is preferable to ``codex resume``
+        which cannot accept additional instructions.
+        """
         if not self.codex_run_id:
             return
-        codex_path = self.codex_executable or Path("codex")
-        resume_cmd = [str(codex_path), "resume", self.codex_run_id]
-        post_log(
-            self.config.server_url,
-            self.config.run_id,
-            self.config.capability_token,
-            level="info",
-            message="attempting codex resume to collect artifacts",
-            extra={"command": resume_cmd},
+
+        manifest_name = self.config.artifact_manifest
+
+        if manifest_result.status == ManifestStatus.MALFORMED:
+            error_detail = manifest_result.error or "unknown error"
+            raw_content = ""
+            if manifest_path.exists():
+                try:
+                    raw_content = manifest_path.read_text(encoding="utf-8")[:2000]
+                except Exception:
+                    raw_content = "<could not read file>"
+
+            fix_prompt = (
+                "The artifact manifest file at "
+                f"$FLYWHEEL_WORKSPACE/{manifest_name} is malformed.\n\n"
+                f"Error: {error_detail}\n\n"
+                f"Current file contents:\n{raw_content}\n\n"
+                "Please rewrite this file so it is a valid JSON list of "
+                "artifact entries. Each entry must be an object with "
+                '"artifact_type" and "payload" keys. The file must be a '
+                "top-level JSON array, for example:\n"
+                "[\n"
+                '  {"artifact_type": "text", "payload": {"content": "..."}},\n'
+                '  {"artifact_type": "image", "payload": {"path": "plot.png",'
+                ' "format": "png"}}\n'
+                "]\n\n"
+                "Do NOT wrap the list in an object. The file must start with "
+                "[ and end with ].\n"
+                "Only fix the manifest format — do not change the actual "
+                "artifact content or paths."
+            )
+            log_msg = "attempting codex exec to fix malformed artifact manifest"
+        else:
+            # MISSING — the file was never written.
+            fix_prompt = (
+                "The artifact manifest file was not found at "
+                f"$FLYWHEEL_WORKSPACE/{manifest_name}.\n\n"
+                "Your task already completed successfully, but the manifest "
+                "file is missing. Please write the manifest now.\n\n"
+                "The file must be a valid JSON list of artifact entries. "
+                'Each entry must be an object with "artifact_type" and '
+                '"payload" keys. The file must be a top-level JSON array, '
+                "for example:\n"
+                "[\n"
+                '  {"artifact_type": "text", "payload": {"content": "..."}},\n'
+                '  {"artifact_type": "image", "payload": {"path": "plot.png",'
+                ' "format": "png"}}\n'
+                "]\n\n"
+                "Do NOT wrap the list in an object. The file must start with "
+                "[ and end with ].\n"
+                "Look at the files you produced in the workspace and create "
+                "the manifest based on what you find."
+            )
+            log_msg = "attempting codex exec to write missing artifact manifest"
+
+        self._log(
+            log_msg,
+            extra={
+                "status": manifest_result.status.value,
+                "error": manifest_result.error,
+            },
         )
+
+        codex_path = self.codex_executable or Path("codex")
         try:
-            run_and_stream(
-                CodexInvocation(
-                    args=resume_cmd,
-                    env={},
-                    workdir=self.workspace or Path("."),
-                )
+            invocation = build_invocation(
+                codex_executable=codex_path,
+                prompt=fix_prompt,
+                workdir=self.workspace or Path("."),
+                env=os.environ.copy(),
             )
+            for event in run_and_stream(invocation):
+                self._handle_event(event)
         except Exception as exc:  # pragma: no cover
-            post_log(
-                self.config.server_url,
-                self.config.run_id,
-                self.config.capability_token,
+            self._log(
+                "codex artifact retry failed",
                 level="error",
-                message="codex resume failed",
                 extra={"error": repr(exc)},
             )
 

{flywheel_bootstrap-0.1.9.202601271702 → flywheel_bootstrap-0.1.9.202601272108}/bootstrap/prompts.py

@@ -25,8 +25,18 @@ def build_prompt_text(
         ARTIFACT MANIFEST (CRITICAL):
         - The environment variable $FLYWHEEL_WORKSPACE contains the absolute path to your workspace root.
         - When finished, write the manifest to: $FLYWHEEL_WORKSPACE/{artifact_manifest}
+        - The manifest MUST be a top-level JSON array (list). Do NOT wrap it in an object.
         - All file paths in the manifest must be relative to $FLYWHEEL_WORKSPACE.
-        - Each entry must include "artifact_type" and "payload".
+        - Each entry must be an object with "artifact_type" and "payload" keys.
+
+        MANIFEST FORMAT — the file must look exactly like this (a JSON array):
+        [
+          {{"artifact_type": "text", "payload": {{"content": "Summary of results..."}}}},
+          {{"artifact_type": "image", "payload": {{"path": "plots/loss_curve.png", "format": "png"}}}},
+          {{"artifact_type": "table", "payload": {{"path": "results/metrics.csv", "format": "csv"}}}}
+        ]
+
+        IMPORTANT: The file must start with [ and end with ]. Do NOT write {{"artifacts": [...]}} or any other wrapper object.
 
         SUPPORTED ARTIFACT TYPES (use ONLY these):
         - "text": For text/markdown. Payload: {{"content": "..."}} or {{"path": "path/to/file.txt"}}

{flywheel_bootstrap-0.1.9.202601271702 → flywheel_bootstrap-0.1.9.202601272108}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "flywheel-bootstrap"
-version = "0.1.9.202601271702"
+version = "0.1.9.202601272108"
 description = "Bootstrap runner for Flywheel provisioned GPU instances"
 readme = "README.md"
 requires-python = ">=3.11"

flywheel_bootstrap-0.1.9.202601272108/tests/test_artifacts.py

@@ -0,0 +1,154 @@
+"""Unit tests for artifact manifest parsing – defensive handling."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+from bootstrap.artifacts import ManifestStatus, read_manifest
+
+
+class TestReadManifestDefensive:
+    """read_manifest should tolerate common LLM output variations."""
+
+    def test_valid_list(self, tmp_path: Path) -> None:
+        """A well-formed JSON list is returned as-is."""
+        manifest = tmp_path / "manifest.json"
+        entries = [{"artifact_type": "text", "payload": {"content": "hi"}}]
+        manifest.write_text(json.dumps(entries), encoding="utf-8")
+
+        result = read_manifest(manifest)
+        assert list(result.artifacts) == entries
+        assert result.status == ManifestStatus.VALID
+        assert result.error is None
+
+    def test_missing_file_returns_empty(self, tmp_path: Path) -> None:
+        """Non-existent manifest returns MISSING status."""
+        result = read_manifest(tmp_path / "nope.json")
+        assert list(result.artifacts) == []
+        assert result.status == ManifestStatus.MISSING
+
+    def test_dict_with_artifacts_key(self, tmp_path: Path) -> None:
+        """LLM wraps the list in {"artifacts": [...]}, we unwrap it."""
+        manifest = tmp_path / "manifest.json"
+        entries = [{"artifact_type": "text", "payload": {"content": "hi"}}]
+        manifest.write_text(json.dumps({"artifacts": entries}), encoding="utf-8")
+
+        result = read_manifest(manifest)
+        assert list(result.artifacts) == entries
+        assert result.status == ManifestStatus.MALFORMED
+        assert result.error is not None
+
+    def test_dict_with_other_list_key(self, tmp_path: Path) -> None:
+        """Dict wrapping with an arbitrary key containing a list is unwrapped."""
+        manifest = tmp_path / "manifest.json"
+        entries = [{"artifact_type": "text", "payload": {"content": "x"}}]
+        manifest.write_text(json.dumps({"results": entries}), encoding="utf-8")
+
+        result = read_manifest(manifest)
+        assert list(result.artifacts) == entries
+        assert result.status == ManifestStatus.MALFORMED
+
+    def test_dict_single_artifact_wrapped_in_list(self, tmp_path: Path) -> None:
+        """A single artifact dict (not in a list) gets wrapped."""
+        manifest = tmp_path / "manifest.json"
+        entry = {"artifact_type": "text", "payload": {"content": "single"}}
+        manifest.write_text(json.dumps(entry), encoding="utf-8")
+
+        result = read_manifest(manifest)
+        assert list(result.artifacts) == [entry]
+        assert result.status == ManifestStatus.MALFORMED
+
+    def test_dict_with_artifact_type_takes_priority_over_nested_list(
+        self, tmp_path: Path
+    ) -> None:
+        """A dict with artifact_type is treated as a single artifact even if it has nested lists."""
+        manifest = tmp_path / "manifest.json"
+        entry = {
+            "artifact_type": "text",
+            "payload": {"content": "hi", "items": ["a", "b"]},
+        }
+        manifest.write_text(json.dumps(entry), encoding="utf-8")
+
+        result = read_manifest(manifest)
+        assert list(result.artifacts) == [entry]
+        assert result.status == ManifestStatus.MALFORMED
+
+    def test_dict_with_multiple_list_values_prefers_artifacts_key(
+        self, tmp_path: Path
+    ) -> None:
+        """When dict has no artifact_type and multiple list values, prefer 'artifacts' key."""
+        manifest = tmp_path / "manifest.json"
+        entries = [{"artifact_type": "text", "payload": {"content": "a"}}]
+        other = [{"something": "else"}]
+        manifest.write_text(
+            json.dumps({"artifacts": entries, "other": other}), encoding="utf-8"
+        )
+
+        result = read_manifest(manifest)
+        assert list(result.artifacts) == entries
+
+    def test_dict_with_no_list_values_is_single_artifact(self, tmp_path: Path) -> None:
+        """A dict with artifact_type but no list values is treated as a single artifact."""
+        manifest = tmp_path / "manifest.json"
+        entry = {"artifact_type": "text", "payload": {"content": "solo"}}
+        manifest.write_text(json.dumps(entry), encoding="utf-8")
+
+        result = read_manifest(manifest)
+        assert list(result.artifacts) == [entry]
+
+    def test_truncated_json_is_malformed(self, tmp_path: Path) -> None:
+        """Truncated/invalid JSON is reported as malformed."""
+        manifest = tmp_path / "manifest.json"
+        manifest.write_text('[{"artifact_type": "text", "pay', encoding="utf-8")
+
+        result = read_manifest(manifest)
+        assert list(result.artifacts) == []
+        assert result.status == ManifestStatus.MALFORMED
+        assert result.error is not None
+        assert "invalid JSON" in result.error
+
+    def test_empty_file_is_malformed(self, tmp_path: Path) -> None:
+        """An empty file is reported as malformed."""
+        manifest = tmp_path / "manifest.json"
+        manifest.write_text("", encoding="utf-8")
+
+        result = read_manifest(manifest)
+        assert list(result.artifacts) == []
+        assert result.status == ManifestStatus.MALFORMED
+
+    def test_non_json_content_is_malformed(self, tmp_path: Path) -> None:
+        """Non-JSON content is reported as malformed."""
+        manifest = tmp_path / "manifest.json"
+        manifest.write_text("this is not json at all", encoding="utf-8")
+
+        result = read_manifest(manifest)
+        assert list(result.artifacts) == []
+        assert result.status == ManifestStatus.MALFORMED
+
+    def test_empty_list(self, tmp_path: Path) -> None:
+        """An empty JSON list is VALID (just no artifacts)."""
+        manifest = tmp_path / "manifest.json"
+        manifest.write_text("[]", encoding="utf-8")
+
+        result = read_manifest(manifest)
+        assert list(result.artifacts) == []
+        assert result.status == ManifestStatus.VALID
+
+    def test_empty_dict_is_malformed(self, tmp_path: Path) -> None:
+        """An empty dict is reported as malformed."""
+        manifest = tmp_path / "manifest.json"
+        manifest.write_text("{}", encoding="utf-8")
+
+        result = read_manifest(manifest)
+        assert list(result.artifacts) == []
+        assert result.status == ManifestStatus.MALFORMED
+
+    def test_scalar_value_is_malformed(self, tmp_path: Path) -> None:
+        """A scalar JSON value (string, number) is reported as malformed."""
+        manifest = tmp_path / "manifest.json"
+        manifest.write_text('"just a string"', encoding="utf-8")
+
+        result = read_manifest(manifest)
+        assert list(result.artifacts) == []
+        assert result.status == ManifestStatus.MALFORMED

flywheel_bootstrap-0.1.9.202601272108/tests/test_orchestrator.py

@@ -0,0 +1,416 @@
+from __future__ import annotations
+
+from typing import Any
+import pytest
+from bootstrap.artifacts import ManifestResult, ManifestStatus
+from bootstrap.config_loader import UserConfig
+from bootstrap.orchestrator import BootstrapConfig, BootstrapOrchestrator
+from bootstrap.payload import BootstrapPayload
+from bootstrap.runner import CodexInvocation, CodexEvent
+
+
+def test_orchestrator_happy_path(monkeypatch, tmp_path):
+    """End-to-end orchestration with fakes: no real network or codex."""
+
+    workspace = tmp_path / "work"
+    artifacts = [{"artifact_type": "text", "payload": {"content": "hi"}}]
+    captured_env: dict[str, str] = {}
+    captured_extra_flags: tuple[str, ...] = ()
+
+    # Prepare a dummy config file
+    cfg_file = tmp_path / "config.toml"
+    cfg_file.write_text("", encoding="utf-8")
+
+    # Telemetry collectors
+    heartbeats: list[dict[str, Any]] = []
+    logs: list[dict[str, Any]] = []
+    posted_artifacts: list[dict[str, Any]] = []
+    completions: list[dict[str, Any]] = []
+    errors: list[dict[str, Any]] = []
+
+    monkeypatch.setattr(
+        "bootstrap.orchestrator.load_codex_config",
+        lambda path: UserConfig(
+            raw={},
+            working_dir=workspace,
+            sandbox_mode=None,
+            approval_policy="unless-allow-listed",
+            oss_provider=None,
+            writable_roots=(workspace,),
+            workspace_instructions="use workspace",
+            instructions_source="inline",
+            warnings=(),
+        ),
+    )
+    monkeypatch.setattr("bootstrap.orchestrator.codex_on_path", lambda: True)
+    monkeypatch.setattr(
+        "bootstrap.orchestrator.codex_login_status_ok", lambda _path: True
+    )
+    monkeypatch.setattr(
+        "bootstrap.orchestrator.fetch_bootstrap_payload",
+        lambda server_url, run_id, token: BootstrapPayload(prompt="PROMPT"),
+    )
+
+    def fake_build_invocation(codex_executable, prompt, workdir, env, extra_flags=()):
+        captured_env.update(env)
+        nonlocal captured_extra_flags
+        captured_extra_flags = tuple(extra_flags)
+        return CodexInvocation(args=["codex", "exec"], env=env, workdir=workdir)
+
+    def fake_run_and_stream(invocation):
+        invocation.exit_code = 0
+        yield CodexEvent(raw={"run_id": "codex-run-1"})
+        yield CodexEvent(raw={"message": "ok"})
+
+    monkeypatch.setattr(
+        "bootstrap.orchestrator.build_invocation", fake_build_invocation
+    )
+    monkeypatch.setattr("bootstrap.orchestrator.run_and_stream", fake_run_and_stream)
+    monkeypatch.setattr(
+        "bootstrap.orchestrator.read_manifest",
+        lambda path: ManifestResult(status=ManifestStatus.VALID, artifacts=artifacts),
+    )
+
+    monkeypatch.setattr(
+        "bootstrap.orchestrator.post_heartbeat",
+        lambda server_url, run_id, token, summary: heartbeats.append(
+            {"summary": summary}
+        ),
+    )
+    monkeypatch.setattr(
+        "bootstrap.orchestrator.post_log",
+        lambda server_url, run_id, token, level, message, extra: logs.append(
+            {"level": level, "message": message}
+        ),
+    )
+    monkeypatch.setattr(
+        "bootstrap.orchestrator.post_artifacts",
+        lambda server_url, run_id, token, entries: posted_artifacts.extend(entries),
+    )
+    monkeypatch.setattr(
+        "bootstrap.orchestrator.post_completion",
+        lambda server_url, run_id, token, summary: completions.append(
+            {"summary": summary}
+        ),
+    )
+    monkeypatch.setattr(
+        "bootstrap.orchestrator.post_error",
+        lambda server_url, run_id, token, reason, summary=None: errors.append(
+            {"reason": reason, "summary": summary}
+        ),
+    )
+
+    cfg = BootstrapConfig(
+        run_id="run-123",
+        capability_token="secret",
+        config_path=cfg_file,
+        server_url="http://server",
+        run_root=tmp_path,
+    )
+    orchestrator = BootstrapOrchestrator(cfg)
+    code = orchestrator.run()
+
+    assert code == 0
+    assert heartbeats, "expected at least one heartbeat"
+    assert logs, "expected log forwarding"
+    assert posted_artifacts == artifacts
+    assert completions and not errors
+    assert "PATH" in captured_env
+    assert captured_env.get("FLYWHEEL_RUN_ID") == "run-123"
+    assert captured_env.get("FLYWHEEL_RUN_TOKEN") == "secret"
+    assert captured_env.get("FLYWHEEL_SERVER") == "http://server"
+    assert "CODEX_HOME" in captured_env
+    # With sandbox_mode=None, no sandbox flags should be added
+    assert len(captured_extra_flags) == 0
+
+
+def test_resolve_workspace_rejects_outside_writable(monkeypatch, tmp_path):
+    cfg_file = tmp_path / "config.toml"
+    cfg_file.write_text("", encoding="utf-8")
+
+    orchestrator = BootstrapOrchestrator(
+        BootstrapConfig(
+            run_id="run-1",
+            capability_token="token",
+            config_path=cfg_file,
+            server_url="http://server",
+            run_root=tmp_path,
+        )
+    )
+    orchestrator.user_config = UserConfig(
+        raw={},
+        working_dir=tmp_path / "work",
+        sandbox_mode="workspace-write",
+        approval_policy="unless-allow-listed",
+        oss_provider=None,
+        writable_roots=(tmp_path / "other",),
+        workspace_instructions="instr",
+        instructions_source="inline",
+        warnings=(),
+    )
+
+    with pytest.raises(SystemExit):
+        orchestrator._resolve_workspace()
+
+
+def test_resolve_workspace_expands_run_id_placeholder(tmp_path) -> None:
+    cfg_file = tmp_path / "config.toml"
+    cfg_file.write_text("", encoding="utf-8")
+
+    orchestrator = BootstrapOrchestrator(
+        BootstrapConfig(
+            run_id="run-xyz",
+            capability_token="token",
+            config_path=cfg_file,
+            server_url="http://server",
+            run_root=tmp_path,
+        )
+    )
+
+    templated = tmp_path / "runs" / "<run_id>"
+    orchestrator.user_config = UserConfig(
+        raw={},
+        working_dir=templated,
+        sandbox_mode="workspace-write",
+        approval_policy="unless-allow-listed",
+        oss_provider=None,
+        writable_roots=(tmp_path,),
+        workspace_instructions="instr",
+        instructions_source="inline",
+        warnings=(),
+    )
+
+    orchestrator._resolve_workspace()
+    assert orchestrator.workspace == (tmp_path / "runs" / "run-xyz").resolve()
+
+
+def test_malformed_manifest_triggers_two_retry_attempts(monkeypatch, tmp_path):
+    """When manifest is malformed, the orchestrator retries up to 2 times with feedback."""
+
+    workspace = tmp_path / "work"
+    good_artifacts = [{"artifact_type": "text", "payload": {"content": "hi"}}]
+
+    cfg_file = tmp_path / "config.toml"
+    cfg_file.write_text("", encoding="utf-8")
+
+    heartbeats: list[dict[str, Any]] = []
+    logs: list[dict[str, Any]] = []
+    posted_artifacts: list[dict[str, Any]] = []
+    completions: list[dict[str, Any]] = []
+    errors: list[dict[str, Any]] = []
+
+    monkeypatch.setattr(
+        "bootstrap.orchestrator.load_codex_config",
+        lambda path: UserConfig(
+            raw={},
+            working_dir=workspace,
+            sandbox_mode=None,
+            approval_policy="unless-allow-listed",
+            oss_provider=None,
+            writable_roots=(workspace,),
+            workspace_instructions="use workspace",
+            instructions_source="inline",
+            warnings=(),
+        ),
+    )
+    monkeypatch.setattr("bootstrap.orchestrator.codex_on_path", lambda: True)
+    monkeypatch.setattr(
+        "bootstrap.orchestrator.codex_login_status_ok", lambda _path: True
+    )
+    monkeypatch.setattr(
+        "bootstrap.orchestrator.fetch_bootstrap_payload",
+        lambda server_url, run_id, token: BootstrapPayload(prompt="PROMPT"),
+    )
+
+    def fake_build_invocation(codex_executable, prompt, workdir, env, extra_flags=()):
+        return CodexInvocation(args=["codex", "exec"], env=env, workdir=workdir)
+
+    def fake_run_and_stream(invocation):
+        invocation.exit_code = 0
+        yield CodexEvent(raw={"run_id": "codex-run-1"})
+        yield CodexEvent(raw={"message": "ok"})
+
+    monkeypatch.setattr(
+        "bootstrap.orchestrator.build_invocation", fake_build_invocation
+    )
+    monkeypatch.setattr("bootstrap.orchestrator.run_and_stream", fake_run_and_stream)
+
+    calls = {"manifest": 0, "retry": 0}
+
+    def fake_read_manifest(path):
+        calls["manifest"] += 1
+        # First two reads return malformed, third returns good data
+        if calls["manifest"] <= 2:
+            return ManifestResult(
+                status=ManifestStatus.MALFORMED,
+                artifacts=[],
+                error="artifact manifest wrapped in dict",
+            )
+        return ManifestResult(status=ManifestStatus.VALID, artifacts=good_artifacts)
+
+    monkeypatch.setattr("bootstrap.orchestrator.read_manifest", fake_read_manifest)
+
+    def fake_attempt_artifact_retry(self, manifest_path, manifest_result):
+        calls["retry"] += 1
+
+    monkeypatch.setattr(
+        "bootstrap.orchestrator.BootstrapOrchestrator._attempt_artifact_retry",
+        fake_attempt_artifact_retry,
+    )
+
+    monkeypatch.setattr("bootstrap.orchestrator.HEARTBEAT_INTERVAL_SECONDS", 0.01)
+    monkeypatch.setattr(
+        "bootstrap.orchestrator.post_heartbeat",
+        lambda server_url, run_id, token, summary: heartbeats.append(
+            {"summary": summary}
+        ),
+    )
+    monkeypatch.setattr(
+        "bootstrap.orchestrator.post_log",
+        lambda server_url, run_id, token, level, message, extra: logs.append(
+            {"level": level, "message": message}
+        ),
+    )
+    monkeypatch.setattr(
+        "bootstrap.orchestrator.post_artifacts",
+        lambda server_url, run_id, token, entries: posted_artifacts.extend(entries),
+    )
+    monkeypatch.setattr(
+        "bootstrap.orchestrator.post_completion",
+        lambda server_url, run_id, token, summary: completions.append(
+            {"summary": summary}
+        ),
+    )
+    monkeypatch.setattr(
+        "bootstrap.orchestrator.post_error",
+        lambda server_url, run_id, token, reason, summary=None: errors.append(
+            {"reason": reason, "summary": summary}
+        ),
+    )
+
+    cfg = BootstrapConfig(
+        run_id="run-456",
+        capability_token="secret",
+        config_path=cfg_file,
+        server_url="http://server",
+        run_root=tmp_path,
+    )
+    orchestrator = BootstrapOrchestrator(cfg)
+    code = orchestrator.run()
+
+    assert code == 0
+    # Should have attempted retry twice (max retries = 2)
+    assert calls["retry"] == 2
+    # manifest read: initial + after 1st retry + after 2nd retry = 3
+    assert calls["manifest"] == 3
+    assert posted_artifacts == good_artifacts
+    assert completions and not errors
+
+
+def test_malformed_manifest_exhausts_retries_still_completes(monkeypatch, tmp_path):
+    """When all retry attempts fail to produce artifacts, run still completes (no crash)."""
+
+    workspace = tmp_path / "work"
+
+    cfg_file = tmp_path / "config.toml"
+    cfg_file.write_text("", encoding="utf-8")
+
+    completions: list[dict[str, Any]] = []
+    errors: list[dict[str, Any]] = []
+
+    monkeypatch.setattr(
+        "bootstrap.orchestrator.load_codex_config",
+        lambda path: UserConfig(
+            raw={},
+            working_dir=workspace,
+            sandbox_mode=None,
+            approval_policy="unless-allow-listed",
+            oss_provider=None,
+            writable_roots=(workspace,),
+            workspace_instructions="use workspace",
+            instructions_source="inline",
+            warnings=(),
+        ),
+    )
+    monkeypatch.setattr("bootstrap.orchestrator.codex_on_path", lambda: True)
+    monkeypatch.setattr(
+        "bootstrap.orchestrator.codex_login_status_ok", lambda _path: True
+    )
+    monkeypatch.setattr(
+        "bootstrap.orchestrator.fetch_bootstrap_payload",
+        lambda server_url, run_id, token: BootstrapPayload(prompt="PROMPT"),
+    )
+
+    def fake_build_invocation(codex_executable, prompt, workdir, env, extra_flags=()):
+        return CodexInvocation(args=["codex", "exec"], env=env, workdir=workdir)
+
+    def fake_run_and_stream(invocation):
+        invocation.exit_code = 0
+        yield CodexEvent(raw={"run_id": "codex-run-1"})
+
+    monkeypatch.setattr(
+        "bootstrap.orchestrator.build_invocation", fake_build_invocation
+    )
+    monkeypatch.setattr("bootstrap.orchestrator.run_and_stream", fake_run_and_stream)
+
+    calls = {"retry": 0}
+
+    # Always return malformed (manifest never gets fixed)
+    monkeypatch.setattr(
+        "bootstrap.orchestrator.read_manifest",
+        lambda path: ManifestResult(
+            status=ManifestStatus.MALFORMED,
+            artifacts=[],
+            error="artifact manifest is empty",
+        ),
+    )
+
+    def fake_attempt_artifact_retry(self, manifest_path, manifest_result):
+        calls["retry"] += 1
+
+    monkeypatch.setattr(
+        "bootstrap.orchestrator.BootstrapOrchestrator._attempt_artifact_retry",
+        fake_attempt_artifact_retry,
+    )
+
+    monkeypatch.setattr("bootstrap.orchestrator.HEARTBEAT_INTERVAL_SECONDS", 0.01)
+    monkeypatch.setattr(
+        "bootstrap.orchestrator.post_heartbeat",
+        lambda server_url, run_id, token, summary: None,
+    )
+    monkeypatch.setattr(
+        "bootstrap.orchestrator.post_log",
+        lambda server_url, run_id, token, level, message, extra: None,
+    )
+    monkeypatch.setattr(
+        "bootstrap.orchestrator.post_artifacts",
+        lambda server_url, run_id, token, entries: None,
+    )
+    monkeypatch.setattr(
+        "bootstrap.orchestrator.post_completion",
+        lambda server_url, run_id, token, summary: completions.append(
+            {"summary": summary}
+        ),
+    )
+    monkeypatch.setattr(
+        "bootstrap.orchestrator.post_error",
+        lambda server_url, run_id, token, reason, summary=None: errors.append(
+            {"reason": reason, "summary": summary}
+        ),
+    )
+
+    cfg = BootstrapConfig(
+        run_id="run-789",
+        capability_token="secret",
+        config_path=cfg_file,
+        server_url="http://server",
+        run_root=tmp_path,
+    )
+    orchestrator = BootstrapOrchestrator(cfg)
+    code = orchestrator.run()
+
+    assert code == 0
+    # Exhausted all 2 retry attempts
+    assert calls["retry"] == 2
+    # Still completes (exit code was 0)
+    assert completions and not errors

flywheel_bootstrap-0.1.9.202601271702/bootstrap/artifacts.py

@@ -1,18 +0,0 @@
-"""Artifact manifest helpers (skeleton)."""
-
-from __future__ import annotations
-
-from pathlib import Path
-from typing import Mapping, Sequence
-import json
-
-
-def read_manifest(manifest_path: Path) -> Sequence[Mapping[str, object]]:
-    """Load artifact entries from the manifest path."""
-    if not manifest_path.exists():
-        return []
-    with manifest_path.open("r", encoding="utf-8") as fp:
-        data = json.load(fp)
-    if isinstance(data, list):
-        return data
-    raise ValueError("artifact manifest must be a JSON list")

flywheel_bootstrap-0.1.9.202601271702/tests/test_orchestrator.py

@@ -1,180 +0,0 @@
-from __future__ import annotations
-
-from typing import Any
-import pytest
-from bootstrap.config_loader import UserConfig
-from bootstrap.orchestrator import BootstrapConfig, BootstrapOrchestrator
-from bootstrap.payload import BootstrapPayload
-from bootstrap.runner import CodexInvocation, CodexEvent
-
-
-def test_orchestrator_happy_path(monkeypatch, tmp_path):
-    """End-to-end orchestration with fakes: no real network or codex."""
-
-    workspace = tmp_path / "work"
-    artifacts = [{"artifact_type": "text", "payload": {"content": "hi"}}]
-    captured_env: dict[str, str] = {}
-    captured_extra_flags: tuple[str, ...] = ()
-
-    # Prepare a dummy config file
-    cfg_file = tmp_path / "config.toml"
-    cfg_file.write_text("", encoding="utf-8")
-
-    # Telemetry collectors
-    heartbeats: list[dict[str, Any]] = []
-    logs: list[dict[str, Any]] = []
-    posted_artifacts: list[dict[str, Any]] = []
-    completions: list[dict[str, Any]] = []
-    errors: list[dict[str, Any]] = []
-
-    monkeypatch.setattr(
-        "bootstrap.orchestrator.load_codex_config",
-        lambda path: UserConfig(
-            raw={},
-            working_dir=workspace,
-            sandbox_mode=None,
-            approval_policy="unless-allow-listed",
-            oss_provider=None,
-            writable_roots=(workspace,),
-            workspace_instructions="use workspace",
-            instructions_source="inline",
-            warnings=(),
-        ),
-    )
-    monkeypatch.setattr("bootstrap.orchestrator.codex_on_path", lambda: True)
-    monkeypatch.setattr(
-        "bootstrap.orchestrator.codex_login_status_ok", lambda _path: True
-    )
-    monkeypatch.setattr(
-        "bootstrap.orchestrator.fetch_bootstrap_payload",
-        lambda server_url, run_id, token: BootstrapPayload(prompt="PROMPT"),
-    )
-
-    def fake_build_invocation(codex_executable, prompt, workdir, env, extra_flags=()):
-        captured_env.update(env)
-        nonlocal captured_extra_flags
-        captured_extra_flags = tuple(extra_flags)
-        return CodexInvocation(args=["codex", "exec"], env=env, workdir=workdir)
-
-    def fake_run_and_stream(invocation):
-        invocation.exit_code = 0
-        yield CodexEvent(raw={"run_id": "codex-run-1"})
-        yield CodexEvent(raw={"message": "ok"})
-
-    monkeypatch.setattr(
-        "bootstrap.orchestrator.build_invocation", fake_build_invocation
-    )
-    monkeypatch.setattr("bootstrap.orchestrator.run_and_stream", fake_run_and_stream)
-    monkeypatch.setattr("bootstrap.orchestrator.read_manifest", lambda path: artifacts)
-
-    monkeypatch.setattr(
-        "bootstrap.orchestrator.post_heartbeat",
-        lambda server_url, run_id, token, summary: heartbeats.append(
-            {"summary": summary}
-        ),
-    )
-    monkeypatch.setattr(
-        "bootstrap.orchestrator.post_log",
-        lambda server_url, run_id, token, level, message, extra: logs.append(
-            {"level": level, "message": message}
-        ),
-    )
-    monkeypatch.setattr(
-        "bootstrap.orchestrator.post_artifacts",
-        lambda server_url, run_id, token, entries: posted_artifacts.extend(entries),
-    )
-    monkeypatch.setattr(
-        "bootstrap.orchestrator.post_completion",
-        lambda server_url, run_id, token, summary: completions.append(
-            {"summary": summary}
-        ),
-    )
-    monkeypatch.setattr(
-        "bootstrap.orchestrator.post_error",
-        lambda server_url, run_id, token, reason, summary=None: errors.append(
-            {"reason": reason, "summary": summary}
-        ),
-    )
-
-    cfg = BootstrapConfig(
-        run_id="run-123",
-        capability_token="secret",
-        config_path=cfg_file,
-        server_url="http://server",
-        run_root=tmp_path,
-    )
-    orchestrator = BootstrapOrchestrator(cfg)
-    code = orchestrator.run()
-
-    assert code == 0
-    assert heartbeats, "expected at least one heartbeat"
-    assert logs, "expected log forwarding"
-    assert posted_artifacts == artifacts
-    assert completions and not errors
-    assert "PATH" in captured_env
-    assert captured_env.get("FLYWHEEL_RUN_ID") == "run-123"
-    assert captured_env.get("FLYWHEEL_RUN_TOKEN") == "secret"
-    assert captured_env.get("FLYWHEEL_SERVER") == "http://server"
-    assert "CODEX_HOME" in captured_env
-    # With sandbox_mode=None, no sandbox flags should be added
-    assert len(captured_extra_flags) == 0
-
-
-def test_resolve_workspace_rejects_outside_writable(monkeypatch, tmp_path):
-    cfg_file = tmp_path / "config.toml"
-    cfg_file.write_text("", encoding="utf-8")
-
-    orchestrator = BootstrapOrchestrator(
-        BootstrapConfig(
-            run_id="run-1",
-            capability_token="token",
-            config_path=cfg_file,
-            server_url="http://server",
-            run_root=tmp_path,
-        )
-    )
-    orchestrator.user_config = UserConfig(
-        raw={},
-        working_dir=tmp_path / "work",
-        sandbox_mode="workspace-write",
-        approval_policy="unless-allow-listed",
-        oss_provider=None,
-        writable_roots=(tmp_path / "other",),
-        workspace_instructions="instr",
-        instructions_source="inline",
-        warnings=(),
-    )
-
-    with pytest.raises(SystemExit):
-        orchestrator._resolve_workspace()
-
-
-def test_resolve_workspace_expands_run_id_placeholder(tmp_path) -> None:
-    cfg_file = tmp_path / "config.toml"
-    cfg_file.write_text("", encoding="utf-8")
-
-    orchestrator = BootstrapOrchestrator(
-        BootstrapConfig(
-            run_id="run-xyz",
-            capability_token="token",
-            config_path=cfg_file,
-            server_url="http://server",
-            run_root=tmp_path,
-        )
-    )
-
-    templated = tmp_path / "runs" / "<run_id>"
-    orchestrator.user_config = UserConfig(
-        raw={},
-        working_dir=templated,
-        sandbox_mode="workspace-write",
-        approval_policy="unless-allow-listed",
-        oss_provider=None,
-        writable_roots=(tmp_path,),
-        workspace_instructions="instr",
-        instructions_source="inline",
-        warnings=(),
-    )
-
-    orchestrator._resolve_workspace()
-    assert orchestrator.workspace == (tmp_path / "runs" / "run-xyz").resolve()