loki-mode 10.6.14 → 10.7.0

package/README.md

@@ -86,7 +86,7 @@ loki "fix the login redirect loop" --no-pr
 loki owner/repo#123
 ```
 
-The v10 engine accepts a quoted multi-word task, a GitHub, GitLab or Jira issue reference, `status`, `verify`, `dashboard`, and other subcommands. Flags (`loki-ts/src/engine10/cli.ts` USAGE): `--no-pr` builds and verifies without opening a pull request, `--deep` requests the deep verify pass and a longer implement budget, `--provider <name>` picks the coding provider, `--max-cost <usd>` sets the per-run cost cap (default $20.00, or `budgets.per_run` in `loki.yaml`; the flag wins; the start line prints it as `cap $20.00 (default)`; reaching it ends the run BUDGET_STOP, exit 3) (`--json` and `--verbose` are also parsed by the supervisor, see [Quiet output](#quiet-output)). The engine needs Bun; without it the command exits 1 with a message and installation instructions.
+The v10 engine accepts a quoted multi-word task, a GitHub, GitLab or Jira issue reference, `status`, `verify`, `dashboard`, and other subcommands. Flags (`loki-ts/src/engine10/cli.ts` USAGE): `--no-pr` builds and verifies without opening a pull request, `--deep` requests the deep verify pass and a longer implement budget, `--provider <name>` picks the coding provider, `--max-cost <usd>` sets the per-run cost cap (default $100.00 when an API key is set, no dollar cap on a subscription run where the start line adds `subscription: no dollar cap; usage counts against your plan limits`; or `budgets.per_run` in `loki.yaml`; the flag wins; the start line prints it as `cap $100.00 (default)`; reaching it ends the run BUDGET_STOP, exit 3) (`--json` and `--verbose` are also parsed by the supervisor, see [Quiet output](#quiet-output)). The engine needs Bun; without it the command exits 1 with a message and installation instructions.
 
 **Legacy engine (being removed).** The previous engine still ships in 10.6.6 and is reachable with `LOKI_ENGINE=legacy` or `loki legacy <args>`. `loki start owner/repo#N`, `loki start <issue URL>` and `loki start "<multi-word task>"` run on Loki 10, the same as `loki owner/repo#N` and `loki "<task>"`; `loki start ./prd.md`, a flag-first call and a one-word start stay on the legacy engine. For many issues use `loki backlog owner/repo --all|--label X|--issues N,N` (many issues, N in parallel, each on a `loki/backlog-N` worktree branch) instead. Legacy removal is planned and resumes on 2026-10-07; see [docs/v10/LEGACY-REMOVAL.md](docs/v10/LEGACY-REMOVAL.md). Sections below marked "legacy" describe features that run only on that engine.
 
@@ -205,7 +205,7 @@ A v10 run ends in exactly one outcome. The mapping is `EXIT` in `loki-ts/src/eng
 | 0 | ALREADY_SATISFIED | The work was already done; evidence is recorded. |
 | 1 | FAILED | A check failed, the stage failed, or the event log was modified outside the engine. |
 | 2 | (usage) | No task given, not inside a git repository, or a preflight refusal. Nothing ran. |
-| 3 | BUDGET_STOP | The cost cap (`--max-cost`, `budgets.per_run`, default $20.00) or the time cap fired before the work finished. |
+| 3 | BUDGET_STOP | The cost cap (`--max-cost`, `budgets.per_run`; default $100.00 with an API key, none on a subscription) or the time cap fired before the work finished. |
 | 4 | BLOCKED | Spec conflict: the contract cannot be satisfied as written. The summary names the conflict (`spec conflict: <reason>`); the run never guesses and calls it done. |
 | 5 | STALLED | The same failures three verifies in a row. |
 
@@ -498,9 +498,12 @@ If you do not have Bun yet:
 curl -fsSL https://bun.sh/install | bash       # macOS / Linux (or: brew install oven-sh/bun/bun)
 ```
 
-Docker without installing loki locally: `loki docker start prd.md` runs it in the
-published image with zero config, bind-mounting the current folder so `.loki`
-state and resume work exactly like local. See [DOCKER_README.md](DOCKER_README.md).
+Docker without installing loki locally: `loki docker start owner/repo#N` (or
+`loki docker start prd.md`) runs it in the published image with zero config,
+bind-mounting the current folder so `.loki` state and resume work exactly like
+local. On macOS, pass your GitHub login for PRs:
+`GH_TOKEN=$(gh auth token) loki docker start owner/repo#17`.
+See [DOCKER_README.md](DOCKER_README.md).
 
 Upgrading: `loki self-update` auto-detects which package manager installed loki
 and runs the right upgrade. `loki self-update --to bun` migrates an npm install

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.6.14
+# Loki Mode v10.7.0
 
 **Current entry points (Loki 10 engine):** `loki "<task>"`, `loki owner/repo#N` and `loki quick "<task>"` run the Loki 10 engine and end with a signed receipt (`loki verify`). `loki backlog owner/repo --all` runs many issues in parallel. Guide: `docs/v10/GUIDE.md`. The skill instructions below, and `loki start`, describe the legacy engine, which still ships and is being removed (`loki start owner/repo#N` still routes to it; prefer `loki owner/repo#N`).
 
@@ -473,4 +473,4 @@ See `CHANGELOG.md` entries [7.5.7], [7.5.8], [7.5.13] for the per-fix list and r
 
 ---
 
-**v10.6.14 | [Autonomi](https://www.autonomi.dev/) flagship product | core skill**
+**v10.7.0 | [Autonomi](https://www.autonomi.dev/) flagship product | core skill**

package/VERSION

@@ -1 +1 @@
-10.6.14
+10.7.0

package/autonomy/acp-agent.py

@@ -0,0 +1,128 @@
+#!/usr/bin/env python3
+"""Loki Mode as an ACP (Agent Client Protocol) agent over stdio.
+
+Newline-delimited JSON-RPC 2.0. stdout carries protocol frames only; all
+diagnostics go to stderr. Each session/prompt runs `loki quick "<prompt>"` in
+the session cwd and streams its output as agent_message_chunk updates. A
+non-zero exit is reported in the text as NOT VERIFIED, never as success.
+"""
+import json
+import os
+import subprocess
+import sys
+import threading
+
+PROTOCOL_VERSION = 1
+LOKI_CMD = os.environ.get("LOKI_ACP_LOKI") or "loki"
+
+out_lock = threading.Lock()
+sessions = {}  # sessionId -> {"cwd": str, "proc": Popen|None, "cancelled": bool}
+
+
+def send(obj):
+    with out_lock:
+        sys.stdout.write(json.dumps(obj) + "\n")
+        sys.stdout.flush()
+
+
+def reply(rid, result):
+    send({"jsonrpc": "2.0", "id": rid, "result": result})
+
+
+def error(rid, code, msg):
+    send({"jsonrpc": "2.0", "id": rid, "error": {"code": code, "message": msg}})
+
+
+def update(sid, text):
+    send({"jsonrpc": "2.0", "method": "session/update", "params": {
+        "sessionId": sid,
+        "update": {"sessionUpdate": "agent_message_chunk",
+                   "content": {"type": "text", "text": text}}}})
+
+
+def prompt_text(blocks):
+    parts = []
+    for b in blocks or []:
+        if b.get("type") == "text":
+            parts.append(b.get("text", ""))
+        elif b.get("type") == "resource_link":
+            parts.append(b.get("uri", ""))
+        elif b.get("type") == "resource":
+            r = b.get("resource", {})
+            parts.append(r.get("text") or r.get("uri", ""))
+    return "\n".join(p for p in parts if p).strip()
+
+
+def run_prompt(rid, sid, text):
+    s = sessions[sid]
+    s["cancelled"] = False
+    if not text:
+        reply(rid, {"stopReason": "end_turn"})
+        return
+    env = dict(os.environ, LOKI_NO_BROWSER="1")
+    try:
+        proc = subprocess.Popen([LOKI_CMD, "quick", text], cwd=s["cwd"], env=env,
+                                stdin=subprocess.DEVNULL, stdout=subprocess.PIPE,
+                                stderr=subprocess.STDOUT, text=True, bufsize=1)
+    except OSError as exc:
+        update(sid, "Could not start loki: %s\nNOT VERIFIED: nothing ran.\n" % exc)
+        reply(rid, {"stopReason": "end_turn"})
+        return
+    s["proc"] = proc
+    for line in proc.stdout:
+        update(sid, line)
+    code = proc.wait()
+    s["proc"] = None
+    if s["cancelled"]:
+        reply(rid, {"stopReason": "cancelled"})
+        return
+    if code != 0:
+        update(sid, "\nloki exited with code %d. This run is NOT VERIFIED.\n" % code)
+    reply(rid, {"stopReason": "end_turn"})
+
+
+def handle(msg):
+    method, rid, params = msg.get("method"), msg.get("id"), msg.get("params") or {}
+    if method == "initialize":
+        reply(rid, {"protocolVersion": PROTOCOL_VERSION,
+                    "agentCapabilities": {"loadSession": False,
+                                          "promptCapabilities": {"embeddedContext": True}},
+                    "agentInfo": {"name": "loki", "title": "Loki Mode"},
+                    "authMethods": []})
+    elif method == "session/new":
+        sid = "loki-%d-%d" % (os.getpid(), len(sessions) + 1)
+        sessions[sid] = {"cwd": params.get("cwd") or os.getcwd(), "proc": None, "cancelled": False}
+        reply(rid, {"sessionId": sid})
+    elif method == "session/prompt":
+        sid = params.get("sessionId")
+        if sid not in sessions:
+            error(rid, -32602, "unknown session")
+            return
+        threading.Thread(target=run_prompt, daemon=True,
+                         args=(rid, sid, prompt_text(params.get("prompt")))).start()
+    elif method == "session/cancel":
+        s = sessions.get(params.get("sessionId"))
+        if s and s["proc"]:
+            s["cancelled"] = True
+            s["proc"].terminate()
+    elif rid is not None:
+        error(rid, -32601, "method not found: %s" % method)
+
+
+def main():
+    for line in sys.stdin:
+        line = line.strip()
+        if not line:
+            continue
+        try:
+            handle(json.loads(line))
+        except json.JSONDecodeError:
+            error(None, -32700, "parse error")
+    # Let in-flight prompts finish their replies before exiting.
+    for t in threading.enumerate():
+        if t is not threading.current_thread():
+            t.join(timeout=600)
+
+
+if __name__ == "__main__":
+    main()

package/autonomy/docker-run.sh

@@ -187,6 +187,14 @@ loki_docker_build_argv() {
     [ -n "${GH_TOKEN:-}" ] && argv+=(-e "GH_TOKEN=${GH_TOKEN}")
     # No desktop notifications inside a container.
     argv+=(-e "LOKI_NOTIFICATIONS=false")
+    # The container runs as uid 1000 but a macOS Docker Desktop bind mount can
+    # look root-owned, so the repo tool refuses /workspace ("dubious ownership").
+    # Trust it via env config, appending after any caller-set GIT_CONFIG_COUNT=N.
+    local _gc_n="${GIT_CONFIG_COUNT:-0}"
+    case "$_gc_n" in ''|*[!0-9]*) _gc_n=0 ;; esac
+    argv+=(-e "GIT_CONFIG_COUNT=$((_gc_n + 1))"
+        -e "GIT_CONFIG_KEY_${_gc_n}=safe.directory"
+        -e "GIT_CONFIG_VALUE_${_gc_n}=/workspace")
     # Multi-repo unified dashboard (Option B): the in-container run.sh must NOT
     # register into the project registry. A container only sees /workspace, not
     # the real host path, and registry.register_project() hard-fails on a path

package/autonomy/issue-parser.sh

@@ -136,7 +136,7 @@ extract_problem_statement() {
 
     # Try to find explicit problem/description section
     # Match: ## Problem, ### Problem, **Problem**, Problem:
-    problem=$(echo "$body" | sed -n '/^#*\s*\*\{0,2\}[Pp]roblem\|^#*\s*\*\{0,2\}[Dd]escription\|^#*\s*\*\{0,2\}[Ss]ummary\|^#*\s*\*\{0,2\}[Bb]ackground/,/^#\|^---/p' | head -30 | tail -n +2)
+    problem=$(echo "$body" | sed -n -E '/^#*[[:space:]]*\*{0,2}([Pp]roblem|[Dd]escription|[Ss]ummary|[Bb]ackground)/,/^(#|---)/p' | head -30 | tail -n +2)
 
     # If no explicit section, use first paragraph
     if [ -z "$problem" ]; then
@@ -156,16 +156,16 @@ extract_acceptance_criteria() {
     local criteria=""
 
     # Look for Acceptance Criteria section
-    criteria=$(echo "$body" | sed -n '/^#*\s*\*\{0,2\}[Aa]cceptance [Cc]riteria\|^#*\s*\*\{0,2\}[Rr]equirements\|^#*\s*\*\{0,2\}[Dd]efinition of [Dd]one/,/^#\|^---/p' | head -30)
+    criteria=$(echo "$body" | sed -n -E '/^#*[[:space:]]*\*{0,2}([Aa]cceptance [Cc]riteria|[Rr]equirements|[Dd]efinition of [Dd]one)/,/^(#|---)/p' | head -30)
 
     # If no section found, extract all checkboxes
     if [ -z "$criteria" ]; then
-        criteria=$(echo "$body" | grep -E '^\s*[-*]\s*\[[ xX]\]' | head -20)
+        criteria=$(echo "$body" | grep -E '^[[:space:]]*[-*][[:space:]]*\[[ xX]\]' | head -20)
     fi
 
     # If still nothing, look for numbered or bulleted lists after "should" or "must"
     if [ -z "$criteria" ]; then
-        criteria=$(echo "$body" | grep -E '^\s*[-*0-9.]+\s+.*(should|must|needs to|required)' | head -20)
+        criteria=$(echo "$body" | grep -E '^[[:space:]]*[-*0-9.]+[[:space:]]+.*(should|must|needs to|required)' | head -20)
     fi
 
     echo "$criteria"
@@ -178,7 +178,7 @@ extract_technical_requirements() {
     local technical=""
 
     # Look for Technical/Implementation section
-    technical=$(echo "$body" | sed -n '/^#*\s*\*\{0,2\}[Tt]echnical\|^#*\s*\*\{0,2\}[Ii]mplementation\|^#*\s*\*\{0,2\}[Aa]rchitecture\|^#*\s*\*\{0,2\}[Tt]ech [Ss]pec/,/^#\|^---/p' | head -40)
+    technical=$(echo "$body" | sed -n -E '/^#*[[:space:]]*\*{0,2}([Tt]echnical|[Ii]mplementation|[Aa]rchitecture|[Tt]ech [Ss]pec)/,/^(#|---)/p' | head -40)
 
     # If no section, look for code-related mentions
     if [ -z "$technical" ]; then
@@ -544,7 +544,7 @@ prd:
 $(yaml_escape "$problem")
 
   goals:
-$(echo "$acceptance" | grep -E '^\s*[-*]\s*\[' | sed 's/^\s*[-*]\s*\[.\]/    -/' | head -10 || echo "    - Complete implementation as described")
+$(echo "$acceptance" | grep -E '^[[:space:]]*[-*][[:space:]]*\[' | sed 's/^[[:space:]]*[-*][[:space:]]*\[.\]/    -/' | head -10 || echo "    - Complete implementation as described")
 
   scope:
     in_scope:
@@ -554,7 +554,7 @@ $(echo "$technical" | head -5 | sed 's/^/      - /' || true)
       - Changes unrelated to this issue
 
   success_criteria:
-$(echo "$acceptance" | grep -E '^\s*[-*]\s*\[' | sed 's/^\s*[-*]\s*\[.\]/    -/' | head -10 || echo "    - Issue requirements satisfied")
+$(echo "$acceptance" | grep -E '^[[:space:]]*[-*][[:space:]]*\[' | sed 's/^[[:space:]]*[-*][[:space:]]*\[.\]/    -/' | head -10 || echo "    - Issue requirements satisfied")
     - All tests passing
     - Code review approved
 

package/autonomy/issue-providers.sh

@@ -35,7 +35,9 @@ ISSUE_PROVIDERS=("github" "gitlab" "jira" "azure_devops")
 detect_issue_provider() {
     local ref="$1"
 
-    if [[ "$ref" =~ github\.com ]]; then
+    if sentry_ref_is_sentry "$ref"; then
+        echo "sentry"
+    elif [[ "$ref" =~ github\.com ]]; then
         echo "github"
     elif [[ "$ref" =~ gitlab\.com ]] || [[ "$ref" =~ gitlab\. ]]; then
         echo "gitlab"
@@ -57,6 +59,150 @@ detect_issue_provider() {
     fi
 }
 
+# Sentry intake. A ref is Sentry when it is an https Sentry issue URL
+# (sentry.io, <org>.sentry.io or a self-hosted .../issues/<id>/ with "sentry" in
+# the host) or an exported Sentry JSON file on disk (works fully offline).
+sentry_file_looks_like_export() {
+    local f="$1"
+    [ -f "$f" ] || return 1
+    case "$f" in *.json) ;; *) return 1 ;; esac
+    head -c 2000000 "$f" 2>/dev/null | grep -Eq '"(shortId|culprit)"[[:space:]]*:|"exception"[[:space:]]*:|"type"[[:space:]]*:[[:space:]]*"exception"'
+}
+
+sentry_ref_is_sentry() {
+    local ref="$1"
+    if [[ "$ref" =~ ^https://[^/]*sentry[^/]*/.*issues/[0-9]+ ]]; then
+        return 0
+    fi
+    sentry_file_looks_like_export "$ref"
+}
+
+# Normalize a Sentry issue/event JSON (stdin) to the common issue shape.
+# Accepts an issue export, an event, {issue:..., event:...}, or an SDK payload.
+# Env: _LOKI_SENTRY_URL (optional permalink fallback).
+normalize_sentry_json() {
+    python3 -c "
+import json, os, sys
+raw = json.loads(sys.stdin.read())
+if isinstance(raw, list) and raw:
+    raw = raw[0]
+issue = raw.get('issue') if isinstance(raw.get('issue'), dict) else raw
+ev = None
+for k in ('latestEvent', 'event'):
+    if isinstance(raw.get(k), dict):
+        ev = raw[k]
+        break
+if ev is None:
+    ev = raw
+entries = {}
+for e in ev.get('entries') or []:
+    if isinstance(e, dict) and e.get('type'):
+        entries[e['type']] = e.get('data') or {}
+exc = entries.get('exception') or ev.get('exception') or {}
+crumbs = entries.get('breadcrumbs') or ev.get('breadcrumbs') or {}
+values = exc.get('values') or []
+meta = issue.get('metadata') or {}
+etype = (values[-1].get('type') if values else '') or meta.get('type') or ''
+evalue = (values[-1].get('value') if values else '') or meta.get('value') or ''
+title = issue.get('title') or ev.get('title') or (etype + ': ' + evalue).strip(': ') or 'Sentry issue'
+number = str(issue.get('shortId') or issue.get('id') or ev.get('eventID') or ev.get('id') or 'sentry')
+url = issue.get('permalink') or os.environ.get('_LOKI_SENTRY_URL', '')
+lines = []
+lines.append('## Error')
+lines.append('')
+lines.append('- Type: ' + (etype or 'unknown'))
+lines.append('- Message: ' + (evalue or title))
+if issue.get('culprit'):
+    lines.append('- Culprit: ' + str(issue['culprit']))
+for k, label in (('level', 'Level'), ('status', 'Status'), ('count', 'Events'), ('firstSeen', 'First seen'), ('lastSeen', 'Last seen')):
+    if issue.get(k) not in (None, ''):
+        lines.append('- ' + label + ': ' + str(issue[k]))
+lines.append('')
+lines.append('## Stack trace')
+lines.append('')
+n_frames = 0
+for v in values:
+    frames = (v.get('stacktrace') or {}).get('frames') or []
+    lines.append(str(v.get('type', '')) + ': ' + str(v.get('value', '')))
+    for f in reversed(frames[-30:]):
+        where = str(f.get('filename') or f.get('absPath') or f.get('module') or '?')
+        if f.get('lineNo') is not None:
+            where += ':' + str(f['lineNo'])
+        mark = '' if f.get('inApp', True) else ' (library)'
+        lines.append('  at ' + str(f.get('function') or '?') + ' (' + where + ')' + mark)
+        for ln in (f.get('context') or []):
+            if isinstance(ln, list) and len(ln) == 2 and ln[0] == f.get('lineNo'):
+                lines.append('      > ' + str(ln[1]).strip())
+        n_frames += 1
+if n_frames == 0:
+    lines.append('(no stack trace in the export)')
+lines.append('')
+lines.append('## Breadcrumbs (oldest first, last 20)')
+lines.append('')
+cv = (crumbs.get('values') or [])[-20:]
+for c in cv:
+    msg = c.get('message') or json.dumps(c.get('data') or {}, sort_keys=True)[:200]
+    lines.append('- ' + str(c.get('timestamp', '')) + ' [' + str(c.get('category', '')) + '/' + str(c.get('level', '')) + '] ' + str(msg))
+if not cv:
+    lines.append('(no breadcrumbs in the export)')
+lines.append('')
+lines.append('## Acceptance criteria')
+lines.append('')
+lines.append('- [ ] The error above no longer occurs for the triggering input')
+lines.append('- [ ] A regression test reproduces the failure and passes after the fix')
+tags = [str(t.get('key')) + ':' + str(t.get('value')) for t in (ev.get('tags') or []) if isinstance(t, dict)][:10]
+proj = issue.get('project')
+slug = proj.get('slug', '') if isinstance(proj, dict) else ''
+lbl = [x for x in [str(issue.get('level') or ''), str(slug)] if x] + tags
+print(json.dumps({
+    'provider': 'sentry', 'number': number, 'title': title,
+    'body': chr(10).join(lines), 'labels': lbl, 'author': '',
+    'url': url, 'created_at': str(issue.get('firstSeen') or ev.get('dateCreated') or ''),
+    'repo': ''
+}))
+"
+}
+
+# Sentry API fetch (only when SENTRY_AUTH_TOKEN is set). The token travels in a
+# curl config on stdin, never on argv, and is never echoed.
+fetch_sentry_url() {
+    local ref="$1" host id base
+    if [ -z "${SENTRY_AUTH_TOKEN:-}" ]; then
+        echo -e "${RED}Error: SENTRY_AUTH_TOKEN is not set, so the Sentry API is not contacted.${NC}" >&2
+        echo "Export the issue as JSON and run: loki start ./issue.json" >&2
+        return 1
+    fi
+    if [[ "$ref" =~ ^https://([^/]+)/.*issues/([0-9]+) ]]; then
+        host="${BASH_REMATCH[1]}"; id="${BASH_REMATCH[2]}"
+    else
+        echo -e "${RED}Error: not a Sentry issue URL${NC}" >&2
+        return 1
+    fi
+    case "$host" in *.sentry.io) host="sentry.io" ;; esac
+    base="https://${host}/api/0/issues/${id}"
+    local issue ev
+    issue=$(printf 'header = "Authorization: Bearer %s"\n' "$SENTRY_AUTH_TOKEN" \
+        | curl -sS --fail --max-time 30 -K - "${base}/" 2>/dev/null) || {
+        echo -e "${RED}Error fetching Sentry issue ${id} (check SENTRY_AUTH_TOKEN scope and URL)${NC}" >&2
+        return 1
+    }
+    ev=$(printf 'header = "Authorization: Bearer %s"\n' "$SENTRY_AUTH_TOKEN" \
+        | curl -sS --fail --max-time 30 -K - "${base}/events/latest/" 2>/dev/null) || ev='{}'
+    printf '{"issue":%s,"event":%s}' "$issue" "$ev" | _LOKI_SENTRY_URL="$ref" normalize_sentry_json
+}
+
+fetch_sentry_issue() {
+    local ref="$ISSUE_SENTRY_SRC"
+    if [ -f "$ref" ]; then
+        normalize_sentry_json < "$ref" || {
+            echo -e "${RED}Error: could not parse Sentry export: $ref${NC}" >&2
+            return 1
+        }
+    else
+        fetch_sentry_url "$ref"
+    fi
+}
+
 # Check if required CLI tools are available for a provider
 check_issue_provider_cli() {
     local provider="$1"
@@ -72,6 +218,9 @@ check_issue_provider_cli() {
                 return 1
             fi
             ;;
+        sentry)
+            # Offline from an exported JSON; the API path checks its own token.
+            ;;
         gitlab)
             if ! command -v glab &>/dev/null; then
                 echo -e "${RED}Error: glab CLI not found. Install with: brew install glab${NC}" >&2
@@ -118,6 +267,14 @@ parse_issue_reference() {
     ISSUE_ORG=""
 
     case "$ISSUE_PROVIDER" in
+        sentry)
+            ISSUE_SENTRY_SRC="$ref"
+            if [[ "$ref" =~ issues/([0-9]+) ]]; then
+                ISSUE_NUMBER="${BASH_REMATCH[1]}"
+            else
+                ISSUE_NUMBER="$(basename "$ref" .json)"
+            fi
+            ;;
         github)
             if [[ "$ref" =~ ^https?://github\.com/([^/]+)/([^/]+)/issues/([0-9]+) ]]; then
                 ISSUE_OWNER="${BASH_REMATCH[1]}"
@@ -424,6 +581,7 @@ fetch_issue() {
     check_issue_provider_cli "$ISSUE_PROVIDER" || return 1
 
     case "$ISSUE_PROVIDER" in
+        sentry)       fetch_sentry_issue ;;
         github)       fetch_github_issue ;;
         gitlab)       fetch_gitlab_issue ;;
         jira)         fetch_jira_issue ;;

package/autonomy/lib/engine10-push.sh

@@ -34,7 +34,10 @@ _e10_region="$(awk '
     END { if (!done) exit 3 }
 ' "$_e10_run_sh")" || die "run.sh trusted-push anchors not found; refusing to push" 3
 for _e10_fn in _loki_trusted_push _loki_with_github_tokens _loki_run_neutral _loki_github_repo_from_url; do
-    printf '%s\n' "$_e10_region" | grep -q "^${_e10_fn}() {\$" \
+    # No pipe into grep -q: under pipefail, grep exiting on its first match
+    # SIGPIPEs the still-writing printf (rc 141), which read as "missing"
+    # intermittently under CPU load and silently skipped the push.
+    [[ $'\n'"$_e10_region"$'\n' == *$'\n'"${_e10_fn}() {"$'\n'* ]] \
         || die "run.sh region lacks ${_e10_fn}; refusing to push" 3
 done
 eval "$_e10_region" || die "run.sh region failed to load" 3

package/autonomy/lib/review_risk.py

@@ -0,0 +1,91 @@
+#!/usr/bin/env python3
+"""Deterministic diff risk score (0-100) for `loki review --risk`.
+
+Reads a unified diff on stdin. Pure function of the diff text: no clock, no
+network, no randomness. Same diff in, same score out.
+"""
+import json
+import re
+import sys
+
+SENSITIVE = re.compile(
+    r"(^|/)(\.github/workflows/|auth|security|secret|crypt|token|credential|password|"
+    r"migrations?/|Dockerfile|docker-compose|\.env|package\.json$|requirements.*\.txt$|"
+    r"VERSION$|autonomy/run\.sh$|providers/|moat/)", re.I)
+TESTISH = re.compile(r"(^|/)(tests?|__tests__|spec)/|(^|/)test[-_][^/]*$|[._-](test|spec)\.[a-z]+$", re.I)
+
+
+def parse(diff):
+    files = {}
+    cur = None
+    for line in diff.splitlines():
+        if line.startswith("diff --git "):
+            m = re.match(r"diff --git a/(.*) b/(.*)$", line)
+            cur = m.group(2) if m else line[11:]
+            files[cur] = {"add": 0, "del": 0, "deleted_file": False}
+        elif cur is None:
+            continue
+        elif line.startswith("deleted file mode"):
+            files[cur]["deleted_file"] = True
+        elif line.startswith("+++") or line.startswith("---"):
+            continue
+        elif line.startswith("+"):
+            files[cur]["add"] += 1
+        elif line.startswith("-"):
+            files[cur]["del"] += 1
+    return files
+
+
+def score(diff):
+    files = parse(diff)
+    names = sorted(files)
+    test_files = [f for f in names if TESTISH.search(f)]
+    src_files = [f for f in names if f not in test_files]
+    sens = [f for f in names if SENSITIVE.search(f)]
+    total = sum(v["add"] + v["del"] for v in files.values())
+    src_lines = sum(files[f]["add"] + files[f]["del"] for f in src_files)
+    test_add = sum(files[f]["add"] for f in test_files)
+    test_del = sum(files[f]["del"] for f in test_files)
+    removed_test_files = [f for f in test_files if files[f]["deleted_file"]]
+
+    f_files = min(20, len(names) * 2)
+    f_sens = min(30, len(sens) * 10)
+    f_size = min(20, total // 25)
+    if src_lines == 0:
+        f_tests = 0
+    elif test_add == 0:
+        f_tests = 15
+    else:
+        f_tests = max(0, 15 - (15 * test_add) // src_lines)
+    f_deleted = min(15, test_del // 5 + 5 * len(removed_test_files))
+    factors = [
+        {"factor": "files_touched", "points": f_files, "max": 20, "detail": "%d files" % len(names)},
+        {"factor": "sensitive_paths", "points": f_sens, "max": 30, "detail": ", ".join(sens) or "none"},
+        {"factor": "size", "points": f_size, "max": 20, "detail": "%d changed lines" % total},
+        {"factor": "test_delta", "points": f_tests, "max": 15,
+         "detail": "%d test lines added vs %d source lines changed" % (test_add, src_lines)},
+        {"factor": "deleted_tests", "points": f_deleted, "max": 15,
+         "detail": "%d test lines removed, %d test files deleted" % (test_del, len(removed_test_files))},
+    ]
+    s = min(100, sum(x["points"] for x in factors))
+    level = "low" if s < 25 else "medium" if s < 50 else "high" if s < 75 else "critical"
+    return {"score": s, "level": level, "files": len(names), "factors": factors}
+
+
+def main():
+    args = sys.argv[1:]
+    as_json = "--json" in args
+    rest = [a for a in args if a != "--json"]
+    src = rest[0] if rest else ""
+    r = score(sys.stdin.read())
+    r["source"] = src
+    if as_json:
+        print(json.dumps(r, sort_keys=True))
+        return
+    print("Risk score: %d/100 (%s)%s" % (r["score"], r["level"], " - " + src if src else ""))
+    for x in r["factors"]:
+        print("  %-16s %2d/%-2d  %s" % (x["factor"], x["points"], x["max"], x["detail"]))
+
+
+if __name__ == "__main__":
+    main()