loki-mode 7.10.1 → 7.12.0

package/SKILL.md

@@ -3,7 +3,7 @@ name: loki-mode
 description: Autonomous spec-to-product system. Triggers on "Loki Mode". Takes a spec (PRD, GitHub issue, OpenAPI doc, etc.) to deployed product via the RARV-C closure loop, with minimal human intervention. Provider-agnostic. Requires --dangerously-skip-permissions flag.
 ---
 
-# Loki Mode v7.10.1
+# Loki Mode v7.12.0
 
 **You are an autonomous agent. You make decisions. You do not ask questions. You do not stop.**
 
@@ -381,4 +381,4 @@ See `CHANGELOG.md` entries [7.5.7], [7.5.8], [7.5.13] for the per-fix list and r
 
 ---
 
-**v7.10.1 | [Autonomi](https://www.autonomi.dev/) flagship product | ~260 lines core**
+**v7.12.0 | [Autonomi](https://www.autonomi.dev/) flagship product | ~260 lines core**

package/VERSION

@@ -1 +1 @@
-7.10.1
+7.12.0

package/autonomy/loki

@@ -543,6 +543,7 @@ show_help() {
     echo "  optimize         Optimize prompts based on session history"
     echo "  enterprise       Enterprise feature management (tokens, OIDC)"
     echo "  metrics [opts]   Session productivity report (--json, --last N, --save, --share)"
+    echo "  cost [opts]      Transparent cost view: per-run/project spend + budget (--json, --last N)"
     echo "  dogfood          Show self-development statistics"
     echo "  secrets [cmd]    API key status and validation (status|validate)"
     echo "  reset [target]   Reset session state (all|retries|failed)"
@@ -738,6 +739,17 @@ detect_arg_type() {
         return 0
     fi
 
+    # R7 (zero-config first run): a one-line brief. An arg that contains
+    # whitespace and matched none of the file/issue/path patterns above is a
+    # natural-language brief (e.g. "build a todo app"), NOT a PRD path. This is
+    # additive: a single-token arg with no whitespace still falls through to
+    # "unknown" (PRD-path back-compat) below. The `--brief` flag is the
+    # deterministic escape hatch for the rare single-word brief.
+    if [[ "$arg" == *[[:space:]]* ]]; then
+        echo "brief"
+        return 0
+    fi
+
     # Fallback: unknown. Caller treats as PRD for backward compat.
     echo "unknown"
 }
@@ -751,6 +763,7 @@ cmd_start() {
     local args=()
     local prd_file=""
     local provider=""
+    local brief_text=""           # R7: explicit one-line brief (--brief "...")
     local bmad_project_path=""
     local openspec_change_path=""
     local mirofish_url=""
@@ -783,6 +796,8 @@ cmd_start() {
                 echo "  PRD mode    - path ending in .md/.json/.txt/.yaml -> build from PRD"
                 echo "  ISSUE mode  - GitHub/GitLab/Jira/Azure DevOps URL, owner/repo#N,"
                 echo "                PROJ-123, #123, or bare number -> generate PRD from issue"
+                echo "  BRIEF mode  - a quoted one-line description (with spaces) -> fast"
+                echo "                zero-config first run; visible artifact + proof quickly"
                 echo "  no input    - analyze current directory, auto-generate PRD"
                 echo ""
                 echo "Arguments:"
@@ -792,6 +807,7 @@ cmd_start() {
                 echo "Explicit mode flags (override auto-detection):"
                 echo "  --prd FILE            Force PRD mode with FILE"
                 echo "  --issue URL|NUM       Force issue mode with URL or number"
+                echo "  --brief \"TEXT\"        Force zero-config brief mode (fast first run)"
                 echo ""
                 echo "Options:"
                 echo "  --provider NAME       AI provider: claude (default), codex, cline, aider"
@@ -815,6 +831,7 @@ cmd_start() {
                 echo "  --mirofish-bg         Run MiroFish pipeline in background"
                 echo "  --no-mirofish         Disable MiroFish even if env var is set"
                 echo "  --no-plan             Skip auto-shown PRD analysis at startup"
+                echo "  --brief \"TEXT\"        Zero-config fast first run from a one-line brief"
                 echo "  --yes, -y             Skip confirmation prompts (auto-confirm)"
                 echo ""
                 echo "Issue-mode options (only used when input is an ISSUE-REF):"
@@ -835,6 +852,8 @@ cmd_start() {
                 echo ""
                 echo "Examples:"
                 echo "  loki start                              # Interactive, analyze current dir"
+                echo "  loki start \"build a todo app\"           # BRIEF mode (zero-config fast run)"
+                echo "  loki start --brief \"snake\"              # BRIEF mode (single-word escape hatch)"
                 echo "  loki start ./prd.md                     # PRD mode"
                 echo "  loki start https://github.com/o/r/issues/42  # ISSUE mode (GitHub)"
                 echo "  loki start 123                          # ISSUE mode (current repo GitHub issue)"
@@ -1064,6 +1083,22 @@ cmd_start() {
                 no_plan=true
                 shift
                 ;;
+            --brief)
+                # R7: explicit one-line brief (escape hatch for single-word
+                # briefs that detect_arg_type would otherwise treat as a PRD
+                # path). Forces the zero-config first-run brief sub-path.
+                if [[ -n "${2:-}" ]] && [[ "${2:-}" != --* ]]; then
+                    brief_text="$2"
+                    shift 2
+                else
+                    echo -e "${RED}--brief requires a one-line description (e.g., --brief \"build a todo app\")${NC}"
+                    exit 1
+                fi
+                ;;
+            --brief=*)
+                brief_text="${1#*=}"
+                shift
+                ;;
             --budget)
                 if [[ -n "${2:-}" ]]; then
                     if ! echo "$2" | grep -qE '^[0-9]+(\.[0-9]+)?$'; then
@@ -1183,12 +1218,21 @@ cmd_start() {
     done
 
     # v6.84.0: Unified dispatch based on explicit flags or auto-detection
-    # Precedence: --issue > --prd > positional auto-detect > LOKI_PRD_FILE env
+    # Precedence: --brief > --issue > --prd > positional auto-detect >
+    #             LOKI_PRD_FILE env
     local detected_type=""
-    if [ -n "$explicit_mode" ]; then
+    if [ -n "$brief_text" ]; then
+        # R7: explicit --brief always forces the zero-config brief sub-path.
+        detected_type="brief"
+    elif [ -n "$explicit_mode" ]; then
         detected_type="$explicit_mode"
     elif [ -n "$positional_arg" ]; then
         detected_type=$(detect_arg_type "$positional_arg")
+        # R7: a positional one-line brief (whitespace, not a file/issue) maps to
+        # the brief sub-path; capture the text from the positional arg.
+        if [ "$detected_type" = "brief" ]; then
+            brief_text="$positional_arg"
+        fi
     elif [ -n "${LOKI_PRD_FILE:-}" ]; then
         detected_type="prd"
         prd_file="$LOKI_PRD_FILE"
@@ -1228,6 +1272,51 @@ cmd_start() {
         return $?
     fi
 
+    # R7 (zero-config first run): BRIEF mode. The user gave a one-line brief
+    # (`loki start "build a todo app"` or `loki start --brief "..."`). Synthesize
+    # a forward-looking PRD, switch to the lightweight TTFV profile (honest fast:
+    # capped iterations, council off, simple tier, heavy phases off), and mark
+    # LOKI_TTFV=1 so run.sh prints the "what next / go deeper" framing at the
+    # end. Then fall through to the normal flow, which appends prd_file to args
+    # and execs run.sh. This is additive -- nothing here changes the PRD/issue
+    # paths above.
+    if [ "$detected_type" = "brief" ]; then
+        local version
+        version=$(get_version)
+        local _ttfv_max_iter="${LOKI_MAX_ITERATIONS:-3}"
+        mkdir -p "$LOKI_DIR" 2>/dev/null || true
+        local brief_prd="$LOKI_DIR/brief-prd-$$.md"
+        synthesize_brief_prd "$brief_prd" "$brief_text"
+        prd_file="$brief_prd"
+
+        # Apply the shared lightweight profile and flag the TTFV first-run path.
+        # The signal value ("brief") drives the end-of-run wording in run.sh so
+        # the message matches what actually ran (lightweight, council off).
+        set_ttfv_lightweight_profile "$_ttfv_max_iter"
+        export LOKI_TTFV=brief
+        # Skip the heavy auto-plan analysis -- the brief path is the fast path,
+        # and we already printed the upfront framing below.
+        no_plan=true
+
+        echo -e "${BOLD}Loki Mode v$version - Zero-config first run${NC}"
+        echo ""
+        echo -e "${CYAN}Brief:${NC} $brief_text"
+        echo -e "${DIM}Fast first pass: $_ttfv_max_iter iterations max, council off, simple tier.${NC}"
+        echo -e "${DIM}You will get a runnable artifact and a proof-of-run quickly.${NC}"
+        echo -e "${DIM}Go deeper later with: loki start (full RARV-C depth).${NC}"
+        echo -e "${GREEN}Brief PRD written${NC} to $brief_prd"
+        echo ""
+    fi
+
+    # R7: existing-repo no-arg path also gets the TTFV "what next" framing at the
+    # end of the run. Execution here is UNCHANGED (full-depth no-PRD codebase
+    # analysis + generated-PRD-reuse); we only add accurate end-of-run framing.
+    # The signal value ("repo") drives the full-depth wording in run.sh so the
+    # message does not falsely claim a lightweight pass.
+    if [ "$detected_type" = "empty" ] && [ -z "${LOKI_TTFV:-}" ]; then
+        export LOKI_TTFV=repo
+    fi
+
     # PRD mode: positional arg is the PRD file (if not already set via --prd)
     if [ "$detected_type" = "prd" ] && [ -z "$prd_file" ]; then
         prd_file="$positional_arg"
@@ -8846,6 +8935,65 @@ cmd_demo() {
     return $start_exit
 }
 
+# R7 (zero-config first run): set the lightweight TTFV execution profile.
+# Shared by `cmd_quick` and the `loki start "<brief>"` brief sub-path so the
+# fast first pass means the same thing in both: capped iterations, completion
+# council off, simple complexity tier, heavy phases off. This is HONEST fast --
+# it genuinely shortens the path to first visible value; it does not fake
+# progress. Depth is opt-in via a plain `loki start` re-run.
+# Usage: set_ttfv_lightweight_profile [max_iter]
+set_ttfv_lightweight_profile() {
+    local max_iter="${1:-${LOKI_MAX_ITERATIONS:-3}}"
+    export LOKI_MAX_ITERATIONS="$max_iter"
+    export LOKI_COMPLEXITY=simple
+    export LOKI_COUNCIL_ENABLED=false
+    export LOKI_PHASE_CODE_REVIEW=false
+    export LOKI_PHASE_PERFORMANCE=false
+    export LOKI_PHASE_ACCESSIBILITY=false
+    export LOKI_PHASE_REGRESSION=false
+    export LOKI_PHASE_UAT=false
+    export LOKI_PHASE_WEB_RESEARCH=false
+}
+
+# R7: synthesize a forward-looking PRD from a one-line brief. Writes to a
+# unique path (caller-provided) and echoes nothing -- the file is the output.
+# Kept DISTINCT from .loki/generated-prd.md (codebase-analysis artifact) so it
+# never pollutes the v7.8.1 generated-PRD-reuse signature logic. The brief text
+# is the project intent; the rest is a minimal scaffold the agent fills in.
+# Usage: synthesize_brief_prd <output_file> <brief_text>
+synthesize_brief_prd() {
+    local out_file="$1"
+    local brief_text="$2"
+    local out_dir
+    out_dir="$(dirname "$out_file")"
+    mkdir -p "$out_dir" 2>/dev/null || true
+    cat > "$out_file" << BRIEFEOF
+# Project Brief
+
+## Overview
+$brief_text
+
+## Requirements
+- Build the smallest working version of the above that a user can see and run.
+- Prefer a runnable artifact (a page, a CLI, an API endpoint) over scaffolding.
+- Follow conventional structure for the chosen stack; keep dependencies minimal.
+- Write a short README describing how to run it.
+
+## Success Criteria
+- A user can run the result and observe the core behavior described above.
+- No errors on a clean start; the happy path works end to end.
+
+## Constraints
+- This is a fast first pass (zero-config first run). Keep scope tight.
+- Do not over-engineer; depth and hardening come on a later full run.
+- No emojis, no em dashes in code, comments, or docs.
+
+---
+
+**Mode:** Brief (zero-config first run, lightweight first pass)
+BRIEFEOF
+}
+
 # Quick mode - lightweight single-task execution
 cmd_quick() {
     # v7.6.3 B-11 fix: --help previously fell through to provider invocation
@@ -8933,16 +9081,9 @@ QPRDEOF
     echo -e "${GREEN}Quick PRD generated${NC} at $quick_prd"
     echo ""
 
-    # Set lightweight execution environment
-    export LOKI_MAX_ITERATIONS="$max_iter"
-    export LOKI_COMPLEXITY=simple
-    export LOKI_COUNCIL_ENABLED=false
-    export LOKI_PHASE_CODE_REVIEW=false
-    export LOKI_PHASE_PERFORMANCE=false
-    export LOKI_PHASE_ACCESSIBILITY=false
-    export LOKI_PHASE_REGRESSION=false
-    export LOKI_PHASE_UAT=false
-    export LOKI_PHASE_WEB_RESEARCH=false
+    # Set lightweight execution environment (shared TTFV profile -- see
+    # set_ttfv_lightweight_profile; same profile the R7 brief sub-path uses).
+    set_ttfv_lightweight_profile "$max_iter"
 
     # Record start for efficiency tracking
     record_session_start
@@ -13034,6 +13175,9 @@ main() {
         metrics)
             cmd_metrics "$@"
             ;;
+        cost)
+            cmd_cost "$@"
+            ;;
         syslog)
             cmd_syslog "$@"
             ;;
@@ -17833,6 +17977,299 @@ cmd_syslog() {
     esac
 }
 
+# Transparent cost view (R3): per-run + per-project spend, model routing, and
+# budget status with the 80% warn line. Reuses efficiency_cost.collect_efficiency
+# for the current-run aggregate (single source of truth) and reads .loki/proofs/
+# for persistent per-run history. Honest: prints "not recorded" when cost was
+# never collected, never a fabricated $0.00.
+cmd_cost() {
+    local show_json=false
+    local last_n=0
+
+    while [[ $# -gt 0 ]]; do
+        case "$1" in
+            --help|-h)
+                echo -e "${BOLD}loki cost${NC} - Transparent cost and budget view"
+                echo ""
+                echo "Usage: loki cost [options]"
+                echo ""
+                echo "Shows the current run's spend (from .loki/metrics/efficiency/),"
+                echo "per-run history (from .loki/proofs/), model routing by spend, and"
+                echo "budget status. Budgets warn at 80% and hard-stop at 100%."
+                echo ""
+                echo "Options:"
+                echo "  --json               Machine-readable JSON output"
+                echo "  --last N             Show only the last N runs in history (default: all)"
+                echo "  --help, -h           Show this help"
+                echo ""
+                echo "Examples:"
+                echo "  loki cost                      # Cost summary + budget status"
+                echo "  loki cost --json               # Machine-readable output"
+                echo "  loki cost --last 10            # Last 10 runs of history"
+                echo ""
+                echo "Budget cap: set LOKI_BUDGET_LIMIT (USD). Warns at 80%, stops at 100%."
+                exit 0
+                ;;
+            --json) show_json=true; shift ;;
+            --last) last_n="${2:-0}"; shift 2 ;;
+            --last=*) last_n="${1#*=}"; shift ;;
+            *) echo -e "${RED}Unknown option: $1${NC}"; echo "Run 'loki cost --help' for usage."; exit 1 ;;
+        esac
+    done
+
+    local loki_dir="${LOKI_DIR:-.loki}"
+
+    if ! command -v python3 &>/dev/null; then
+        echo -e "${RED}python3 is required for the cost view${NC}"
+        exit 1
+    fi
+
+    LOKI_DIR="$loki_dir" \
+    LOKI_SKILL_DIR="$SKILL_DIR" \
+    COST_JSON="$show_json" \
+    COST_LAST_N="$last_n" \
+    COST_BUDGET_LIMIT="${LOKI_BUDGET_LIMIT:-}" \
+    python3 << 'COST_SCRIPT'
+import json
+import os
+import sys
+
+loki_dir = os.environ.get("LOKI_DIR", ".loki")
+skill_dir = os.environ.get("LOKI_SKILL_DIR", "")
+show_json = os.environ.get("COST_JSON", "false") == "true"
+try:
+    last_n = int(os.environ.get("COST_LAST_N", "0") or "0")
+except ValueError:
+    last_n = 0
+budget_limit_env = os.environ.get("COST_BUDGET_LIMIT", "").strip()
+
+# ANSI (suppressed under --json / non-tty)
+use_color = (not show_json) and sys.stdout.isatty()
+BOLD = "\033[1m" if use_color else ""
+DIM = "\033[2m" if use_color else ""
+CYAN = "\033[36m" if use_color else ""
+GREEN = "\033[32m" if use_color else ""
+YELLOW = "\033[33m" if use_color else ""
+RED = "\033[31m" if use_color else ""
+NC = "\033[0m" if use_color else ""
+
+# Reuse the shared cost lib (single source of truth). Never duplicate the
+# cost-summing logic; collect_efficiency returns usd=None when nothing was
+# recorded, which we surface honestly.
+collect_efficiency = None
+if skill_dir:
+    lib_dir = os.path.join(skill_dir, "autonomy", "lib")
+    if lib_dir not in sys.path:
+        sys.path.insert(0, lib_dir)
+    try:
+        from efficiency_cost import collect_efficiency as _ce
+        collect_efficiency = _ce
+    except Exception:
+        collect_efficiency = None
+
+def _fmt_usd(v):
+    if v is None:
+        return "not recorded"
+    try:
+        n = float(v)
+    except (TypeError, ValueError):
+        return "not recorded"
+    s = ("%.4f" % n).rstrip("0").rstrip(".")
+    if "." not in s:
+        s += ".00"
+    elif len(s.split(".")[1]) == 1:
+        s += "0"
+    return "$" + s
+
+# --- current run aggregate (reuse collect_efficiency, single source) -----
+# We do NOT re-implement the cost sum here: efficiency_cost.collect_efficiency
+# is the single source of truth (shared with the proof generator and the R2
+# benchmark adapters). On a broken install where the lib is missing, we degrade
+# honestly rather than ship a divergent 5th copy of the cost math.
+current_cost = None
+current_model = ""
+lib_available = collect_efficiency is not None
+if lib_available:
+    try:
+        cost_dict, current_model = collect_efficiency(loki_dir)
+        current_cost = cost_dict.get("usd")
+    except Exception:
+        current_cost = None
+
+# --- per-run history from .loki/proofs/ ----------------------------------
+runs = []
+project_total = 0.0
+proofs_dir = os.path.join(loki_dir, "proofs")
+if os.path.isdir(proofs_dir):
+    for name in sorted(os.listdir(proofs_dir)):
+        run_dir = os.path.join(proofs_dir, name)
+        proof_json = os.path.join(run_dir, "proof.json")
+        if not os.path.isfile(proof_json):
+            continue
+        try:
+            d = json.load(open(proof_json))
+        except Exception:
+            continue
+        if not isinstance(d, dict):
+            continue
+        run_cost = (d.get("cost") or {}).get("usd")
+        run_cost_num = None
+        if run_cost is not None:
+            try:
+                run_cost_num = float(run_cost)
+                project_total += run_cost_num
+            except (TypeError, ValueError):
+                run_cost_num = None
+        runs.append({
+            "run_id": d.get("run_id", name),
+            "generated_at": d.get("generated_at"),
+            "model": (d.get("provider") or {}).get("model"),
+            "cost_usd": run_cost_num,
+            "files_changed": (d.get("files_changed") or {}).get("count"),
+            "final_verdict": (d.get("council") or {}).get("final_verdict"),
+        })
+runs.sort(key=lambda x: (x.get("generated_at") or ""), reverse=True)
+if last_n > 0:
+    runs = runs[:last_n]
+
+# --- budget status (read-time; warn at 80%, exceeded at 100%) ------------
+budget_limit = None
+budget_file = os.path.join(loki_dir, "metrics", "budget.json")
+if os.path.isfile(budget_file):
+    try:
+        bd = json.load(open(budget_file))
+        budget_limit = bd.get("limit") or bd.get("budget_limit")
+    except Exception:
+        budget_limit = None
+if budget_limit is None and budget_limit_env:
+    try:
+        budget_limit = float(budget_limit_env)
+    except ValueError:
+        budget_limit = None
+if budget_limit is not None:
+    try:
+        budget_limit = float(budget_limit)
+    except (TypeError, ValueError):
+        budget_limit = None
+
+budget_used = current_cost if isinstance(current_cost, (int, float)) else 0.0
+status = "none"
+percent_used = None
+remaining = None
+if budget_limit is not None and budget_limit > 0:
+    percent_used = round(budget_used / budget_limit * 100, 2)
+    remaining = max(0.0, budget_limit - budget_used)
+    if budget_used >= budget_limit:
+        status = "exceeded"
+    elif budget_used >= 0.80 * budget_limit:
+        status = "warn"
+    else:
+        status = "ok"
+
+# --- model routing by spend (from run history) ---------------------------
+by_model = {}
+for r in runs:
+    c = r.get("cost_usd")
+    if c is None:
+        continue
+    m = r.get("model") or "unknown"
+    by_model[m] = by_model.get(m, 0.0) + c
+
+if show_json:
+    out = {
+        "current_run": {
+            "cost_usd": current_cost,
+            "model": current_model or None,
+            "cost_recorded": current_cost is not None,
+            "cost_lib_available": lib_available,
+        },
+        "runs": runs,
+        "runs_count": len(runs),
+        "project_total_usd": round(project_total, 6) if runs else 0.0,
+        "by_model": {k: round(v, 6) for k, v in by_model.items()},
+        "budget": {
+            "limit": budget_limit,
+            "used": round(budget_used, 6),
+            "remaining": round(remaining, 6) if remaining is not None else None,
+            "percent_used": percent_used,
+            "status": status,
+            "warn_threshold_percent": 80,
+            "exceeded": status == "exceeded",
+        },
+    }
+    print(json.dumps(out, indent=2))
+    sys.exit(0)
+
+# --- human-readable ------------------------------------------------------
+ds = chr(36)
+print()
+print(BOLD + "Loki Cost" + NC)
+print(DIM + "=" * 50 + NC)
+
+print()
+print(CYAN + "Current run" + NC)
+if not lib_available:
+    print(DIM + "  Cost library unavailable (efficiency_cost.py not found)." + NC)
+    print(DIM + "  Current-run spend cannot be computed on this install." + NC)
+elif current_cost is None:
+    print("  Cost not recorded for this run.")
+else:
+    mtxt = (" (" + current_model + ")") if current_model else ""
+    print("  Spend: " + BOLD + _fmt_usd(current_cost) + NC + mtxt)
+
+print()
+print(CYAN + "Project history" + NC)
+print("  Runs recorded: " + str(len(runs)))
+print("  Total spend:   " + BOLD + (_fmt_usd(project_total) if runs else "$0.00") + NC)
+
+if by_model:
+    print()
+    print(CYAN + "Model routing (by spend)" + NC)
+    total_m = sum(by_model.values()) or 1.0
+    for m in sorted(by_model, key=lambda k: by_model[k], reverse=True):
+        v = by_model[m]
+        pct = v / total_m * 100
+        bar_len = int(pct / 5)
+        bar = "#" * bar_len + "." * (20 - bar_len)
+        print("  {:<16} {}{:>9} ({:4.1f}%) [{}]".format(m[:16], "", _fmt_usd(v), pct, bar))
+
+print()
+print(CYAN + "Budget" + NC)
+if budget_limit is None:
+    print("  No cap set. Set LOKI_BUDGET_LIMIT (USD) to cap spend.")
+    print(DIM + "  When set, Loki warns at 80% and hard-stops at 100%." + NC)
+else:
+    col = GREEN
+    if status == "warn":
+        col = YELLOW
+    elif status == "exceeded":
+        col = RED
+    print("  Cap:       " + _fmt_usd(budget_limit))
+    print("  Used:      " + _fmt_usd(budget_used) + " (" + col + str(percent_used) + "%" + NC + ")")
+    print("  Remaining: " + _fmt_usd(remaining))
+    print("  Status:    " + col + BOLD + status.upper() + NC)
+    if status == "warn":
+        print(YELLOW + "  Warning: at or above 80% of cap. Run continues; hard-stop at 100%." + NC)
+    elif status == "exceeded":
+        print(RED + "  Cap reached. The run is paused to prevent a surprise bill." + NC)
+
+if runs:
+    print()
+    print(CYAN + "Recent runs" + NC)
+    print(DIM + "  {:<28} {:<10} {:>9}  {}".format("Run", "Model", "Cost", "Verdict") + NC)
+    for r in runs[:max(last_n, 10) if last_n else 10]:
+        rid = str(r.get("run_id") or "")[:28]
+        mdl = str(r.get("model") or "")[:10]
+        cst = _fmt_usd(r.get("cost_usd"))
+        vrd = str(r.get("final_verdict") or "")
+        print("  {:<28} {:<10} {:>9}  {}".format(rid, mdl, cst, vrd))
+
+print()
+print(DIM + "Dashboard cost panel: /cost   |   JSON: loki cost --json" + NC)
+print()
+COST_SCRIPT
+}
+
 # Fetch and display Prometheus metrics from dashboard
 cmd_metrics() {
     local show_json=false