loki-mode 10.6.6 → 10.6.8

package/autonomy/lib/workspace.py

@@ -0,0 +1,290 @@
+#!/usr/bin/env python3
+"""loki workspace: run one issue across several repos (D51 Phase B, D65).
+
+    loki workspace list
+    loki workspace run <name> <issue-ref>
+
+Gated by LOKI_WORKSPACES=1. Workspaces are defined in loki.yaml:
+
+    workspaces:
+      shop:
+        repos:
+          - {repo: acme/api, path: ~/src/api, setup: "npm ci"}
+          - {repo: acme/web, path: ~/src/web, after: [acme/api]}
+        integration: {command: "make e2e", timeout_s: 900}
+
+Each repo gets its own worktree and engine run (continue-and-report: a failing
+repo does not stop the others; dependents of a failed repo are SKIPPED). After
+every repo has finished, the integration command runs once with each run branch
+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.
+
+Test seam: LOKI_WORKSPACE_LAUNCHER replaces the engine launcher (called with
+the issue ref or task text, cwd = the repo worktree).
+"""
+import datetime
+import hashlib
+import json
+import os
+import re
+import signal
+import subprocess
+import sys
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+sys.path.insert(0, HERE)
+
+REPO_ROOT = os.path.abspath(os.path.join(HERE, "..", ".."))
+REPO_RE = re.compile(r"^[A-Za-z0-9_.-]+/[A-Za-z0-9_.-]+$")
+REF_RE = re.compile(r"^([A-Za-z0-9_.-]+/[A-Za-z0-9_.-]+)#(\d+)$")
+
+
+def say(msg):
+    print(msg, flush=True)
+
+
+def enabled(env=None):
+    return (os.environ if env is None else env).get("LOKI_WORKSPACES") == "1"
+
+
+def git(*args, cwd=None):
+    return subprocess.run(["git", *args], cwd=cwd, capture_output=True, text=True)
+
+
+def load_workspaces(cfg=None):
+    """Return (workspaces, errors) from loki.yaml (or the given cfg mapping)."""
+    if cfg is None:
+        import loki_yaml
+        cfg, _path, errors = loki_yaml.load()
+        if errors:
+            return {}, errors
+    return cfg.get("workspaces") or {}, []
+
+
+def order_repos(ws):
+    """Return repo entries ordered so every `after` predecessor comes first.
+
+    Raises ValueError on an unknown `after` entry, a duplicate repo or a cycle.
+    """
+    entries = list(ws.get("repos") or [])
+    names = [e.get("repo") for e in entries]
+    if len(set(names)) != len(names):
+        raise ValueError("duplicate repo in workspace")
+    for e in entries:
+        if not isinstance(e.get("repo"), str) or not REPO_RE.match(e["repo"]):
+            raise ValueError("repo must be owner/name, got %r" % (e.get("repo"),))
+        for dep in e.get("after") or []:
+            if dep not in names:
+                raise ValueError("%s: unknown after repo %s" % (e["repo"], dep))
+    done, ordered, remaining = set(), [], entries
+    while remaining:
+        ready = [e for e in remaining if all(d in done for d in e.get("after") or [])]
+        if not ready:
+            raise ValueError("cycle in `after`: " + ", ".join(e["repo"] for e in remaining))
+        for e in ready:
+            ordered.append(e)
+            done.add(e["repo"])
+        remaining = [e for e in remaining if e not in ready]
+    return ordered
+
+
+def _slug(repo):
+    return repo.replace("/", "__")
+
+
+def source_checkout(entry):
+    """Local checkout for a repo entry: its `path`, else clone into ~/.loki/repos/<slug>."""
+    if entry.get("path"):
+        return os.path.abspath(os.path.expanduser(entry["path"]))
+    dest = os.path.join(os.path.expanduser("~"), ".loki", "repos", _slug(entry["repo"]))
+    if not os.path.isdir(os.path.join(dest, ".git")):
+        os.makedirs(os.path.dirname(dest), exist_ok=True)
+        r = subprocess.run(["git", "clone", "https://github.com/%s.git" % entry["repo"], dest],
+                           capture_output=True, text=True)
+        if r.returncode != 0:
+            raise RuntimeError("clone failed: " + (r.stderr.strip().splitlines() or ["git error"])[-1])
+    return dest
+
+
+def prepare(source, dest, branch, setup):
+    """Make a worktree via worktree_prep when available, else a minimal `git worktree add`."""
+    try:
+        import worktree_prep
+        res = worktree_prep.prepare_worktree(source, dest, branch, setup=setup)
+        return res["path"]
+    except ImportError:
+        pass
+    os.makedirs(os.path.dirname(dest), exist_ok=True)
+    r = git("worktree", "add", "-B", branch, dest, "HEAD", cwd=source)
+    if r.returncode != 0:
+        raise RuntimeError("worktree: " + (r.stderr.strip().splitlines() or ["git error"])[-1])
+    if setup:
+        s = subprocess.run(setup, shell=True, cwd=dest, capture_output=True, text=True)
+        if s.returncode != 0:
+            raise RuntimeError("setup failed: " + (s.stderr.strip().splitlines() or ["no output"])[-1])
+    return dest
+
+
+def task_for(entry, ref, siblings):
+    """(launcher argument, extra env) for a repo: the issue ref when it lives here, else task text."""
+    m = REF_RE.match(ref)
+    if m and m.group(1) == entry["repo"]:
+        return ref, {}
+    text = ("Implement the change described by %s for the repo %s. Sibling worktrees (read-only "
+            "context, do not edit): %s" % (ref, entry["repo"], ", ".join(siblings) or "none"))
+    return text, {"LOKI_E10_TASK_TEXT": text}
+
+
+def run_integration(ws, run_dir, worktrees, heads):
+    """Run the integration command once; return the evidence dict."""
+    integ = ws.get("integration") or {}
+    cmd = integ.get("command")
+    ev = {"heads": heads, "exit_code": None, "log_sha256": None, "status": "not_configured",
+          "seal": False, "note": "integration evidence is not part of the Seal"}
+    if not cmd:
+        return ev
+    timeout = integ.get("timeout_s", 900)
+    env = dict(os.environ)
+    for repo, wt in worktrees.items():
+        env["LOKI_WS_DIR_" + re.sub(r"[^A-Za-z0-9]", "_", repo).upper()] = wt
+    log_path = os.path.join(run_dir, "integration.log")
+    with open(log_path, "wb") as lf:
+        p = subprocess.Popen(cmd, shell=True, cwd=run_dir, env=env, stdout=lf, stderr=subprocess.STDOUT,
+                             stdin=subprocess.DEVNULL, start_new_session=True)
+        try:
+            rc = p.wait(timeout=timeout)
+            ev["status"] = "passed" if rc == 0 else "failed"
+        except subprocess.TimeoutExpired:
+            try:
+                os.killpg(p.pid, signal.SIGKILL)
+            except OSError:
+                pass
+            p.wait()
+            rc = 124
+            ev["status"] = "failed"
+            ev["note"] += "; timeout after %ss" % timeout
+    ev["exit_code"] = rc
+    with open(log_path, "rb") as f:
+        ev["log_sha256"] = hashlib.sha256(f.read()).hexdigest()
+    return ev
+
+
+def run_workspace(name, ref, workspaces, base_dir=None, launcher=None):
+    """Run the workspace; return (exit_code, evidence_path_or_None)."""
+    ws = workspaces.get(name)
+    if ws is None:
+        say("workspace: unknown workspace %r (known: %s)" % (name, ", ".join(sorted(workspaces)) or "none"))
+        return 2, None
+    try:
+        ordered = order_repos(ws)
+    except ValueError as e:
+        say("workspace: %s: %s" % (name, e))
+        return 2, None
+    if not ordered:
+        say("workspace: %s has no repos" % name)
+        return 2, None
+
+    base_dir = base_dir or os.getcwd()
+    run_id = datetime.datetime.now(datetime.timezone.utc).strftime("%Y%m%dT%H%M%S%fZ")
+    run_dir = os.path.join(base_dir, ".loki", "workspaces", name, run_id)
+    os.makedirs(run_dir, exist_ok=True)
+    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 = {}
+
+    def stop(*_):
+        for p 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:
+            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]))
+
+    for repo, wt in worktrees.items():
+        r = git("rev-parse", "HEAD", cwd=wt)
+        heads[repo] = r.stdout.strip() if r.returncode == 0 else None
+
+    ev = run_integration(ws, run_dir, worktrees, heads)
+    ev["outcomes"] = outcome
+    ev_path = os.path.join(run_dir, "integration.json")
+    tmp = ev_path + ".tmp"
+    with open(tmp, "w") as f:
+        json.dump(ev, f, indent=2, sort_keys=True)
+    os.replace(tmp, ev_path)
+
+    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
+
+
+def main(argv):
+    if not enabled():
+        say("loki workspace is disabled. Set LOKI_WORKSPACES=1 to use it.")
+        return 2
+    if not argv or argv[0] in ("-h", "--help", "help"):
+        say("Usage: loki workspace list | run <name> <owner/repo#N | task text>")
+        return 0 if argv else 2
+    try:
+        workspaces, errors = load_workspaces()
+    except Exception as e:  # CannotCheck or parse failure
+        say("workspace: cannot read loki.yaml: %s" % e)
+        return 2
+    if errors:
+        for e in errors:
+            say("workspace: config error: %s" % e)
+        return 2
+    cmd = argv[0]
+    if cmd == "list":
+        if not workspaces:
+            say("no workspaces defined in loki.yaml")
+        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 == "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>")
+    return 2
+
+
+if __name__ == "__main__":
+    sys.exit(main(sys.argv[1:]))

package/autonomy/lib/worktree_prep.py

@@ -0,0 +1,143 @@
+#!/usr/bin/env python3
+"""Shared worktree substrate (D51 Phase B, D61 slice 7).
+
+prepare_worktree() creates a git worktree for a run from a clean start point,
+never carrying the source checkout's uncommitted edits, and prepares
+dependencies (setup command, else copy-on-write copy of ignored dep dirs).
+"""
+
+import fcntl
+import json
+import os
+import re
+import subprocess
+import sys
+
+DEP_DIRS = ("node_modules", ".venv", "venv", "vendor")
+
+
+def _git(repo, *args, check=True):
+    return subprocess.run(
+        ["git", "-C", repo, *args], capture_output=True, text=True, check=check
+    )
+
+
+def _slug(repo):
+    real = os.path.realpath(repo)
+    return re.sub(r"[^A-Za-z0-9._-]+", "-", real).strip("-")[-120:] or "repo"
+
+
+def _lock_path(repo):
+    d = os.path.join(os.path.expanduser("~"), ".loki", "repos")
+    os.makedirs(d, exist_ok=True)
+    return os.path.join(d, _slug(repo) + ".lock")
+
+
+def _start_point(repo, base):
+    if base:
+        return base
+    if _git(repo, "remote", check=False).stdout.strip():
+        _git(repo, "fetch", "--quiet", check=False)
+    for ref in ("origin/HEAD", "HEAD"):
+        probe = _git(repo, "rev-parse", "--verify", "--quiet", ref + "^{commit}", check=False)
+        if probe.returncode == 0:
+            return ref
+    raise RuntimeError("no start point: repository has no commits")
+
+
+def _left_out_changes(repo):
+    out = _git(repo, "status", "--porcelain", check=False).stdout
+    return len([line for line in out.splitlines() if line.strip()])
+
+
+def _cow_copy(src, dst):
+    if sys.platform == "darwin":
+        cmds = [["cp", "-c", "-R", src, dst]]
+    else:
+        cmds = [["cp", "-R", "--reflink=auto", src, dst]]
+    cmds.append(["cp", "-R", src, dst])
+    for cmd in cmds:
+        if os.path.lexists(dst):
+            subprocess.run(["rm", "-rf", dst], check=False)
+        if subprocess.run(cmd, capture_output=True).returncode == 0:
+            return True
+    return False
+
+
+def _escapes_source(path):
+    """True if a dep dir has an absolute symlink or an editable finder."""
+    for root, dirs, files in os.walk(path):
+        for name in dirs + files:
+            p = os.path.join(root, name)
+            if os.path.islink(p):
+                if os.path.isabs(os.readlink(p)):
+                    return True
+            elif name.endswith(".pth") or name.startswith("__editable__"):
+                return True
+    return False
+
+
+def _copy_deps(source, dest, start):
+    copied = 0
+    for name in DEP_DIRS:
+        s = os.path.join(source, name)
+        if not os.path.isdir(s) or os.path.islink(s):
+            continue
+        if _git(source, "check-ignore", "-q", name + "/", check=False).returncode != 0:
+            continue
+        if _git(source, "ls-tree", "-d", start, name, check=False).stdout.strip():
+            continue
+        if _escapes_source(s):
+            raise RuntimeError("deps: copy unsafe, declare setup")
+        if not _cow_copy(s, os.path.join(dest, name)):
+            raise RuntimeError("deps: copy failed, declare setup")
+        copied += 1
+    return copied
+
+
+def prepare_worktree(source_repo, dest, branch, setup=None, base=None):
+    source_repo = os.path.abspath(source_repo)
+    dest = os.path.abspath(dest)
+    lock = open(_lock_path(source_repo), "w")
+    try:
+        fcntl.flock(lock, fcntl.LOCK_EX)
+        left_out = _left_out_changes(source_repo)
+        start = _start_point(source_repo, base)
+        base_sha = _git(source_repo, "rev-parse", start + "^{commit}").stdout.strip()
+        _git(source_repo, "worktree", "add", "-b", branch, dest, base_sha)
+    finally:
+        fcntl.flock(lock, fcntl.LOCK_UN)
+        lock.close()
+
+    deps = "none"
+    if setup:
+        r = subprocess.run(setup, shell=True, cwd=dest)
+        if r.returncode != 0:
+            raise RuntimeError("deps: setup command failed (exit %d)" % r.returncode)
+        deps = "setup"
+    elif _copy_deps(source_repo, dest, base_sha):
+        deps = "cow" if sys.platform in ("darwin", "linux") else "copy"
+    return {"path": dest, "base_sha": base_sha, "deps": deps, "left_out_changes": left_out}
+
+
+def main(argv=None):
+    import argparse
+
+    p = argparse.ArgumentParser(description="Prepare an isolated git worktree")
+    p.add_argument("source")
+    p.add_argument("dest")
+    p.add_argument("branch")
+    p.add_argument("--setup", default=None)
+    p.add_argument("--base", default=None)
+    a = p.parse_args(argv)
+    try:
+        res = prepare_worktree(a.source, a.dest, a.branch, a.setup, a.base)
+    except (RuntimeError, subprocess.CalledProcessError) as e:
+        print(json.dumps({"error": str(e)}))
+        return 1
+    print(json.dumps(res))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/autonomy/loki

@@ -1630,6 +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 "  quickstart [idea]  Guided first build: setup, idea, template, plan, go"
     echo ""
     echo "Session:"
@@ -1872,12 +1873,39 @@ for p in range(int(sys.argv[1]), int(sys.argv[1]) + 100):
 PY
 }
 
+# Fail-closed reuse check for a dashboard found via the ~/.loki/dashboard
+# registry or a busy port: reusable only if /health reports THIS package's
+# version AND realpath, and GET / is 200 text/html. Any missing field, curl
+# error or mismatch means "not ours". Mirrors _loki_dashboard_reusable in run.sh.
+_loki_dashboard_port_is_ours() {
+    local port="$1" want want_pkg health probe
+    case "$port" in ''|*[!0-9]*) return 1 ;; esac
+    want="$(tr -d '[:space:]' <"$SKILL_DIR/VERSION" 2>/dev/null)" || return 1
+    [ -n "$want" ] || return 1
+    want_pkg="$(cd "$SKILL_DIR" 2>/dev/null && pwd -P)" || return 1
+    health="$(curl -s --max-time 2 "http://127.0.0.1:${port}/health" 2>/dev/null)" || return 1
+    case "$health" in
+        *"\"version\":\"${want}\""* | *"\"version\": \"${want}\""*) ;;
+        *) return 1 ;;
+    esac
+    case "$health" in
+        *"\"package\":\"${want_pkg}\""* | *"\"package\": \"${want_pkg}\""*) ;;
+        *) return 1 ;;
+    esac
+    probe="$(curl -s -o /dev/null -w '%{http_code} %{content_type}' --max-time 2 "http://127.0.0.1:${port}/" 2>/dev/null)" || return 1
+    case "$probe" in "200 text/html"*) return 0 ;; esac
+    return 1
+}
+
 cmd_ui() {
     local port="" pid=""
     if [ -f "$DASHBOARD_PID_FILE" ]; then
         pid=$(cat "$DASHBOARD_PID_FILE" 2>/dev/null)
         if [ -n "$pid" ] && kill -0 "$pid" 2>/dev/null; then
             port=$(cat "${DASHBOARD_PID_DIR}/port" 2>/dev/null)
+            # A registry entry whose live server is not this package's dashboard
+            # (stale, foreign worktree, other version) is never reused.
+            _loki_dashboard_port_is_ours "$port" || port=""
         fi
     fi
     if [ -z "$port" ]; then
@@ -3759,9 +3787,18 @@ cmd_start() {
                 # + cockpit, honoring the card's "open dashboard" promise. The
                 # cockpit hint is printed by _loki_start_handoff for the Both path.
                 args+=("--bg")
-                local _du="http://127.0.0.1:${LOKI_DASHBOARD_PORT:-57374}"
-                # stdout must stay unredirected: loki_open_url checks the TTY.
-                loki_open_url "$_du" 2>/dev/null &
+                # Open the URL the runner PUBLISHES for the port it actually bound
+                # or reused (it walks past refused ports); never guess the default
+                # 57374, which may be a foreign or stale dashboard. stdout must
+                # stay unredirected: loki_open_url checks the TTY.
+                local _dfile="${PWD}/.loki/dashboard/url"
+                rm -f "$_dfile" 2>/dev/null
+                (
+                    for _ in $(seq 1 120); do
+                        if [ -s "$_dfile" ]; then loki_open_url "$(head -1 "$_dfile")" 2>/dev/null; exit 0; fi
+                        sleep 0.5
+                    done
+                ) &
                 ;;
             launch-bg-watch)
                 # Watch (cockpit only) detaches without opening the browser.
@@ -7288,6 +7325,17 @@ _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
+
     # If no subcommand provided, show help (backward compatible with old behavior)
     if [ -z "$subcommand" ]; then
         cmd_dashboard_help
@@ -7482,13 +7530,15 @@ cmd_dashboard_start() {
     if [ -f "$DASHBOARD_PID_FILE" ]; then
         local existing_pid
         existing_pid=$(cat "$DASHBOARD_PID_FILE" 2>/dev/null)
-        if [ -n "$existing_pid" ] && kill -0 "$existing_pid" 2>/dev/null; then
+        if [ -n "$existing_pid" ] && kill -0 "$existing_pid" 2>/dev/null \
+            && _loki_dashboard_port_is_ours "$(cat "${DASHBOARD_PID_DIR}/port" 2>/dev/null)"; then
             echo -e "${YELLOW}Dashboard server already running (PID: $existing_pid)${NC}"
             echo ""
             cmd_dashboard_status
             exit 0
         fi
-        # Stale PID file, remove it
+        # Stale PID file, or a live server that is not this package's dashboard
+        # (never killed here, just not reused): remove the registry entry.
         rm -f "$DASHBOARD_PID_FILE"
     fi
 
@@ -12871,6 +12921,16 @@ cmd_config_schema() {
     loki_config_generate_schema
 }
 
+# D65: multi-repo workspaces (D51 Phase B). Gated by LOKI_WORKSPACES=1.
+cmd_workspace() {
+    if [ "${LOKI_WORKSPACES:-}" != "1" ]; then
+        echo -e "${RED}loki workspace is disabled.${NC} Set LOKI_WORKSPACES=1 to use it." >&2
+        return 2
+    fi
+    command -v python3 >/dev/null 2>&1 || { echo -e "${RED}loki workspace: python3 is required${NC}" >&2; return 2; }
+    python3 "$_LOKI_SCRIPT_DIR/lib/workspace.py" "$@"
+}
+
 # D51: headless backlog runner. One v10 issue-mode run per open issue, each in
 # its own worktree and branch, at most N in parallel (loki.yaml concurrency).
 cmd_backlog() {
@@ -21884,6 +21944,9 @@ main() {
         backlog)
             cmd_backlog "$@"
             ;;
+        workspace)
+            cmd_workspace "$@"
+            ;;
         config)
             cmd_config "$@"
             ;;

package/autonomy/run.sh

@@ -19183,6 +19183,14 @@ _loki_dashboard_reusable() {
     return 1
 }
 
+# Publish the URL of the port actually bound or reused, so the launcher (bg
+# banner, browser opener) never guesses the default 57374 after start_dashboard
+# walked past a refused port.
+_loki_publish_dashboard_url() {
+    mkdir -p .loki/dashboard 2>/dev/null || return 0
+    printf '%s\n' "$1" > .loki/dashboard/url.tmp 2>/dev/null && mv -f .loki/dashboard/url.tmp .loki/dashboard/url 2>/dev/null || true
+}
+
 start_dashboard() {
     loki_background_services_enabled || return 0
     log_header "Starting Loki Dashboard"
@@ -19262,6 +19270,7 @@ start_dashboard() {
     if [ "${DASHBOARD_REUSED:-0}" = "1" ]; then
         export LOKI_DASHBOARD_PORT="$DASHBOARD_PORT"
         log_info "Dashboard already live on port $DASHBOARD_PORT; reusing it."
+        _loki_publish_dashboard_url "http://127.0.0.1:${DASHBOARD_PORT}/"
         return 0
     fi
 
@@ -19419,6 +19428,7 @@ start_dashboard() {
         DASHBOARD_LAST_ALIVE=$(date +%s)
         log_info "Dashboard started (PID: $DASHBOARD_PID)"
         log_info "Dashboard: ${CYAN}${url_scheme}://127.0.0.1:$DASHBOARD_PORT/${NC}"
+        _loki_publish_dashboard_url "${url_scheme}://127.0.0.1:${DASHBOARD_PORT}/"
 
         # Auto-open the dashboard in the browser, but ONLY for an interactive
         # foreground session. loki_open_url (lib/browser-open.sh) refuses on
@@ -28816,6 +28826,8 @@ main() {
         fi
         # Initialize .loki directory first
         mkdir -p .loki/logs
+        # A url left by an earlier run must never be mistaken for this child's.
+        rm -f .loki/dashboard/url
 
         local log_file=".loki/logs/background-$(date +%Y%m%d-%H%M%S).log"
         local pid_file
@@ -28869,6 +28881,19 @@ main() {
         echo "$bg_pid" > "$pid_file"
         register_pid "$bg_pid" "background-session" "log=$log_file"
 
+        # The child picks the dashboard port (it walks past refused ports), so
+        # print the URL it publishes, never the requested default.
+        local _bg_dash_line="disabled (LOKI_DASHBOARD=false)"
+        if [ "$ENABLE_DASHBOARD" = "true" ] && loki_background_services_enabled; then
+            _bg_dash_line="starting (run: loki dashboard url, or see $log_file)"
+            local _bg_i
+            for _bg_i in $(seq 1 60); do
+                if [ -s .loki/dashboard/url ]; then _bg_dash_line="$(head -1 .loki/dashboard/url)"; break; fi
+                kill -0 "$bg_pid" 2>/dev/null || break
+                sleep 0.5
+            done
+        fi
+
         echo ""
         echo -e "${GREEN}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
         echo -e "${GREEN}  Loki Mode Running in Background${NC}"
@@ -28878,7 +28903,7 @@ main() {
         echo -e "  ${CYAN}Path:${NC}       $project_path"
         echo -e "  ${CYAN}PID:${NC}        $bg_pid"
         echo -e "  ${CYAN}Log:${NC}        $log_file"
-        echo -e "  ${CYAN}Dashboard:${NC}  http://127.0.0.1:${DASHBOARD_PORT}/"
+        echo -e "  ${CYAN}Dashboard:${NC}  ${_bg_dash_line}"
         echo ""
         echo -e "${YELLOW}Control Commands:${NC}"
         echo -e "  ${DIM}Pause:${NC}      touch .loki/PAUSE"

package/bin/loki

@@ -350,6 +350,14 @@ case "${LOKI_ENGINE:-$_loki_engine_default}" in
                     *) _e10=1; _e10_args=(--no-pr "${@:2}") ;;
                 esac
                 ;;
+            # D58: `loki start <issue ref|issue URL|"multi-word task">` takes the same v10 path as
+            # `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}") ;;
+                    *) _e10=0 ;;
+                esac
+                ;;
             # http*://*/issues/* also covers GitLab's /-/issues/ URLs.
             */*\#[0-9]*|http*://*/issues/*|http*://*/browse/*) _e10=1 ;;
             *" "*) _e10=1 ;;
@@ -559,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)
+    version|--version|-v|status|stats|doctor|provider|memory|rollback|internal|kpis|trust|proof|receipt|wiki|crash|control|contract)
         # 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

@@ -207,6 +207,7 @@ function _loki_commands {
         'otel:OpenTelemetry management'
         'wiki:Wiki commands'
         'control:Control plane (preview, LOKI_CONTROL=1)'
+        'workspace:Multi-project workspaces (preview, LOKI_WORKSPACES=1)'
         'backlog:Run every matching open issue, N in parallel'
         'explain:Explain Loki concepts'
         'optimize:Optimization commands'