loki-mode 10.6.8 → 10.6.10

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
 
 

package/autonomy/lib/workspace_comment.py

@@ -0,0 +1,91 @@
+"""Post the workspace integration result as one PR comment per repo PR (D51-B11).
+
+No LLM. Uses the `gh` CLI with the caller's own environment, so GH_TOKEN or
+GITHUB_TOKEN is read by gh itself and never placed in argv, the comment body
+or any log line. Commenting is best effort: it never raises and never changes
+the run's exit code. Opt out with LOKI_WORKSPACE_COMMENT=0.
+"""
+import os
+import re
+import subprocess
+import tempfile
+
+GH_TIMEOUT_S = 60
+
+
+def verdict(ev):
+    """Map integration evidence to a label. Only a clean exit 0 reads as PASSED."""
+    status = ev.get("status")
+    if "timeout" in str(ev.get("note") or "").lower():
+        return "TIMEOUT"
+    if status == "passed" and ev.get("exit_code") == 0:
+        return "PASSED"
+    if status == "not_configured":
+        return "NOT CONFIGURED"
+    return "FAILED"
+
+
+def render(ws_name, run_id, repo, ev):
+    heads = ev.get("heads") or {}
+    lines = ["Loki workspace `%s` run `%s`" % (ws_name, run_id), "",
+             "Integration: **%s** (exit code %s)" % (verdict(ev), ev.get("exit_code")), "",
+             "| Repo | Outcome | Head SHA |", "| --- | --- | --- |"]
+    outcomes = ev.get("outcomes") or {}
+    for r in sorted(heads.keys() | outcomes.keys()):
+        out = outcomes.get(r, "unknown")
+        out = "ok" if out == "ok" else str(out).replace("|", "/")
+        mark = " (this PR)" if r == repo else ""
+        lines.append("| %s%s | %s | %s |" % (r, mark, out, heads.get(r) or "none"))
+    if ev.get("log_sha256"):
+        lines += ["", "Integration log sha256: `%s`" % ev["log_sha256"]]
+    lines += ["", "Integration evidence is not part of the Seal."]
+    return "\n".join(lines) + "\n"
+
+
+def _gh(args, cwd):
+    return subprocess.run(["gh"] + args, cwd=cwd, stdin=subprocess.DEVNULL, capture_output=True,
+                          text=True, timeout=GH_TIMEOUT_S)
+
+
+def _branch(wt):
+    r = subprocess.run(["git", "-C", wt, "rev-parse", "--abbrev-ref", "HEAD"], capture_output=True, text=True,
+                       timeout=GH_TIMEOUT_S)
+    b = r.stdout.strip()
+    return b if r.returncode == 0 and b and b != "HEAD" else None
+
+
+def post_comments(ws_name, run_id, run_dir, worktrees, ev, say):
+    """One comment per repo that has an open PR on its run branch. Never raises."""
+    if os.environ.get("LOKI_WORKSPACE_COMMENT") == "0":
+        return 0
+    posted = 0
+    try:
+        for repo, wt in sorted(worktrees.items()):
+            try:
+                branch = _branch(wt)
+                if not branch:
+                    continue
+                r = _gh(["pr", "list", "--repo", repo, "--head", branch, "--state", "open",
+                         "--json", "number", "--jq", ".[0].number"], wt)
+                num = r.stdout.strip()
+                if r.returncode != 0 or not re.fullmatch(r"\d+", num):
+                    continue
+                fd, body = tempfile.mkstemp(prefix="comment-", suffix=".md", dir=run_dir)  # mode 0600
+                try:
+                    with os.fdopen(fd, "w") as f:
+                        f.write(render(ws_name, run_id, repo, ev))
+                    c = _gh(["pr", "comment", num, "--repo", repo, "--body-file", body], wt)
+                finally:
+                    try:
+                        os.unlink(body)
+                    except OSError:
+                        pass
+                if c.returncode == 0:
+                    posted += 1
+                else:
+                    say("workspace: comment on %s#%s failed (gh exit %d)" % (repo, num, c.returncode))
+            except (OSError, subprocess.SubprocessError, ValueError) as e:
+                say("workspace: comment for %s skipped (%s)" % (repo, type(e).__name__))
+    except Exception as e:  # never fail the run because commenting failed
+        say("workspace: commenting skipped (%s)" % type(e).__name__)
+    return posted

package/autonomy/loki

@@ -1630,7 +1630,7 @@ show_help() {
     echo "  start [SPEC]     Start a build (PRD file, GitHub/GitLab/Jira/Azure issue, or no arg)"
     echo "  plan <PRD-file>  Dry-run analysis: complexity, cost, execution plan"
     echo "  backlog <owner/repo> --all|--label X|--issues N,N   Run every matching open issue, N in parallel"
-    echo "  workspace list | run <name> <ref>   Multi-repo runs from loki.yaml workspaces (LOKI_WORKSPACES=1)"
+    echo "  workspace list | run <name> <ref>   Multi-repo runs from loki.yaml workspaces (LOKI_WORKSPACES=0 disables)"
     echo "  quickstart [idea]  Guided first build: setup, idea, template, plan, go"
     echo ""
     echo "Session:"
@@ -1783,7 +1783,7 @@ show_help() {
     echo "  syslog telemetry template test tour trigger trust trust-metrics"
     echo "  ultracode update verify version voice watch watchdog web welcome why"
     echo "  wiki worktree (wt)"
-    echo "  control (preview, needs LOKI_CONTROL=1)"
+    echo "  control"
     echo ""
     echo "Any command: loki <command> --help"
     echo ""
@@ -1897,7 +1897,74 @@ _loki_dashboard_port_is_ours() {
     return 1
 }
 
+# C3: the Control Plane is the default UI. Prints a live loopback URL from
+# ~/.loki/control/instance.json (pid alive, http loopback only, /health says
+# service=loki-control), or starts `loki control serve` detached and waits for
+# it to publish one. Returns 1 when the caller should fall back to the old
+# dashboard (LOKI_CONTROL_DEFAULT=0, no bun, no python3, server did not start).
+_loki_control_live_url() {
+    local inst="${HOME}/.loki/control/instance.json" fields pid url health
+    [ -f "$inst" ] || return 1
+    fields=$(python3 - "$inst" 2>/dev/null <<'PY'
+import json, sys, urllib.parse
+d = json.load(open(sys.argv[1]))
+pid, url = d.get("pid"), d.get("url")
+if not isinstance(pid, int) or isinstance(pid, bool) or not isinstance(url, str):
+    sys.exit(1)
+u = urllib.parse.urlparse(url)
+if u.scheme != "http" or u.hostname not in ("127.0.0.1", "localhost", "::1"):
+    sys.exit(1)
+if u.path not in ("", "/") or u.query or u.fragment or u.params or "@" in u.netloc or "?" in url or "#" in url:
+    sys.exit(1)
+print(pid, url.rstrip("/"))
+PY
+) || return 1
+    pid="${fields%% *}"; url="${fields#* }"
+    kill -0 "$pid" 2>/dev/null || return 1
+    health=$(curl -g -s --max-time 2 "${url}/health" 2>/dev/null) || return 1
+    case "$health" in *'"service"'*'"loki-control"'*) ;; *) return 1 ;; esac
+    printf '%s\n' "$url"
+}
+
+_loki_control_ui() {
+    [ "${LOKI_CONTROL_DEFAULT:-1}" = "0" ] && return 1
+    local url="" open_it=1 arg i
+    for arg in "$@"; do [ "$arg" = "--no-open" ] && open_it=0; done
+    if [ "${LOKI_HEADLESS:-0}" = "1" ] || [ "${LOKI_NO_BROWSER:-0}" = "1" ]; then open_it=0; fi
+    command -v python3 >/dev/null 2>&1 || return 1
+    url=$(_loki_control_live_url) || url=""
+    if [ -z "$url" ]; then
+        if ! command -v bun >/dev/null 2>&1; then
+            echo "loki: the Control Plane needs bun (https://bun.sh); using the classic dashboard." >&2
+            return 1
+        fi
+        local cli="$SKILL_DIR/loki-ts/dist/loki.js" cdir="${HOME}/.loki/control" spid
+        [ -f "$cli" ] || cli="$SKILL_DIR/loki-ts/src/cli.ts"
+        mkdir -p "$cdir" && chmod 700 "$cdir" 2>/dev/null || true
+        LOKI_CONTROL=1 LOKI_NO_BROWSER=1 nohup bun "$cli" control serve >"$cdir/serve.log" 2>&1 </dev/null &
+        spid=$!
+        echo "$spid" > "$cdir/serve.pid" 2>/dev/null || true
+        for i in $(seq 1 100); do
+            url=$(_loki_control_live_url) && break
+            url=""
+            kill -0 "$spid" 2>/dev/null || break
+            sleep 0.1
+        done
+        if [ -z "$url" ]; then
+            echo "loki: the Control Plane did not start (see $cdir/serve.log); using the classic dashboard." >&2
+            return 1
+        fi
+    fi
+    if [ "$open_it" = "1" ]; then
+        loki_open_url "$url" || echo "$url"
+    else
+        echo "$url"
+    fi
+    return 0
+}
+
 cmd_ui() {
+    _loki_control_ui "$@" && return 0
     local port="" pid=""
     if [ -f "$DASHBOARD_PID_FILE" ]; then
         pid=$(cat "$DASHBOARD_PID_FILE" 2>/dev/null)
@@ -7325,16 +7392,15 @@ _loki_dashboard_bind_is_safe() {
 cmd_dashboard() {
     local subcommand="${1:-}"
 
-    # LOKI_CONTROL_DEFAULT=1 (off by default): open the Control Plane instead of the old dashboard.
-    # The old dashboard stays available when the flag is unset, and via `loki dashboard stop|status|url`.
-    if [ "${LOKI_CONTROL_DEFAULT:-0}" = "1" ]; then
-        case "$subcommand" in
-            ""|start|open)
-                echo "LOKI_CONTROL_DEFAULT=1: starting the Control Plane (unset it to use the old dashboard)"
-                LOKI_CONTROL=1 exec "$0" control serve
-                ;;
-        esac
-    fi
+    # The Control Plane is the default UI; LOKI_CONTROL_DEFAULT=0 restores the classic dashboard.
+    # Only the bare forms are taken over; `start --port ...` and friends keep the classic server.
+    case "$subcommand" in
+        ""|start|open)
+            if [ $# -le 1 ] || { [ $# -eq 2 ] && [ "$2" = "--no-open" ]; }; then
+                _loki_control_ui "${@:2}" && return 0
+            fi
+            ;;
+    esac
 
     # If no subcommand provided, show help (backward compatible with old behavior)
     if [ -z "$subcommand" ]; then
@@ -12921,10 +12987,10 @@ cmd_config_schema() {
     loki_config_generate_schema
 }
 
-# D65: multi-repo workspaces (D51 Phase B). Gated by LOKI_WORKSPACES=1.
+# D65: multi-repo workspaces (D51 Phase B). On by default; LOKI_WORKSPACES=0 disables.
 cmd_workspace() {
-    if [ "${LOKI_WORKSPACES:-}" != "1" ]; then
-        echo -e "${RED}loki workspace is disabled.${NC} Set LOKI_WORKSPACES=1 to use it." >&2
+    if [ "${LOKI_WORKSPACES:-}" = "0" ]; then
+        echo -e "${RED}loki workspace is disabled.${NC} Unset LOKI_WORKSPACES (it is set to 0)." >&2
         return 2
     fi
     command -v python3 >/dev/null 2>&1 || { echo -e "${RED}loki workspace: python3 is required${NC}" >&2; return 2; }
@@ -18714,10 +18780,12 @@ with open(manifest_path, 'w') as f:
 # usable.
 # ---------------------------------------------------------------------------
 cmd_verify() {
-    # D48: --pubkey verifies a receipt against a given public key (v10 engine, no ~/.loki needed).
+    # D48: --pubkey FILE or --pubkey=FILE (any position) verifies a receipt against a given public key (v10 engine, no ~/.loki needed).
     local _pk_arg
     for _pk_arg in "$@"; do
-        [ "$_pk_arg" = "--pubkey" ] && LOKI_ENGINE=v10 exec "$_LOKI_SCRIPT_DIR/../bin/loki" verify "$@"
+        case "$_pk_arg" in
+            --pubkey|--pubkey=*) LOKI_ENGINE=v10 exec "$_LOKI_SCRIPT_DIR/../bin/loki" verify "$@" ;;
+        esac
     done
     # --fast: deterministic checks only, in milliseconds. Measured on this repo
     # (1,932 tracked files): 298 ms cold, 87 ms warm, 19 ms diff-scoped, against
@@ -21897,6 +21965,8 @@ main() {
                     echo "Alias for 'loki api start'. Starts the dashboard HTTP API"
                     echo "server (FastAPI, port 57374 by default)."
                     echo ""
+                    echo "For the UI, run 'loki' (opens the Control Plane) or 'loki control serve'."
+                    echo ""
                     echo "Options:"
                     echo "  --host HOST    Bind host (default: 127.0.0.1)"
                     echo "  --port PORT    Bind port (default: 57374)"
@@ -33870,14 +33940,14 @@ cmd_outcomes() {
     LOKI_DIR="${LOKI_DIR:-.loki}" python3 "$lib" "$@"
 }
 
-# loki control -- D56 control plane (preview). The live route is the Bun CLI
+# loki control -- D56 control plane (on by default). The live route is the Bun CLI
 # (loki-ts/src/commands/control.ts); this is the LOKI_LEGACY_BASH / no-shim
-# fallback. It keeps the gate and help in bash and hands the work to Bun.
+# fallback. It keeps the off switch and help in bash and hands the work to Bun.
 cmd_control() {
     local sub="${1:-}"
     case "$sub" in
         ""|-h|--help|help)
-            echo "Usage: loki control <command> [options]   (preview, requires LOKI_CONTROL=1)"
+            echo "Usage: loki control <command> [options]   (on by default; LOKI_CONTROL=0 turns it off; requires bun)"
             echo ""
             echo "Commands:"
             echo "  serve [--port N] [--db PATH]   Run the control plane + UI on 127.0.0.1"
@@ -33886,8 +33956,8 @@ cmd_control() {
             return 0
             ;;
     esac
-    if [ "${LOKI_CONTROL:-}" != "1" ]; then
-        echo "loki control is in preview. Enable it with: export LOKI_CONTROL=1"
+    if [ "${LOKI_CONTROL:-}" = "0" ]; then
+        echo "loki control is off (LOKI_CONTROL=0). Unset it to turn the Control Plane back on."
         return 0
     fi
     local cli="$SKILL_DIR/loki-ts/dist/loki.js"

package/bin/loki

@@ -354,12 +354,12 @@ case "${LOKI_ENGINE:-$_loki_engine_default}" in
             # `loki <ref>`; any other start call (PRD file, flags first, one word) stays legacy.
             start)
                 case "${2:-}" in
-                    */*\#[0-9]*|http*://*/issues/*|http*://*/browse/*|*" "*) _e10=1; _e10_args=("${@:2}") ;;
+                    */*\#[0-9]*|http*://*/issues/*|http*://*/browse/*|jira:*|linear:*|https://linear.app/*/issue/*|*" "*) _e10=1; _e10_args=("${@:2}") ;;
                     *) _e10=0 ;;
                 esac
                 ;;
             # http*://*/issues/* also covers GitLab's /-/issues/ URLs.
-            */*\#[0-9]*|http*://*/issues/*|http*://*/browse/*) _e10=1 ;;
+            */*\#[0-9]*|http*://*/issues/*|http*://*/browse/*|jira:*|linear:*|https://linear.app/*/issue/*) _e10=1 ;;
             *" "*) _e10=1 ;;
             # ponytail: a one-word argument stays on the legacy CLI. The telemetry
             # allowlist is not a command registry (estimate, intent, outcomes are
@@ -567,7 +567,7 @@ fi
 # Two-token routes (provider show/list, memory list/index) match on the first
 # token only; the Bun dispatcher handles subcommand routing internally.
 case "${1:-}" in
-    version|--version|-v|status|stats|doctor|provider|memory|rollback|internal|kpis|trust|proof|receipt|wiki|crash|control|contract)
+    version|--version|-v|status|stats|doctor|provider|memory|rollback|internal|kpis|trust|proof|receipt|wiki|crash|control|contract|slack|answer)
         # v7.5.2: rollback added (wires loki-ts/src/commands/rollback.ts).
         # v7.5.3: internal added for autonomy/run.sh phase1-hooks calls.
         # v7.5.28: kpis added (Phase K MVP: read-only KPI snapshot).

package/completions/_loki

@@ -206,6 +206,7 @@ function _loki_commands {
         'crash:Crash report management'
         'otel:OpenTelemetry management'
         'wiki:Wiki commands'
+        'answer:Resume a BLOCKED run with an answer'
         'control:Control plane (preview, LOKI_CONTROL=1)'
         'workspace:Multi-project workspaces (preview, LOKI_WORKSPACES=1)'
         'backlog:Run every matching open issue, N in parallel'

package/completions/loki.bash

@@ -5,7 +5,7 @@ _loki_completion() {
     _init_completion || return
 
     # Main subcommands (must match autonomy/loki main case statement)
-    local main_commands="start backlog quick monitor demo tour welcome init stop pause resume steer status next ship dashboard web serve api sandbox notify import github issue intent config provider reset memory compound checkpoint council dogfood projects enterprise secrets cockpit secure own handoff doctor watchdog audit metrics syslog onboard share proof receipt outcomes explain plan report cost estimate kpis stats test ci watch telemetry agent context ctx code run export review optimize heal modernize migrate cluster worktree wt trigger failover remote deploy docker mcp magic assets analyze compliance crash control workspace open otel preview quickstart rc rollback self-update sentrux setup-skill spec state template trust trust-metrics ultracode update verify voice why wiki bench cleanup logs grill docs cp version completions help keys"
+    local main_commands="start backlog quick monitor demo tour welcome init stop pause resume steer status next ship dashboard web serve api sandbox notify import github issue intent config provider reset memory compound checkpoint council dogfood projects enterprise secrets cockpit secure own handoff doctor watchdog audit metrics syslog onboard share proof receipt outcomes explain plan report cost estimate kpis stats test ci watch telemetry agent context ctx code run export review optimize heal modernize migrate cluster worktree wt trigger failover remote deploy docker mcp magic assets analyze compliance crash control workspace open otel preview quickstart rc rollback self-update sentrux setup-skill spec state template trust trust-metrics ultracode update verify voice why wiki bench cleanup logs grill docs cp version completions help keys answer"
 
     # 1. If we are on the first argument (subcommand)
     if [[ $cword -eq 1 ]]; then

package/dashboard/__init__.py

@@ -7,7 +7,7 @@ Modules:
     control: Session control API (start/stop/pause/resume)
 """
 
-__version__ = "10.6.8"
+__version__ = "10.6.10"
 
 # Expose the control app for easy import
 try:

package/dashboard/api_start.py

@@ -21,6 +21,7 @@ import os
 import re
 import shutil
 import subprocess
+import sys
 import threading
 import time
 import urllib.error
@@ -156,6 +157,25 @@ def _project_dir() -> str:
     return os.environ.get("LOKI_PROJECT_DIR") or os.getcwd()
 
 
+def _autonomy_lib():
+    lib = os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), "autonomy", "lib")
+    if lib not in sys.path:
+        sys.path.insert(0, lib)
+
+
+def _workspaces_enabled() -> bool:
+    """Same rule as `loki workspace`: on by default, LOKI_WORKSPACES=0 disables."""
+    _autonomy_lib()
+    import workspace
+    return workspace.enabled()
+
+
+def _worktree_prep():
+    _autonomy_lib()
+    import worktree_prep
+    return worktree_prep
+
+
 def _prepare_workdir(repo: str, number: int, token: str) -> str:
     """One git worktree per issue, off the repo's default branch."""
     env = dict(os.environ, GH_TOKEN=token, GIT_TERMINAL_PROMPT="0")
@@ -180,7 +200,12 @@ def _prepare_workdir(repo: str, number: int, token: str) -> str:
     stamp = time.strftime("%Y%m%d%H%M%S")
     wt = _home() / "worktrees" / slug / ("issue-%d-%s" % (number, stamp))
     wt.parent.mkdir(parents=True, exist_ok=True)
-    _git("worktree", "add", "-b", "loki/backlog-%d-%s" % (number, stamp), str(wt), start, cwd=base)
+    branch = "loki/backlog-%d-%s" % (number, stamp)
+    if _workspaces_enabled():
+        # Shared worktree prep (D51-B06): same per-base lock and dep copy as backlog and workspace runs.
+        _worktree_prep().prepare_worktree(base, str(wt), branch, base=start)
+        return str(wt)
+    _git("worktree", "add", "-b", branch, str(wt), start, cwd=base)
     return str(wt)
 
 

package/docs/INSTALLATION.md

@@ -2,7 +2,7 @@
 
 The flagship product of [Autonomi](https://www.autonomi.dev/). Loki Mode is a spec-driven autonomous builder with a built-in trust layer that takes any spec to a deployed product and verifies completion with evidence (quality gates plus a completion council), not just a "done" claim. Complete installation instructions for all platforms and use cases.
 
-**Version:** v10.6.8
+**Version:** v10.6.10
 
 **Engine note:** `loki "<task>"`, `loki owner/repo#N` and `loki quick` run the Loki 10 engine. `loki start` still routes to the legacy engine, which is being removed (planned work resumes 2026-10-07); prefer `loki owner/repo#N`. See [docs/v10/GUIDE.md](v10/GUIDE.md).