loki-mode 10.6.7 → 10.6.9

package/README.md

@@ -11,7 +11,7 @@ An autonomous software factory that knows what it is supposed to deliver, and pr
 
 Loki Mode is a free, source-available autonomous coding agent by [Autonomi](https://www.autonomi.dev/). Hand it a PRD, GitHub issue, OpenAPI doc or one-line brief. It derives a delivery contract (the acceptance criteria), builds against it, and ends with a signed Evidence Receipt that states what was proven and what was not. If the contract cannot be derived, it stops and asks one question instead of guessing.
 
-Before a build counts as done, a review council selects reviewers from a specialist pool (`agents/types.json`, scored by `run.sh:FOCUS_KEYWORDS`). The bundled MCP server exposes 36 tools over stdio (`mcp/server.py`).
+Before a build counts as done, a review council selects reviewers from a specialist pool (`agents/types.json`, scored by `run.sh:FOCUS_KEYWORDS`). The bundled MCP server exposes 39 tools over stdio (`mcp/server.py`), including `loki_v10_run`, `loki_v10_status` and `loki_v10_verify` to start a Loki 10 run in the background, read its phase, verdict and cost, and verify its receipt (`BLOCKED` runs report their question). Add it with `claude mcp add loki-mode -- python3 -m mcp.server` from the install directory.
 
 ## Contents
 
@@ -120,6 +120,8 @@ flowchart TD
 | pr | Opened by the supervisor, not the worker (the worker never holds a GitHub token). A non-VERIFIED run opens a draft PR. The body is written for a 60-second review: what the issue asked, what changed, how it was tested, NOT PROVEN, then the receipt digest and `loki verify`. Data the run did not record prints "not recorded". |
 | deep verify | Detached, started after the PR opens (so not with `--no-pr`): full suite, app-boot probe, council, secret scan. A check that is refused or unavailable is reported as NOT PROVEN, never as red. `--deep` is a separate flag that raises the implement and run budgets. |
 
+Warm start (experimental, `LOKI_SPEED=1`, off by default): `loki engine10 dashboard` also serves a unix socket at `~/.loki/run/engine.sock` (override with `LOKI_WARM_SOCK`) that keeps the repo map and test map in memory, keyed by the tree SHA plus a hash of dirty files, so an edit invalidates them. A run tries the socket for 50ms and prints `warm in Xs` when it answers; with no daemon it runs the cold path with identical events.
+
 PR body sample (`loki-ts/src/e10ext/reviewer_body.ts`):
 
 ```
@@ -151,7 +153,29 @@ The run cap is 900s (2700s with `--deep`, `DEFAULT_CAP_S` and `DEEP_CAP_S` in `t
 
 A finished run prints a short summary (see [Quiet output](#quiet-output), which also shows an example) whose `NOT PROVEN` line is never empty by omission: deep checks deferred to the deep-verify pass are always listed there.
 
-`loki status [run-id]` and `loki verify [run-id]` are built on the v10 path (bare `loki verify` follows the newest run, v10 or legacy). `loki dashboard` and `loki status` reach the v10 commands with `LOKI_ENGINE=v10`. Slack notifications are not part of the v10 engine surface yet.
+`loki status [run-id]` and `loki verify [run-id]` are built on the v10 path (bare `loki verify` follows the newest run, v10 or legacy). `loki dashboard` and `loki status` reach the v10 commands with `LOKI_ENGINE=v10`. Two-way Slack (`loki slack serve`) is on by default and documented in [docs/slack.md](docs/slack.md); outbound notifications use `LOKI_SLACK_WEBHOOK_URL`.
+
+## Run from Jira or Linear
+
+Loki 10 can start from a Jira or Linear issue the same way it starts from a GitHub issue: same run, same receipt. The issue is fetched deterministically before any model runs and normalized into the same `issue.json`, with a `source` field of `jira` or `linear`.
+
+```bash
+loki jira:PROJ-123     # or https://<site>.atlassian.net/browse/PROJ-123
+loki linear:ENG-42     # or a linear.app issue URL
+```
+
+- Jira needs `JIRA_EMAIL` and `JIRA_API_TOKEN`, plus `JIRA_BASE_URL` (for example `https://acme.atlassian.net`) unless you pass the full browse URL. The ADF description is converted to plain text.
+- Linear needs `LINEAR_API_KEY`.
+- A missing variable stops the run before any work with an error naming it (exit code 2, like other intake errors). GitHub refs are unchanged.
+- Self-hosted Jira: `<JIRA_BASE_URL>/browse/KEY` is accepted when its origin matches `JIRA_BASE_URL`. `LOKI_TRACKER_INTAKE=0` turns tracker intake off. Intake only, no sync. Details: [docs/trackers.md](docs/trackers.md).
+
+## Two-way Slack
+
+Two-way Slack is on by default. With `SLACK_BOT_TOKEN` and `SLACK_SIGNING_SECRET` in the environment, `loki slack serve --port N` (127.0.0.1 by default) lets you mention `@loki <issue ref or task>` in a Slack thread to start a run, and a BLOCKED question is answered in the same thread. With either variable missing it prints one line naming both and exits 2 without binding a port. Set `LOKI_SLACK_INBOUND=0` to disable it. See [docs/slack.md](docs/slack.md) for the scopes.
+
+## Spec to contract
+
+On by default; set `LOKI_CONTRACT=0` to turn it off. It does nothing unless `.loki/contract.json` exists. `loki contract <spec.md>` parses a spec or PRD into numbered acceptance criteria (AC-1, AC-2, up to 50) from checklist items (`- [ ]`) and from bullets and numbered lists under headings such as "Acceptance criteria", "Requirements" or "Must", prints them, and writes `.loki/contract.json` at the repo root. When a run seals with a contract present, each criterion is matched to changed files and checks by keyword overlap and recorded in an optional `contract` field on the receipt (`keyword_match` or `no_match`). Unmatched criteria are listed under NOT PROVEN in the receipt and the PR body (advisory only, the verdict is unchanged). Keyword overlap is a heuristic: `keyword_match` means a changed file plausibly relates to the criterion, not that the criterion is proven. The legacy PRD path is unchanged.
 
 ## Triggers without a cloud
 
@@ -210,6 +234,10 @@ loki verify
 
 A verified receipt is bound to the run's event log, so a receipt lifted out of its run, or a log edited after sealing, does not verify. Signing proves the receipt came from the key holder; it does not prove the generated code is bug-free. A receipt only claims what its checks ran, and states what they did not.
 
+### Visual evidence (opt-in)
+
+With `LOKI_VISUAL_EVIDENCE=1`, a v10 run that changed web page files (html, jsx, tsx, vue, svelte under app/, pages/, src/ or public/) starts the repo's dev, preview or start script and screenshots each changed route with the repo's own Playwright (nothing is downloaded) into a fresh per-run directory `.loki/runs/<run_id>/evidence/<random>/` (at most 5 routes, total capture budget 25s, aborted with the seal stage). API-only repos with an openapi file get an HTTP transcript at `.loki/runs/<run_id>/evidence/<random>/http.json` (not hashed into the receipt). Each screenshot's sha256 is recorded in the receipt as `evidence_screens`, the PR body gets an Evidence section, and `loki verify` reports TAMPERED if a recorded screenshot is altered, missing or a symlink. Capture never fails the run; a skip is listed in NOT PROVEN. Off by default.
+
 ## Quiet output
 
 The v10 run is quiet by default: no stage chatter, only the final summary. `--verbose` tails the event stream live (one line per finished stage and a heartbeat with elapsed time and the running diff size). `--json` prints one JSON object (`ok`, `outcome`, `stop`, `run_id`, `receipt_sha256`) instead of text.
@@ -249,17 +277,23 @@ Exit 0 when every required check passes; optional warnings (an absent provider C
 
 Migration: `loki modernize heal <repo> --assess` was a legacy command for read-only analysis. The v10 path `loki modernize <repo> --to <target>` is not yet finished: only `--dry-run` works (inventory, dependency graph, unit clustering, cost, time and risk estimate). A real run stops after the estimate and prints `modernize: oracle capture and execution are not built yet; use --dry-run`. Targets `python3` and `java21` exist; the Java dependency graph is not wired in yet. Design: [docs/v10/MODERNIZE.md](docs/v10/MODERNIZE.md), user summary: [docs/v10/GUIDE-MODERNIZE.md](docs/v10/GUIDE-MODERNIZE.md).
 
-## Control Plane v0 (preview)
+## Control Plane v0
 
-A local control plane and UI for many runs, off by default. Enable it with `LOKI_CONTROL=1`:
+A local control plane and UI for many runs, on by default. Turn it off with `LOKI_CONTROL=0`:
 
 ```bash
-LOKI_CONTROL=1 loki control serve        # 127.0.0.1, default port 47821 (--port N, --db PATH)
-LOKI_CONTROL=1 loki control backfill .   # ship ./.loki/runs to the control plane
-LOKI_CONTROL=1 loki control status       # reachable? how many runs held?
+loki control serve                       # 127.0.0.1, default port 47821 (--port N, --db PATH)
+loki control backfill .                  # ship ./.loki/runs to the control plane
+loki control status                      # reachable? how many runs held?
 ```
 
-The URL comes from `LOKI_CONTROL_URL`, else `http://127.0.0.1:${LOKI_CONTROL_PORT:-47821}`. Set `LOKI_CONTROL_URL` on a run to ship it live. See [docs/v10/CONTROL-PLANE.md](docs/v10/CONTROL-PLANE.md).
+The URL comes from `LOKI_CONTROL_URL`, else `http://127.0.0.1:${LOKI_CONTROL_PORT:-47821}`. While `loki control serve` is running, runs on this machine ship to it automatically (it publishes `~/.loki/control/instance.json`, mode 0600, removed on exit); a run never starts the server. Set `LOKI_CONTROL_URL` to ship elsewhere. See [docs/v10/CONTROL-PLANE.md](docs/v10/CONTROL-PLANE.md).
+
+Answering a BLOCKED run: when a run stops on a spec conflict, its run page shows the question and an answer box. Submitting posts to `POST /v1/runs/<source>/<run>/answer` (JSON `{"answer": "..."}`, up to 4000 characters, loopback only) and writes `~/.loki/control/answers/<source>/<run>.answer.txt` (override the directory with `LOKI_CONTROL_ANSWER_DIR`). The page prints the resume command, `loki answer <run>`, which starts a fresh run carrying the task, the question and that file's text (or pass `--text "..."` yourself; with no run id it picks the newest BLOCKED run). A run that is not BLOCKED exits 2.
+
+Set `LOKI_CONTROL_DEFAULT=1` (off by default) to make `loki dashboard`, `loki dashboard start` and `loki dashboard open` start the Control Plane instead of the old dashboard. The old dashboard is unchanged when the flag is unset.
+
+Container, Helm and ECS deployment: [docs/control-plane-container.md](docs/control-plane-container.md).
 
 ## Providers
 
@@ -515,6 +549,7 @@ Loki 10 engine:
 | `loki owner/repo#N` | Same, from a GitHub, GitLab or Jira issue |
 | `loki quick "<task>"` | Small task, lean path, no PR |
 | `loki backlog owner/repo --all\|--label X\|--issues N,N` | Run every matching open issue, N in parallel (`--concurrency N`, `--dry-run`) |
+| `loki workspace list \| run <name> <ref>` | Experimental (`LOKI_WORKSPACES=1`): run one issue across the repos of a `loki.yaml` workspace; see [docs/WORKSPACES.md](docs/WORKSPACES.md) |
 | `loki status [--json]` | Current status |
 | `loki verify [run-id]` | Re-check a sealed receipt (exit codes above) |
 | `loki doctor [--json] [--airgap]` | Check environment and providers |
@@ -611,7 +646,7 @@ loki enterprise status
 | **Testing** | 8 automated quality gates | Test quality depends on AI assertions |
 | **Providers** | Claude, Cline, Codex, Aider and opencode | Non-Claude providers are experimental and mostly sequential |
 | **Dashboard** | Real-time single-machine monitoring | No multi-node clustering |
-| **Loki 10** | The v10 run (`loki "<task>"`, `loki owner/repo#N`, `loki quick`), `status`, `verify`, `backlog` | `loki start <issue ref|issue URL|"task">` runs Loki 10, `loki start <file>` stays legacy; `loki modernize <repo> --to` runs `--dry-run` only; Slack is not wired in; Control Plane v0 is a preview |
+| **Loki 10** | The v10 run (`loki "<task>"`, `loki owner/repo#N`, `loki quick`), `status`, `verify`, `backlog` | `loki start <issue ref|issue URL|"task">` runs Loki 10, `loki start <file>` stays legacy; `loki modernize <repo> --to` runs `--dry-run` only; two-way Slack is on by default (`loki slack serve`, `LOKI_SLACK_INBOUND=0` disables); Control Plane v0 is a preview |
 
 > **What "autonomous" means:** the system runs RARV cycles without prompting. It does NOT access your cloud accounts, payment systems or external services unless you provide credentials. Human oversight is expected for deployment, API keys and critical decisions.
 

package/SKILL.md

@@ -3,7 +3,7 @@ name: loki-mode
 description: An autonomous software factory that knows what it is supposed to deliver, and proves it did. Use when the user says Loki Mode or asks to build, fix or verify software autonomously.
 ---
 
-# Loki Mode v10.6.7
+# Loki Mode v10.6.9
 
 **Current entry points (Loki 10 engine):** `loki "<task>"`, `loki owner/repo#N` and `loki quick "<task>"` run the Loki 10 engine and end with a signed receipt (`loki verify`). `loki backlog owner/repo --all` runs many issues in parallel. Guide: `docs/v10/GUIDE.md`. The skill instructions below, and `loki start`, describe the legacy engine, which still ships and is being removed (`loki start owner/repo#N` still routes to it; prefer `loki owner/repo#N`).
 
@@ -473,4 +473,4 @@ See `CHANGELOG.md` entries [7.5.7], [7.5.8], [7.5.13] for the per-fix list and r
 
 ---
 
-**v10.6.7 | [Autonomi](https://www.autonomi.dev/) flagship product | core skill**
+**v10.6.9 | [Autonomi](https://www.autonomi.dev/) flagship product | core skill**

package/VERSION

@@ -1 +1 @@
-10.6.7
+10.6.9

package/autonomy/lib/backlog.py

@@ -10,6 +10,15 @@ ladder: 0 VERIFIED, 1 FAILED, 3 BUDGET_STOP, 4 BLOCKED, 5 STALLED). A draft PR
 from a failed run is still FAILED. Exit: 0 all ok, 3 only budget stops, 1 other
 failures, 2 usage/config error.
 
+Unit mode (D61 slice 10): --dag FILE [--group G] also runs the units of a
+decomposer DAG (engine10 Dag JSON: units[] with id, items, writeSet, optional
+deps; edges[] {from,to} mean "to" waits for "from"). Unit n runs on branch
+loki/unit-<group>-<n> in worktree unit-<group>-<n>, shares the one slot pool
+with issues, starts only after every parent passed, and is SKIPPED when a
+parent did not. The launcher gets the unit task text plus --no-pr, and the env
+LOKI_GROUP_ID, LOKI_UNIT_ID, LOKI_UNIT_N, LOKI_UNIT_DEPS, LOKI_UNIT_WRITE_SET.
+Passing unit branches are kept for the integrator; issue mode is unchanged.
+
 Test seam: LOKI_BACKLOG_LAUNCHER replaces the real launcher (called with the
 issue ref, cwd = the issue worktree).
 """
@@ -27,6 +36,8 @@ import time
 HERE = os.path.dirname(os.path.abspath(__file__))
 sys.path.insert(0, HERE)
 import loki_yaml  # noqa: E402
+import workspace  # noqa: E402
+import worktree_prep  # noqa: E402
 
 REPO_ROOT = os.path.abspath(os.path.join(HERE, "..", ".."))
 REPO_RE = re.compile(r"^[A-Za-z0-9_.-]+/[A-Za-z0-9_.-]+$")
@@ -110,6 +121,72 @@ def parse_result(rc, text):
     return False, "FAILED: " + (reason or "exit %d" % rc), usd
 
 
+MAX_DAG_UNITS = 500
+MAX_DAG_EDGES = 5000
+UNIT_ID_RE = re.compile(r"^[A-Za-z0-9_][A-Za-z0-9_.:/-]{0,127}$")
+
+
+def load_dag(path, group):
+    """-> (group, units) where units = [{n, id, task, deps(list of ids), write_set}] or raises ValueError."""
+    try:
+        with open(path) as f:
+            dag = json.load(f)
+    except (OSError, ValueError) as e:
+        raise ValueError("cannot read DAG %s: %s" % (path, e))
+    raw = dag.get("units") if isinstance(dag, dict) else None
+    if not isinstance(raw, list) or not raw:
+        raise ValueError("DAG has no units")
+    group = group or str(dag.get("group") or "g1")
+    if not re.match(r"^[A-Za-z0-9_][A-Za-z0-9_.-]*$", group) or ".." in group:
+        raise ValueError("group must match [A-Za-z0-9_][A-Za-z0-9_.-]* with no '..', got %r" % group)
+    if len(raw) > MAX_DAG_UNITS:
+        raise ValueError("DAG has %d units, the limit is %d" % (len(raw), MAX_DAG_UNITS))
+    ids = []
+    for u in raw:
+        uid = str(u.get("id", "")) if isinstance(u, dict) else ""
+        if not uid or uid in ids:
+            raise ValueError("DAG unit ids must be present and unique (got %r)" % uid)
+        if not UNIT_ID_RE.match(uid):
+            raise ValueError("DAG unit id %r is invalid (allowed: %s)" % (uid, UNIT_ID_RE.pattern))
+        ids.append(uid)
+    deps = {i: [] for i in ids}
+    for u in raw:
+        for d in u.get("deps") or []:
+            deps[str(u["id"])].append(str(d))
+    edges = dag.get("edges") or []
+    if not isinstance(edges, list) or len(edges) > MAX_DAG_EDGES:
+        raise ValueError("DAG edges must be a list of at most %d entries" % MAX_DAG_EDGES)
+    for e in edges:
+        if not isinstance(e, dict):
+            raise ValueError("DAG edge must be an object, got %r" % (e,))
+        src, dst = str(e.get("from")), str(e.get("to"))
+        if src not in deps or dst not in deps:
+            raise ValueError("DAG edge %s -> %s names an unknown unit id" % (src, dst))
+        if src not in deps[dst]:
+            deps[dst].append(src)
+    for i, ds in deps.items():
+        for d in ds:
+            if d not in deps or d == i:
+                raise ValueError("unit %s depends on unknown or itself: %s" % (i, d))
+    left = dict(deps)
+    while left:
+        free = [i for i, ds in left.items() if not [d for d in ds if d in left]]
+        if not free:
+            raise ValueError("DAG has a dependency cycle among: " + ", ".join(sorted(left)))
+        for i in free:
+            del left[i]
+    units = []
+    for n, u in enumerate(raw, 1):
+        uid = str(u["id"])
+        items = u.get("items") or []
+        task = "\n".join(str(x) for x in items) or str(u.get("task") or uid)
+        if task.lstrip().startswith("-"):
+            raise ValueError("unit %s task text starts with '-' and would be read as an option" % uid)
+        units.append({"n": n, "id": uid, "deps": deps[uid], "write_set": list(u.get("writeSet") or []),
+                      "task": task})
+    return group, units
+
+
 def main(argv):
     ap = argparse.ArgumentParser(prog="loki backlog", add_help=True)
     ap.add_argument("repo")
@@ -119,12 +196,20 @@ def main(argv):
     sel.add_argument("--issues")
     ap.add_argument("--concurrency", type=int)
     ap.add_argument("--dry-run", action="store_true")
+    ap.add_argument("--dag", help="decomposer DAG JSON; its units run on loki/unit-<group>-<n>")
+    ap.add_argument("--group", help="unit group id (default: the DAG's group, else g1)")
     a = ap.parse_args(argv)
 
     if not REPO_RE.match(a.repo):
         return die("repo must be owner/repo, got %r" % a.repo)
-    if not (a.all or a.label or a.issues):
-        return die("choose one of --all, --label X, --issues 1,2,3")
+    if not (a.all or a.label or a.issues or a.dag):
+        return die("choose one of --all, --label X, --issues 1,2,3, --dag FILE")
+    group, dag_units = None, []
+    if a.dag:
+        try:
+            group, dag_units = load_dag(a.dag, a.group)
+        except ValueError as e:
+            return die(str(e))
     numbers = None
     if a.issues:
         if not re.match(r"^\d+(,\d+)*$", a.issues):
@@ -162,16 +247,19 @@ def main(argv):
 
     try:
         issues = ([{"number": n, "title": ""} for n in numbers] if numbers
-                  else list_issues(a.repo, a.label, env))
+                  else list_issues(a.repo, a.label, env) if (a.all or a.label) else [])
     except RuntimeError as e:
         return die(redact(str(e), token), 1)
 
-    say("backlog: %s concurrency %d, %d issue(s)" % (a.repo, conc, len(issues)))
+    say("backlog: %s concurrency %d, %d issue(s)" % (a.repo, conc, len(issues))
+        + (", %d unit(s) in group %s" % (len(dag_units), group) if dag_units else ""))
     if a.dry_run:
         for i in issues:
             say("backlog: would run #%d %s" % (i["number"], i["title"]))
+        for u in dag_units:
+            say("backlog: would run unit %s-%d (%s) after: %s" % (group, u["n"], u["id"], ", ".join(u["deps"]) or "nothing"))
         return 0
-    if not issues:
+    if not issues and not dag_units:
         say("backlog: nothing to do")
         return 0
 
@@ -191,11 +279,25 @@ def main(argv):
         child_env["LOKI_BUDGET_LIMIT"] = str(cfg["budgets"]["per_run_usd"])
     day_cap = cfg.get("budgets", {}).get("per_day_usd")
 
-    state = {i["number"]: {"status": "queued", "ok": None, "cost": None, "ran": False} for i in issues}
-    for n in state:
-        say("backlog: #%d queued" % n)
-    pending = [i["number"] for i in issues]
-    running = {}  # n -> (Popen, log path, worktree)
+    # One job table for issues and units: they share one slot pool.
+    spec = {}
+    for i in issues:
+        n = i["number"]
+        spec[n] = {"label": "#%d" % n, "branch": "loki/backlog-%d" % n, "wt": "issue-%d" % n,
+                   "cmd": [launcher, "%s#%d" % (a.repo, n)], "env": {}, "deps": [], "unit": False}
+    key_of = {u["id"]: "unit-%s-%d" % (group, u["n"]) for u in dag_units}
+    for u in dag_units:
+        k = key_of[u["id"]]
+        spec[k] = {"label": k, "branch": "loki/" + k, "wt": k, "unit": True,
+                   "cmd": [launcher, u["task"], "--no-pr"],
+                   "deps": [key_of[d] for d in u["deps"]],
+                   "env": {"LOKI_GROUP_ID": group, "LOKI_UNIT_ID": u["id"], "LOKI_UNIT_N": str(u["n"]),
+                           "LOKI_UNIT_DEPS": ",".join(u["deps"]), "LOKI_UNIT_WRITE_SET": "\n".join(u["write_set"])}}
+    state = {k: {"status": "queued", "ok": None, "cost": None, "ran": False} for k in spec}
+    for k in state:
+        say("backlog: %s queued" % spec[k]["label"])
+    pending = list(spec)
+    running = {}  # key -> (Popen, log path, worktree)
     unmeasured = 0
 
     def stop_children(*_):
@@ -208,9 +310,9 @@ def main(argv):
     signal.signal(signal.SIGTERM, stop_children)
     signal.signal(signal.SIGINT, stop_children)
 
-    def finish(n):
+    def finish(k):
         nonlocal unmeasured
-        p, log, wt = running.pop(n)
+        p, log, wt = running.pop(k)
         try:
             with open(log, errors="replace") as f:
                 text = redact(f.read(), token)
@@ -223,51 +325,80 @@ def main(argv):
             unmeasured += 1
         else:
             add_spend(usd)
-        state[n].update(status=status, ok=ok, cost=usd)
-        say("backlog: #%d %s" % (n, status))
+        state[k].update(status=status, ok=ok, cost=usd)
+        say("backlog: %s %s" % (spec[k]["label"], status))
         if ok:
             git("worktree", "remove", "--force", wt, cwd=top)
-            git("branch", "-D", "loki/backlog-%d" % n, cwd=top)
+            if not spec[k]["unit"]:  # a passing unit branch is kept for the integrator
+                git("branch", "-D", spec[k]["branch"], cwd=top)
 
-    def launch(n):
-        wt = os.path.join(wt_root, "issue-%d" % n)
+    def launch(k):
+        s = spec[k]
+        wt = os.path.join(wt_root, s["wt"])
         if os.path.exists(wt):
             git("worktree", "remove", "--force", wt, cwd=top)
-        r = git("worktree", "add", "-B", "loki/backlog-%d" % n, wt, "HEAD", cwd=top)
-        if r.returncode != 0:
+        if workspace.enabled():
+            # Shared worktree prep (D51-B05): per-base lock, clean start point, deps copied.
+            git("branch", "-D", s["branch"], cwd=top)
+            try:
+                worktree_prep.prepare_worktree(top, wt, s["branch"])
+                r = None
+            except (RuntimeError, subprocess.CalledProcessError) as e:
+                msg = getattr(e, "stderr", None) or str(e)
+                r = subprocess.CompletedProcess([], 1, "", msg)
+        else:
+            r = git("worktree", "add", "-B", s["branch"], wt, "HEAD", cwd=top)
+        if r is not None and r.returncode != 0:
             err = (r.stderr.strip().splitlines() or ["git error"])[-1]
-            state[n].update(status="FAILED: worktree: " + redact(err, token), ok=False)
-            say("backlog: #%d %s" % (n, state[n]["status"]))
+            state[k].update(status="FAILED: worktree: " + redact(err, token), ok=False)
+            say("backlog: %s %s" % (s["label"], state[k]["status"]))
             return
-        log = os.path.join(wt_root, "logs", "issue-%d.log" % n)
-        cmd = [launcher, "%s#%d" % (a.repo, n)]
+        log = os.path.join(wt_root, "logs", s["wt"] + ".log")
         with open(log, "w") as lf:
-            p = subprocess.Popen(cmd, cwd=wt, env=child_env, stdout=lf, stderr=subprocess.STDOUT,
-                                 stdin=subprocess.DEVNULL, start_new_session=True)
-        running[n] = (p, log, wt)
-        state[n].update(status="running", ran=True)
-        say("backlog: #%d running" % n)
+            p = subprocess.Popen(s["cmd"], cwd=wt, env=dict(child_env, **s["env"]), stdout=lf,
+                                 stderr=subprocess.STDOUT, stdin=subprocess.DEVNULL, start_new_session=True)
+        running[k] = (p, log, wt)
+        state[k].update(status="running", ran=True)
+        say("backlog: %s running" % s["label"])
+
+    def next_ready():
+        """First pending job whose parents all passed; skip jobs whose parent did not."""
+        for k in list(pending):
+            ds = spec[k]["deps"]
+            bad = [d for d in ds if state[d]["ok"] is False]
+            if bad:
+                pending.remove(k)
+                state[k].update(status="SKIPPED: dependency %s did not pass" % spec[bad[0]]["label"], ok=False)
+                say("backlog: %s %s" % (spec[k]["label"], state[k]["status"]))
+                return next_ready()
+            if all(state[d]["ok"] is True for d in ds):
+                pending.remove(k)
+                return k
+        return None
 
     while pending or running:
-        for n in [n for n, (p, _l, _w) in running.items() if p.poll() is not None]:
-            finish(n)
+        for k in [k for k, (p, _l, _w) in running.items() if p.poll() is not None]:
+            finish(k)
         while pending and len(running) < conc:
             if day_cap and spent_today() >= day_cap:
-                for n in pending:
-                    state[n].update(status="BUDGET_STOP: daily budget $%.2f reached ($%.2f spent)" % (day_cap, spent_today()), ok=False)
-                    say("backlog: #%d %s" % (n, state[n]["status"]))
+                for k in pending:
+                    state[k].update(status="BUDGET_STOP: daily budget $%.2f reached ($%.2f spent)" % (day_cap, spent_today()), ok=False)
+                    say("backlog: %s %s" % (spec[k]["label"], state[k]["status"]))
                 pending = []
                 break
-            launch(pending.pop(0))
+            k = next_ready()
+            if k is None:
+                break
+            launch(k)
         if running:
             time.sleep(0.2)
 
     # ---- summary -----------------------------------------------------------
     say("")
     say("Summary: %s" % a.repo)
-    say("%-8s %-8s %s" % ("ISSUE", "COST", "RESULT"))
+    say("%-14s %-10s %s" % ("ITEM", "COST", "RESULT"))
     for n, s in state.items():
-        say("%-8s %-8s %s" % ("#%d" % n, ("$%.2f" % s["cost"] if s["cost"] is not None else "unmeasured" if s["ran"] else "-"), s["status"]))
+        say("%-14s %-10s %s" % (spec[n]["label"], ("$%.2f" % s["cost"] if s["cost"] is not None else "unmeasured" if s["ran"] else "-"), s["status"]))
     measured = sum(s["cost"] or 0 for s in state.values())
     say("Total measured cost: $%.2f%s" % (measured, " (%d run(s) unmeasured, not counted as $0)" % unmeasured if unmeasured else ""))
     bad = [s for s in state.values() if not s["ok"]]