loki-mode 10.6.8 → 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 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.
+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
 
@@ -153,7 +153,7 @@ 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
 
@@ -167,14 +167,15 @@ 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 (preview)
+## Two-way Slack
 
-With `LOKI_SLACK_INBOUND=1`, `loki slack serve --port N` (127.0.0.1 by default) lets you mention `@loki <issue ref or task>` in Slack to start a run, and answer a BLOCKED question in the same thread. Needs `SLACK_BOT_TOKEN` and `SLACK_SIGNING_SECRET` in the environment. See [docs/slack.md](docs/slack.md) for the scopes.
+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
 
-Opt in with `LOKI_CONTRACT=1` (off by default). `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.
+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
 
@@ -276,19 +277,19 @@ 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, which re-runs the task with that file's text.
+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.
 
@@ -645,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.8
+# 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.8 | [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.8
+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"]]

package/autonomy/lib/workspace.py

@@ -2,9 +2,11 @@
 """loki workspace: run one issue across several repos (D51 Phase B, D65).
 
     loki workspace list
+    loki workspace show <name>
     loki workspace run <name> <issue-ref>
+    loki workspace status [<run-id>]
 
-Gated by LOKI_WORKSPACES=1. Workspaces are defined in loki.yaml:
+On by default (LOKI_WORKSPACES=0 disables). Workspaces are defined in loki.yaml:
 
     workspaces:
       shop:
@@ -20,7 +22,12 @@ checked out, and evidence lands in
 .loki/workspaces/<name>/<run-id>/integration.json. Integration evidence is not
 part of the Seal.
 
-Exit: 0 all repos ok and integration not failed; 1 otherwise; 2 usage/config.
+Repos with no pending `after` run in parallel, at most `concurrency` at once
+(workspace key or LOKI_WORKSPACE_CONCURRENCY, default 2). SIGINT and SIGTERM
+kill each recorded child process group.
+
+Exit: 0 all repos ok and integration not failed; 3 when the only non-ok
+outcomes are budget stops (child exit 3); 1 otherwise; 2 usage/config.
 
 Test seam: LOKI_WORKSPACE_LAUNCHER replaces the engine launcher (called with
 the issue ref or task text, cwd = the repo worktree).
@@ -33,6 +40,8 @@ import re
 import signal
 import subprocess
 import sys
+import threading
+import time
 
 HERE = os.path.dirname(os.path.abspath(__file__))
 sys.path.insert(0, HERE)
@@ -46,8 +55,12 @@ def say(msg):
     print(msg, flush=True)
 
 
+BUDGET_EXIT = 3
+
+
 def enabled(env=None):
-    return (os.environ if env is None else env).get("LOKI_WORKSPACES") == "1"
+    """On by default; LOKI_WORKSPACES=0 disables."""
+    return (os.environ if env is None else env).get("LOKI_WORKSPACES") != "0"
 
 
 def git(*args, cwd=None):
@@ -194,46 +207,73 @@ def run_workspace(name, ref, workspaces, base_dir=None, launcher=None):
     launcher = launcher or os.environ.get("LOKI_WORKSPACE_LAUNCHER") or os.path.join(REPO_ROOT, "bin", "loki")
     child_env_base = dict(os.environ, LOKI_ENGINE="v10", LOKI_NO_BROWSER="1")
 
-    outcome, worktrees, heads = {}, {}, {}
-    running = {}
+    outcome, worktrees, heads, kind = {}, {}, {}, {}
+    running = {}  # repo -> (Popen, log file handle)
+    try:
+        conc = max(1, int(os.environ.get("LOKI_WORKSPACE_CONCURRENCY") or ws.get("concurrency") or 2))
+    except (TypeError, ValueError):
+        conc = 2
 
     def stop(*_):
-        for p in running.values():
+        for p, _lf in running.values():
             try:
                 os.killpg(p.pid, signal.SIGTERM)
             except OSError:
                 pass
         sys.exit(130)
-    signal.signal(signal.SIGTERM, stop)
-
-    for i, entry in enumerate(ordered):
-        repo = entry["repo"]
-        failed_dep = [d for d in entry.get("after") or [] if outcome.get(d) != "ok"]
-        if failed_dep:
-            outcome[repo] = "SKIPPED (predecessor failed: %s)" % ", ".join(failed_dep)
-            say("workspace: %s %s" % (repo, outcome[repo]))
-            continue
-        try:
-            src = source_checkout(entry)
-            dest = os.path.join(run_dir, "worktrees", _slug(repo))
-            wt = prepare(src, dest, "loki/ws-%s-%d" % (run_id, i), entry.get("setup"))
-        except (RuntimeError, OSError) as e:
-            outcome[repo] = "FAILED: %s" % e
-            say("workspace: %s %s" % (repo, outcome[repo]))
-            continue
-        worktrees[repo] = wt
-        siblings = [os.path.join(run_dir, "worktrees", _slug(o["repo"])) for o in ordered if o["repo"] != repo]
-        arg, extra = task_for(entry, ref, siblings)
-        log = os.path.join(run_dir, "%s.log" % _slug(repo))
-        say("workspace: %s running" % repo)
-        with open(log, "w") as lf:
+    if threading.current_thread() is threading.main_thread():
+        signal.signal(signal.SIGTERM, stop)
+        signal.signal(signal.SIGINT, stop)
+
+    index = {e["repo"]: i for i, e in enumerate(ordered)}
+    pending = list(ordered)
+    while pending or running:
+        for entry in list(pending):
+            repo = entry["repo"]
+            deps = entry.get("after") or []
+            failed_dep = [d for d in deps if d in kind and kind[d] != "ok"]
+            if failed_dep:
+                pending.remove(entry)
+                outcome[repo] = "SKIPPED (predecessor failed: %s)" % ", ".join(failed_dep)
+                kind[repo] = "budget" if all(kind[d] == "budget" for d in failed_dep) else "fail"
+                say("workspace: %s %s" % (repo, outcome[repo]))
+        for entry in list(pending):
+            repo = entry["repo"]
+            if len(running) >= conc:
+                break
+            if not all(kind.get(d) == "ok" for d in entry.get("after") or []):
+                continue
+            pending.remove(entry)
+            try:
+                src = source_checkout(entry)
+                dest = os.path.join(run_dir, "worktrees", _slug(repo))
+                wt = prepare(src, dest, "loki/ws-%s-%d" % (run_id, index[repo]), entry.get("setup"))
+            except (RuntimeError, OSError) as e:
+                outcome[repo], kind[repo] = "FAILED: %s" % e, "fail"
+                say("workspace: %s %s" % (repo, outcome[repo]))
+                continue
+            worktrees[repo] = wt
+            siblings = [os.path.join(run_dir, "worktrees", _slug(o["repo"])) for o in ordered if o["repo"] != repo]
+            arg, extra = task_for(entry, ref, siblings)
+            lf = open(os.path.join(run_dir, "%s.log" % _slug(repo)), "w")
+            say("workspace: %s running" % repo)
             p = subprocess.Popen([launcher, arg], cwd=wt, env=dict(child_env_base, **extra), stdout=lf,
                                  stderr=subprocess.STDOUT, stdin=subprocess.DEVNULL, start_new_session=True)
-            running[repo] = p
-            rc = p.wait()
-            running.pop(repo, None)
-        outcome[repo] = "ok" if rc == 0 else "FAILED: exit %d" % rc
-        say("workspace: %s %s" % (repo, outcome[repo]))
+            running[repo] = (p, lf)
+        for repo, (p, lf) in list(running.items()):
+            rc = p.poll()
+            if rc is None:
+                continue
+            lf.close()
+            running.pop(repo)
+            if rc == 0:
+                outcome[repo], kind[repo] = "ok", "ok"
+            else:
+                outcome[repo] = "FAILED: exit %d" % rc
+                kind[repo] = "budget" if rc == BUDGET_EXIT else "fail"
+            say("workspace: %s %s" % (repo, outcome[repo]))
+        if running:
+            time.sleep(0.05)
 
     for repo, wt in worktrees.items():
         r = git("rev-parse", "HEAD", cwd=wt)
@@ -247,21 +287,71 @@ def run_workspace(name, ref, workspaces, base_dir=None, launcher=None):
         json.dump(ev, f, indent=2, sort_keys=True)
     os.replace(tmp, ev_path)
 
+    try:
+        import workspace_comment
+        workspace_comment.post_comments(name, run_id, run_dir, worktrees, ev, say)
+    except Exception as e:  # commenting must never fail the run
+        say("workspace: commenting skipped (%s)" % type(e).__name__)
+
     say("")
     say("Summary: workspace %s (%s)" % (name, run_id))
     for repo, res in outcome.items():
         say("%-30s %s" % (repo, res))
     say("%-30s %s" % ("integration", ev["status"]))
-    bad = any(v != "ok" for v in outcome.values()) or ev["status"] == "failed"
-    return (1 if bad else 0), ev_path
+    if ev["status"] == "failed" or any(k == "fail" for k in kind.values()):
+        return 1, ev_path
+    return (3 if any(k == "budget" for k in kind.values()) else 0), ev_path
+
+
+def _runs(base_dir):
+    """Yield (workspace, run_id, evidence dict) for every recorded run, oldest first."""
+    root = os.path.join(base_dir, ".loki", "workspaces")
+    if not os.path.isdir(root):
+        return
+    for name in sorted(os.listdir(root)):
+        for run_id in sorted(os.listdir(os.path.join(root, name))):
+            path = os.path.join(root, name, run_id, "integration.json")
+            try:
+                with open(path) as f:
+                    yield name, run_id, json.load(f)
+            except (OSError, ValueError):
+                continue
+
+
+def status(base_dir, run_id=None, say=say):
+    """Print per-repo rows from integration.json for one run, or for every run."""
+    found = [r for r in _runs(base_dir) if run_id in (None, r[1])]
+    if not found:
+        say("workspace: no such run %s" % run_id if run_id else "no workspace runs recorded")
+        return 0 if run_id is None else 1
+    for name, rid, ev in found:
+        say("%s %s" % (name, rid))
+        for repo, res in sorted((ev.get("outcomes") or {}).items()):
+            say("%-30s %s" % (repo, res))
+        say("%-30s %s" % ("integration", ev.get("status")))
+    return 0
+
+
+def show(name, workspaces, say=say):
+    ws = workspaces.get(name)
+    if ws is None:
+        say("workspace: unknown workspace %r (known: %s)" % (name, ", ".join(sorted(workspaces)) or "none"))
+        return 2
+    say("%s (concurrency %s)" % (name, ws.get("concurrency") or 2))
+    for e in ws.get("repos") or []:
+        extra = "; after: " + ", ".join(e["after"]) if e.get("after") else ""
+        say("%s  path: %s%s" % (e.get("repo", "?"), e.get("path") or "(clone)", extra))
+    integ = ws.get("integration") or {}
+    say("integration: %s" % (integ.get("command") or "not configured"))
+    return 0
 
 
 def main(argv):
     if not enabled():
-        say("loki workspace is disabled. Set LOKI_WORKSPACES=1 to use it.")
+        say("loki workspace is disabled (LOKI_WORKSPACES=0). Unset it to use workspaces.")
         return 2
     if not argv or argv[0] in ("-h", "--help", "help"):
-        say("Usage: loki workspace list | run <name> <owner/repo#N | task text>")
+        say("Usage: loki workspace list | show <name> | run <name> <owner/repo#N | task text> | status [<run-id>]")
         return 0 if argv else 2
     try:
         workspaces, errors = load_workspaces()
@@ -279,10 +369,14 @@ def main(argv):
         for n, ws in sorted(workspaces.items()):
             say("%s: %s" % (n, ", ".join(e.get("repo", "?") for e in ws.get("repos") or [])))
         return 0
+    if cmd == "show" and len(argv) == 2:
+        return show(argv[1], workspaces)
+    if cmd == "status" and len(argv) <= 2:
+        return status(os.getcwd(), argv[1] if len(argv) == 2 else None)
     if cmd == "run" and len(argv) >= 3:
         rc, _ = run_workspace(argv[1], " ".join(argv[2:]), workspaces)
         return rc
-    say("Usage: loki workspace list | run <name> <issue-ref>")
+    say("Usage: loki workspace list | show <name> | run <name> <issue-ref> | status [<run-id>]")
     return 2