loki-mode 7.129.5 → 8.0.1

package/autonomy/lib/proof-generator.py

@@ -22,6 +22,7 @@ import hashlib
 import json
 import os
 import random
+import re
 import string
 import subprocess
 import sys
@@ -37,6 +38,8 @@ if _HERE not in sys.path:
 import proof_redact  # noqa: E402
 from efficiency_cost import collect_efficiency as _collect_efficiency  # noqa: E402
 import effort_estimator  # noqa: E402
+from tree_digest import MANIFEST_VERSION, compute_tree_digest  # noqa: E402
+from workspace_diff import collect_workspace_diff  # noqa: E402
 
 
 # ---------------------------------------------------------------------------
@@ -326,6 +329,38 @@ def _collect_quality_gates(loki_dir):
                         {"name": "unit_tests", "status": _norm_gate_status(st)}
                     )
                     total += 1
+    # The iteration loop writes the authoritative unresolved-gate set here.
+    # These failures must be merged even when individual pass markers exist.
+    # Otherwise a run can stop on code_review while the receipt reports only
+    # static_analysis and unit_tests, producing a cryptographically valid but
+    # semantically false green receipt.
+    failure_path = os.path.join(loki_dir, "quality", "gate-failures.txt")
+    try:
+        with open(failure_path, "r", encoding="utf-8") as handle:
+            raw_failures = handle.read(8192)
+    except OSError:
+        raw_failures = ""
+    failed_names = []
+    for token in re.split(r"[,\s]+", raw_failures):
+        name = token.strip()
+        if not name or not re.fullmatch(r"[A-Za-z0-9_.:-]+", name):
+            continue
+        name = re.sub(r"_(PAUSED|ESCALATED)$", "", name,
+                      flags=re.IGNORECASE)
+        if name not in failed_names:
+            failed_names.append(name)
+    if failed_names:
+        by_name = {str(g.get("name") or ""): g for g in gates}
+        for name in failed_names:
+            if name in by_name:
+                by_name[name]["status"] = "failed"
+            else:
+                gate = {"name": name, "status": "failed"}
+                gates.append(gate)
+                by_name[name] = gate
+
+    total = len(gates)
+    passed = sum(1 for gate in gates if gate.get("status") == "passed")
     return {"passed": passed, "total": total, "gates": gates}
 
 
@@ -378,6 +413,88 @@ def _collect_build(loki_dir):
     return out
 
 
+def _collect_termination(loki_dir, session_exit_code=None):
+    """Read the supervised-process termination marker.
+
+    The marker is written before proof generation when INT or TERM ends a
+    supervised build. File presence is fail-closed: a truncated marker still
+    proves that the process did not complete normally.
+    """
+    path = os.path.join(loki_dir, "state", "termination.json")
+    out = {
+        "terminated": False,
+        "status": "completed",
+        "reason": "",
+        "signal": "",
+        "exit_code": None,
+        "outcome": "",
+        "run_status": "",
+    }
+    state_paths = [os.path.join(loki_dir, "autonomy-state.json")]
+    sessions_dir = os.path.join(loki_dir, "sessions")
+    try:
+        for entry in os.listdir(sessions_dir):
+            state_paths.append(
+                os.path.join(sessions_dir, entry, "autonomy-state.json")
+            )
+    except OSError:
+        pass
+    state_paths = [path for path in state_paths if os.path.isfile(path)]
+    if state_paths:
+        latest_state = max(state_paths, key=os.path.getmtime)
+        state = _read_json(latest_state, default=None)
+        if isinstance(state, dict):
+            out["run_status"] = str(state.get("status") or "").strip().lower()
+    completion = _read_json(
+        os.path.join(loki_dir, "state", "completion.json"), default=None
+    )
+    if isinstance(completion, dict):
+        outcome = str(completion.get("outcome") or "").strip().lower()
+        out["outcome"] = outcome
+        if outcome:
+            out["status"] = outcome
+            if outcome not in ("complete", "completed", "success"):
+                out["reason"] = outcome
+    if session_exit_code is not None:
+        out["exit_code"] = session_exit_code
+        if session_exit_code != 0 and not out["reason"]:
+            out["reason"] = "nonzero_session_exit"
+    if not os.path.exists(path):
+        return out
+    raw = _read_json(path, default=None)
+    out["terminated"] = True
+    out["status"] = "interrupted"
+    if not isinstance(raw, dict):
+        out["reason"] = "invalid_termination_record"
+        return out
+    out["reason"] = str(raw.get("reason") or "supervisor_signal")
+    out["signal"] = str(raw.get("signal") or "")
+    ec = raw.get("exit_code")
+    out["exit_code"] = _to_int(ec, None) if ec is not None else None
+    return out
+
+
+def _collect_model(loki_dir, observed):
+    """Return the dispatched model when recorded, otherwise ``unavailable``."""
+    for value in (
+        observed,
+        os.environ.get("LOKI_CURRENT_MODEL"),
+        os.environ.get("LOKI_SESSION_MODEL"),
+        os.environ.get("SESSION_MODEL"),
+    ):
+        if str(value or "").strip():
+            return str(value).strip()
+    policy = _read_json(
+        os.path.join(loki_dir, "state", "execution-policy.json"), default={}
+    )
+    model = policy.get("model") if isinstance(policy, dict) else None
+    if isinstance(model, dict):
+        value = model.get("sdk_id") or model.get("alias")
+        if str(value or "").strip():
+            return str(value).strip()
+    return "unavailable"
+
+
 def _collect_security(loki_dir):
     """Read .loki/quality/security-findings.json (the secure-by-default gate).
 
@@ -584,6 +701,53 @@ def _collect_evidence_gate(loki_dir):
     return out
 
 
+def _classify_func_axis(raw):
+    """Map one recorded functional axis {ok, inconclusive, reason} to an HONEST
+    tri-state. This is the trust-critical rule -- get it wrong and the receipt
+    fabricates a green:
+
+      - PROVEN   iff ok is True AND NOT inconclusive (a fresh positive proof:
+                 the record survived / the 401 was observed / the scan was clean).
+      - GAP      iff ok is False AND NOT inconclusive (freshly disproven).
+      - NOT_CHECKED otherwise (inconclusive, or absent). Never a green, never a
+                 gap -- it was not proven and it was not disproven.
+
+    inconclusive DOMINATES ok: an axis flagged inconclusive is never proven even
+    if ok happens to be true (the gate writes ok:true as its non-blocking default
+    when it could not run, so ok alone is not evidence)."""
+    if not isinstance(raw, dict):
+        return "not_checked", ""
+    reason = str(raw.get("reason") or "")
+    if raw.get("inconclusive") is True:
+        return "not_checked", reason
+    if raw.get("ok") is True:
+        return "proven", reason
+    if raw.get("ok") is False:
+        return "gap", reason
+    return "not_checked", reason
+
+
+def _collect_functionality(loki_dir):
+    """Read the nomock/persistence/auth axes from evidence-gate-details.json and
+    surface each as an HONEST proof fact. Deterministic + re-derivable: the values
+    come straight from the recorded axes, no LLM opinion.
+
+    Shape (per axis): {state: proven|gap|not_checked, reason}. Only `proven` is a
+    green receipt row; `gap` is an honest disproven row (lands in degraded[]);
+    `not_checked` is omitted from the receipt's green rows entirely. Absent file
+    or absent axis -> not_checked (the gate did not record it -> nothing proven)."""
+    raw = _read_json(
+        os.path.join(loki_dir, "council", "evidence-gate-details.json"),
+        default=None,
+    )
+    axes = raw if isinstance(raw, dict) else {}
+    out = {}
+    for axis in ("nomock", "persistence", "auth", "authorization"):
+        state, reason = _classify_func_axis(axes.get(axis))
+        out[axis] = {"state": state, "reason": reason}
+    return out
+
+
 def _diff_sha256(files_changed):
     """sha256 of the canonical diff stat (count/insertions/deletions/files).
 
@@ -602,93 +766,58 @@ def _diff_sha256(files_changed):
 
 
 def _git_diffstat(target_dir, include_diffs):
-    """Return (files_changed dict, diffs list|None).
-
-    base = $_LOKI_ITER_START_SHA, else HEAD~1. Non-git -> empty.
+    """Return the final worktree diff relative to the RUN's base.
+
+    The receipt is a run-level document, so its diff stat must span the WHOLE
+    run. This previously passed _LOKI_ITER_START_SHA -- the per-ITERATION
+    baseline -- so a multi-iteration run attested only to the changes since its
+    last iteration. Measured on a real 2-commit run: 850 insertions + 76
+    deletions reported where the run actually produced 1300 insertions.
+
+    That matters more than an ordinary display bug: the returned object flows
+    into _diff_sha256, the receipt's integrity hash, which is written on EVERY
+    run. A verifier recomputing it therefore attests to the understated stat,
+    and the receipt is exactly the artifact users are told to trust. (Detached
+    GPG signing is a separate opt-in layer gated on LOKI_PROOF_GPG_KEY and
+    default OFF; when enabled it signs these same bytes, but the integrity hash
+    is the always-on path.)
+
+    Order of preference:
+      1. _LOKI_RUN_START_SHA -- the run's own baseline (run.sh exports it).
+      2. The empty tree -- correct for a GREENFIELD run (a repo with no commits
+         at start), where "everything that now exists" IS the run's output and
+         there is no earlier commit to diff against.
+      3. Empty string -- let workspace_diff apply its own fallbacks.
     """
-    empty = {"count": 0, "insertions": 0, "deletions": 0, "files": []}
-
-    def _git(args):
-        try:
-            out = subprocess.run(
-                ["git", "-C", target_dir] + args,
-                capture_output=True, text=True, timeout=30,
-            )
-            if out.returncode != 0:
-                return None
-            return out.stdout
-        except Exception:
-            return None
-
-    # Confirm we are in a git repo.
-    if _git(["rev-parse", "--is-inside-work-tree"]) is None:
-        return empty, (None if not include_diffs else None)
-
-    base = os.environ.get("_LOKI_ITER_START_SHA", "").strip()
+    base = os.environ.get("_LOKI_RUN_START_SHA", "").strip()
     if not base:
-        base = "HEAD~1"
-
-    numstat = _git(["diff", "--numstat", base, "HEAD"])
-    if numstat is None:
-        # base may be invalid (shallow / first commit); fall back to HEAD only.
-        numstat = _git(["diff", "--numstat", "HEAD"])
-    if numstat is None:
-        return empty, (None if not include_diffs else None)
-
-    files = []
-    ins_total = 0
-    del_total = 0
-    for line in numstat.splitlines():
-        parts = line.split("\t")
-        if len(parts) < 3:
-            continue
-        ins_s, del_s, path = parts[0], parts[1], parts[2]
-        ins = _to_int(ins_s) if ins_s != "-" else 0
-        dele = _to_int(del_s) if del_s != "-" else 0
-        ins_total += ins
-        del_total += dele
-        files.append({
-            "path": path,
-            "insertions": ins,
-            "deletions": dele,
-            "status": "binary" if ins_s == "-" else "modified",
-        })
+        # Greenfield: no baseline commit existed when the run started.
+        base = _empty_tree_sha(target_dir)
+    files_changed, diffs = collect_workspace_diff(target_dir, base, include_diffs)
+    # Return the base too. git_facts records base_sha NEXT TO diff and
+    # diff_sha256; if they disagree the signed receipt is internally
+    # inconsistent and a verifier recomputing the diff from base_sha gets a
+    # different answer than the one that was signed.
+    return files_changed, diffs, base
 
-    files_changed = {
-        "count": len(files),
-        "insertions": ins_total,
-        "deletions": del_total,
-        "files": files,
-    }
 
-    diffs = None
-    if include_diffs:
-        diffs = []
-        patch = _git(["diff", base, "HEAD"])
-        if patch is None:
-            patch = _git(["diff", "HEAD"])
-        if patch:
-            # Split per file on the diff --git markers, preserving the header.
-            chunks = []
-            current = []
-            for line in patch.splitlines(keepends=True):
-                if line.startswith("diff --git ") and current:
-                    chunks.append("".join(current))
-                    current = [line]
-                else:
-                    current.append(line)
-            if current:
-                chunks.append("".join(current))
-            for chunk in chunks:
-                # Best-effort path extraction from the "diff --git a/x b/x" line.
-                p = ""
-                first = chunk.splitlines()[0] if chunk else ""
-                bits = first.split(" b/")
-                if len(bits) == 2:
-                    p = bits[1].strip()
-                diffs.append({"path": p, "patch": chunk})
+def _empty_tree_sha(repo_dir):
+    """The canonical empty-tree object, or "" when git is unavailable.
 
-    return files_changed, diffs
+    Diffing against this yields "everything that currently exists", which is the
+    truthful baseline for a run that started from a repo with no commits.
+    """
+    try:
+        out = subprocess.run(
+            ["git", "hash-object", "-t", "tree", os.devnull],
+            cwd=repo_dir,
+            capture_output=True,
+            text=True,
+            timeout=10,
+        )
+    except Exception:
+        return ""
+    return out.stdout.strip() if out.returncode == 0 else ""
 
 
 def _collect_iterations(loki_dir):
@@ -823,20 +952,22 @@ def _build_proof(args, loki_dir, target_dir, repo_root):
 
     cost, model_from_eff = _collect_efficiency(loki_dir)
     provider_name = args.provider or os.environ.get("PROVIDER_NAME") or "claude"
-    model = model_from_eff or os.environ.get("SESSION_MODEL") or ""
+    model = _collect_model(loki_dir, model_from_eff)
 
-    files_changed, diffs = _git_diffstat(target_dir, args.include_diffs)
+    files_changed, diffs, diff_base_sha = _git_diffstat(target_dir, args.include_diffs)
     iterations = _collect_iterations(loki_dir)
     spec = _collect_spec(loki_dir, target_dir)
     council = _collect_council(loki_dir)
     quality_gates = _collect_quality_gates(loki_dir)
 
     build = _collect_build(loki_dir)
+    termination = _collect_termination(loki_dir, args.session_exit_code)
     tests = _collect_tests(loki_dir)
     security = _collect_security(loki_dir)
     functional = _collect_functional(loki_dir)  # FV-2 record-half: descriptive only
     healthcheck = _collect_healthcheck(loki_dir)  # Evidence Receipt record-half
     evidence_gate = _collect_evidence_gate(loki_dir)
+    functionality = _collect_functionality(loki_dir)  # func axes as HONEST facts
 
     deployed_url = os.environ.get("LOKI_DEPLOYED_URL") or None
 
@@ -859,13 +990,19 @@ def _build_proof(args, loki_dir, target_dir, repo_root):
     # recompute the hash. True non-forgeability requires the neutral signed record
     # (service-held key). See proof-verify.py verify() docstring.
     git_facts = {
-        "base_sha": os.environ.get("_LOKI_ITER_START_SHA", "").strip(),
+        # Must be the SAME base the diff above was computed against.
+        "base_sha": diff_base_sha,
         "head_sha": _git_head_sha(target_dir),
         "diff": files_changed,
         "diff_sha256": _diff_sha256(files_changed),
+        # Exact source snapshot verified by this receipt. Dashboard supervisors
+        # recompute it after runner exit to reject proofs followed by code edits.
+        "tree_sha256": compute_tree_digest(target_dir),
+        "tree_manifest_version": MANIFEST_VERSION,
     }
     facts = {
         "git": git_facts,
+        "execution": termination,
         "build": build,
         "tests": tests,
         "quality_gates": [
@@ -878,6 +1015,14 @@ def _build_proof(args, loki_dir, target_dir, repo_root):
         # _compute_degraded, so it does not (yet) change the verdict. Wiring it into
         # the green headline is the founder-gated trust-semantics decision.
         "functional": functional,
+        # Functionality-proving axes (nomock / persistence / auth), surfaced as
+        # HONEST facts straight from the recorded evidence-gate axes. Each is
+        # {state: proven|gap|not_checked, reason}. ONLY `proven` (a fresh ok:true)
+        # is a green receipt row; `not_checked` (inconclusive/absent) is never a
+        # green and never a gap; `gap` (a fresh ok:false) is a disproven row and
+        # ALSO lands in degraded[] (below), so it forces VERIFIED WITH GAPS and can
+        # never hide behind a green headline. Deterministic + re-derivable.
+        "functionality": functionality,
         # Evidence Receipt (record half): did the built app come up + respond?
         # Descriptive; NOT read by _compute_headline (gating is founder-gated).
         "healthcheck": healthcheck,
@@ -966,6 +1111,9 @@ def _build_proof(args, loki_dir, target_dir, repo_root):
         "quality_gates": quality_gates,
         "cost": cost,
         "deployment": deployment,
+        # Typed compatibility mirror for consumers that do not traverse facts.
+        "tree_sha256": git_facts["tree_sha256"],
+        "tree_manifest_version": git_facts["tree_manifest_version"],
         # Rank 6: work-based engineering-hours estimate (top-level, NOT a fact).
         "effort_estimate": effort_estimate,
         # v1.1 evidence model (additive).
@@ -988,6 +1136,28 @@ def _compute_degraded(facts):
     # must SHOW it (otherwise a failed test would render an amber banner whose
     # "items below" list is empty -- the exact misleading state we forbid).
     weak = ("not_run", "inconclusive", "skipped", "failed")
+    execution = facts.get("execution") or {}
+    if execution.get("terminated"):
+        signal_name = execution.get("signal") or "unknown"
+        reason = execution.get("reason") or "interrupted"
+        out.append({"item": "execution", "status": "failed",
+                    "reason": "%s (%s)" % (reason, signal_name)})
+    else:
+        outcome = str(execution.get("outcome") or "").lower()
+        run_status = str(execution.get("run_status") or "").lower()
+        if execution.get("exit_code") not in (None, 0):
+            out.append({"item": "execution", "status": "failed",
+                        "reason": "exit_code=%s" % execution.get("exit_code")})
+        elif outcome and outcome not in ("complete", "completed", "success"):
+            out.append({"item": "execution", "status": "failed",
+                        "reason": outcome})
+        elif run_status in {
+            "failed", "force_stopped", "inconclusive_spec_contradiction",
+            "interrupted", "max_iterations_reached", "max_retries_exceeded",
+            "paused", "policy_blocked", "provider_deadline_partial_mutation",
+        }:
+            out.append({"item": "execution", "status": "failed",
+                        "reason": run_status})
     tests = facts.get("tests") or {}
     if tests.get("status") in weak:
         reason = "no test command recorded" if not tests.get("command") \
@@ -1018,6 +1188,19 @@ def _compute_degraded(facts):
     if not (git.get("diff") or {}).get("count"):
         out.append({"item": "git.diff", "status": "not_run",
                     "reason": "no file changes detected"})
+    # Functionality axes: ONLY a freshly-disproven axis (state == gap, i.e. the
+    # gate ran and the axis FAILED -- a record did not survive, auth was NOT
+    # enforced, the diff shipped mock data) is a gap in the proof of done. A
+    # `not_checked` axis (inconclusive / not attempted) is deliberately NOT a gap:
+    # the honesty rule is that not-proven is not the same as disproven, and the
+    # gate already passes those through. Surfacing them here would spam the ledger
+    # with "we didn't check X" for every axis the driver could not exercise.
+    fnc = facts.get("functionality") or {}
+    for axis in ("nomock", "persistence", "auth", "authorization"):
+        rec = fnc.get(axis) or {}
+        if rec.get("state") == "gap":
+            out.append({"item": "functionality:%s" % axis, "status": "failed",
+                        "reason": rec.get("reason") or "axis disproven"})
     return out
 
 
@@ -1057,8 +1240,31 @@ def _compute_headline(facts, degraded):
         and fn.get("ran")
         and fn.get("functional_status") == "failed"
     )
+    execution = facts.get("execution") or {}
+    execution_outcome = str(execution.get("outcome") or "").lower()
+    failed_run_statuses = {
+        "failed",
+        "force_stopped",
+        "inconclusive_spec_contradiction",
+        "interrupted",
+        "max_iterations_reached",
+        "max_retries_exceeded",
+        "paused",
+        "policy_blocked",
+        "provider_deadline_partial_mutation",
+    }
+    execution_failed = bool(
+        execution.get("terminated")
+        or execution.get("exit_code") not in (None, 0)
+        or str(execution.get("run_status") or "").lower() in failed_run_statuses
+        or (
+            execution_outcome
+            and execution_outcome not in ("complete", "completed", "success")
+        )
+    )
     any_failed = (
-        tests.get("status") == "failed"
+        execution_failed
+        or tests.get("status") == "failed"
         or build.get("status") == "failed"
         or any(g.get("status") == "failed"
                for g in (facts.get("quality_gates") or []))
@@ -1165,6 +1371,15 @@ def _build_social_hook(proof):
     return " - ".join(parts)
 
 
+def _receipt_title(proof):
+    """Conservative user-facing verdict label for the rendered receipt."""
+    headline = str((proof.get("honesty") or {}).get("headline") or "").upper()
+    return {
+        "VERIFIED": "Recorded checks passed",
+        "VERIFIED WITH GAPS": "Checks completed with gaps",
+    }.get(headline, "Not verified")
+
+
 def _attr_esc(s):
     """HTML-attribute-escape a string destined for content="...".`"""
     return (str(s).replace("&", "&amp;").replace('"', "&quot;")
@@ -1213,10 +1428,14 @@ def _render_fallback_html(proof):
     rows.append("<ul>")
     rows.append("<li>Cost (USD): %s</li>" % (
         esc(usd_disp) if usd_disp is not None else "not recorded for this run"))
-    rows.append("<li>Input tokens: %s</li>" % esc(cost.get("input_tokens", 0)))
-    rows.append("<li>Output tokens: %s</li>" % esc(cost.get("output_tokens", 0)))
-    rows.append("<li>Cache read tokens: %s</li>" % esc(cost.get("cache_read_tokens", 0)))
-    rows.append("<li>Cache creation tokens: %s</li>" % esc(cost.get("cache_creation_tokens", 0)))
+    def token_value(key):
+        value = cost.get(key)
+        return value if value is not None else "not recorded"
+
+    rows.append("<li>Input tokens: %s</li>" % esc(token_value("input_tokens")))
+    rows.append("<li>Output tokens: %s</li>" % esc(token_value("output_tokens")))
+    rows.append("<li>Cache read tokens: %s</li>" % esc(token_value("cache_read_tokens")))
+    rows.append("<li>Cache creation tokens: %s</li>" % esc(token_value("cache_creation_tokens")))
     rows.append("<li>Wall clock (sec): %s</li>" % esc(proof.get("wall_clock_sec", 0)))
     rows.append("</ul>")
 
@@ -1269,6 +1488,9 @@ def _render_html(proof, repo_root):
     tpl = _read_text(template_path, default="")
     marker = "__PROOF_JSON__"
     if tpl and marker in tpl:
+        receipt_title = _receipt_title(proof)
+        tpl = tpl.replace("__PROOF_RECEIPT_TITLE__", _attr_esc(receipt_title))
+        tpl = tpl.replace("__PROOF_RECEIPT_TITLE_JSON__", json.dumps(receipt_title))
         # Substitute the dynamic social hook BEFORE the JSON payload, so a proof
         # value that happens to contain the hook token cannot get clobbered.
         # The hook embeds the real measured cost + files-changed + council ratio
@@ -1406,7 +1628,14 @@ def generate(args):
     return out_dir
 
 
-def main(argv=None):
+def build_parser():
+    """The generator's CLI parser.
+
+    Split out of main() so callers (notably the tests, which drive generate()
+    directly with a synthetic args object) can obtain every argument at its
+    declared default instead of hand-listing fields that go stale whenever a new
+    argument lands here.
+    """
     parser = argparse.ArgumentParser(description="Loki Mode proof-of-run generator")
     parser.add_argument("--loki-dir", default=".loki")
     parser.add_argument("--out-dir", default="")
@@ -1414,8 +1643,13 @@ def main(argv=None):
     parser.add_argument("--run-id", default="")
     parser.add_argument("--loki-version", default="")
     parser.add_argument("--provider", default="")
+    parser.add_argument("--session-exit-code", type=int, default=None)
     parser.add_argument("--quiet", action="store_true")
-    args = parser.parse_args(argv)
+    return parser
+
+
+def main(argv=None):
+    args = build_parser().parse_args(argv)
 
     try:
         generate(args)

package/autonomy/lib/proof-template.html

@@ -20,9 +20,8 @@
        the literal token anywhere else (this comment deliberately spells it out
        instead of repeating it, and the renderer detects an un-substituted
        blob structurally rather than by string-matching the token).
-    4. No other token substitution is required. All rendering happens client
-       side from the parsed blob. This keeps Bun and bash routes at exact
-       parity (one string replace, one template).
+    4. The generator also substitutes the receipt title, social description,
+       and share-button setting before embedding the parsed blob.
 
   The renderer below is defensive: every nullable / optional schema field is
   guarded (deployed_url, public_url, diffs, council.enabled false, empty
@@ -42,10 +41,10 @@
 <head>
 <meta charset="utf-8">
 <meta name="viewport" content="width=device-width, initial-scale=1">
-<title>Loki Mode - Proof of Run</title>
+<title>__PROOF_RECEIPT_TITLE__ - Loki Mode Evidence Receipt</title>
 <!-- Static text-only social meta. No og:image (would break self-containment). -->
 <meta property="og:type" content="website">
-<meta property="og:title" content="Built and verified autonomously by Loki Mode">
+<meta property="og:title" content="__PROOF_RECEIPT_TITLE__ - Loki Mode Evidence Receipt">
 <!-- og:description and twitter:description are filled at generation time with
      the real measured cost + files-changed + council ratio (cost-free variant
      when cost was not collected). The generator replaces the og token below in
@@ -589,7 +588,7 @@
   function honestyVariant(headline) {
     var h = String(headline || "").toUpperCase();
     if (h === "VERIFIED") return { cls: "is-verified", mark: "OK",
-      sub: "Tests verified, a real diff exists, and nothing was left unverified. Every claim below is deterministic and re-checkable." };
+      sub: "The recorded tests passed and this receipt contains a non-empty source change. Review the evidence below for the exact scope." };
     if (h.indexOf("GAPS") !== -1) return { cls: "is-gaps", mark: "!",
       sub: "Some evidence is verified, but the items listed below were not. A gap is never hidden: read them before trusting this run." };
     return { cls: "is-failed", mark: "X",
@@ -776,7 +775,7 @@
     // fmtUsd: a skeptic seeing a zero-dollar total assumes the artifact is fake.
     var usdRaw = g(p, "cost.usd", null);
     var fc = num(g(p, "files_changed.count", 0));
-    var parts = ["Built and verified autonomously"];
+    var parts = [__PROOF_RECEIPT_TITLE_JSON__];
     if (usdRaw !== null) parts.push(fmtUsd(usdRaw));
     else parts.push("cost not recorded");
     parts.push(fc + " file" + (fc === 1 ? "" : "s") + " changed");
@@ -929,11 +928,15 @@
   function renderCost(p) {
     var card = document.getElementById("costCard");
     var usdRaw = g(p, "cost.usd", null);
+    function tokenValue(path) {
+      var raw = g(p, path, null);
+      return raw === null ? "not recorded" : fmtInt(raw);
+    }
     var cells = [
-      ["Input tokens", fmtInt(g(p, "cost.input_tokens", 0))],
-      ["Output tokens", fmtInt(g(p, "cost.output_tokens", 0))],
-      ["Cache read", fmtInt(g(p, "cost.cache_read_tokens", 0))],
-      ["Cache write", fmtInt(g(p, "cost.cache_creation_tokens", 0))]
+      ["Input tokens", tokenValue("cost.input_tokens")],
+      ["Output tokens", tokenValue("cost.output_tokens")],
+      ["Cache read", tokenValue("cost.cache_read_tokens")],
+      ["Cache write", tokenValue("cost.cache_creation_tokens")]
     ];
     var grid = "";
     for (var i = 0; i < cells.length; i++) {
@@ -1249,7 +1252,7 @@
     function shareHook() {
       var m = document.querySelector('meta[property="og:description"]');
       var c = m ? (m.getAttribute("content") || "") : "";
-      return c || "Built and verified autonomously by Loki Mode";
+      return c || (__PROOF_RECEIPT_TITLE_JSON__ + " - Loki Mode Evidence Receipt");
     }
     document.addEventListener("click", function (e) {
       var t = e.target && e.target.closest ? e.target.closest("[data-share]") : null;