agentic-dev-loop 1.0.0a6__tar.gz → 1.0.0a8__tar.gz

agentic_dev_loop-1.0.0a6/README.md → agentic_dev_loop-1.0.0a8/PKG-INFO

@@ -1,3 +1,42 @@
+Metadata-Version: 2.4
+Name: agentic-dev-loop
+Version: 1.0.0a8
+Summary: Turn an LLM into a gated, sandboxed, resumable construction loop over your codebase.
+Author: Luke Wilson
+License-Expression: Apache-2.0
+Project-URL: Homepage, https://github.com/lukedawilson/agentic-dev-loop
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Software Development
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Software Development :: Quality Assurance
+Classifier: Topic :: Security
+Classifier: Typing :: Typed
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pydantic>=2.0
+Requires-Dist: PyYAML>=6.0
+Requires-Dist: openhands-sdk~=1.17.0
+Requires-Dist: openhands-tools~=1.17.0
+Requires-Dist: agent-client-protocol<1.0.0
+Requires-Dist: langgraph>=1.2
+Requires-Dist: langgraph-checkpoint-sqlite>=3.0
+Provides-Extra: dev
+Requires-Dist: hypothesis>=6.0; extra == "dev"
+Requires-Dist: pytest>=8.0; extra == "dev"
+Dynamic: license-file
+
 # agentic-dev-loop
 
 > **Turn an LLM into a gated, sandboxed, resumable construction loop over your codebase.**
@@ -23,11 +62,6 @@ flowchart LR
 - **Sandboxed by default.** The agent's shell and every command step run inside
   an always-on Docker sandbox. There is no opt-out.
 
-Two modes share one `pipeline.yaml`: **engine mode** (the sandboxed, resumable
-loop above) and **workflow mode** — a Claude Dynamic Workflow exported from the
-same pipeline that runs in Claude Code's own environment, with the live graph
-visualiser. See [Workflow mode](#workflow-mode-claude-code).
-
 ---
 
 ## Core features
@@ -56,13 +90,8 @@ LLM timeout (agent runs are long).
 | LLM API key | The env var named by your pipeline's `api_key_env` (e.g. `OPENAI_API_KEY`) must be set — a missing key fails fast, naming it. |
 
 ```bash
-# engine mode (sandboxed loop — the full install)
-pip install "agentic-dev-loop[engine]==1.0.0a6"
+pip install "agentic-dev-loop==1.0.0a8"
 agentic-dev-loop --version
-
-# workflow mode (Claude Code — core + viz only, no SDK/Docker deps)
-pip install "agentic-dev-loop==1.0.0a6"
-agentic-dev-loop-workflow install-skill
 ```
 
 On the first run the engine pulls the **digest-pinned** dev image
@@ -73,43 +102,6 @@ image. Engine setup, first-run details, the full `pipeline.yaml` contract, and
 troubleshooting for every fail-fast code live in
 [docs/setup.md](docs/setup.md).
 
-## Workflow mode (Claude Code)
-
-For developers who know and love the agentic dev loop but are forced to use
-Claude Code at work: workflow mode exports a **Claude Dynamic Workflow** from
-the `pipeline.yaml` they already trust, plus the visualiser they trust. It adds
-the deterministic loop through Claude's mechanism — nothing more. **No Docker
-sandboxing, and no new security claims**: workflow steps run in Claude Code's
-own environment under its permission model (a documented trust-model change
-from engine mode).
-
-Install the skill once:
-
-```bash
-pip install "agentic-dev-loop==1.0.0a6"  # base install: core + viz, no SDK/Docker
-agentic-dev-loop-workflow install-skill # → ~/.claude/skills/agentic-dev-loop/
-```
-
-Then invoke `/agentic-dev-loop` in Claude Code. The skill walks through:
-
-1. **Build** — `python -m agentic_dev_loop.core.project <pipeline.yaml>` loads +
-   validates the pipeline, verifies every agent step's `.agent.md` prompt exists
-   (a missing prompt fails the build loudly, naming the file), and writes a
-   self-contained `.agentic-dev-loop/workflow.js`. Steps are frozen at creation
-   — mid-run `pipeline.yaml` edits never affect a running workflow.
-2. **Run** — the generated JS routes `on_pass` / `on_fail` / `goto` with its own
-   attempt counter, injects the failing subagent's output as the next retry note,
-   launches the live-graph server (localhost, token-authenticated ingest), and
-   invokes the docker-free commit shim, which refuses loudly unless the worktree
-   was clean at run start.
-
-Engine-only fields (`isolation:`, per-step `network:`, `setup:`) are ignored in
-workflow mode with no effect on the build or run.
-
-The base install is deliberately dependency-light (`pydantic` + `PyYAML` only);
-the heavy OpenHands-SDK engine lives in the `[engine]` extra. The `core` and
-`viz` packages are guarded against pulling engine deps.
-
 ## Usage
 
 ```bash

agentic_dev_loop-1.0.0a6/src/agentic_dev_loop.egg-info/PKG-INFO → agentic_dev_loop-1.0.0a8/README.md

@@ -1,45 +1,3 @@
-Metadata-Version: 2.4
-Name: agentic-dev-loop
-Version: 1.0.0a6
-Summary: Turn an LLM into a gated, sandboxed, resumable construction loop over your codebase.
-Author: Luke Wilson
-License-Expression: Apache-2.0
-Project-URL: Homepage, https://github.com/lukedawilson/agentic-dev-loop
-Classifier: Development Status :: 4 - Beta
-Classifier: Environment :: Console
-Classifier: Intended Audience :: Developers
-Classifier: Operating System :: MacOS
-Classifier: Operating System :: Microsoft :: Windows
-Classifier: Operating System :: POSIX :: Linux
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3 :: Only
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: 3.13
-Classifier: Programming Language :: Python :: 3.14
-Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
-Classifier: Topic :: Software Development
-Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Classifier: Topic :: Software Development :: Quality Assurance
-Classifier: Topic :: Security
-Classifier: Typing :: Typed
-Requires-Python: >=3.12
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: pydantic>=2.0
-Requires-Dist: PyYAML>=6.0
-Provides-Extra: engine
-Requires-Dist: openhands-sdk~=1.17.0; extra == "engine"
-Requires-Dist: openhands-tools~=1.17.0; extra == "engine"
-Requires-Dist: agent-client-protocol<1.0.0; extra == "engine"
-Requires-Dist: langgraph>=1.2; extra == "engine"
-Requires-Dist: langgraph-checkpoint-sqlite>=3.0; extra == "engine"
-Provides-Extra: workflow
-Provides-Extra: dev
-Requires-Dist: agentic-dev-loop[engine]; extra == "dev"
-Requires-Dist: hypothesis>=6.0; extra == "dev"
-Requires-Dist: pytest>=8.0; extra == "dev"
-Dynamic: license-file
-
 # agentic-dev-loop
 
 > **Turn an LLM into a gated, sandboxed, resumable construction loop over your codebase.**
@@ -65,11 +23,6 @@ flowchart LR
 - **Sandboxed by default.** The agent's shell and every command step run inside
   an always-on Docker sandbox. There is no opt-out.
 
-Two modes share one `pipeline.yaml`: **engine mode** (the sandboxed, resumable
-loop above) and **workflow mode** — a Claude Dynamic Workflow exported from the
-same pipeline that runs in Claude Code's own environment, with the live graph
-visualiser. See [Workflow mode](#workflow-mode-claude-code).
-
 ---
 
 ## Core features
@@ -98,13 +51,8 @@ LLM timeout (agent runs are long).
 | LLM API key | The env var named by your pipeline's `api_key_env` (e.g. `OPENAI_API_KEY`) must be set — a missing key fails fast, naming it. |
 
 ```bash
-# engine mode (sandboxed loop — the full install)
-pip install "agentic-dev-loop[engine]==1.0.0a6"
+pip install "agentic-dev-loop==1.0.0a8"
 agentic-dev-loop --version
-
-# workflow mode (Claude Code — core + viz only, no SDK/Docker deps)
-pip install "agentic-dev-loop==1.0.0a6"
-agentic-dev-loop-workflow install-skill
 ```
 
 On the first run the engine pulls the **digest-pinned** dev image
@@ -115,43 +63,6 @@ image. Engine setup, first-run details, the full `pipeline.yaml` contract, and
 troubleshooting for every fail-fast code live in
 [docs/setup.md](docs/setup.md).
 
-## Workflow mode (Claude Code)
-
-For developers who know and love the agentic dev loop but are forced to use
-Claude Code at work: workflow mode exports a **Claude Dynamic Workflow** from
-the `pipeline.yaml` they already trust, plus the visualiser they trust. It adds
-the deterministic loop through Claude's mechanism — nothing more. **No Docker
-sandboxing, and no new security claims**: workflow steps run in Claude Code's
-own environment under its permission model (a documented trust-model change
-from engine mode).
-
-Install the skill once:
-
-```bash
-pip install "agentic-dev-loop==1.0.0a6"  # base install: core + viz, no SDK/Docker
-agentic-dev-loop-workflow install-skill # → ~/.claude/skills/agentic-dev-loop/
-```
-
-Then invoke `/agentic-dev-loop` in Claude Code. The skill walks through:
-
-1. **Build** — `python -m agentic_dev_loop.core.project <pipeline.yaml>` loads +
-   validates the pipeline, verifies every agent step's `.agent.md` prompt exists
-   (a missing prompt fails the build loudly, naming the file), and writes a
-   self-contained `.agentic-dev-loop/workflow.js`. Steps are frozen at creation
-   — mid-run `pipeline.yaml` edits never affect a running workflow.
-2. **Run** — the generated JS routes `on_pass` / `on_fail` / `goto` with its own
-   attempt counter, injects the failing subagent's output as the next retry note,
-   launches the live-graph server (localhost, token-authenticated ingest), and
-   invokes the docker-free commit shim, which refuses loudly unless the worktree
-   was clean at run start.
-
-Engine-only fields (`isolation:`, per-step `network:`, `setup:`) are ignored in
-workflow mode with no effect on the build or run.
-
-The base install is deliberately dependency-light (`pydantic` + `PyYAML` only);
-the heavy OpenHands-SDK engine lives in the `[engine]` extra. The `core` and
-`viz` packages are guarded against pulling engine deps.
-
 ## Usage
 
 ```bash

{agentic_dev_loop-1.0.0a6 → agentic_dev_loop-1.0.0a8}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "agentic-dev-loop"
-version = "1.0.0a6"
+version = "1.0.0a8"
 description = "Turn an LLM into a gated, sandboxed, resumable construction loop over your codebase."
 readme = "README.md"
 requires-python = ">=3.12"
@@ -32,23 +32,8 @@ classifiers = [
     "Typing :: Typed",
 ]
 dependencies = [
-    # Base install = workflow mode (core + viz + workflow CLI). Deliberately
-    # dependency-light (TS-1 / NFR-4.1 / BR-2): pydantic + PyYAML only. The
-    # heavy OpenHands-SDK engine deps live in the [engine] extra below.
     "pydantic>=2.0",
     "PyYAML>=6.0",
-]
-
-[project.urls]
-Homepage = "https://github.com/lukedawilson/agentic-dev-loop"
-
-[project.scripts]
-agentic-dev-loop = "agentic_dev_loop.engine.cli:main"
-agentic-dev-loop-workflow = "agentic_dev_loop.workflow.cli:main"
-agentic-dev-loop-commit = "agentic_dev_loop.engine.commit_shim:main"
-
-[project.optional-dependencies]
-engine = [
     "openhands-sdk ~=1.17.0",
     "openhands-tools ~=1.17.0",
     # openhands-sdk declares agent-client-protocol>=0.8.1 with NO upper bound;
@@ -59,12 +44,15 @@ engine = [
     "langgraph>=1.2",
     "langgraph-checkpoint-sqlite>=3.0",
 ]
-# Workflow mode is the BASE install — this empty extra exists only so
-# `pip install agentic-dev-loop[workflow]` reads naturally and pulls nothing
-# beyond the light base (core + viz). See README / NFR-4.1.
-workflow = []
+
+[project.urls]
+Homepage = "https://github.com/lukedawilson/agentic-dev-loop"
+
+[project.scripts]
+agentic-dev-loop = "agentic_dev_loop.engine.cli:main"
+
+[project.optional-dependencies]
 dev = [
-    "agentic-dev-loop[engine]",
     "hypothesis>=6.0",
     "pytest>=8.0",
 ]
@@ -74,7 +62,6 @@ where = ["src"]
 
 [tool.setuptools.package-data]
 agentic_dev_loop = ["py.typed"]
-"agentic_dev_loop.core" = ["workflow.js.template"]
 
 [tool.pytest.ini_options]
 markers = [

{agentic_dev_loop-1.0.0a6 → agentic_dev_loop-1.0.0a8}/src/agentic_dev_loop/core/__init__.py

@@ -1,4 +1,4 @@
-"""Pipeline model + parse + workflow projection (unit-4 core).
+"""Pipeline model + parse + results (core).
 
 Dependency-light by contract (BR-2): pydantic + PyYAML + stdlib only. A guard
 test fails if this package imports engine/viz or heavy deps.
@@ -9,17 +9,10 @@ from .config import (PipelineConfig, StepConfig, LlmConfig, IsolationConfig,
                      default_state_dir, TERMINALS)
 from .results import Result
 from .verdict import Verdict, VerdictError, parse_verdict, RETRY
-from .projection import (ProjectedStep, WorkflowProjection, project_workflow,
-                         validate_prompt_refs, render_workflow_js,
-                         clean_at_start_flag, pipeline_hash, core_version,
-                         WORKFLOW_TEMPLATE)
 
 __all__ = [
     "PipelineConfig", "StepConfig", "LlmConfig", "IsolationConfig",
     "VerdictSpec", "Route", "route_target", "load_config",
     "default_state_dir", "TERMINALS",
     "Result", "Verdict", "VerdictError", "parse_verdict", "RETRY",
-    "ProjectedStep", "WorkflowProjection", "project_workflow",
-    "validate_prompt_refs", "render_workflow_js", "clean_at_start_flag",
-    "pipeline_hash", "core_version", "WORKFLOW_TEMPLATE",
 ]

{agentic_dev_loop-1.0.0a6 → agentic_dev_loop-1.0.0a8}/src/agentic_dev_loop/core/verdict.py

@@ -2,7 +2,7 @@
 
 `Verdict.from_text` parses the captured response for routing; expected
 conditions are typed `Result` errors, never exceptions. `parse_verdict`
-collapses that `Result` to a route string for workflow consumers: a clear
+collapses that `Result` to a route string for routing consumers: a clear
 decision maps to its canonical value, anything unclear maps to ``retry`` —
 totality for arbitrary input (no crash, no silent routing).
 """

{agentic_dev_loop-1.0.0a6 → agentic_dev_loop-1.0.0a8}/src/agentic_dev_loop/engine/__init__.py

@@ -1,2 +1,2 @@
 """Engine package — graph/stages/sandbox/CLI and the heavy OpenHands-SDK
-dependencies (unit-4 re-homing, FR-4.1)."""
+dependencies."""

{agentic_dev_loop-1.0.0a6 → agentic_dev_loop-1.0.0a8}/src/agentic_dev_loop/engine/isolation.py

@@ -20,6 +20,7 @@ import json
 import math
 import os
 import re
+import shlex
 import shutil
 import subprocess
 import time
@@ -66,6 +67,14 @@ AUDIT_MAX_BYTES = 5 * 1024 * 1024
 # hung `setup:` hook can never wedge startup (BR-8 fail fast, not a hang).
 PROVISION_TIMEOUT_SECONDS = 3600
 
+# The sandbox venv the shipped pipeline relies on (016 sandbox-venv
+# hardening). The engine probes this path INSIDE the exec container
+# before trusting a warm provision stamp — a host-built (darwin) venv
+# symlinks to a host interpreter that does not exist in the Linux
+# container, so it must be detected and re-provisioned there.
+SANDBOX_VENV_DIR = ".venv-sandbox"
+SANDBOX_VENV_PYTHON = ".venv-sandbox/bin/python"
+
 
 class SandboxError(RuntimeError):
     """A loud fail-fast sandbox failure; the message names the problem and
@@ -270,6 +279,58 @@ def setup_stamp_key(setup_cmd: str, lockfile_hashes: dict[str, str]) -> str:
         json.dumps(canonical, sort_keys=True).encode("utf-8")).hexdigest()
 
 
+def venv_probe_command() -> str:
+    """In-container probe classifying the sandbox venv (016 self-heal).
+
+    Returns a shell command that prints exactly one of ``valid`` /
+    ``missing`` / ``broken`` and exits 0. ``broken`` is the host-tampered
+    class: the python entry exists as a path (including a dangling symlink —
+    the host-darwin venv case) but is not executable/importable in the
+    container. ``missing`` means no such entry at all (the setup hook may
+    legitimately not create a venv), so it is treated as a stamp hit, never a
+    self-heal trigger.
+    """
+    py = shlex.quote(SANDBOX_VENV_PYTHON)
+    return (
+        f"if [ -L {py} ] && [ ! -x {py} ]; then echo broken; "
+        f"elif [ ! -e {py} ]; then echo missing; "
+        f"elif {py} -c 'import sys' >/dev/null 2>&1; then echo valid; "
+        f"else echo broken; fi"
+    )
+
+
+def venv_probe_argv(container: str, workspace: str) -> list[str]:
+    """``docker exec`` argv that runs the venv probe inside the (already
+    running) execution container against the bind-mounted workspace."""
+    return ["docker", "exec", "-w", workspace, container,
+            "/bin/sh", "-c", venv_probe_command()]
+
+
+def venv_probe_state(stdout: str, exit_code: int | None) -> str:
+    """Classify a probe result. A nonzero exit (docker exec failed) is
+    ``unknown`` — the caller leaves the stamp alone rather than guessing."""
+    if exit_code != 0:
+        return "unknown"
+    line = stdout.strip().splitlines()[-1] if stdout.strip() else ""
+    return line if line in ("valid", "missing", "broken") else "unknown"
+
+
+def remove_sandbox_venv(workspace: str | Path) -> None:
+    """Remove the workspace's sandbox venv before re-provision (016 self-heal).
+    Fails loud when the venv exists but cannot be removed — a silent skip
+    would re-create the ENOENT failure the next run."""
+    venv = Path(workspace) / SANDBOX_VENV_DIR
+    try:
+        if venv.is_symlink() or venv.is_file():
+            venv.unlink()
+        elif venv.is_dir():
+            shutil.rmtree(venv)
+    except OSError as e:
+        raise SandboxError(
+            f"AE-SBX-014: cannot remove invalid sandbox venv at {venv}: {e} "
+            f"— remove it manually and re-run (docs/setup.md §5)") from e
+
+
 def host_user_flag() -> str | None:
     """The ``docker --user`` value binding the sandbox to the host user.
 
@@ -507,9 +568,20 @@ class DockerBackend(Sandbox):
     def provision(self, setup_cmd: str, stamp_key: str, stamp_dir: str,
                   force: bool) -> None:
         """Run one ``setup:`` hook in the provision container (network ON),
-        stamp-cached. Nonzero exit → AE-SBX-009, no stamp written."""
+        stamp-cached. Nonzero exit → AE-SBX-009, no stamp written.
+
+        016 self-heal: a warm stamp no longer blind-skips. Before trusting it,
+        probe the sandbox venv inside the exec container — a host-built venv
+        (darwin symlinks to a host interpreter) looks valid on the host but is
+        broken in the Linux container. A ``broken`` probe removes the venv
+        (fail loud if removal is impossible) and falls through to re-provision;
+        ``valid``/``missing``/``unknown`` keep the stamp skip.
+        """
         if not force and read_stamp(Path(stamp_dir), stamp_key):
-            return
+            if self._probe_venv() == "broken":
+                remove_sandbox_venv(self._workspace)
+            else:
+                return
         payload = docker_provision_payload(
             run_id=self._run_id, image=self._image, workspace=self._workspace,
             setup_cmd=setup_cmd)
@@ -521,6 +593,12 @@ class DockerBackend(Sandbox):
                 f"— stamp not written (docs/setup.md §5)")
         write_stamp(Path(stamp_dir), stamp_key)
 
+    def _probe_venv(self) -> str:
+        """Run the in-container venv probe and classify it (016 self-heal)."""
+        res = self._runner.run(
+            venv_probe_argv(self._container, self._workspace), timeout=30)
+        return venv_probe_state(res.stdout, res.exit_code)
+
     # -- execution ----------------------------------------------------------
 
     def run(self, request: SandboxExecutionRequest) -> SandboxExecutionResult:

{agentic_dev_loop-1.0.0a6 → agentic_dev_loop-1.0.0a8}/src/agentic_dev_loop/engine/outputs.py

@@ -2,9 +2,9 @@
 channel (unit-1).
 
 The pipeline — not the agent — writes the step's artifact from the agent's
-final SDK response. Verdict parsing lives in `core.verdict` (shared with
-workflow mode); this module only owns the SDK-side capture. Expected
-conditions are typed `Result` errors, never exceptions.
+final SDK response. Verdict parsing lives in `core.verdict`; this module only
+owns the SDK-side capture. Expected conditions are typed `Result` errors,
+never exceptions.
 """
 
 from __future__ import annotations

{agentic_dev_loop-1.0.0a6 → agentic_dev_loop-1.0.0a8}/src/agentic_dev_loop/viz/__init__.py

@@ -1,14 +1,13 @@
-"""The live-graph visualiser + workflow-mode ingest surface (unit-4 viz)."""
+"""The live-graph visualiser."""
 
 import time  # noqa: F401 — re-exported so tests can pin NodeWatch's clock
 
 from .server import (MAX_LINE, PAGE, ConsoleCapture, HeartbeatThread,
                      NodeWatch, VizBus, _ReuseSafeServer, _Tee,
                      _handler_class, serve_viz, topology_mermaid, translate)
-from .ingest import issue_ingest_token, make_ingest_event
 
 __all__ = [
     "MAX_LINE", "PAGE", "ConsoleCapture", "HeartbeatThread", "NodeWatch",
     "VizBus", "_ReuseSafeServer", "_Tee", "_handler_class", "serve_viz",
-    "topology_mermaid", "translate", "issue_ingest_token", "make_ingest_event",
+    "topology_mermaid", "translate",
 ]

{agentic_dev_loop-1.0.0a6 → agentic_dev_loop-1.0.0a8}/src/agentic_dev_loop/viz/__main__.py

@@ -1,7 +1,5 @@
-"""Standalone workflow-mode viz launcher (FD-4): `python -m
-agentic_dev_loop.viz --pipeline <pipeline.yaml>` serves the live graph on
-localhost, issues an ingest token, and prints both. Step subagents POST stage
-events to `/ingest` with that token (BR-9)."""
+"""Standalone viz launcher: `python -m agentic_dev_loop.viz --pipeline
+<pipeline.yaml>` serves the live graph on localhost."""
 
 from __future__ import annotations
 
@@ -31,7 +29,6 @@ def main(argv: list[str] | None = None) -> int:
     bound = httpd.server_address[1]
     url = f"http://127.0.0.1:{bound}"
     print(f"Live graph viz: {url}", flush=True)
-    print(f"ingest-token: {httpd.ingest_token}", flush=True)
     if args.port and bound != args.port:
         print(f"viz port {args.port} busy — serving on {url}", flush=True)
     try:

{agentic_dev_loop-1.0.0a6 → agentic_dev_loop-1.0.0a8}/src/agentic_dev_loop/viz/server.py

@@ -27,8 +27,6 @@ from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
 
 from agentic_dev_loop.core.config import PipelineConfig, Route, route_target
 
-from .ingest import issue_ingest_token
-
 STATE_WHITELIST = ("attempt", "step_verdicts", "outcome", "failed")
 
 
@@ -341,15 +339,13 @@ class HeartbeatThread(threading.Thread):
 
 
 def _handler_class(bus: VizBus, topology_mermaid: str,
-                   subject: str, nodes: Iterable[str],
-                   ingest_token: str | None = None) -> type[BaseHTTPRequestHandler]:
+                   subject: str, nodes: Iterable[str]) -> type[BaseHTTPRequestHandler]:
     class Handler(BaseHTTPRequestHandler):
         protocol_version = "HTTP/1.1"
         viz_bus = bus
         viz_topology = topology_mermaid
         viz_subject = subject
         viz_nodes = list(nodes)
-        viz_ingest_token = ingest_token
 
         def log_message(self, *_args) -> None:  # keep test output quiet
             pass
@@ -373,30 +369,6 @@ def _handler_class(bus: VizBus, topology_mermaid: str,
             else:
                 self.send_error(404)
 
-        def do_POST(self) -> None:
-            if self.path != "/ingest":
-                self.send_error(404)
-                return
-            supplied = self.headers.get("X-Ingest-Token", "")
-            if not self.viz_ingest_token or supplied != self.viz_ingest_token:
-                self._send(403, "application/json",
-                           json.dumps({"error": "forbidden"}))
-                return
-            length = int(self.headers.get("Content-Length", "0") or "0")
-            body = self.rfile.read(length).decode("utf-8")
-            try:
-                event = json.loads(body)
-            except json.JSONDecodeError:
-                self._send(400, "application/json",
-                           json.dumps({"error": "invalid json"}))
-                return
-            if not isinstance(event, dict):
-                self._send(400, "application/json",
-                           json.dumps({"error": "event must be an object"}))
-                return
-            self.viz_bus.publish(event)
-            self._send(200, "application/json", json.dumps({"ok": True}))
-
         def _send(self, status: int, content_type: str, body: str) -> None:
             data = body.encode("utf-8")
             self.send_response(status)
@@ -439,8 +411,7 @@ class _ReuseSafeServer(ThreadingHTTPServer):
 
 
 def serve_viz(bus: VizBus, topology_mermaid: str, subject: str,
-              port: int, nodes: Iterable[str] = (),
-              ingest_token: str | None = None) -> tuple[_ReuseSafeServer, threading.Thread]:
+              port: int, nodes: Iterable[str] = ()) -> tuple[_ReuseSafeServer, threading.Thread]:
     """Bind a loopback HTTP server on ``port`` and serve it on a daemon
     thread. Returns ``(httpd, thread)`` — the caller reads the real bound
     port from ``httpd.server_address[1]``.
@@ -449,10 +420,7 @@ def serve_viz(bus: VizBus, topology_mermaid: str, subject: str,
     (``errno.EADDRINUSE``) the server rebinds port 0 and lets the OS pick a
     free port. Any other bind error (e.g. ``EACCES`` on a privileged port)
     still fails loud, naming ``--viz-port``."""
-    if ingest_token is None:
-        ingest_token = issue_ingest_token()
-    handler = _handler_class(bus, topology_mermaid, subject, nodes,
-                             ingest_token)
+    handler = _handler_class(bus, topology_mermaid, subject, nodes)
     try:
         httpd = _ReuseSafeServer(("127.0.0.1", port), handler)
     except OSError as exc:
@@ -462,7 +430,6 @@ def serve_viz(bus: VizBus, topology_mermaid: str, subject: str,
             raise OSError(
                 f"Could not bind the viz server to 127.0.0.1:{port} — the "
                 f"--viz-port may already be in use. ({exc})") from exc
-    httpd.ingest_token = ingest_token
     thread = threading.Thread(target=httpd.serve_forever, daemon=True)
     thread.start()
     return httpd, thread