lemming-cli 0.5.2__tar.gz → 0.6.1__tar.gz

lemming_cli-0.5.2/README.md → lemming_cli-0.6.1/PKG-INFO

@@ -1,3 +1,23 @@
+Metadata-Version: 2.5
+Name: lemming-cli
+Version: 0.6.1
+Summary: An autonomous, iterative task runner for AI coding agents.
+Project-URL: Homepage, https://github.com/owahltinez/lemming
+Project-URL: Repository, https://github.com/owahltinez/lemming
+Author: Lemming Contributors
+License: MIT
+License-File: LICENSE
+Keywords: agents,ai,antigravity,automation,claude,opencode
+Requires-Python: >=3.12
+Requires-Dist: click-agentcli>=0.5.0
+Requires-Dist: click>=8.0.0
+Requires-Dist: fastapi>=0.124.4
+Requires-Dist: pydantic>=2.12.5
+Requires-Dist: pyyaml>=6.0.3
+Requires-Dist: readability-cli>=0.10.4
+Requires-Dist: uvicorn>=0.33.0
+Description-Content-Type: text/markdown
+
 # Lemming 🐹
 
 **The transparent, tool-agnostic orchestrator for autonomous AI coding agents.**
@@ -78,6 +98,11 @@ lemming run
 lemming run -- --model claude-3-5-sonnet
 ```
 
+The loop runs every task in one shared workspace, and the orchestrator never
+branches or commits on your behalf. Give the whole run its own branch or
+worktree first if you want to be able to throw it away — see
+[docs/WORKSPACE.md](docs/WORKSPACE.md).
+
 ---
 
 ## One-Off Tasks Without a Roadmap
@@ -158,6 +183,8 @@ For Git, stop when the source checkout has modified or untracked files instead
 of silently excluding them. Retain every isolated working copy until its changes
 have been recovered. The packaged skill includes a minimal Git example.
 
+For a roadmap loop, see [docs/WORKSPACE.md](docs/WORKSPACE.md).
+
 ### Teaching Your Agent to Use It
 
 Lemming ships an Agent Skill so that an agent already running — Codex, Claude
@@ -246,6 +273,9 @@ conventions control their behavior:
   runs before `90-roadmap.md`); files without a prefix default to priority 50.
 - **Failure hooks**: Hooks at priority 90 and above also run when a task fails;
   all others only run on success.
+- **Oneshot tasks**: A task added with `--oneshot` skips all hooks once it
+  completes, so mechanical work (a typo fix, a version bump) does not pay for
+  the full review lifecycle. Failure hooks still run if it fails.
 - **Disabling**: An empty file masks (disables) the hook of the same name from a
   lower-precedence layer.
 
@@ -349,17 +379,24 @@ These come before the subcommand and apply to all of them.
   - `--brief`: Omit task descriptions, which otherwise dominate the output.
 - **`goal [<text>]`**: Set or view the long-term goal shared by all tasks.
   Supports `-f/--file`.
-- **`add <desc>`**: Append a new task. Supports `--index`, `--runner`, and
-  `--model`.
-- **`edit <id>`**: Modify a task's description, runner, model, or position.
+- **`add <desc>`**: Append a new task. Supports `--index`, `--runner`,
+  `--model`, and `--oneshot`.
+- **`edit <id>`**: Modify a task's description, runner, model, position, or
+  oneshot flag (`--oneshot/--no-oneshot`).
 - **`brief <id> [text]`**: View or set a task's long-form brief. Unlike the
   description it has no length cap, and it is appended to the runner prompt
   automatically — the right home for measured timings, exact failing selectors,
   or why a previous attempt was wrong. Supports `-f/--file`.
-- **`delete <id>`**: Remove an unstarted task while retaining its runner log.
-  Tasks with execution history require `--force`; autonomous restructuring
-  should use `supersede`. Supports `--all` and `--completed` for bulk cleanup,
-  including logs.
+- **`artifact <id> [name] [text]`**: Store or read a task's verbose
+  diagnostics — stack traces, test dumps, long logs — outside `tasks.yml`, so
+  they never bloat the prompts of later attempts. With no name it lists what the
+  task has stored; with `--note` it also records the one-line progress pointer
+  for you. Later attempts see the artifact names in their prompt automatically.
+  Supports `-f/--file`.
+- **`delete <id>`**: Remove an unstarted task while retaining its runner log;
+  its artifacts go with it. Tasks with execution history require `--force`;
+  autonomous restructuring should use `supersede`. Supports `--all` and
+  `--completed` for bulk cleanup, including logs.
 - **`supersede <id> --reason <text>`**: Retire a replaced or split task without
   losing its progress, timings, log, or links to replacement tasks.
 - **`progress`**: Manage progress entries and findings for specific tasks.
@@ -468,6 +505,10 @@ lemming -C ~/src/other-project add "check --fix drops the trailing newline"
 # Attach the evidence; the brief has no length cap
 lemming -C ~/src/other-project brief <id> --file repro.md
 
+# Park a failed attempt's output out of band, with a one-line pointer
+lemming -C ~/src/other-project artifact <id> pytest.log --file pytest.log \
+  --note 'suite fails in teardown'
+
 # Read the other project's roadmap without leaving yours
 lemming -C ~/src/other-project status
 ```

lemming_cli-0.5.2/PKG-INFO → lemming_cli-0.6.1/README.md

@@ -1,26 +1,3 @@
-Metadata-Version: 2.5
-Name: lemming-cli
-Version: 0.5.2
-Summary: An autonomous, iterative task runner for AI coding agents.
-Project-URL: Homepage, https://github.com/owahltinez/lemming
-Project-URL: Repository, https://github.com/owahltinez/lemming
-Author: Lemming Contributors
-License: MIT
-License-File: LICENSE
-Keywords: agents,ai,antigravity,automation,claude,opencode
-Requires-Python: >=3.12
-Requires-Dist: beautifulsoup4>=4.13.3
-Requires-Dist: click-agentcli>=0.4.1
-Requires-Dist: click>=8.0.0
-Requires-Dist: fastapi>=0.124.4
-Requires-Dist: markdownify>=0.14.1
-Requires-Dist: pydantic>=2.12.5
-Requires-Dist: pyyaml>=6.0.3
-Requires-Dist: readability-cli>=0.10.0
-Requires-Dist: requests>=2.32.3
-Requires-Dist: uvicorn>=0.33.0
-Description-Content-Type: text/markdown
-
 # Lemming 🐹
 
 **The transparent, tool-agnostic orchestrator for autonomous AI coding agents.**
@@ -101,6 +78,11 @@ lemming run
 lemming run -- --model claude-3-5-sonnet
 ```
 
+The loop runs every task in one shared workspace, and the orchestrator never
+branches or commits on your behalf. Give the whole run its own branch or
+worktree first if you want to be able to throw it away — see
+[docs/WORKSPACE.md](docs/WORKSPACE.md).
+
 ---
 
 ## One-Off Tasks Without a Roadmap
@@ -181,6 +163,8 @@ For Git, stop when the source checkout has modified or untracked files instead
 of silently excluding them. Retain every isolated working copy until its changes
 have been recovered. The packaged skill includes a minimal Git example.
 
+For a roadmap loop, see [docs/WORKSPACE.md](docs/WORKSPACE.md).
+
 ### Teaching Your Agent to Use It
 
 Lemming ships an Agent Skill so that an agent already running — Codex, Claude
@@ -269,6 +253,9 @@ conventions control their behavior:
   runs before `90-roadmap.md`); files without a prefix default to priority 50.
 - **Failure hooks**: Hooks at priority 90 and above also run when a task fails;
   all others only run on success.
+- **Oneshot tasks**: A task added with `--oneshot` skips all hooks once it
+  completes, so mechanical work (a typo fix, a version bump) does not pay for
+  the full review lifecycle. Failure hooks still run if it fails.
 - **Disabling**: An empty file masks (disables) the hook of the same name from a
   lower-precedence layer.
 
@@ -372,17 +359,24 @@ These come before the subcommand and apply to all of them.
   - `--brief`: Omit task descriptions, which otherwise dominate the output.
 - **`goal [<text>]`**: Set or view the long-term goal shared by all tasks.
   Supports `-f/--file`.
-- **`add <desc>`**: Append a new task. Supports `--index`, `--runner`, and
-  `--model`.
-- **`edit <id>`**: Modify a task's description, runner, model, or position.
+- **`add <desc>`**: Append a new task. Supports `--index`, `--runner`,
+  `--model`, and `--oneshot`.
+- **`edit <id>`**: Modify a task's description, runner, model, position, or
+  oneshot flag (`--oneshot/--no-oneshot`).
 - **`brief <id> [text]`**: View or set a task's long-form brief. Unlike the
   description it has no length cap, and it is appended to the runner prompt
   automatically — the right home for measured timings, exact failing selectors,
   or why a previous attempt was wrong. Supports `-f/--file`.
-- **`delete <id>`**: Remove an unstarted task while retaining its runner log.
-  Tasks with execution history require `--force`; autonomous restructuring
-  should use `supersede`. Supports `--all` and `--completed` for bulk cleanup,
-  including logs.
+- **`artifact <id> [name] [text]`**: Store or read a task's verbose
+  diagnostics — stack traces, test dumps, long logs — outside `tasks.yml`, so
+  they never bloat the prompts of later attempts. With no name it lists what the
+  task has stored; with `--note` it also records the one-line progress pointer
+  for you. Later attempts see the artifact names in their prompt automatically.
+  Supports `-f/--file`.
+- **`delete <id>`**: Remove an unstarted task while retaining its runner log;
+  its artifacts go with it. Tasks with execution history require `--force`;
+  autonomous restructuring should use `supersede`. Supports `--all` and
+  `--completed` for bulk cleanup, including logs.
 - **`supersede <id> --reason <text>`**: Retire a replaced or split task without
   losing its progress, timings, log, or links to replacement tasks.
 - **`progress`**: Manage progress entries and findings for specific tasks.
@@ -491,6 +485,10 @@ lemming -C ~/src/other-project add "check --fix drops the trailing newline"
 # Attach the evidence; the brief has no length cap
 lemming -C ~/src/other-project brief <id> --file repro.md
 
+# Park a failed attempt's output out of band, with a one-line pointer
+lemming -C ~/src/other-project artifact <id> pytest.log --file pytest.log \
+  --note 'suite fails in teardown'
+
 # Read the other project's roadmap without leaving yours
 lemming -C ~/src/other-project status
 ```

{lemming_cli-0.5.2 → lemming_cli-0.6.1}/SKILL.md

@@ -156,6 +156,10 @@ lemming add "Queue writes in IndexedDB while offline"
 lemming run                                  # runs until the queue drains
 ```
 
+The loop shares one workspace across all its tasks, so isolate the **whole run**
+— one branch or worktree created before `lemming run`, driven with
+`lemming -C <worktree> run` — never one per task.
+
 Check on it, and read what an agent actually did:
 
 ```sh
@@ -173,7 +177,9 @@ lemming stop --after-current-task                             # drain, then stop
 
 After each task, review hooks run automatically and a roadmap hook may revise
 the queue. `lemming hooks list` shows them; `lemming hooks disable <name>` turns
-one off for the project.
+one off for the project. Queue a mechanical task — a typo fix, a version bump, a
+rename — with `lemming add "..." --oneshot` to skip those hooks when it
+completes.
 
 ## What to know before running any of it
 

{lemming_cli-0.5.2 → lemming_cli-0.6.1}/docs/HOOKS.md

@@ -31,6 +31,11 @@ conventions control their behavior:
 - **Failure hooks**: Hooks at priority 90 and above also run when a task fails.
   All other hooks only run after successful tasks. The built-in `roadmap` hook
   ships as `90-roadmap.md` so it can react to failures.
+- **Oneshot tasks**: No hook runs after a task marked `--oneshot` completes,
+  keeping mechanical changes cheap. A oneshot task that fails still gets its
+  failure hooks, so recovery is never skipped. Note that `roadmap` is skipped
+  too: if a oneshot task is the last one in the queue, the run ends without a
+  goal audit, so nothing is queued to carry the goal further.
 - **Masking**: An empty file disables the hook of the same name from a
   lower-precedence layer (see below). For example, an empty
   `.lemming/hooks/readability.md` disables the built-in `readability` hook for
@@ -72,6 +77,33 @@ gaps, and exits immediately when the task did not change user-facing behavior.
 Its prompt instructs the agent to stay advisory, but this is not
 sandbox-enforced. It runs after `testing` and before `roadmap`.
 
+### Rejecting Completion
+
+A hook that finds a real defect it cannot fix should not exit 0 and let the
+task be marked completed. It rejects the completion instead:
+
+```bash
+lemming --tasks-file <path> reject <taskid> '<reason>'
+```
+
+A rejection only applies to a task that is finalizing as completed, and it
+does not change the task's status on the spot. The remaining hooks still run
+and see the task as `REJECTED` with the reason, so the roadmap hook can tell
+a rejected task from a finished one. Once every hook has run, the task is
+reverted to pending with its attempt count intact, exactly as it is when a
+hook process fails, and the reason is left in its progress so the next
+attempt starts with the diagnosis.
+
+Under `lemming exec` there is no second attempt: the run ends on the first
+rejection, and under `lemming run` a rejection on the task's final attempt
+sends it straight to the exhausted-retries path, where the failure hooks get
+their chance to repair it.
+
+Reject only for an objective, reproducible failure the hook could not repair
+itself, such as a failing test suite or a `lemming readability check` that
+still fails. Advisory findings, and anything the hook already fixed, belong
+in `lemming progress`.
+
 ### Reviews Are Not Read-Only
 
 When selected with `lemming exec --review`, the hooks above may edit the working

lemming_cli-0.6.1/docs/WORKSPACE.md

@@ -0,0 +1,120 @@
+# Workspace Isolation 🧰
+
+## Lemming is VCS-Agnostic
+
+An agent run writes to a real directory on your disk. The orchestrator never
+creates a branch, a commit, or a worktree, and never reverts anything: it runs
+the agent in a directory and gets out of the way, so whatever a run leaves
+behind — finished work, half-applied edits, scratch files — is what you get. The
+task-runner prompt does allow the agent itself to commit when that is the
+project's convention, but the orchestrator neither asks for that nor relies on
+it.
+
+This is deliberate: branching would tie the orchestrator to Git, and Lemming is
+expected to work in a Mercurial repository, a Perforce client, or a plain
+directory under no version control at all. No portable "undo the last run"
+primitive exists across those, so **isolation and recovery are the caller's
+job**. If you need to be able to throw a run away, set that up before it starts.
+
+## Isolating a One-Off `exec` Run
+
+Concurrent writing runs must not share a checkout: two agents editing one
+directory interleave their edits, and neither result is reviewable. Give each
+writing run its own working copy and pass it with the global `-C` option
+(`lemming -C <working-copy> -v exec ...`). The full Git worktree recipe is under
+"Isolate concurrent writing runs" in [SKILL.md](../SKILL.md), summarized in the
+[README](../README.md#one-off-tasks-without-a-roadmap).
+
+## Isolating a Roadmap Loop
+
+`lemming run` executes its tasks **sequentially in one shared workspace**. Task
+2 starts in whatever state task 1 left behind — that is the point, since tasks
+build on each other. So the unit of isolation is the whole run: **one branch or
+worktree for the entire loop**, created once before `lemming run`.
+
+**Never one branch per task.** Whichever branch the last runner left checked out
+would silently become the next task's baseline, and the loop's history would
+fragment across branches nobody asked for. This is why the task-runner prompt
+says nothing about branching: a runner has no business changing what is checked
+out under it.
+
+The minimal Git shape, from a clean tree:
+
+```bash
+repo=$(git rev-parse --show-toplevel) || exit 1
+test -z "$(git -C "$repo" status --porcelain)" || exit 1
+
+# One worktree for the whole run, from committed HEAD.
+worktree=$(mktemp -d "${TMPDIR:-/tmp}/lemming-run.XXXXXX") || exit 1
+branch="lemming/$(basename "$worktree")"
+git -C "$repo" worktree add -b "$branch" "$worktree" HEAD || exit 1
+
+# Drive the loop against it; -C is a global option, before the subcommand.
+lemming -C "$worktree" goal "<the long-term goal>"
+lemming -C "$worktree" add "<first task>"
+lemming -C "$worktree" -v run
+```
+
+A plain branch (`git switch -c lemming/<run>`) does just as well when nothing
+else needs the checkout; the worktree only buys you the original directory to
+keep working in meanwhile. Either way the roadmap travels with the workspace: a
+tracked `tasks.yml` is copied into the worktree and the loop's edits stay there,
+and without one Lemming keeps isolated state keyed on the worktree path.
+
+## Recovering After an Aborted Run
+
+With a pre-run baseline, recovery is ordinary version control, and `-C` reaches
+the run's own records without your having to know where they are stored:
+
+```bash
+git -C "$worktree" status        # what the run touched
+git -C "$worktree" log HEAD      # commits, if the runners made any
+git -C "$worktree" diff          # whatever is still uncommitted
+
+lemming -C "$worktree" status    # queue, attempts, recorded progress
+lemming -C "$worktree" logs <id> # the full runner log for one task
+```
+
+Keep the branch, or discard it wholesale. There is no partial rollback of one
+task inside a loop — the tasks share a workspace, so their edits are not
+separable unless the runners committed them separately.
+
+Runners are also told to write verbose evidence into Lemming's per-project
+scratch directory rather than into the workspace, so a failed task's notes
+survive even after you throw the branch away. It sits under `~/.local/lemming/`
+(or `$LEMMING_HOME`), named for the first 12 hex digits of the SHA-256 of the
+resolved tasks-file path — or of the workspace path, when Lemming is keeping the
+roadmap itself. Once the worktree is gone `-C` can no longer resolve it, and
+`lemming --tasks-file <that dir>/tasks.yml logs <id>` is the way back in.
+
+So retain the worktree until its changes have been recovered, then clean up
+non-forcibly, which refuses rather than destroying uncommitted work — including
+a tracked `tasks.yml` the loop has edited, which must be committed or discarded
+first:
+
+```bash
+git -C "$repo" worktree remove "$worktree"
+git -C "$repo" branch -d "$branch"
+```
+
+## What the Runner Prompt Guarantees
+
+Runners are instructed to leave a coherent workspace, to back out their own
+half-applied edits before failing, and never to restore files from version
+control history; the rules live in the "Workspace Hygiene" directive of
+`src/lemming/prompts/taskrunner.md`, not in a copy here. Treat them as a strong
+prior, not a guarantee: runners are LLMs, a prompt is guidance rather than
+enforcement, and a run killed by a timeout never gets to clean up at all. The
+branch or worktree is what actually makes a bad run recoverable; the prompt only
+reduces how often you need it.
+
+## Workspaces Not Under Version Control
+
+If the workspace is a plain directory, there is nothing to diff against and
+nothing to reset. **Copy the directory before the run**; that copy is the only
+rollback available.
+
+```bash
+cp -a project project.bak
+lemming -C project run
+```

{lemming_cli-0.5.2 → lemming_cli-0.6.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "lemming-cli"
-version = "0.5.2"
+version = "0.6.1"
 description = "An autonomous, iterative task runner for AI coding agents."
 readme = "README.md"
 authors = [
@@ -14,15 +14,12 @@ license = { text = "MIT" }
 requires-python = ">=3.12"
 keywords = ["ai", "agents", "automation", "antigravity", "claude", "opencode"]
 dependencies = [
-    "beautifulsoup4>=4.13.3",
     "click>=8.0.0",
-    "click-agentcli>=0.4.1",
+    "click-agentcli>=0.5.0",
     "fastapi>=0.124.4",
-    "markdownify>=0.14.1",
     "pydantic>=2.12.5",
     "pyyaml>=6.0.3",
-    "readability-cli>=0.10.0",
-    "requests>=2.32.3",
+    "readability-cli>=0.10.4",
     "uvicorn>=0.33.0",
 ]
 
@@ -49,7 +46,7 @@ Homepage = "https://github.com/owahltinez/lemming"
 Repository = "https://github.com/owahltinez/lemming"
 
 [project.scripts]
-lemming = "lemming.main:cli"
+lemming = "lemming.main:main"
 
 [tool.hatch.metadata]
 allow-direct-references = true

lemming_cli-0.6.1/src/lemming/api/__init__.py

@@ -0,0 +1 @@
+"""HTTP API for the lemming web UI, built on FastAPI."""

{lemming_cli-0.5.2 → lemming_cli-0.6.1}/src/lemming/api/auth_test.py

@@ -1,17 +1,17 @@
 import fastapi.testclient
 
-from lemming import api
+from lemming.api import main
 
 
 def test_share_token_middleware():
     # Setup test client
-    original_token = getattr(api.app.state, "share_token", None)
+    original_token = getattr(main.app.state, "share_token", None)
     try:
-        api.app.state.share_token = "secret123"
+        main.app.state.share_token = "secret123"
         # We need a fresh client for each test that modifies app state
         # middleware if it uses the app state, but here TestClient is
-        # created with api.app
-        client = fastapi.testclient.TestClient(api.app)
+        # created with main.app
+        client = fastapi.testclient.TestClient(main.app)
 
         # Missing token -> 401
         response = client.get("/api/data")
@@ -36,15 +36,15 @@ def test_share_token_middleware():
             assert response.status_code == 401, host
     finally:
         # Restore
-        api.app.state.share_token = original_token
+        main.app.state.share_token = original_token
 
 
 def test_share_token_middleware_rejects_exotic_tokens():
     """Odd tokens must be rejected, not crash the comparison."""
-    original_token = getattr(api.app.state, "share_token", None)
+    original_token = getattr(main.app.state, "share_token", None)
     try:
-        api.app.state.share_token = "secret123"
-        client = fastapi.testclient.TestClient(api.app)
+        main.app.state.share_token = "secret123"
+        client = fastapi.testclient.TestClient(main.app)
 
         # Non-ASCII and differing lengths must stay a clean 401. A digest
         # comparison rejects both only if the values are encoded first.
@@ -53,15 +53,15 @@ def test_share_token_middleware_rejects_exotic_tokens():
             assert response.status_code == 401, token
     finally:
         # Restore
-        api.app.state.share_token = original_token
+        main.app.state.share_token = original_token
 
 
 def test_share_token_middleware_inert_without_token():
     """Local (non-tunnel) mode sets no share token, so nothing is required."""
-    original_token = getattr(api.app.state, "share_token", None)
+    original_token = getattr(main.app.state, "share_token", None)
     try:
-        api.app.state.share_token = None
-        client = fastapi.testclient.TestClient(api.app)
+        main.app.state.share_token = None
+        client = fastapi.testclient.TestClient(main.app)
 
         response = client.get("/api/data")
         assert response.status_code == 200
@@ -70,4 +70,4 @@ def test_share_token_middleware_inert_without_token():
         )
     finally:
         # Restore
-        api.app.state.share_token = original_token
+        main.app.state.share_token = original_token

{lemming_cli-0.5.2 → lemming_cli-0.6.1}/src/lemming/api/config.py

@@ -7,7 +7,8 @@ import sys
 import fastapi
 import pydantic
 
-from .. import models, tasks
+from .. import models, persistence
+from ..tasks import operations
 from . import context
 
 router = fastapi.APIRouter()
@@ -25,22 +26,22 @@ def update_goal(
 ):
     """Update the long-term goal shared with all task runners."""
     tasks_file = context.resolve_tasks_file(request.app.state, project)
-    tasks.update_goal(tasks_file, update.get("goal", ""))
+    operations.update_goal(tasks_file, update.get("goal", ""))
     return {"status": "ok"}
 
 
 @router.post("/api/config")
 def update_config(
     request: fastapi.Request,
-    config: tasks.RoadmapConfig,
+    config: models.RoadmapConfig,
     project: str | None = None,
 ):
     """Replace the roadmap configuration and return the saved value."""
     tasks_file = context.resolve_tasks_file(request.app.state, project)
-    with tasks.lock_tasks(tasks_file):
-        data = tasks.load_tasks(tasks_file)
+    with persistence.lock_tasks(tasks_file):
+        data = persistence.load_tasks(tasks_file)
         data.config = config
-        tasks.save_tasks(tasks_file, data)
+        persistence.save_tasks(tasks_file, data)
     return data.config
 
 

{lemming_cli-0.5.2 → lemming_cli-0.6.1}/src/lemming/api/config_test.py

@@ -1,6 +1,6 @@
 from unittest.mock import patch
 
-from lemming import api
+from lemming.api import main
 
 
 def test_run_loop(client, test_tasks):
@@ -25,7 +25,7 @@ def test_get_runners(client):
 
 def test_project_goal_isolation(client, test_tasks):
     """The goal is isolated per project."""
-    root = api.app.state.root
+    root = main.app.state.root
     subdir = root / "goal_test"
     subdir.mkdir(exist_ok=True)
 
@@ -50,7 +50,7 @@ def test_project_goal_isolation(client, test_tasks):
 
 def test_run_loop_with_project(client, test_tasks):
     """POST /api/run with project param uses the correct tasks file."""
-    root = api.app.state.root
+    root = main.app.state.root
     subdir = root / "run_project"
     subdir.mkdir(exist_ok=True)
     (subdir / "tasks.yml").touch()