loki-mode 11.12.1 → 11.15.0

package/README.md

@@ -102,7 +102,7 @@ Time:       4m12s (intake 11s, plan 20s, implement 3m10s, verify 31s)
 | `loki agents list\|new\|show\|export --claude` | Custom child agents in `.loki/agents/*.md` |
 | `loki status [run-id]` | Status of the latest run, or of a given run |
 | `loki verify [run-id]` | Check a receipt's hash, signature and event log |
-| `loki answer [run-id]` | Resume a BLOCKED run with your answer (`--text "..."`) |
+| `loki answer [run-id]` | Start a follow-up run from a BLOCKED run with your answer (`--text "..."`) |
 | `loki doctor [--fix] [--json]` | Check prerequisites, providers and login; `--fix` applies safe fixes |
 | `loki control serve` | Start the Control Plane (see below) |
 | `loki dashboard` | Open the Control Plane UI, starting it if needed |
@@ -139,7 +139,7 @@ Required:
 
 - Claude Code (`claude`), installed and logged in: the default provider and the only one with every feature. The bundled Agent SDK with `ANTHROPIC_API_KEY` can stand in on the main `loki start` path, but `loki edit` and `loki chat` call the `claude` CLI.
 - Python 3.8+ (`python3`)
-- Node.js 18+ (`node`; 20+ recommended)
+- Node.js 20+ (`node`; 22 LTS is the CI target)
 - `jq`
 - Git 2.x (`git`)
 - `curl`

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 v11.12.1
+# Loki Mode v11.15.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 previous bash loop. PRD-file starts (`loki start ./prd.md`) and the opencode provider still run on it until FC38-SWEEP ports them; the legacy-engine command and the LOKI_ENGINE switch remain removed. Prefer `loki owner/repo#N` for issues.
 
@@ -483,4 +483,4 @@ See `CHANGELOG.md` entries [7.5.7], [7.5.8], [7.5.13] for the per-fix list and r
 
 ---
 
-**v11.12.1 | [Autonomi](https://www.autonomi.dev/) flagship product | core skill**
+**v11.15.0 | [Autonomi](https://www.autonomi.dev/) flagship product | core skill**

package/VERSION

@@ -1 +1 @@
-11.12.1
+11.15.0

package/autonomy/lib/backlog.py

@@ -308,9 +308,17 @@ def main(argv):
         child_env["LOKI_PROVIDER"] = a.provider
     elif cfg.get("provider"):
         child_env["LOKI_PROVIDER"] = cfg["provider"]
-    # ponytail: per-run cap is forwarded only; the v10 engine itself caps on time
-    if cfg.get("budgets", {}).get("per_run_usd"):
-        child_env["LOKI_BUDGET_LIMIT"] = str(cfg["budgets"]["per_run_usd"])
+    # per-run cap forwarded to each child (budgets.per_run is the TS-side alias); an exported LOKI_BUDGET_LIMIT wins over loki.yaml
+    bud = cfg.get("budgets", {})
+    per_run = bud.get("per_run_usd") or bud.get("per_run")
+    if per_run and not env.get("LOKI_BUDGET_LIMIT"):
+        child_env["LOKI_BUDGET_LIMIT"] = str(per_run)
+    group_cap = None  # a DAG group shares one total: the run cap bounds the sum of its units, not each unit
+    if dag_units:
+        try:
+            group_cap = float(env.get("LOKI_BUDGET_LIMIT") or 0) or None
+        except ValueError:
+            group_cap = None
     day_cap = cfg.get("budgets", {}).get("per_day_usd")
 
     # One job table for issues and units: they share one slot pool.
@@ -444,6 +452,13 @@ def main(argv):
         for k in [k for k, (p, _l, _w) in running.items() if p.poll() is not None]:
             finish(k)
         while pending and len(running) < conc:
+            group_spent = sum(st["cost"] or 0 for st in state.values())
+            if group_cap and group_spent >= group_cap:
+                for k in pending:
+                    state[k].update(status="BUDGET_STOP: group budget $%.2f reached ($%.2f spent)" % (group_cap, group_spent), ok=False)
+                    say("backlog: %s %s" % (spec[k]["label"], state[k]["status"]))
+                pending = []
+                break
             spent = spent_today() if day_cap else 0.0
             if day_cap and (spent is None or spent >= day_cap):
                 for k in pending:

package/autonomy/lib/chat.sh

@@ -52,7 +52,9 @@ Loki chat commands:
   /model <id>        set model for this session
   /provider <name>   switch provider (claude, codex, cline, aider, opencode)
   /cost              loki cost
+  /merge <args>      loki merge (pr <pr>, watch <pr> to repair red CI, run, list)
   /diff              git diff --stat plus diff
+  /doctor [--json]   loki doctor --repo: repo readiness score and fixes (alias /ready)
   /undo [args]       loki undo
   /help, /exit
 Attached mode (loki chat --attach or /attach): /status /steer <msg> /diff /verify /receipt /stop
@@ -355,8 +357,12 @@ Question: $line" || true
                 _chat_do "$loki" verify $rest ;;
             /receipt) _chat_do "$loki" receipt ;;
             /cost) _chat_do "$loki" cost ;;
+            /merge) # shellcheck disable=SC2086
+                _chat_do "$loki" merge $rest ;;
             /undo) # shellcheck disable=SC2086
                 _chat_do "$loki" undo $rest ;;
+            /doctor|/ready) # shellcheck disable=SC2086
+                _chat_do "$loki" doctor --repo $rest ;;
             /diff) _chat_do git diff --stat; _chat_do git diff ;;
             /model)
                 if [ -n "$rest" ]; then _CHAT_MODEL="$rest"; echo "model: $rest"; else echo "model: ${_CHAT_MODEL:-default}"; fi ;;

package/autonomy/lib/engine10-push.sh

@@ -4,7 +4,7 @@
 #   engine10-push.sh push-pr <repo-dir> <branch> <title> <body-file> [--draft] [--base <branch>]
 #   engine10-push.sh check-origin   (exit 0 when the pinned origin is acceptable to push-pr, else the refusal; no network)
 #   engine10-push.sh comment <pr-number> <body-file>
-#   engine10-push.sh issue-comment <issue-ref> <body-file>
+#   engine10-push.sh issue-comment [--update] <issue-ref> <body-file>
 #   engine10-push.sh status  <sha> <pending|success|failure|error> <description>
 #
 # Holds GitHub credentials, runs no LLM, reads no untrusted text. Inputs come
@@ -159,11 +159,14 @@ case "$mode" in
         fi
         url="$(_e10_gh pr list --repo "$_e10_repo" --head "$branch" --state open --json url --jq '.[0].url')" \
             || die "gh pr list failed"
+        _e10_pr_state=reused
         if [ -z "$url" ] || [ "$url" = "null" ]; then
+            _e10_pr_state=created
             url="$(_e10_gh pr create --repo "$_e10_repo" --head "$branch" --title "$title" --body-file "$body" "${draft[@]}" "${base[@]}")" \
                 || die "gh pr create failed"
             url="$(printf '%s\n' "$url" | tail -n 1)"
         fi
+        printf '%s\n' "$_e10_pr_state"  # marker line before the URL: reused (open PR found) or created
         printf '%s\n' "$url"
         ;;
     comment)
@@ -176,11 +179,32 @@ case "$mode" in
     issue-comment)
         # E-67: a FAILED run with no diff (or no remote) has no PR to open; comment on the issue
         # instead so the run's reason is never silently lost. <issue-ref> is owner/repo#N or #N.
-        [ "$#" -eq 2 ] || die "usage: issue-comment <issue-ref> <body-file>"
+        # --update: the status projector. One comment carrying the marker below is edited in place (created when absent),
+        # so an issue shows live run state without a new comment per event. Only a comment written by the authenticated
+        # gh user counts, and the body file must carry the marker (it is built by the supervisor, never from task text).
+        _e10_upd=""
+        [ "${1:-}" != "--update" ] || { _e10_upd=1; shift; }
+        [ "$#" -eq 2 ] || die "usage: issue-comment [--update] <issue-ref> <body-file>"
         num="${1##*#}"
         case "$num" in '' | *[!0-9]*) die "cannot extract issue number from: $1" ;; esac
         [ -f "$2" ] || die "body file not found: $2"
         [ -z "$_e10_local" ] || { log_info "local origin: no issue to comment on (no-op)"; exit 0; }
+        if [ -n "$_e10_upd" ]; then
+            _e10_marker='<!-- loki-status -->'
+            grep -qF -- "$_e10_marker" "$2" || die "status body must carry $_e10_marker"
+            _e10_me="$(_e10_gh api user --jq .login 2>/dev/null)" || _e10_me=""
+            _e10_cid=""
+            if [ -n "$_e10_me" ]; then
+                _e10_cid="$(_e10_gh api "repos/$_e10_repo/issues/$num/comments" --paginate \
+                    --jq ".[] | select(.user.login == \"$_e10_me\") | select(.body | contains(\"$_e10_marker\")) | .id" 2>/dev/null | head -n 1)" || _e10_cid=""
+            fi
+            case "$_e10_cid" in
+                '') _e10_gh issue comment "$num" --repo "$_e10_repo" --body-file "$2" || die "gh issue comment failed" ;;
+                *[!0-9]*) die "unexpected comment id" ;;
+                *) _e10_gh api -X PATCH "repos/$_e10_repo/issues/comments/$_e10_cid" -F "body=@$2" >/dev/null || die "gh api comment update failed" ;;
+            esac
+            exit 0
+        fi
         _e10_gh issue comment "$num" --repo "$_e10_repo" --body-file "$2" || die "gh issue comment failed"
         ;;
     status)

package/autonomy/lib/proof-generator.py

@@ -1441,6 +1441,20 @@ def _collect_journey(loki_dir):
         n = iv.get("count")
         if isinstance(n, int) and n >= 0:
             out["interventions"] = n
+        # by_type / waited_s exist only for counters written by the current
+        # handle_pause. A count-only legacy file yields no detail (unmeasured,
+        # never a fabricated zero). waited_s is wall-clock blocked seconds, an
+        # upper bound on human attention, not active time.
+        bt = iv.get("by_type")
+        ws = iv.get("waited_s")
+        if isinstance(bt, dict) and isinstance(ws, int) and not isinstance(ws, bool) and ws >= 0:
+            out["interventions_detail"] = {
+                "by_type": {
+                    k: (bt[k] if isinstance(bt.get(k), int) and not isinstance(bt.get(k), bool) and bt[k] >= 0 else 0)
+                    for k in ("steer", "input", "authorization", "repair")
+                },
+                "waited_s": ws,
+            }
 
     # PR state/URL, written by the consent-gated PR step. "prepared" means a PR
     # body exists locally and GitHub was NOT mutated.
@@ -1847,6 +1861,8 @@ def _build_proof(args, loki_dir, target_dir, repo_root):
     # "unavailable" rather than showing a fabricated zero.
     if isinstance(journey, dict) and isinstance(journey.get("interventions"), int):
         proof["interventions"] = journey["interventions"]
+    if isinstance(journey, dict) and isinstance(journey.get("interventions_detail"), dict):
+        proof["interventions_detail"] = journey["interventions_detail"]
 
     return proof, run_id
 

package/autonomy/lib/trust_trajectory.py

@@ -21,6 +21,14 @@ Direction (up/down/flat) is computed by a median half-split: mean of the later
 half minus mean of the earlier half. Robust to one noisy run, no float
 regression needed, and a 2-run series degrades to last-vs-first.
 
+Outcome effort definitions (shared with loki-ts/src/metrics/trust.ts and
+benchmarks/bench/attribution.py; see docs/EVALUATING.md "Outcome analytics"):
+accepted = verdict VERIFIED and not later contradicted; misleading completion =
+false_verified / VERIFIED-claimed (attribution false_completion); cost per
+accepted = total spend over ALL runs / accepted, None when nothing was accepted
+or any run's cost is unmeasured. Waited seconds are wall-clock blocked time, an
+upper bound on human attention; active minutes are NOT measured.
+
 Public API:
   compute_trajectory(loki_dir) -> dict   (schema_version 1)
   format_trajectory_human(traj) -> str
@@ -160,6 +168,50 @@ def _interventions_value(proof):
     return None
 
 
+_IV_TYPES = ("steer", "input", "authorization", "repair")
+
+
+def _cost_value(proof):
+    usd = _obj(proof.get("cost")).get("usd")
+    if usd is None or isinstance(usd, bool):
+        return None
+    try:
+        n = float(usd)
+    except (TypeError, ValueError):
+        return None
+    return n if n >= 0 and n == n and n != float("inf") else None
+
+
+def _intervention_detail(proof):
+    """(by_type, waited_s) from proof.interventions_detail; None when absent."""
+    d = _obj(proof.get("interventions_detail"))
+    bt = _obj(d.get("by_type"))
+    out = {}
+    any_key = False
+    for k in _IV_TYPES:
+        try:
+            n = int(bt.get(k))
+        except (TypeError, ValueError):
+            n = 0
+        out[k] = n if n >= 0 else 0
+        if bt.get(k) is not None:
+            any_key = True
+    w = d.get("waited_s")
+    ws = w if isinstance(w, (int, float)) and not isinstance(w, bool) and w >= 0 else None
+    return (out if any_key else None), ws
+
+
+def _verdict_evidence(proof):
+    raw = str(proof.get("verdict") or "").strip().upper()
+    verdict = raw or None
+    later = str(proof.get("later_verdict") or "").strip().upper()
+    if proof.get("false_verified") is True:
+        return verdict, True
+    if verdict is None:
+        return verdict, None
+    return verdict, verdict == "VERIFIED" and later == "FAILED"
+
+
 def _load_runs(loki_dir):
     """Read every .loki/proofs/<id>/proof.json into a time-ordered run list."""
     proofs_dir = os.path.join(loki_dir, "proofs")
@@ -176,7 +228,14 @@ def _load_runs(loki_dir):
         if not isinstance(proof, dict):
             # Malformed / partial proof: skip, do not fail the trajectory.
             continue
+        verdict, false_verified = _verdict_evidence(proof)
+        by_type, waited_s = _intervention_detail(proof)
         runs.append({
+            "verdict": verdict,
+            "false_verified": false_verified,
+            "cost_usd": _cost_value(proof),
+            "interventions_by_type": by_type,
+            "waited_s": waited_s,
             "run_id": str(proof.get("run_id") or name),
             "generated_at": proof.get("generated_at"),
             "council_pass_rate": _council_pass_value(proof.get("council")),
@@ -262,6 +321,65 @@ def _direction_for_axis(axis, ordered_values):
     }
 
 
+def outcome_effort(series):
+    """Effort-per-outcome block; every unmeasured input yields None, never 0."""
+    accepted = sum(1 for r in series if r["verdict"] == "VERIFIED" and r["false_verified"] is not True)
+    claimed = sum(1 for r in series if r["verdict"] == "VERIFIED" or r["false_verified"] is True)
+    false_v = sum(1 for r in series if r["false_verified"] is True)
+    unmeasured = sum(1 for r in series if r["cost_usd"] is None)
+    cost = None
+    cost_note = None
+    if not series:
+        cost_note = "no runs"
+    elif accepted == 0:
+        cost_note = "no accepted run, cost per accepted is undefined"
+    elif unmeasured:
+        cost_note = "cost unmeasured for %d of %d runs, a partial sum is not a total" % (unmeasured, len(series))
+    else:
+        cost = round(sum(r["cost_usd"] for r in series) / accepted, 6)
+    with_detail = [r for r in series if r["interventions_by_type"] is not None]
+    by_type = None
+    if with_detail:
+        by_type = {k: sum(r["interventions_by_type"][k] for r in with_detail) for k in _IV_TYPES}
+    all_iv = bool(series) and all(r["interventions"] is not None for r in series)
+    all_waited = bool(series) and all(r["waited_s"] is not None for r in series)
+    return {
+        "runs": len(series),
+        "accepted": accepted,
+        "claimed_verified": claimed,
+        "false_verified": false_v,
+        "misleading_completion_rate": round(false_v / claimed, 4) if claimed else None,
+        "cost_per_accepted_usd": cost,
+        "cost_note": cost_note,
+        "interventions_by_type": by_type,
+        "interventions_per_accepted": (
+            round(sum(r["interventions"] for r in series) / accepted, 4) if accepted and all_iv else None),
+        "waited_min_per_accepted": (
+            round(sum(r["waited_s"] for r in series) / 60.0 / accepted, 1) if accepted and all_waited else None),
+    }
+
+
+def _fmt_outcome_effort(e):
+    mc = e.get("misleading_completion_rate")
+    lines = ["Outcome effort"]
+    lines.append("  Accepted (VERIFIED): %d of %d runs" % (e["accepted"], e["runs"]))
+    lines.append("  Misleading completion: %s" % (
+        "n/a (no VERIFIED claims)" if mc is None else
+        "%d of %d VERIFIED claims (%s%%)" % (e["false_verified"], e["claimed_verified"], round(mc * 100, 1))))
+    lines.append("  Cost per accepted: %s" % (
+        "n/a (%s)" % (e.get("cost_note") or "unmeasured") if e["cost_per_accepted_usd"] is None
+        else "$%.2f" % e["cost_per_accepted_usd"]))
+    bt = e.get("interventions_by_type")
+    lines.append("  Interventions by type: %s" % (
+        "not recorded" if bt is None else ", ".join("%s %d" % (k, bt[k]) for k in _IV_TYPES)))
+    ipa = e.get("interventions_per_accepted")
+    lines.append("  Interventions per accepted: %s" % ("n/a" if ipa is None else ipa))
+    w = e.get("waited_min_per_accepted")
+    lines.append("  Minutes per accepted: %s" % (
+        "n/a" if w is None else "%s (waited, upper bound; active minutes are not measured)" % w))
+    return lines
+
+
 def compute_trajectory(loki_dir):
     """Return the R4 trust trajectory snapshot for a project's .loki dir."""
     runs = _load_runs(loki_dir)
@@ -276,6 +394,11 @@ def compute_trajectory(loki_dir):
             "gate_pass_rate": r["gate_pass_rate"],
             "iterations": r["iterations"],
             "interventions": r["interventions"],
+            "cost_usd": r["cost_usd"],
+            "interventions_by_type": r["interventions_by_type"],
+            "waited_s": r["waited_s"],
+            "verdict": r["verdict"],
+            "false_verified": r["false_verified"],
         })
 
     axes = {}
@@ -317,6 +440,7 @@ def compute_trajectory(loki_dir):
         "regressing_axes": regressing_axes,
         "series": series,
         "notes": notes,
+        "outcome_effort": outcome_effort(series),
     }
 
 
@@ -376,6 +500,9 @@ def format_trajectory_human(traj):
         lines.append("Not enough history yet.")
         lines.append("Trust trajectory needs 2+ recorded runs to show a direction.")
         lines.append("Each `loki start` run writes a proof-of-run; come back after the next run.")
+        if traj.get("runs_count") and traj.get("outcome_effort"):
+            lines.append("")
+            lines.extend(_fmt_outcome_effort(traj["outcome_effort"]))
         if traj.get("notes"):
             lines.append("")
             lines.append("Notes")
@@ -398,6 +525,9 @@ def format_trajectory_human(traj):
         lines.append("Overall: mixed (%d improving / %d regressing)." % (imp, reg))
     else:
         lines.append("Overall: stable.")
+    if traj.get("outcome_effort"):
+        lines.append("")
+        lines.extend(_fmt_outcome_effort(traj["outcome_effort"]))
     if traj.get("notes"):
         lines.append("")
         lines.append("Notes")

package/autonomy/lib/workspace.py

@@ -222,8 +222,7 @@ def run_integration(ws, run_dir, worktrees, heads):
     """Run the integration command once; return the evidence dict."""
     integ = ws.get("integration") or {}
     cmd = integ.get("command")
-    ev = {"heads": heads, "exit_code": None, "log_sha256": None, "status": "not_configured",
-          "seal": False, "note": "integration evidence is bound by composite.json only when the run seals one"}
+    ev = {"heads": heads, "exit_code": None, "log_sha256": None, "status": "not_configured"}
     if not cmd:
         return ev
     timeout = integ.get("timeout_s", 900)
@@ -245,7 +244,7 @@ def run_integration(ws, run_dir, worktrees, heads):
             p.wait()
             rc = 124
             ev["status"] = "failed"
-            ev["note"] += "; timeout after %ss" % timeout
+            ev["note"] = "timeout after %ss" % timeout
     ev["exit_code"] = rc
     with open(log_path, "rb") as f:
         ev["log_sha256"] = hashlib.sha256(f.read()).hexdigest()