loki-mode 10.5.17 → 10.5.20

package/SKILL.md

@@ -3,7 +3,7 @@ name: loki-mode
 description: An autonomous software factory that knows what it is supposed to deliver, and proves it did. Use when the user says Loki Mode or asks to build, fix or verify software autonomously.
 ---
 
-# Loki Mode v10.5.17
+# Loki Mode v10.5.20
 
 **You are an autonomous agent. You make decisions. You do not ask questions. You do not stop.**
 
@@ -458,7 +458,7 @@ See `CHANGELOG.md` entries [7.5.7], [7.5.8], [7.5.13] for the per-fix list and r
 |---------|--------|-------|
 | Bun runtime (Phase 2+) | TBD | Migrate write-path commands; tracked on `feat/bun-migration` |
 | Managed Agents multiagent path | TBD | `LOKI_EXPERIMENTAL_MANAGED_*` flags -- RESEARCH PREVIEW, not on live API |
-| Benchmarks (HumanEval, SWE-bench) | TBD | Runner scripts and datasets exist in `benchmarks/`; no published results |
+| Benchmarks | TBD | Runner scripts and datasets exist in `benchmarks/`; no published results |
 | `loki run` removal | next major | Currently a deprecated alias for `loki start` |
 
 ## Deprecated
@@ -470,4 +470,4 @@ See `CHANGELOG.md` entries [7.5.7], [7.5.8], [7.5.13] for the per-fix list and r
 
 ---
 
-**v10.5.17 | [Autonomi](https://www.autonomi.dev/) flagship product | ~410 lines core**
+**v10.5.20 | [Autonomi](https://www.autonomi.dev/) flagship product | ~410 lines core**

package/VERSION

@@ -1 +1 @@
-10.5.17
+10.5.20

package/autonomy/lib/proof-generator.py

@@ -1115,6 +1115,230 @@ def _empty_tree_sha(repo_dir):
     return out.stdout.strip() if out.returncode == 0 else ""
 
 
+# A-118 / D47: tests_integrity. Did the run WEAKEN the tests that vouch for it?
+# CFG_ALWAYS is copied from loki-ts/src/engine10/stages/verify.ts (A-115); keep in sync.
+# The comparison is base vs the final WORKING TREE plus untracked files (like
+# collect_workspace_diff), so uncommitted work is covered.
+_TI_CFG_ALWAYS = re.compile(r"(^|/)(conftest\.py|\.?pytest\.(?:ini|toml)|tox\.ini|jest\.config\.[\w.]+|vitest\.config\.[\w.]+|\.mocharc[\w.]*)$")
+_TI_CFG_SHARED = re.compile(r"(^|/)(setup\.cfg|pyproject\.toml|package\.json)$")
+_TI_TEST_FILE = re.compile(
+    r"(^|/)(tests?|__tests__|spec|specs)/|\.(test|spec)\.[\w]+$|(^|/)test_[^/]*\.py$|_test\.(py|go|rs)$|(^|/)conftest\.py$")
+_TI_SKIP_JS = re.compile(
+    # options object only as the 2nd argument: title (string or identifier), then `, {`
+    r"\b(test|it|describe|suite|context|specify)\s*\(\s*(?:'[^'\n]*'|\"[^\"\n]*\"|`[^`\n]*`|[\w.$]+)\s*,\s*\{[^}]*\b(skip|todo)\s*:\s*(?!(?:false|0|null|undefined)\b)\S"
+    r"|\b(it|test|describe|suite|context|specify)\s*\.\s*(skip|only|todo)\b"
+    r"|\bx(it|test|describe)\s*\(|\bf(it|describe)\s*\("
+    r"|\b(t|ctx)\s*\.\s*(skip|todo)\s*\(")
+_TI_SKIP_PY = re.compile(
+    r"\b(?:pytest\.)?mark\.(skip|skipif|xfail)\b|\bpytest\.(skip|xfail|importorskip)\s*\("
+    r"|@(?:unittest\.)?(skip|skipIf|skipUnless|expectedFailure)\b|\bSkipTest\b|\bskipTest\s*\(")
+_TI_SKIP_GO = re.compile(r"\b[tb]\.Skip(f|Now)?\s*\(")
+_TI_SKIP_RS = re.compile(r"#\[ignore")
+_TI_SKIP_BY_EXT = (
+    (("js", "jsx", "ts", "tsx", "mjs", "cjs"), _TI_SKIP_JS),
+    (("py",), _TI_SKIP_PY), (("go",), _TI_SKIP_GO), (("rs",), _TI_SKIP_RS))
+_TI_ASSERT = re.compile(r"\bassert|\bexpect\(|\.should\b|\.to[A-Z]\w*\(|\bt\.(Error|Fatal)")
+_TI_PKG_KEYS = ("jest", "mocha", "vitest", "ava")
+
+
+def _ti_skip_re(path):
+    ext = path.rsplit(".", 1)[-1].lower() if "." in path else ""
+    for exts, rx in _TI_SKIP_BY_EXT:
+        if ext in exts:
+            return rx
+    return None
+
+
+def _ti_run(repo, *args):
+    """Run a read-only git command; returns text decoded from bytes (so a lone
+    CR is never a line break; callers split on \\n only), or None on failure."""
+    try:
+        r = subprocess.run(["git", "-c", "core.quotePath=false", *args], cwd=repo,
+                           capture_output=True, timeout=30)
+    except Exception:
+        return None
+    if r.returncode != 0:
+        return None
+    return r.stdout.decode("utf-8", "replace")
+
+
+def _ti_pkg_view(text, _path=""):
+    """Test-relevant slice of a package.json, or None when unparseable."""
+    try:
+        d = json.loads(text) if text.strip() else {}
+    except ValueError:
+        return None
+    if not isinstance(d, dict):
+        return None
+    scripts = d.get("scripts") if isinstance(d.get("scripts"), dict) else {}
+    view = {k: v for k, v in scripts.items() if re.match(r"^(pre|post)?test(:.*)?$", k)}
+    return {"scripts": view, **{k: d[k] for k in _TI_PKG_KEYS if k in d}}
+
+
+_TI_PYTEST_KEYS = ("addopts", "testpaths", "python_files", "python_functions",
+                   "python_classes", "norecursedirs")
+
+
+def _ti_pytest_view(text, path):
+    """The test-selection keys of a pytest config, or None when unparseable.
+    Parsed (tomllib / configparser), so a multi-line addopts edit is seen.
+    ponytail: without tomllib (python < 3.11) try tomli, else compare only the
+    whitespace-normalized [tool.pytest.ini_options] section text."""
+    if not text.strip():
+        return {}
+    if path.endswith(".toml"):
+        try:
+            try:
+                import tomllib
+            except ImportError:
+                import tomli as tomllib
+        except ImportError:
+            m = re.search(r"^\[tool\.pytest\.ini_options\][ \t]*(?:#.*)?$(.*?)(?=^\[[^\[\]\n]+\][ \t]*(?:#.*)?$|\Z)",
+                          text, re.M | re.S)
+            return {"ini_options": " ".join(m.group(1).split())} if m else {}
+        try:
+            d = tomllib.loads(text)
+        except Exception:
+            return None
+        t = d.get("tool", {}).get("pytest", {})
+        t = t.get("ini_options", t) if isinstance(t, dict) else {}
+        return {k: t[k] for k in _TI_PYTEST_KEYS if k in t}
+    import configparser
+    cp = configparser.ConfigParser(interpolation=None, strict=False)
+    try:
+        cp.read_string(text)
+    except Exception:
+        return None
+    out = {}
+    for sec in ("pytest", "tool:pytest"):
+        if cp.has_section(sec):
+            for k in _TI_PYTEST_KEYS:
+                if cp.has_option(sec, k):
+                    out[sec + "." + k] = cp.get(sec, k)
+    return out
+
+
+_TI_SELECT_PY = re.compile(r"\bcollect_ignore(?:_glob)?\b|\bpytest_collection_modifyitems\b")
+_TI_PYTEST_NAMED = re.compile(r"(^|/)(conftest\.py|\.?pytest\.ini|tox\.ini)$")
+
+
+def _ti_base_has_pytest_config(target_dir, base):
+    names = _ti_run(target_dir, "ls-tree", "-r", "--name-only", "-z", base) or ""
+    for n in names.split("\0"):
+        if _TI_PYTEST_NAMED.search(n):
+            return True
+        if n.endswith(("pyproject.toml", "setup.cfg")) and \
+                _ti_pytest_view(_ti_run(target_dir, "show", "%s:./%s" % (base, n)) or "", n):
+            return True
+    return False
+
+
+def _ti_added_config_selects(path, text):
+    """True when a newly added pytest config changes test selection (unparseable counts)."""
+    if path.endswith(".py"):
+        return bool(_TI_SELECT_PY.search(text))
+    if path.endswith((".ini", ".toml", ".cfg")):
+        v = _ti_pytest_view(text, path)
+        return v is None or bool(v)
+    return False
+
+
+def _collect_tests_integrity(target_dir, base):
+    """Return {"weakened": [...], "assertions_edited": [...], "disclosed": [...]} or None.
+
+    Derived from base vs the final working tree (committed, staged, unstaged and
+    untracked). None when there is no usable diff (no repo, no base)."""
+    if not base:
+        return None
+    names = _ti_run(target_dir, "diff", "--relative", "--name-status", "-M", "-z", base, "--")
+    if names is None:
+        return None
+    weakened, edited, disclosed = [], [], []
+    greenfield = base == _empty_tree_sha(target_dir)
+    toks = names.split("\0")
+    entries, i = [], 0  # (status, old_path, new_path)
+    while i < len(toks) and toks[i]:
+        st = toks[i][:1]
+        if st in "RC" and i + 2 < len(toks):
+            entries.append((st, toks[i + 1], toks[i + 2]))
+            i += 3
+        else:
+            entries.append((st, toks[i + 1] if i + 1 < len(toks) else "", toks[i + 1] if i + 1 < len(toks) else ""))
+            i += 2
+    untracked = _ti_run(target_dir, "ls-files", "--others", "--exclude-standard", "-z") or ""
+    for u in untracked.split("\0"):
+        if u and not u.startswith(".loki/"):
+            entries.append(("A", u, u))
+    for st, old, new in entries:
+        if st in ("D", "R") and _TI_TEST_FILE.search(old):
+            weakened.append("test file %s: %s" % ("deleted" if st == "D" else "renamed", old))
+    if not greenfield:
+        for st, old, new in entries:
+            path = new if st != "D" else old
+            is_always = bool(_TI_CFG_ALWAYS.search(path))
+            if not (is_always or _TI_CFG_SHARED.search(path)):
+                continue
+            if st == "A":  # no base version: disclose, unless it re-selects tests over a base pytest config
+                try:
+                    with open(os.path.join(target_dir, new), encoding="utf-8", errors="replace") as h:
+                        text = h.read()
+                except OSError:
+                    text = ""
+                if _ti_added_config_selects(path, text) and _ti_base_has_pytest_config(target_dir, base):
+                    weakened.append("test runner config changed: " + path)
+                else:
+                    disclosed.append("new test runner config: " + path)
+            elif is_always:
+                weakened.append("test runner config changed: " + path)
+            else:
+                before = _ti_run(target_dir, "show", "%s:./%s" % (base, old)) or ""
+                try:
+                    with open(os.path.join(target_dir, new), encoding="utf-8", errors="replace") as h:
+                        after = h.read()
+                except OSError:
+                    after = ""
+                view = _ti_pkg_view if path.endswith("package.json") else _ti_pytest_view
+                b, a = view(before, path), view(after, path)
+                if b is None or a is None or b != a:
+                    weakened.append("test runner config changed: " + path)
+    # Skip markers: added lines of tracked test files, and the content of untracked ones.
+    patch = _ti_run(target_dir, "diff", "--relative", "-U0", "-M", base, "--") or ""
+    cur, rx, removed_assert = None, None, False
+    for line in patch.split("\n") + ["diff --git a/ b/"]:
+        if line.startswith("diff --git "):
+            if cur and removed_assert and cur not in edited:
+                edited.append(cur)
+            cur, rx, removed_assert = None, None, False
+        elif line.startswith("+++ b/"):
+            cur = line[6:] if _TI_TEST_FILE.search(line[6:]) else None
+            rx = _ti_skip_re(cur) if cur else None
+        elif cur and line.startswith("+") and rx and rx.search(line):
+            weakened.append("skip added in %s" % cur)
+        elif cur and line.startswith("-") and not line.startswith("---") \
+                and _TI_ASSERT.search(line):
+            removed_assert = True
+    for u in untracked.split("\0"):
+        if not u or u.startswith(".loki/") or not _TI_TEST_FILE.search(u):
+            continue
+        rx = _ti_skip_re(u)
+        if not rx:
+            continue
+        try:
+            with open(os.path.join(target_dir, u), "rb") as h:
+                text = h.read().decode("utf-8", "replace")
+        except OSError:
+            continue
+        if any(rx.search(ln) for ln in text.split("\n")):
+            weakened.append("skip added in %s" % u)
+    uniq = []
+    for w in weakened:
+        if w not in uniq:
+            uniq.append(w)
+    if not uniq and not edited and not disclosed:
+        return None
+    return {"weakened": uniq, "assertions_edited": edited, "disclosed": disclosed}
+
+
 def _collect_iterations(loki_dir):
     completed = _read_json(os.path.join(loki_dir, "queue", "completed.json"), default=[])
     failed = _read_json(os.path.join(loki_dir, "queue", "failed.json"), default=[])
@@ -1455,6 +1679,10 @@ def _build_proof(args, loki_dir, target_dir, repo_root):
     # only, never read by _compute_headline / _compute_degraded.
     if journey:
         facts["journey"] = journey
+    # A-118: additive, present only when the diff touched test integrity.
+    _ti = _collect_tests_integrity(target_dir, diff_base_sha)
+    if _ti:
+        facts["tests_integrity"] = _ti
     ablation = _collect_ablation(loki_dir)
     if ablation is not None:
         facts["ablation"] = ablation
@@ -1517,6 +1745,24 @@ def _build_proof(args, loki_dir, target_dir, repo_root):
             "post_headline": True,
         })
 
+    # D47: edited assertion lines are disclosed but never move the headline or rc.
+    _ae = (facts.get("tests_integrity") or {}).get("assertions_edited")
+    if _ae:
+        degraded.append({
+            "item": "tests_integrity:assertions_edited",
+            "status": "inconclusive",
+            "reason": "assertion lines edited in: " + ", ".join(_ae),
+            "post_headline": True,
+        })
+    _di = (facts.get("tests_integrity") or {}).get("disclosed")
+    if _di:
+        degraded.append({
+            "item": "tests_integrity:config_added",
+            "status": "inconclusive",
+            "reason": "; ".join(_di),
+            "post_headline": True,
+        })
+
     honesty = {
         "headline": headline,
         "degraded": degraded,
@@ -1653,6 +1899,10 @@ def _compute_degraded(facts):
         out.append({"item": "security", "status": "findings",
                     "reason": "%s un-waived HIGH security finding(s)"
                               % sec.get("high_active")})
+    ti = facts.get("tests_integrity") or {}
+    if ti.get("weakened"):
+        out.append({"item": "tests_integrity", "status": "failed",
+                    "reason": "tests weakened: " + "; ".join(ti["weakened"])})
     git = facts.get("git") or {}
     if not (git.get("diff") or {}).get("count"):
         out.append({"item": "git.diff", "status": "not_run",
@@ -1748,6 +1998,7 @@ def _compute_headline(facts, degraded):
                if _is_exogenous(g))
         or sec_high
         or fn_failed
+        or bool((facts.get("tests_integrity") or {}).get("weakened"))
     )
     if any_failed:
         return "NOT VERIFIED"

package/autonomy/lib/proof-verify.py

@@ -331,6 +331,7 @@ def _compute_headline(facts, degraded):
                if _is_exogenous(g))
         or sec_high
         or fn_failed
+        or bool((facts.get("tests_integrity") or {}).get("weakened"))
     )
     if any_failed:
         return "NOT VERIFIED"

package/autonomy/loki

@@ -1850,6 +1850,48 @@ show_help_aliases() {
     echo "See internal/CLI-CONSOLIDATION-DESIGN.md for the full migration plan."
 }
 
+# D51: bare `loki`. Reuse a running dashboard, else start one on a free
+# loopback port, then open /start (or just print the URL when headless).
+loki_ui_free_port() {
+    python3 - "$1" <<'PY'
+import socket, sys
+for p in range(int(sys.argv[1]), int(sys.argv[1]) + 100):
+    s = socket.socket()
+    try:
+        s.bind(("127.0.0.1", p))
+    except OSError:
+        continue
+    finally:
+        s.close()
+    print(p)
+    break
+PY
+}
+
+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)
+        fi
+    fi
+    if [ -z "$port" ]; then
+        port=$(loki_ui_free_port "${LOKI_DASHBOARD_PORT:-$DASHBOARD_DEFAULT_PORT}")
+        [ -n "$port" ] || { echo "loki: no free local port found" >&2; return 1; }
+        # The WS-origin allowlist must name the chosen port on both loopback names.
+        LOKI_PROJECT_DIR="$PWD" \
+            LOKI_DASHBOARD_CORS="http://localhost:$port,http://127.0.0.1:$port" \
+            cmd_dashboard_start --host 127.0.0.1 --port "$port" >&2 || return 1
+    fi
+    local url="http://127.0.0.1:${port}/start"
+    if [ "${LOKI_HEADLESS:-0}" = "1" ] || [ "${1:-}" = "--no-open" ]; then
+        echo "$url"
+    else
+        loki_open_url "$url" || echo "$url"
+    fi
+}
+
 # Tight newcomer landing for the bare `loki` invocation (no args).
 # v7.28.x UX: the full 70-command table lives in `loki help`; a no-args run
 # now shows only a calm ~12-line orientation so the "what do I do first"
@@ -3397,7 +3439,7 @@ cmd_start() {
                         ${LOKI_MIROFISH_ROUNDS:+--max-rounds "$LOKI_MIROFISH_ROUNDS"} \
                         ${LOKI_MIROFISH_TIMEOUT:+--timeout "$LOKI_MIROFISH_TIMEOUT"}
                     # PID is tracked in .loki/mirofish/pipeline-state.json by the adapter
-                    echo -e "${CYAN}MiroFish pipeline started in background. Check status: loki mirofish status${NC}"
+                    echo -e "${CYAN}MiroFish pipeline started in background. Status: $LOKI_DIR/mirofish/pipeline-state.json${NC}"
                 else
                     echo -e "${YELLOW}Warning: PRD validation for MiroFish failed. Continuing without.${NC}"
                     unset MIROFISH_URL
@@ -21586,11 +21628,15 @@ main() {
         exit 1
     fi
 
-    if [ $# -eq 0 ]; then
-        # v7.28.x UX: bare `loki` shows a tight newcomer landing, not the full
-        # command wall. `loki help`/`--help` still print show_help unchanged.
-        show_landing
-        exit 0
+    if [ $# -eq 0 ] || { [ $# -eq 1 ] && [ "$1" = "--no-open" ]; }; then
+        # D51: bare `loki` starts the local UI. LOKI_LANDING=1 keeps the v7.28
+        # newcomer landing (tests and scripts that parse it set it).
+        if [ "${LOKI_LANDING:-0}" = "1" ]; then
+            show_landing
+            exit 0
+        fi
+        cmd_ui "$@"
+        exit $?
     fi
 
     local command="$1"

package/autonomy/run.sh

@@ -256,7 +256,10 @@ if [ -z "${LOKI_QUICK_INNER:-}" ] && [ "${LOKI_VERBOSE:-0}" != "1" ] && [ "${BAS
         if command -v python3 >/dev/null 2>&1 && python3 -c 'import os,signal' >/dev/null 2>&1; then
             _qexec=(python3 -c 'import os,signal,sys;signal.signal(signal.SIGPIPE,signal.SIG_DFL);os.execv(sys.argv[1],sys.argv[1:])' "${_qexec[@]}")
         fi
-        ( trap - INT QUIT; LOKI_QUICK_DIR="$_qd" LOKI_QUICK_OUTER_PID=$$ LOKI_QUICK_INNER=1 exec "${_qexec[@]}" >"$_qd/quick-run.log" ) &
+        # A background job gets stdin=/dev/null. Only a TTY needs it back (pause-mode
+        # keypress resume); a pipe would block the provider, which reads inherited stdin.
+        if [ -t 0 ]; then exec 3<&0; else exec 3</dev/null; fi
+        ( trap - INT QUIT; LOKI_QUICK_DIR="$_qd" LOKI_QUICK_OUTER_PID=$$ LOKI_QUICK_INNER=1 exec "${_qexec[@]}" >"$_qd/quick-run.log" <&3 3<&- ) &
         _qpid=$!
         trap 'kill -INT "$_qpid" 2>/dev/null' INT
         trap 'kill -TERM "$_qpid" 2>/dev/null' TERM HUP
@@ -265,8 +268,10 @@ if [ -z "${LOKI_QUICK_INNER:-}" ] && [ "${LOKI_VERBOSE:-0}" != "1" ] && [ "${BAS
         trap - INT TERM HUP
         _qw=$(grep -cF '[WARN]' "$_qd/quick-run.log" 2>/dev/null); _qw="${_qw:-0}"
         if [ "$_qrc" -ne 0 ] || [ ! -s "$_qd/quick-receipt.txt" ]; then
-            _qr=$(grep -E '\[(ERROR|WARN)\]|[Ss]topped|[Ff]ailed' "$_qd/quick-run.log" 2>/dev/null | tail -n 3)
-            echo "${_qr:-$(tail -n 3 "$_qd/quick-run.log" 2>/dev/null)}"
+            # Anchored to log_error/log_warn lines (optional ANSI prefix) and capped at 200
+            # chars so a long prompt line mentioning "failed" is never dumped.
+            _qr=$(grep -E $'^(\033\\[[0-9;]*m)?\\[(ERROR|WARN)\\]' "$_qd/quick-run.log" 2>/dev/null | tail -n 3 | cut -c1-200)
+            echo "${_qr:-$(tail -n 3 "$_qd/quick-run.log" 2>/dev/null | cut -c1-200)}"
         fi
         [ "$_qw" -gt 0 ] && echo "Warnings: $_qw (see $_qd/quick-run.log)"
         cat "$_qd/quick-receipt.txt" 2>/dev/null
@@ -11252,6 +11257,27 @@ _loki_proof_json_for_pr() {
 }
 
 # A-134: compact quiet-mode receipt for the outer shell (see top of file) to print.
+# A-118 / D47: a quick run that weakened its own tests exits 3. Prints the rc to use:
+# only ever RAISES a 0 (never lowers a non-zero rc); NOT VERIFIED from unproven gates alone keeps 0.
+_loki_quick_integrity_rc() {
+    local rc="${1:-0}" ld="${TARGET_DIR:-.}/.loki" rid pj
+    [ "$rc" = "0" ] || { echo "$rc"; return 0; }
+    rid="$(cat "$ld/state/last-proof-id.txt" 2>/dev/null || true)"
+    case "$rid" in '' | *[!A-Za-z0-9._-]*) echo 0; return 0 ;; esac
+    pj="$ld/proofs/$rid/proof.json"
+    if [ -f "$pj" ] && python3 -E -c "import sys; sys.path[:] = [p for p in sys.path if p not in ('', '.')]
+import json
+d = json.load(open(sys.argv[1]))
+g = (d.get('facts') or {}).get('git') or {}
+if sys.argv[2] and g.get('head_sha') != sys.argv[2]:
+    sys.exit(1)
+sys.exit(0 if any(isinstance(x, dict) and x.get('item') == 'tests_integrity' and x.get('status') == 'failed' for x in ((d.get('honesty') or {}).get('degraded') or [])) else 1)" "$pj" "$(git -C "${TARGET_DIR:-.}" rev-parse HEAD 2>/dev/null || true)" 2>/dev/null; then
+        echo 3
+    else
+        echo 0
+    fi
+}
+
 _loki_quick_receipt_write() {
     local ld="${TARGET_DIR:-.}/.loki" rid pj
     rid="$(cat "$ld/state/last-proof-id.txt" 2>/dev/null || true)"
@@ -11266,8 +11292,10 @@ v = d.get('verification') or {}
 if sys.argv[3] and g.get('head_sha') != sys.argv[3]:
     print('Evidence Receipt: unavailable (final proof generation failed; newest proof predates the session commit)')
     sys.exit(0)
-deg = [str(x.get('item') or '').split(':')[-1] for x in ((d.get('honesty') or {}).get('degraded') or []) if isinstance(x, dict)]
-notes = ([] if (v.get('gpg_signature') or v.get('attestation')) else ['unsigned']) + (['%d not proven: %s' % (len(deg), ', '.join(deg))] if deg else [])
+dg = [x for x in ((d.get('honesty') or {}).get('degraded') or []) if isinstance(x, dict)]
+tw = [str(x.get('reason') or 'tests weakened') for x in dg if x.get('item') == 'tests_integrity' and x.get('status') == 'failed']
+deg = [str(x.get('item') or '').split(':')[-1] for x in dg if x.get('item') != 'tests_integrity']
+notes = tw[:1] + ([] if (v.get('gpg_signature') or v.get('attestation')) else ['unsigned']) + (['%d not proven: %s' % (len(deg), ', '.join(deg))] if deg else [])
 print('Evidence Receipt: ' + str((d.get('honesty') or {}).get('headline') or 'unavailable') + (' (' + '; '.join(notes) + ')' if notes else ''))
 print('receipt_sha256: ' + str(v.get('hash') or ''))
 print('Head sha: ' + str(g.get('head_sha') or '') + '  Diff sha256: ' + str(g.get('diff_sha256') or ''))
@@ -29402,6 +29430,8 @@ except Exception:
     if [ "${LOKI_PROOF:-1}" != "0" ]; then
         generate_proof_of_run "$result" || true
     fi
+    # A-118: a quick run that weakened its tests exits 3 (quiet and verbose alike).
+    ! _loki_is_quick_prd "${PRD_PATH:-}" || result="$(_loki_quick_integrity_rc "$result")"
     [ -z "${LOKI_QUICK_INNER:-}" ] || _loki_quick_receipt_write
     # Trusted post-session step. NOT wrapped in _loki_with_github_tokens as a
     # whole (round 5): its push (_loki_trusted_push) and gh calls each re-grant

package/autonomy/verify.sh

@@ -3071,7 +3071,7 @@ sys.exit(0 if ok else 3)" "$lib" "$pj" 2>/dev/null || rc=$?
     # Provenance: the deploy gate's own verdict (Ed25519 attestation against the local
     # key plus LOKI_RECEIPT_RETIRED_PUBKEYS; unknown kid or no key is UNCHECKED).
     # Defined in autonomy/loki, so it is absent when verify.sh runs standalone.
-    declare -f _deploy_receipt_verdict >/dev/null 2>&1 || return 0
+    declare -f _deploy_receipt_verdict >/dev/null 2>&1 || { echo "attestation: UNCHECKED (run via loki verify)"; return 0; }
     local att
     att="$(_deploy_receipt_verdict "$pj")"
     # D47: UNSIGNED is never a pass; --allow-unsigned / LOKI_VERIFY_ALLOW_UNSIGNED=1 accepts it, said aloud.

package/dashboard/__init__.py

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