loki-mode 7.89.1 → 7.90.1

package/autonomy/run.sh

@@ -572,6 +572,25 @@ if [ -f "$GIT_PR_ADVISORY_LIB" ]; then
     source "$GIT_PR_ADVISORY_LIB"
 fi
 
+# Proven PR (Loop 6): shared print-only Evidence Receipt renderer for PR bodies.
+# render_evidence_receipt_md prints the run's honest headline + facts +
+# verify-yourself block into the PR body. Pure, never pushes/PRs/mutates.
+PROOF_PR_LIB="$SCRIPT_DIR/lib/proof-pr.sh"
+if [ -f "$PROOF_PR_LIB" ]; then
+    # shellcheck source=lib/proof-pr.sh
+    source "$PROOF_PR_LIB"
+fi
+
+# Proven PR (Loop 6 / Slice B): optional advisory verified-completion check-run.
+# Owned by Slice B (autonomy/lib/proof-check.sh); sourced guarded so this slice
+# is correct whether or not the file is present in the tree, and the single call
+# site is itself guarded on declare -f + LOKI_PROVEN_PR_CHECK.
+PROOF_CHECK_LIB="$SCRIPT_DIR/lib/proof-check.sh"
+if [ -f "$PROOF_CHECK_LIB" ]; then
+    # shellcheck source=lib/proof-check.sh
+    source "$PROOF_CHECK_LIB"
+fi
+
 # Completion Council (v5.25.0) - Multi-agent completion verification
 # Source completion council module
 COUNCIL_SCRIPT="$SCRIPT_DIR/completion-council.sh"
@@ -2330,6 +2349,19 @@ EOF
         jq -r '.completed_tasks[]? | select(.github_issue) | "Closes #\(.github_issue)"' .loki/ledger.json >> "$pr_body" 2>/dev/null || true
     fi
 
+    # Proven PR (Loop 6): append the Evidence Receipt to the body file before
+    # gh pr create --body-file. Default-on; LOKI_PROVEN_PR=0 -> body file bytes
+    # byte-identical to before. Empty expected_head_sha by design (R-DET-1
+    # run_id pointer is the anti-stale guard; the branch head is offset by the
+    # session commit). Best-effort: a missing proof appends nothing extra here.
+    if [ "${LOKI_PROVEN_PR:-1}" != "0" ] && declare -f render_evidence_receipt_md >/dev/null 2>&1; then
+        local _bf_proof=""
+        _bf_proof="$(_loki_proof_json_for_pr 2>/dev/null || true)"
+        if [ -n "$_bf_proof" ]; then
+            { printf '\n'; render_evidence_receipt_md "$_bf_proof" "" "" 2>/dev/null; } >> "$pr_body" 2>/dev/null || true
+        fi
+    fi
+
     # Build PR create command
     local pr_args=("pr" "create" "--repo" "$repo" "--title" "[Loki Mode] $feature_name" "--body-file" "$pr_body")
 
@@ -3184,7 +3216,30 @@ on_run_complete() {
         log_info "LOKI_DELEGATE_PR=1: PR already exists for branch '$branch': $existing_pr (skipping create)."
         return 0
     fi
-    pr_url="$( (cd "${TARGET_DIR:-.}" && _loki_net gh pr create --title "$pr_title" --body "Opened by Loki Mode (delegate mode). Review locally before merge." --head "$branch") 2>/dev/null || true )"
+    # Proven PR (Loop 6): append the Evidence Receipt to the inline body.
+    # Default-on; LOKI_PROVEN_PR=0 -> body byte-identical to before. This path
+    # runs gh from a `cd "${TARGET_DIR:-.}"` subshell, so resolve the proof
+    # relative to TARGET_DIR (not the bare-relative helper). Empty
+    # expected_head_sha by design (R-DET-1 run_id pointer is the anti-stale guard).
+    local _del_body="Opened by Loki Mode (delegate mode). Review locally before merge."
+    if [ "${LOKI_PROVEN_PR:-1}" != "0" ] && declare -f render_evidence_receipt_md >/dev/null 2>&1; then
+        local _del_loki="${TARGET_DIR:-.}/.loki"
+        local _del_idfile="$_del_loki/state/last-proof-id.txt"
+        if [ -s "$_del_idfile" ]; then
+            local _del_rid=""
+            _del_rid="$(cat "$_del_idfile" 2>/dev/null || true)"
+            if [ -n "$_del_rid" ] && [ -f "$_del_loki/proofs/$_del_rid/proof.json" ]; then
+                local _del_receipt=""
+                _del_receipt="$(render_evidence_receipt_md "$_del_loki/proofs/$_del_rid/proof.json" "" "" 2>/dev/null || true)"
+                if [ -n "$_del_receipt" ]; then
+                    _del_body="${_del_body}
+
+${_del_receipt}"
+                fi
+            fi
+        fi
+    fi
+    pr_url="$( (cd "${TARGET_DIR:-.}" && _loki_net gh pr create --title "$pr_title" --body "$_del_body" --head "$branch") 2>/dev/null || true )"
     if [ -n "$pr_url" ]; then
         # Export so build_completion_summary folds the url into the summary.
         _LOKI_DELEGATE_PR_URL="$pr_url"
@@ -5501,6 +5556,46 @@ generate_proof_of_run() {
     local ver provider
     ver="$(get_version 2>/dev/null || echo unknown)"
     provider="${PROVIDER_NAME:-claude}"
+
+    # Proven PR (Loop 6 / Slice A2): resolve a deterministic run_id so the
+    # proof + the PR Evidence Receipt agree, and persist a stable pointer the PR
+    # sites read (never newest-by-mtime). The generator otherwise mints a fresh
+    # _gen_run_id() when LOKI_SESSION_ID is unset (the `loki start ./prd.md`
+    # case), which the later PR step could not know. Gated on the SAME flag as the
+    # receipt so LOKI_PROVEN_PR=0 is a byte-identical no-op (no --run-id passed,
+    # no pointer written): the pointer is only ever READ by the renderer, which
+    # is itself off under that flag.
+    if [ "${LOKI_PROVEN_PR:-1}" != "0" ]; then
+        local _rid=""
+        if declare -f _loki_trust_run_id >/dev/null 2>&1; then
+            _rid="$(_loki_trust_run_id 2>/dev/null || true)"
+        fi
+        # Fall back to a locally minted id when no persisted per-run id exists.
+        # Do NOT call _loki_trust_run_id --new here: that would clobber the
+        # trust-events run-id file; this is a read-or-mint-local resolution.
+        if [ -z "$_rid" ]; then
+            _rid="proof-$(date -u +%Y%m%d%H%M%S 2>/dev/null || echo 0)-$$-${RANDOM:-0}"
+        fi
+        ITERATION_COUNT="${ITERATION_COUNT:-0}" \
+        PROVIDER_NAME="$provider" \
+        PRD_PATH="${prd_path:-}" \
+        python3 "$gen" \
+            --loki-dir "$loki_dir" \
+            --loki-version "$ver" \
+            --provider "$provider" \
+            --run-id "$_rid" \
+            --quiet >/dev/null 2>&1 || true
+        # Persist the resolved run_id atomically (.tmp + mv) so the PR sites read
+        # the exact run the generator wrote, never an mtime guess.
+        local _id_dir="$loki_dir/state"
+        local _id_file="$_id_dir/last-proof-id.txt"
+        mkdir -p "$_id_dir" 2>/dev/null || true
+        if printf '%s' "$_rid" > "${_id_file}.tmp" 2>/dev/null; then
+            mv -f "${_id_file}.tmp" "$_id_file" 2>/dev/null || rm -f "${_id_file}.tmp" 2>/dev/null || true
+        fi
+        return 0
+    fi
+
     ITERATION_COUNT="${ITERATION_COUNT:-0}" \
     PROVIDER_NAME="$provider" \
     PRD_PATH="${prd_path:-}" \
@@ -6327,6 +6422,25 @@ commit_session_changes() {
     return 0
 }
 
+# _loki_proof_json_for_pr
+# Resolve THIS run's proof.json path from the persisted run_id pointer
+# (.loki/state/last-proof-id.txt, written by generate_proof_of_run / Slice A2).
+# Echoes the path when both the pointer and the file exist, else empty. NEVER
+# uses newest-by-mtime (R-DET-1). Best-effort, always returns 0. Uses the bare
+# relative .loki to match the other create_session_pr state reads (cwd==TARGET_DIR
+# at PR time). Returns empty under LOKI_PROVEN_PR=0 (pointer is never written).
+_loki_proof_json_for_pr() {
+    local id_file=".loki/state/last-proof-id.txt"
+    [ -s "$id_file" ] || { printf '%s' ""; return 0; }
+    local rid=""
+    rid="$(cat "$id_file" 2>/dev/null || true)"
+    [ -n "$rid" ] || { printf '%s' ""; return 0; }
+    local p=".loki/proofs/$rid/proof.json"
+    [ -f "$p" ] || { printf '%s' ""; return 0; }
+    printf '%s' "$p"
+    return 0
+}
+
 create_session_pr() {
     # Advise the user how to open a PR for the agent branch. PRINT-ONLY by
     # default (no push, no PR). LOKI_AUTO_PR=1 restores the legacy auto behavior.
@@ -6371,6 +6485,22 @@ create_session_pr() {
         else
             log_info "To open a pull request: git push -u origin ${branch_name}, then open a PR (base: ${base})"
         fi
+        # Proven PR (Loop 6): print the Evidence Receipt block AFTER the push/PR
+        # advice so a user opening a manual PR can paste it into the body. This is
+        # the print-PR-body fallback. Default-on; LOKI_PROVEN_PR=0 -> not invoked
+        # (advisory output byte-identical to before). Production callers pass an
+        # empty expected_head_sha: the session commit lands between proof-gen and
+        # this point, so the branch head is structurally offset from the proof's
+        # head and feeding it would false-degrade every legitimate receipt; the
+        # anti-stale guarantee is the run_id pointer (R-DET-1), not a head match.
+        if [ "${LOKI_PROVEN_PR:-1}" != "0" ] && declare -f render_evidence_receipt_md >/dev/null 2>&1; then
+            local _pr_proof=""
+            _pr_proof="$(_loki_proof_json_for_pr 2>/dev/null || true)"
+            if [ -n "$_pr_proof" ]; then
+                printf '\n'
+                render_evidence_receipt_md "$_pr_proof" "" "" || true
+            fi
+        fi
         return 0
     fi
 
@@ -6395,21 +6525,95 @@ create_session_pr() {
         if [ -n "$existing_pr" ]; then
             log_info "PR already exists for branch $branch_name: $existing_pr (skipping create)"
             audit_log "PR_EXISTS" "branch=$branch_name,url=$existing_pr"
+            # Proven PR (Loop 6, PO-locked Q1): on idempotent reuse, leave the
+            # existing PR untouched (do not rewrite the body, edit the PR, or
+            # post a comment). Just hint that an Evidence Receipt is available.
+            if [ "${LOKI_PROVEN_PR:-1}" != "0" ]; then
+                local _exist_proof=""
+                _exist_proof="$(_loki_proof_json_for_pr 2>/dev/null || true)"
+                if [ -n "$_exist_proof" ]; then
+                    log_info "Evidence Receipt available for this run: loki proof open (run id in .loki/state/last-proof-id.txt)"
+                fi
+            fi
             return 0
         fi
-        pr_url=$(gh pr create \
-            --title "Loki Mode: Agent session changes ($branch_name)" \
-            --body "Automated changes from Loki Mode agent session.
+        # Build the body into a variable so the Proven PR Evidence Receipt can be
+        # appended (Loop 6). Default-on; LOKI_PROVEN_PR=0 -> body bytes are
+        # byte-identical to the legacy inline body. Empty expected_head_sha by
+        # design (see the advisory-branch note: the session commit offsets the
+        # branch head from the proof head; R-DET-1 run_id pointer is the guard).
+        local _auto_body
+        _auto_body="Automated changes from Loki Mode agent session.
 
 Branch: \`$branch_name\`
 Session PID: $$
-Created: $(date -u +%Y-%m-%dT%H:%M:%SZ)" \
+Created: $(date -u +%Y-%m-%dT%H:%M:%SZ)"
+        local _auto_proof=""
+        if [ "${LOKI_PROVEN_PR:-1}" != "0" ] && declare -f render_evidence_receipt_md >/dev/null 2>&1; then
+            _auto_proof="$(_loki_proof_json_for_pr 2>/dev/null || true)"
+            if [ -n "$_auto_proof" ]; then
+                local _auto_receipt=""
+                _auto_receipt="$(render_evidence_receipt_md "$_auto_proof" "" "" 2>/dev/null || true)"
+                if [ -n "$_auto_receipt" ]; then
+                    _auto_body="${_auto_body}
+
+${_auto_receipt}"
+                fi
+            fi
+        fi
+        pr_url=$(gh pr create \
+            --title "Loki Mode: Agent session changes ($branch_name)" \
+            --body "$_auto_body" \
             --base "$base" \
             --head "$branch_name" 2>/dev/null) || true
 
         if [ -n "$pr_url" ]; then
             log_info "PR created: $pr_url"
             audit_log "PR_CREATED" "branch=$branch_name,url=$pr_url"
+            # Proven PR (Loop 6 / Slice D linkage): persist {run_id, pr_url} next
+            # to the proof so the dashboard proofs panel can show "PR #N:
+            # <headline>". Slice D owns the READ; Slice A owns this WRITE. Atomic
+            # .tmp + mv, python3-guarded for correct JSON escaping, only when a
+            # proof for THIS run exists and a pr_url was returned. Best-effort.
+            if [ -n "$_auto_proof" ] && command -v python3 >/dev/null 2>&1; then
+                local _pr_json_dir
+                _pr_json_dir="$(dirname "$_auto_proof" 2>/dev/null || true)"
+                if [ -n "$_pr_json_dir" ] && [ -d "$_pr_json_dir" ]; then
+                    local _pr_run_id
+                    _pr_run_id="$(basename "$_pr_json_dir" 2>/dev/null || true)"
+                    LOKI_PR_JSON_DIR="$_pr_json_dir" \
+                    LOKI_PR_RUN_ID="$_pr_run_id" \
+                    LOKI_PR_URL="$pr_url" \
+                    python3 - <<'PR_JSON_PY' 2>/dev/null || true
+import json
+import os
+
+d = os.environ.get("LOKI_PR_JSON_DIR", "")
+run_id = os.environ.get("LOKI_PR_RUN_ID", "")
+pr_url = os.environ.get("LOKI_PR_URL", "")
+if d and os.path.isdir(d):
+    path = os.path.join(d, "pr.json")
+    tmp = path + ".tmp"
+    try:
+        with open(tmp, "w") as f:
+            json.dump({"run_id": run_id, "pr_url": pr_url}, f)
+        os.replace(tmp, path)
+    except Exception:
+        try:
+            os.remove(tmp)
+        except Exception:
+            pass
+PR_JSON_PY
+                fi
+            fi
+            # Proven PR (Loop 6 / Slice B integration): one guarded call to the
+            # optional advisory verified-completion check-run. Posts NOTHING by
+            # default (LOKI_PROVEN_PR_CHECK unset). Slice B owns proof-check.sh;
+            # guarded on the file being sourced (declare -f) so this slice is
+            # correct whether or not B is integrated. Best-effort, never fails PR.
+            if [ "${LOKI_PROVEN_PR_CHECK:-0}" = "1" ] && declare -f post_verified_completion_check >/dev/null 2>&1; then
+                post_verified_completion_check "${_auto_proof:-}" "$pr_url" || true
+            fi
         else
             log_warn "Failed to create PR - branch pushed to: $branch_name"
         fi
@@ -10446,7 +10650,14 @@ start_dashboard() {
     # Start the FastAPI dashboard server
     # Dashboard module is at project root (parent of autonomy/)
     # LOKI_SKILL_DIR tells server.py where to find static files
+    # LOKI_DASHBOARD_AUTOSTARTED=1 marks this as a run-launched (auto-started)
+    # dashboard, distinct from an explicit `loki dashboard start`. The server
+    # uses this so that, after the dashboard Stop button stops the last active
+    # run, it may shut ITSELF down -- but ONLY when it was auto-started, never
+    # when the user started it deliberately to keep monitoring. The explicit
+    # cmd_dashboard_start path never sets this var (M4 fix).
     LOKI_TLS_CERT="${LOKI_TLS_CERT:-}" LOKI_TLS_KEY="${LOKI_TLS_KEY:-}" \
+        LOKI_DASHBOARD_AUTOSTARTED=1 \
         LOKI_SKILL_DIR="${skill_dir}" PYTHONPATH="${skill_dir}" nohup "$python_cmd" -m dashboard.server > "$log_file" 2>&1 &
     DASHBOARD_PID=$!
     register_pid "$DASHBOARD_PID" "dashboard" "port=${DASHBOARD_PORT:-57374}"

package/dashboard/__init__.py

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

package/dashboard/server.py

@@ -3325,12 +3325,14 @@ async def stop_running_project(request: Request, body: RunningProjectStopRequest
             except OSError:
                 pass
         registry.mark_project_stopped(project_id)
-        return {
+        _resp = {
             "success": True,
             "project_id": project_id,
             "stopped": stop_signaled,
             "already_stopped": not stop_signaled,
         }
+        _resp.update(_dashboard_teardown_after_project_stop(path))
+        return _resp
 
     # Write the STOP file so the runner's own cleanup STOP-branch fires for a
     # clean teardown. Only into the registry-resolved .loki dir.
@@ -3392,12 +3394,14 @@ async def stop_running_project(request: Request, body: RunningProjectStopRequest
 
     registry.mark_project_stopped(project_id)
 
-    return {
+    _resp = {
         "success": True,
         "project_id": project_id,
         "stopped": stopped,
         "already_stopped": False,
     }
+    _resp.update(_dashboard_teardown_after_project_stop(path))
+    return _resp
 
 
 def _recover_spec_source(path: str) -> Optional[_Path]:
@@ -4057,6 +4061,17 @@ def get_compliance_status(request: Request, report_type: str = Query("soc2", ali
 # When set, _get_loki_dir() resolves .loki/ relative to this path instead of CWD.
 _active_project_dir: Optional[str] = None
 
+# M4 (v7.90.1): was this dashboard auto-started by a run (`loki start` ->
+# run.sh start_dashboard), or started deliberately by the user
+# (`loki dashboard start`)? Captured ONCE at import from the environment marker
+# that ONLY the auto-start path sets. Used to decide whether the dashboard may
+# shut ITSELF down after its Stop button stops the last active run: an
+# auto-started dashboard self-exits (it came up with the run, so it should go
+# down with the last run), while a user-started dashboard is left up and only
+# surfaces a non-destructive notice. Frozen at startup so a later child process
+# inheriting/clearing the var cannot flip the decision.
+_DASHBOARD_AUTOSTARTED: bool = os.environ.get("LOKI_DASHBOARD_AUTOSTARTED") == "1"
+
 
 def _get_loki_dir() -> _Path:
     """Get LOKI_DIR, refreshing from env on each call for consistency.
@@ -4364,6 +4379,126 @@ def _reap_orchestrators_until_clear(project_dir: _Path, expected_cwd: str,
     return (found_any, not _find_orchestrator_pids_for_dir(project_dir))
 
 
+def _other_runs_alive(exclude_path: Optional[str] = None) -> bool:
+    """True if ANY registered project OTHER than exclude_path still has a live
+    orchestrator pid. Mirrors run.sh's CLEAR/KEEP check (and cmd_stop's): a
+    project counts as alive only when its recorded pid is still running. The
+    just-stopped project must already be marked stopped in the registry (its pid
+    set to None by mark_project_stopped) before this is called, so it is not
+    self-counted; exclude_path is an extra belt-and-suspenders guard by realpath.
+    Best-effort: any registry/probe error degrades to True (KEEP) so we NEVER
+    tear the dashboard down on uncertain information.
+    """
+    try:
+        exclude_real = None
+        if exclude_path:
+            try:
+                exclude_real = os.path.realpath(exclude_path)
+            except OSError:
+                exclude_real = os.path.abspath(exclude_path)
+        for p in registry.list_projects(include_inactive=True):
+            path = p.get("path", "")
+            if exclude_real and path:
+                try:
+                    if os.path.realpath(path) == exclude_real:
+                        continue
+                except OSError:
+                    if os.path.abspath(path) == exclude_real:
+                        continue
+            pid = p.get("pid")
+            if isinstance(pid, int) and pid > 0 and not _pid_is_gone(pid):
+                return True
+        return False
+    except Exception:
+        # Unknown -> assume something is still running so we never wrongly kill
+        # the dashboard.
+        return True
+
+
+def _self_shutdown_after_response(delay_s: float = 1.0) -> None:
+    """Gracefully shut THIS dashboard server down shortly after the current HTTP
+    response has been sent. Used only after the dashboard's own Stop button stops
+    the LAST active run and only when this dashboard was auto-started (M4).
+
+    Why a delayed background thread (not an inline exit): the Stop request is
+    still in flight when this is decided. We must let FastAPI/uvicorn finish
+    writing the response (so the UI gets its JSON) before the process goes away.
+    A short-delay daemon thread sends SIGTERM to our OWN pid, which uvicorn
+    handles as a graceful shutdown (runs the lifespan teardown). This sidesteps
+    the fragile path where the dashboard relied on the orchestrator's cleanup
+    trap to kill it -- a path that a SIGKILL of the orchestrator (after the 5s
+    window) or a uvicorn graceful-shutdown deadlock could bypass, leaving the
+    dashboard lingering (the reported M4 bug). Best-effort; never raises into
+    the request.
+    """
+    import signal as _signal
+
+    def _kill_self() -> None:
+        try:
+            time.sleep(max(0.0, delay_s))
+        except Exception:
+            pass
+        try:
+            logger.info(
+                "Auto-started dashboard: last active run stopped and no other "
+                "run is alive; shutting self down (pid=%s).", os.getpid())
+        except Exception:
+            pass
+        try:
+            os.kill(os.getpid(), _signal.SIGTERM)
+        except OSError:
+            # Last resort: hard-exit this process only (never touches others).
+            os._exit(0)
+
+    try:
+        threading.Thread(target=_kill_self, name="loki-dash-selfstop",
+                         daemon=True).start()
+    except Exception:
+        # If we cannot even spawn the thread, do nothing: a lingering dashboard
+        # is strictly safer than any broader action.
+        pass
+
+
+def _dashboard_teardown_after_project_stop(stopped_path: Optional[str]) -> dict:
+    """Decide what happens to THIS dashboard after a per-project Stop, and return
+    fields to merge into the Stop response (M4).
+
+    Rules (conservative; never touches any process but this server's own):
+      - If another registered run is still alive -> KEEP: do nothing, the
+        dashboard stays up because other projects still need it.
+      - If no other run is alive (CLEAR) and this dashboard was AUTO-STARTED by a
+        run -> schedule a graceful self-shutdown after the response is sent. It
+        came up with a run, so it goes down with the last run.
+      - If CLEAR but the dashboard was started DELIBERATELY by the user
+        (`loki dashboard start`) -> do NOT self-kill; return a non-destructive
+        notice so the UI can tell the user how to stop it (loki dashboard stop).
+
+    Returns one of:
+      {"dashboard": "kept"}                              # other runs alive
+      {"dashboard": "stopping", ...}                     # auto-started + CLEAR
+      {"dashboard": "idle", "notice": "...", ...}        # user-started + CLEAR
+    """
+    try:
+        if _other_runs_alive(exclude_path=stopped_path):
+            return {"dashboard": "kept"}
+        if _DASHBOARD_AUTOSTARTED:
+            _self_shutdown_after_response()
+            return {
+                "dashboard": "stopping",
+                "dashboard_autostarted": True,
+            }
+        return {
+            "dashboard": "idle",
+            "dashboard_autostarted": False,
+            "notice": ("No active runs. This dashboard was started manually; "
+                       "stop it with: loki dashboard stop"),
+        }
+    except Exception:
+        # Any failure in the decision must never break the Stop response, and
+        # must never kill the dashboard on uncertain info.
+        return {"dashboard": "kept"}
+
+
 def _pid_is_gone(pid: int) -> bool:
     """True if pid no longer exists OR is a zombie/defunct (effectively dead,
     just not yet reaped by its parent). os.kill(pid,0) succeeds on a zombie, so
@@ -10078,6 +10213,25 @@ def _safe_proof_run_dir(run_id: str) -> _Path:
     return _Path(target)
 
 
+def _proof_pr_url(run_dir: _Path) -> Optional[str]:
+    """Return the PR URL linked to this run, or None.
+
+    Reads the optional <run_dir>/pr.json that the run.sh auto-PR path writes at
+    PR-creation time ({"run_id": "...", "pr_url": "..."}). The file is read only
+    inside the already-validated run dir (the caller passes either an iterdir()
+    entry or a _safe_proof_run_dir result -- never a raw run_id), so there is no
+    additional traversal surface. Missing/unreadable/non-dict pr.json or an
+    empty/non-string pr_url -> None, never an error. Most proofs have no PR.
+    """
+    pr_data = _safe_json_read(run_dir / "pr.json", default=None)
+    if not isinstance(pr_data, dict):
+        return None
+    url = pr_data.get("pr_url")
+    if isinstance(url, str) and url:
+        return url
+    return None
+
+
 @app.get("/api/proofs", dependencies=[Depends(auth.require_scope("read"))])
 async def list_proofs():
     """List proof-of-run artifacts for the active project's .loki/proofs/."""
@@ -10096,6 +10250,11 @@ async def list_proofs():
         data = _safe_json_read(proof_json, default=None)
         if not isinstance(data, dict):
             continue
+        # Deterministic honesty headline (single source of truth, same access as
+        # proofs_summary's bucketing). Read, never recomputed. The list endpoint
+        # surfaces it so the panel can show the verdict without a second fetch.
+        honesty = data.get("honesty")
+        headline = honesty.get("headline") if isinstance(honesty, dict) else None
         items.append({
             "run_id": data.get("run_id", entry.name),
             "generated_at": data.get("generated_at"),
@@ -10103,6 +10262,8 @@ async def list_proofs():
             "cost_usd": (data.get("cost") or {}).get("usd"),
             "files_changed": (data.get("files_changed") or {}).get("count"),
             "final_verdict": (data.get("council") or {}).get("final_verdict"),
+            "headline": headline,
+            "pr_url": _proof_pr_url(entry),
             "has_html": (entry / "index.html").is_file(),
         })
     # Newest first when generated_at is present.
@@ -10176,6 +10337,10 @@ async def get_proof(run_id: str):
     data = _safe_json_read(proof_json, default=None)
     if not isinstance(data, dict):
         raise HTTPException(status_code=500, detail="proof.json unreadable")
+    # Surface the optional PR linkage alongside the proof. The proof.json itself
+    # already carries honesty.headline; we only add pr_url so the panel can show
+    # "PR #N -> <headline>". Absent pr.json -> pr_url null, never an error.
+    data["pr_url"] = _proof_pr_url(run_dir)
     return JSONResponse(content=data)