loki-mode 10.6.14 → 10.7.0

package/autonomy/loki

@@ -1693,6 +1693,7 @@ show_help() {
     echo "Observe:"
     echo "  dashboard [cmd]  Operations UI server (start|stop|status|url|open)"
     echo "  mcp              Launch the MCP server (Model Context Protocol, stdio)"
+    echo "  acp              Run Loki as an ACP agent over stdio (VS Code, JetBrains, Zed)"
     echo ""
     echo "Report:"
     echo "  report [cmd]     Reporting: session|metrics|cost|export|share|dogfood"
@@ -1812,7 +1813,7 @@ show_help() {
     # missing from this list, so a new command cannot ship invisible.
     echo ""
     echo "All commands:"
-    echo "  agent analyze api assets audit backlog bench checkpoint (cp) ci cleanup"
+    echo "  acp agent analyze api assets audit backlog bench checkpoint (cp) ci cleanup"
     echo "  cluster cockpit code compliance completions compound config context (ctx)"
     echo "  cost council crash dashboard demo deploy docker docs doctor dogfood"
     echo "  enterprise estimate explain export failover github grill heal help"
@@ -1820,7 +1821,7 @@ show_help() {
     echo "  issue keys kpis logs magic mcp memory metrics migrate modernize monitor"
     echo "  next notify onboard open optimize otel outcomes own (handoff) pause plan preview"
     echo "  projects proof (receipt) provider quick quickstart rc remote report reset"
-    echo "  resume review rollback run sandbox secrets secure self-update sentrux"
+    echo "  merge resume review rollback run sandbox secrets secure self-update sentrux"
     echo "  serve setup-skill share ship spec start state stats status steer stop"
     echo "  syslog telemetry template test tour trigger trust trust-metrics"
     echo "  ultracode update verify version voice watch watchdog web welcome why"
@@ -2007,6 +2008,9 @@ _loki_control_ui() {
 
 cmd_ui() {
     _loki_control_ui "$@" && return 0
+    # CP-LEGACY: callers that must never start the classic server (run.sh
+    # auto-open) set LOKI_UI_NO_CLASSIC=1.
+    [ "${LOKI_UI_NO_CLASSIC:-0}" = "1" ] && return 1
     local port="" pid=""
     if [ -f "$DASHBOARD_PID_FILE" ]; then
         pid=$(cat "$DASHBOARD_PID_FILE" 2>/dev/null)
@@ -2084,6 +2088,18 @@ detect_arg_type() {
         return 0
     fi
 
+    # Sentry intake: an https Sentry issue URL, or an exported Sentry JSON file
+    # on disk, is an issue (checked before the .json -> prd rule below).
+    if [[ "$arg" =~ ^https://[^/]*sentry[^/]*/.*issues/[0-9]+ ]]; then
+        echo "issue"
+        return 0
+    fi
+    if [[ "$arg" == *.json ]] && [ -f "$arg" ] \
+        && head -c 2000000 "$arg" 2>/dev/null | grep -Eq '"(shortId|culprit)"[[:space:]]*:|"exception"[[:space:]]*:|"type"[[:space:]]*:[[:space:]]*"exception"'; then
+        echo "issue"
+        return 0
+    fi
+
     # Known PRD extensions - treat as PRD first (highest priority).
     # This handles edge case where a file is literally named "123.md" or
     # sits in a dir that matches another pattern.
@@ -7441,14 +7457,28 @@ _loki_dashboard_bind_is_safe() {
     return 1
 }
 
+_loki_dashboard_args_need_classic() {
+    local a
+    for a in "$@"; do
+        case "$a" in
+            --host|--host=*|--tls-cert|--tls-cert=*|--tls-key|--tls-key=*) return 0 ;;
+        esac
+    done
+    return 1
+}
+
 cmd_dashboard() {
     local subcommand="${1:-}"
 
-    # 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.
+    # CP-LEGACY (D57): the Control Plane is the default UI for `dashboard`,
+    # `dashboard start` and `dashboard open`, with or without flags. The legacy
+    # Python dashboard stays reachable only by explicit opt-in:
+    # LOKI_LEGACY_DASHBOARD=1 or LOKI_CONTROL_DEFAULT=0. Enterprise bind/TLS
+    # flags (--host, --tls-cert, --tls-key) are classic-server concepts and
+    # keep the classic server.
     case "$subcommand" in
         ""|start|open)
-            if [ $# -le 1 ] || { [ $# -eq 2 ] && [ "$2" = "--no-open" ]; }; then
+            if [ "${LOKI_LEGACY_DASHBOARD:-0}" != "1" ] && ! _loki_dashboard_args_need_classic "${@:2}"; then
                 _loki_control_ui "${@:2}" && return 0
             fi
             ;;
@@ -8307,6 +8337,11 @@ cmd_web_redirect_to_dashboard() {
         echo "      it watches runs that are already going. To build from that spec:" >&2
         echo "        loki start '${_web_dropped_prd}'" >&2
     fi
+    # Flags such as --port must reach the classic validator, so only the
+    # bare form (optionally --no-open) is routed to the Control Plane.
+    if [ "${LOKI_LEGACY_DASHBOARD:-0}" != "1" ] && [ ${#dash_args[@]} -eq 0 ] && _loki_control_ui; then
+        return 0
+    fi
     cmd_dashboard_start ${dash_args[@]+"${dash_args[@]}"}
 }
 
@@ -21764,8 +21799,10 @@ ultracode council demo dogfood heal modernize import issue github init template
 status stop pause resume monitor watch watchdog dashboard web open preview share \
 memory context ctx checkpoint state report kpis cost metrics stats logs otel \
 syslog telemetry crash config provider doctor setup-skill onboard quickstart \
-welcome update self-update rollback failover cluster enterprise remote deploy docker \
+welcome update self-update rollback merge failover cluster enterprise remote deploy docker \
 sandbox api mcp magic compound assets export wiki control docs explain why audit compliance \
+welcome update self-update rollback failover cluster enterprise remote deploy docker \
+sandbox api mcp acp magic compound assets export wiki control docs explain why audit compliance \
 secrets analyze optimize bench ci reset cleanup notify trigger voice sentrux \
 worktree wt projects cp rc trust-metrics serve agent code self_update test help version"
     local best
@@ -22097,6 +22134,9 @@ main() {
         rollback)
             cmd_rollback "$@"
             ;;
+        merge)
+            cmd_merge "$@"
+            ;;
         council)
             cmd_council "$@"
             ;;
@@ -22177,6 +22217,10 @@ main() {
         mcp)
             cmd_mcp "$@"
             ;;
+        acp)
+            # ACP agent over stdio; stdout is protocol-only. See docs/acp-editors.md.
+            LOKI_ACP_LOKI="${LOKI_ACP_LOKI:-$_LOKI_SCRIPT_DIR/loki}" exec python3 "$_LOKI_SCRIPT_DIR/acp-agent.py"
+            ;;
         migrate)
             # CLI consolidation (Phase B): 'migrate' -> 'modernize migrate'.
             _deprecated_alias migrate "modernize migrate" "$@"
@@ -22709,6 +22753,7 @@ cmd_review() {
     local review_ultra=false
     local review_assume_yes=false
     local review_timeout=""
+    local review_risk=false
 
     while [[ $# -gt 0 ]]; do
         case "$1" in
@@ -22736,6 +22781,10 @@ cmd_review() {
                 echo "                       skip the prompt. Optional [file-or-dir] is"
                 echo "                       passed as the ultrareview target (branch / PR"
                 echo "                       number / base branch)."
+                echo "  --risk               Deterministic 0-100 diff risk score with per-factor"
+                echo "                       breakdown (files, sensitive paths, size, test delta,"
+                echo "                       deleted tests). Works with --pr/--staged/--since;"
+                echo "                       'loki review <pr-number> --risk' also works. Use --json"
                 echo "  --yes, -y            Skip the --ultra confirmation prompt"
                 echo "  --timeout <minutes>  --ultra: max minutes to wait (default 30)"
                 echo "  --help, -h           Show this help"
@@ -22759,6 +22808,8 @@ cmd_review() {
                 return 0
                 ;;
             --ultra) review_ultra=true; shift ;;
+            --risk) review_risk=true; shift ;;
+            --json) review_format="json"; shift ;;
             --yes|-y) review_assume_yes=true; shift ;;
             --timeout)
                 shift
@@ -22814,6 +22865,29 @@ cmd_review() {
         return $?
     fi
 
+    if [ "$review_risk" = true ]; then
+        if [ -z "$review_pr" ] && [ -z "$review_since" ] && [[ "$review_target" =~ ^[0-9]+$ ]] && [ ! -e "$review_target" ]; then
+            review_pr="$review_target"
+        fi
+        local risk_diff risk_src="uncommitted changes"
+        if [ -n "$review_pr" ]; then
+            command -v gh &>/dev/null || { echo "Error: gh CLI required for PR risk" >&2; return 1; }
+            risk_diff=$(gh pr diff "$review_pr" 2>&1) || { echo "Error: Could not fetch PR #${review_pr}: $risk_diff" >&2; return 1; }
+            risk_src="PR #${review_pr}"
+        elif [ -n "$review_since" ]; then
+            risk_diff=$(git diff "$review_since" 2>&1) || { echo "Error: Invalid commit reference: $review_since" >&2; return 1; }
+            risk_src="changes since $review_since"
+        elif [ "$review_staged" = true ]; then
+            risk_diff=$(git diff --cached 2>/dev/null); risk_src="staged changes"
+        else
+            risk_diff=$(git diff 2>/dev/null)
+        fi
+        local risk_args=()
+        [ "$review_format" = "json" ] && risk_args+=(--json)
+        printf '%s\n' "$risk_diff" | python3 "$_LOKI_SCRIPT_DIR/lib/review_risk.py" ${risk_args[@]+"${risk_args[@]}"} "$risk_src"
+        return $?
+    fi
+
     # Severity level ordering (higher number = more severe)
     _review_sev_level() {
         case "$1" in
@@ -26294,6 +26368,93 @@ SHOW_EOF
     esac
 }
 
+# loki merge: serial PR merge queue. Queue lives in .loki/merge-queue (one PR
+# number per line). A PR merges only when `gh pr checks` exits 0 (all green);
+# after each merge the next PR is rebased onto the new base (gh pr update-branch
+# --rebase) and must go green again before it merges. Never forces anything.
+cmd_merge() {
+    local sub="${1:-help}"
+    shift 2>/dev/null || true
+    local qfile=".loki/merge-queue"
+    case "$sub" in
+        add)
+            [ $# -gt 0 ] || { echo "Usage: loki merge add <pr-number>..." >&2; return 2; }
+            mkdir -p .loki || return 1
+            local n
+            for n in "$@"; do
+                case "$n" in ''|*[!0-9]*) echo "Invalid PR number: $n" >&2; return 2 ;; esac
+                if [ -f "$qfile" ] && grep -qx "$n" "$qfile"; then
+                    echo "PR #$n already queued"
+                else
+                    echo "$n" >> "$qfile"
+                    echo "Queued PR #$n"
+                fi
+            done
+            ;;
+        list|ls)
+            if [ -s "$qfile" ]; then cat "$qfile" | sed 's/^/#/'; else echo "Merge queue is empty"; fi
+            ;;
+        clear)
+            rm -f "$qfile"; echo "Merge queue cleared"
+            ;;
+        run)
+            local dry=false
+            [ "${1:-}" = "--dry-run" ] && dry=true
+            if [ ! -s "$qfile" ]; then echo "Merge queue is empty"; return 0; fi
+            command -v gh >/dev/null 2>&1 || { echo "gh CLI is required" >&2; return 1; }
+            local poll="${LOKI_MERGE_POLL_S:-20}" tries="${LOKI_MERGE_MAX_POLLS:-90}"
+            local first=true n rc i remaining="" merged=0 blocked=0
+            while IFS= read -r n; do
+                [ -n "$n" ] || continue
+                if $dry; then
+                    rc=0; gh pr checks "$n" >/dev/null 2>&1 || rc=$?
+                    case "$rc" in
+                        0) echo "#$n: checks green, would merge (squash)" ;;
+                        8) echo "#$n: checks pending, would wait" ;;
+                        *) echo "#$n: checks not green, would skip" ;;
+                    esac
+                    $first || echo "#$n: would rebase onto new base first"
+                    first=false
+                    continue
+                fi
+                if ! $first; then
+                    gh pr update-branch "$n" --rebase >/dev/null 2>&1 \
+                        || { echo "#$n: rebase onto new base failed, left in queue"; remaining="$remaining$n"$'\n'; blocked=$((blocked+1)); continue; }
+                    echo "#$n: rebased onto new base"
+                fi
+                rc=8; i=0
+                while [ "$rc" = "8" ] && [ "$i" -lt "$tries" ]; do
+                    rc=0; gh pr checks "$n" >/dev/null 2>&1 || rc=$?
+                    [ "$rc" = "8" ] && { sleep "$poll"; i=$((i+1)); }
+                done
+                if [ "$rc" != "0" ]; then
+                    echo "#$n: checks not green (rc=$rc), left in queue, not merged"
+                    remaining="$remaining$n"$'\n'; blocked=$((blocked+1)); continue
+                fi
+                if gh pr merge "$n" --squash >/dev/null 2>&1; then
+                    echo "#$n: merged"; merged=$((merged+1)); first=false
+                else
+                    echo "#$n: merge failed, left in queue"
+                    remaining="$remaining$n"$'\n'; blocked=$((blocked+1))
+                fi
+            done < "$qfile"
+            if $dry; then echo "Dry run: nothing changed"; return 0; fi
+            printf '%s' "$remaining" > "$qfile"
+            echo "Merged: $merged, left in queue: $blocked"
+            [ "$blocked" -eq 0 ]
+            ;;
+        help|--help|-h|*)
+            echo "Usage: loki merge <add|list|run|clear>"
+            echo "  add <pr>...        Queue pull requests"
+            echo "  list               Show the queue"
+            echo "  run [--dry-run]    Merge one at a time, only when checks are green;"
+            echo "                     each next PR is rebased onto the new base first."
+            echo "                     --dry-run lists what would happen, changes nothing."
+            [ "$sub" = "help" ] || [ "$sub" = "--help" ] || [ "$sub" = "-h" ] || return 2
+            ;;
+    esac
+}
+
 # R6: one-command rollback. Top-level, obvious entry point that mirrors the Bun
 # `loki rollback` subcommands (list/show/to/latest) so both routes are at parity.
 # Restore is destructive on .loki/ state, so it ALWAYS captures a forced
@@ -38109,18 +38270,28 @@ cmd_docker() {
         # the port-in-use check, so the picked port is ignored on reuse). Run in
         # a subshell so its internal `exit` paths (already-running -> exit 0,
         # errors -> exit 1) never abort the blocking docker run.
-        local _dash_port="57374"
-        if declare -F loki_docker_pick_host_port >/dev/null 2>&1; then
-            _dash_port="$(loki_docker_pick_host_port 2>/dev/null || echo 57374)"
-        fi
-        ( cmd_dashboard_start --port "$_dash_port" ) || true
+        # CP-LEGACY (D57): open the Control Plane, never the classic server,
+        # unless LOKI_LEGACY_DASHBOARD=1 opts back in. Same open gate as before.
+        if [ "${LOKI_LEGACY_DASHBOARD:-0}" != "1" ]; then
+            local _cp_args=()
+            if [ ! -t 1 ] || [ "$_docker_bg" = "1" ] || [ "${LOKI_NO_AUTO_OPEN:-0}" = "1" ]; then
+                _cp_args=(--no-open)
+            fi
+            ( _loki_control_ui ${_cp_args[@]+"${_cp_args[@]}"} ) >&2 || true
+        else
+            local _dash_port="57374"
+            if declare -F loki_docker_pick_host_port >/dev/null 2>&1; then
+                _dash_port="$(loki_docker_pick_host_port 2>/dev/null || echo 57374)"
+            fi
+            ( cmd_dashboard_start --port "$_dash_port" ) || true
 
-        # Auto-open the dashboard in the browser, gated EXACTLY like
-        # run.sh:~10088: a TTY on stdout, not background, and not opted out via
-        # LOKI_NO_AUTO_OPEN=1. cmd_dashboard_open reads the persisted port file,
-        # so the URL is correct even when an existing dashboard was reused.
-        if [ -t 1 ] && [ "$_docker_bg" != "1" ] && [ "${LOKI_NO_AUTO_OPEN:-0}" != "1" ]; then
-            ( cmd_dashboard_open ) || true
+            # Auto-open the dashboard in the browser, gated EXACTLY like
+            # run.sh:~10088: a TTY on stdout, not background, and not opted out via
+            # LOKI_NO_AUTO_OPEN=1. cmd_dashboard_open reads the persisted port file,
+            # so the URL is correct even when an existing dashboard was reused.
+            if [ -t 1 ] && [ "$_docker_bg" != "1" ] && [ "${LOKI_NO_AUTO_OPEN:-0}" != "1" ]; then
+                ( cmd_dashboard_open ) || true
+            fi
         fi
 
         # F4 FIX-DOCKER-STOP (write side): record this run's container/state so
@@ -38139,8 +38310,27 @@ cmd_docker() {
     # its live status from the bind-mounted .loki/session.json. Best-effort and
     # failure-swallowed: registry bookkeeping must never block a build.
     _loki_docker_register_host running
-    "${docker_argv[@]}"
-    local rc=$?
+    local rc _errlog=""
+    # Capture output for a failure summary only when no TTY is attached (a TTY
+    # run already shows the live output and must not be piped).
+    if [ ! -t 1 ] || [ ! -t 0 ]; then
+        _errlog="$(mktemp "${TMPDIR:-/tmp}/loki-docker-out.XXXXXX" 2>/dev/null)" || _errlog=""
+    fi
+    if [ -n "$_errlog" ]; then
+        "${docker_argv[@]}" 2>&1 | tee "$_errlog"
+        rc=${PIPESTATUS[0]}
+    else
+        "${docker_argv[@]}"
+        rc=$?
+    fi
+    if [ "$rc" -ne 0 ]; then
+        local _last=""
+        [ -n "$_errlog" ] && _last="$(grep -v '^[[:space:]]*$' "$_errlog" 2>/dev/null | tail -n 1)"
+        echo -e "${RED}loki docker: container exited with code ${rc}.${NC}" >&2
+        [ -n "$_last" ] && echo "Last error: ${_last}" >&2
+        echo "Fix hint: for PRs set GH_TOKEN=\$(gh auth token), and ensure ANTHROPIC_API_KEY or a Claude login is available, then rerun." >&2
+    fi
+    [ -n "$_errlog" ] && rm -f "$_errlog" 2>/dev/null
     _loki_docker_register_host stopped
     # F4 FIX-DOCKER-STOP (clear side): runs unconditionally after the blocking
     # call (not gated on rc), same as register_host stopped.

package/autonomy/mobile-verify.sh

@@ -0,0 +1,66 @@
+#!/usr/bin/env bash
+# Mobile emulator tests: run a mobile project's tests on an available emulator
+# or simulator. Never reports PASS without a run.
+# Usage: mobile-verify.sh [project_dir]
+# Env:   LOKI_MOBILE_TEST_CMD  override the test command
+#        LOKI_MOBILE_TIMEOUT   seconds (default 600)
+# Exit:  0 = ran and passed, or not a mobile project (stated)
+#        1 = ran and failed
+#        3 = NOT VERIFIED (no emulator/simulator, or no runnable test command)
+set -u
+dir="${1:-.}"
+cd "$dir" || { echo "mobile tests: NOT VERIFIED (cannot enter $dir)"; exit 3; }
+
+kind=""
+if [ -f pubspec.yaml ] && grep -q "flutter" pubspec.yaml 2>/dev/null; then
+    kind="flutter"
+elif [ -f package.json ] && grep -qE '"(expo|react-native)"[[:space:]]*:' package.json 2>/dev/null; then
+    kind="react-native"
+fi
+if [ -z "$kind" ]; then
+    echo "mobile tests: not applicable (no React Native, Expo or Flutter project)"
+    exit 0
+fi
+
+device=""
+if command -v adb >/dev/null 2>&1; then
+    d="$(adb devices 2>/dev/null | awk 'NR>1 && $2=="device" {print $1; exit}')"
+    [ -n "$d" ] && device="android:$d"
+fi
+if [ -z "$device" ] && command -v xcrun >/dev/null 2>&1; then
+    d="$(xcrun simctl list devices booted 2>/dev/null | awk '/\(Booted\)/ {print "ios-simulator"; exit}')"
+    [ -n "$d" ] && device="$d"
+fi
+if [ -z "$device" ]; then
+    echo "mobile tests: NOT VERIFIED ($kind project, no booted Android emulator or iOS simulator found; tests were not run)"
+    exit 3
+fi
+
+cmd="${LOKI_MOBILE_TEST_CMD:-}"
+if [ -z "$cmd" ]; then
+    if [ "$kind" = "flutter" ]; then
+        if [ -d integration_test ]; then cmd="flutter test integration_test"; else cmd="flutter test"; fi
+    elif grep -q '"test:e2e"' package.json 2>/dev/null; then
+        cmd="npm run test:e2e"
+    elif grep -q '"e2e"' package.json 2>/dev/null; then
+        cmd="npm run e2e"
+    fi
+fi
+if [ -z "$cmd" ]; then
+    echo "mobile tests: NOT VERIFIED ($kind project on $device, but no e2e test script (test:e2e or e2e) to run)"
+    exit 3
+fi
+
+timeout_s="${LOKI_MOBILE_TIMEOUT:-600}"
+if command -v timeout >/dev/null 2>&1; then
+    timeout -k 10 "$timeout_s" bash -c "$cmd"
+else
+    bash -c "$cmd"
+fi
+rc=$?
+if [ "$rc" -eq 0 ]; then
+    echo "mobile tests: PASS ($kind on $device, ran: $cmd)"
+    exit 0
+fi
+echo "mobile tests: FAIL ($kind on $device, ran: $cmd, exit $rc)"
+exit 1

package/autonomy/run.sh

@@ -11804,6 +11804,26 @@ result = {
     "successes": filter_relevant(successes, context)
 }
 
+# Project memory: learnings and decisions persisted by earlier runs in THIS
+# project, newest first, bounded by entry count and total characters.
+if os.environ.get("LOKI_PROJECT_MEMORY", "1") != "0":
+    try:
+        max_chars = int(os.environ.get("LOKI_PROJECT_MEMORY_MAX_CHARS", "2000"))
+    except ValueError:
+        max_chars = 2000
+    mem, used = [], 0
+    for kind in ("mistakes", "patterns", "successes"):
+        for e in reversed(load_jsonl(f".loki/memory/learnings/project-{kind}.jsonl")):
+            d = e.get("description", "").strip()[:300]
+            if not d or used + len(d) > max_chars:
+                continue
+            used += len(d)
+            mem.append({"kind": kind[:-1] if kind != "successes" else "success", "description": d})
+            if len(mem) >= 15:
+                break
+    if mem:
+        result["project_memory"] = mem
+
 with open(".loki/state/relevant-learnings.json", 'w') as f:
     json.dump(result, f, indent=2)
 LEARNINGS_SCRIPT
@@ -11863,7 +11883,23 @@ def get_existing_hashes(filepath):
     return hashes
 
 def save_entries(filepath, entries, category):
-    """Save entries avoiding duplicates (case-insensitive)"""
+    """Save entries avoiding duplicates (case-insensitive).
+
+    Also mirrors into the project-scoped memory (.loki/memory/learnings/
+    project-<kind>.jsonl) so the next run in this project reads them back.
+    """
+    if os.environ.get("LOKI_PROJECT_MEMORY", "1") != "0":
+        try:
+            pdir = ".loki/memory/learnings"
+            os.makedirs(pdir, exist_ok=True)
+            pfile = os.path.join(pdir, "project-" + os.path.basename(filepath))
+            if pfile != filepath:
+                save_entries_to(pfile, entries, category)
+        except Exception:
+            pass
+    return save_entries_to(filepath, entries, category)
+
+def save_entries_to(filepath, entries, category):
     existing = get_existing_hashes(filepath)
     saved = 0
     with open(filepath, 'a') as f:
@@ -19522,8 +19558,14 @@ start_dashboard() {
         # Auto-open the dashboard in the browser, but ONLY for an interactive
         # foreground session. loki_open_url (lib/browser-open.sh) refuses on
         # no TTY, CI, test runners, LOKI_NO_BROWSER=1 or LOKI_NO_AUTO_OPEN=1.
+        # CP-LEGACY (D57): open the Control Plane, not this legacy server,
+        # unless LOKI_LEGACY_DASHBOARD=1 opts back in.
         if [ "${BACKGROUND_MODE:-false}" != "true" ]; then
-            loki_open_url "${url_scheme}://127.0.0.1:$DASHBOARD_PORT/" 2>/dev/null || true
+            if [ "${LOKI_LEGACY_DASHBOARD:-0}" = "1" ]; then
+                loki_open_url "${url_scheme}://127.0.0.1:$DASHBOARD_PORT/" 2>/dev/null || true
+            elif [ -t 1 ] && [ "${LOKI_NO_AUTO_OPEN:-0}" != "1" ] && [ -x "${skill_dir}/autonomy/loki" ]; then
+                LOKI_UI_NO_CLASSIC=1 "${skill_dir}/autonomy/loki" ui >/dev/null 2>&1 || true
+            fi
         fi
         return 0
     else

package/completions/_loki

@@ -188,6 +188,8 @@ function _loki_commands {
         'deploy:Advisory deploy command (print-only)'
         'docker:Run Loki in a Docker container'
         'mcp:MCP server commands'
+        'merge:Green-only serial merge queue'
+        'acp:Agent Client Protocol agent over stdio'
         'magic:Spec-driven component generation'
         'assets:Export/import shareable team assets'
         'spec:Living spec drift detection'

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 answer"
+    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 merge 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 acp"
 
     # 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.14"
+__version__ = "10.7.0"
 
 # Expose the control app for easy import
 try:

package/dashboard/api_runs_v1.py

@@ -0,0 +1,80 @@
+"""REST API for runs: /api/v1/runs.
+
+A thin, stable surface over code that already exists:
+  GET  /api/v1/runs            -> api_runs.list_runs (envelope kept intact)
+  GET  /api/v1/runs/{id}       -> api_runs.get_run (404 when the run is unknown)
+  POST /api/v1/runs            -> the existing /api/control/start handler
+  POST /api/v1/runs/{id}/stop  -> the existing /api/control/stop handler,
+                                  only when {id} is the current run
+
+Auth is the dashboard's own scope check: "read" for GETs, "control" for POSTs.
+The dashboard binds loopback by default; nothing here opens a listener.
+"""
+import os
+from typing import Optional
+
+from fastapi import APIRouter, Depends, HTTPException, Request
+from pydantic import BaseModel, Field
+
+from . import auth
+
+router = APIRouter(prefix="/api/v1/runs", tags=["runs-v1"])
+_READ = [Depends(auth.require_scope("read"))]
+_CONTROL = [Depends(auth.require_scope("control"))]
+
+
+def _loki_dir() -> str:
+    try:
+        from . import server
+        return str(server._get_loki_dir())
+    except Exception:
+        return os.environ.get("LOKI_DIR") or os.path.join(os.getcwd(), ".loki")
+
+
+class RunStartIn(BaseModel):
+    prd_text: Optional[str] = Field(default=None, max_length=1_048_576)
+    prd_path: Optional[str] = None
+    provider: str = "claude"
+    parallel: bool = False
+
+
+async def _start_impl(request: Request, body: RunStartIn):
+    from . import server
+    return await server.start_build(request, server.StartBuildRequest(**body.model_dump()))
+
+
+async def _stop_impl(request: Request):
+    from . import server
+    return await server.stop_session(request)
+
+
+@router.get("", dependencies=_READ)
+def list_runs_v1():
+    from . import api_runs
+    return api_runs.list_runs(_loki_dir())
+
+
+@router.get("/{run_id}", dependencies=_READ)
+def get_run_v1(run_id: str):
+    from . import api_runs
+    env = api_runs.get_run(_loki_dir(), run_id)
+    if env.get("run") is None:
+        raise HTTPException(status_code=404, detail=env.get("reason") or "run not found")
+    return env
+
+
+@router.post("", dependencies=_CONTROL)
+async def start_run_v1(request: Request, body: RunStartIn):
+    return await _start_impl(request, body)
+
+
+@router.post("/{run_id}/stop", dependencies=_CONTROL)
+async def stop_run_v1(run_id: str, request: Request):
+    from . import api_runs
+    env = api_runs.get_run(_loki_dir(), run_id)
+    row = env.get("run")
+    if row is None:
+        raise HTTPException(status_code=404, detail=env.get("reason") or "run not found")
+    if not row.get("current"):
+        raise HTTPException(status_code=409, detail="only the current run can be stopped")
+    return await _stop_impl(request)

package/dashboard/server.py

@@ -1362,6 +1362,8 @@ else:
 # D51 Phase A: first-run onboarding + backlog API and its /start page.
 from .api_start import router as api_start_router, START_HTML as _START_HTML
 app.include_router(api_start_router)
+from .api_runs_v1 import router as api_runs_v1_router
+app.include_router(api_runs_v1_router)
 
 
 @app.get("/start", include_in_schema=False, dependencies=[Depends(auth.require_scope("read"))])

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.14
+**Version:** v10.7.0
 
 **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).
 
@@ -434,11 +434,15 @@ runs any loki command inside the published `asklokesh/loki-mode` image with zero
 config:
 
 ```bash
+loki docker start owner/repo#17      # work a GitHub issue or PR in Docker (primary path)
 loki docker start prd.md             # full local experience in Docker
 loki docker status                   # any loki command works
 loki docker --dry-run start prd.md   # print the docker command, do not run
 ```
 
+On macOS, pass your GitHub login for PRs with
+`GH_TOKEN=$(gh auth token) loki docker start owner/repo#17`.
+
 It bind-mounts the current folder to `/workspace`, so `.loki/` state (memory,
 session, queue, checkpoints) persists on the host and resume and continuity
 behave exactly like the local `loki` CLI. Auth is auto-detected:

package/docs/acp-editors.md

@@ -0,0 +1,29 @@
+# Loki in VS Code and JetBrains via ACP
+
+`loki acp` speaks the Agent Client Protocol (newline-delimited JSON-RPC over
+stdio). It supports `initialize`, `session/new`, `session/prompt` and
+`session/cancel`. Each prompt runs `loki quick "<prompt>"` in the session's
+working directory and streams the output back. A non-zero exit is reported as
+"NOT VERIFIED"; nothing is claimed that did not run. Loki never receives editor
+credentials, and no network listener is opened.
+
+## JetBrains (AI Assistant with ACP support)
+
+Edit `~/.jetbrains/acp.json`:
+
+    {"agent_servers": {"Loki": {"command": "loki", "args": ["acp"]}}}
+
+## Zed
+
+In settings.json:
+
+    {"agent_servers": {"Loki": {"command": "loki", "args": ["acp"]}}}
+
+## VS Code
+
+Use any ACP client extension and register a custom agent with command `loki`
+and args `acp`.
+
+## Smoke test
+
+    printf '%s\n' '{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":1}}' | loki acp