claude-mem 13.26.1 → 13.27.0

package/openclaw/skills/agent-cost-report/scripts/acr/behavior.py

@@ -0,0 +1,313 @@
+"""Phase 2B shared machinery (plan 2B.1, 2B.2, 2B.9): a second streaming pass over the same
+transcript files and window as the Phase 1 collector, building ordered turns per session, tagging
+every user turn human | bot | unknown (prerequisite R2, plan 0.5), finding frustration episodes,
+and pricing wasted turns with the Phase 1 rate() table in integer micro-dollars.
+
+Sources: box Claude Code transcripts (agent turns plus tagged user turns) and claude-mem
+`user_prompts` rows (local and replica, tagged). Grok Bot chats stay "unavailable" (R1).
+Field names were verified on box transcripts 2026-09-25 (plan 2B.7): assistant lines carry
+`message.content[] {type: text|tool_use {id, name, input}}`, user lines carry
+`{type: tool_result {tool_use_id, is_error, content}}` or text; `entrypoint` is cli | sdk-cli | sdk-ts.
+"""
+import collections
+import datetime as dt
+import glob
+import hashlib
+import json
+import os
+import re
+
+from . import costs, prices, transcripts
+from .period import PT
+
+# ---- constants (plan 2B.1) ----
+GAP_MIN = 45                 # episode grouping gap (MI:8)
+WASTED_CAP_MS = 6 * 3600_000 # wasted window cap (MI:9)
+REDO_MS = 60 * 60_000        # redo window after the episode's last message (MI:9)
+ALEX_WAIT_CAP_MIN = 60       # Alex-minutes wait cap (MI:10)
+EXCERPT_CHARS = 160
+TEXT_KEEP = 6000             # chars of assistant text kept per turn (bounded memory)
+RESULT_KEEP = 2048           # first 2 KB of a tool result (S1 rule)
+INPUT_KEEP = 1500
+HEADLESS = ("sdk-cli", "sdk-ts")
+
+# Frustration Arc markers (MI:7) plus the agent markers in plan 2B.1 and the relay/automation
+# prefixes seen in claude-mem user_prompts on this box (2026-09-26 probe).
+BOT_MARKERS = re.compile(
+    r"^\s*(STEER from Alex|HOUSE LOCK|\[SAND_HIDDEN_PROMPT\]|<system-reminder>|<timestamp>|<cross-session-message|<command-|<local-command|"
+    r"\[Request interrupted|MAKE-PLAN\b|make-plan ONLY|# make-plan|Branch: [\w/.-]+ \(this worktree|"
+    r"\[Cross-session idle notice\]|\[Group chat:|\[Artifact comment|Agent sweep|AJ email check|Quiet overnight|"
+    r"You name new code workspaces|You are\b|/do\b|/make-plan\b|/loop\b|/claude-mem:|/ccs-|/[a-z][\w-]*:[a-z][\w-]*\b|"
+    r"(STEER|RESET|CORRECTION) from Alex|Resuming after|\[SYSTEM NOTIFICATION|<task-notification>|<pasted_content)"
+    r"|^.{0,200}\bAlex (asked|said|wants|greened|approved)\b"            # third-person relays of Alex are agent-written
+    r"|^(?=.{400,})[^\n]{0,300}\bYou are (a|an|the|in|one|running|working)\b", re.I | re.S)   # long briefs that address the agent
+CORRECTION = re.compile(r"^\s*(STEER|RESET|CORRECTION) from Alex|\bSTEER\b.{0,10}\bfrom Alex\b|^\s*(RESET|CORRECTION):", re.I)
+PROFANITY = re.compile(r"\b(fuck\w*|shit\w*|wtf|goddamn)\b", re.I)
+FRUSTRATION_PHRASE = re.compile(r"\b(i told you|i said|why did you|who (said|made|told)|stop|never|again)\b", re.I)
+SECRET_RE = re.compile(r"(sk-or-[\w-]+|sk-[\w-]{8,}|Bearer\s+\S+|ghp_\w+|gho_\w+|xox[abp]-[\w-]+|AKIA\w{12,}|[A-Za-z0-9+/=_-]{32,})")
+# key=value / key: value credentials of any length (password=hunter2, token: abc, api_key="x"); the key stays, the value goes
+KV_SECRET_RE = re.compile(r"\b(pass(?:word|wd|phrase|code)?|pwd|secret|token|api[_-]?key|access[_-]?key|private[_-]?key|auth|credentials?)\b(\s*[:=]\s*)[\"']?[^\s\"',;]+[\"']?", re.I)
+FENCE_RE = re.compile(r"```.*?```", re.S)
+QUOTE_RE = re.compile(r"^\s*>.*$", re.M)
+MISS_RE = re.compile(r"usage limit|rate.?limit|\b429\b|\b401\b|dead token|token (has )?expired|unauthori[sz]ed|quota", re.I)
+
+FIELDS = ("input", "output", "cache_write_5m", "cache_write_1h", "cache_read")
+
+
+def scrub(text, n=EXCERPT_CHARS):
+    """Excerpts: at most 160 chars after the secret scrubber (plan 2B.1)."""
+    t = KV_SECRET_RE.sub(lambda m: f"{m.group(1)}{m.group(2)}[redacted]", (text or "").replace("\n", " ").strip())
+    t = SECRET_RE.sub("[redacted]", t)
+    return t[:n]
+
+
+def user_facing(text):
+    """'User-facing text' = assistant text with code fences, block quotes and tool inputs removed."""
+    return QUOTE_RE.sub("", FENCE_RE.sub("", text or "")).strip()
+
+
+def words(text):
+    return len(re.findall(r"[A-Za-z0-9'’]+", text or ""))
+
+
+def is_frustrated(text):
+    """Heuristic frustration detector (MI:6, ~51% precision): profanity, ≥40% caps over ≥12 letters,
+    !!! or ???, or a phrase like 'i told you'."""
+    if not text: return False
+    if PROFANITY.search(text) or "!!!" in text or "???" in text or FRUSTRATION_PHRASE.search(text): return True
+    letters = [c for c in text if c.isalpha()]
+    return len(letters) >= 12 and sum(c.isupper() for c in letters) / len(letters) >= 0.4
+
+
+def _ts_ms(iso):
+    t = transcripts.ts(iso)
+    return int(t.timestamp() * 1000)
+
+
+def _usage_row(u):
+    """copied from transcripts.py:66-75 (the same 5m/1h split as Phase 1)."""
+    cc = u.get("cache_creation") or {}
+    cw = u.get("cache_creation_input_tokens", 0) or 0
+    cw1 = cc.get("ephemeral_1h_input_tokens", 0) or 0
+    cw5 = cc.get("ephemeral_5m_input_tokens")
+    return dict(input=u.get("input_tokens", 0) or 0, output=u.get("output_tokens", 0) or 0,
+                cache_write_5m=cw5 if cw5 is not None else cw - cw1, cache_write_1h=cw1,
+                cache_read=u.get("cache_read_input_tokens", 0) or 0)
+
+
+def _blocks(content):
+    if isinstance(content, str): return [dict(type="text", text=content)]
+    return [b for b in (content or []) if isinstance(b, dict)]
+
+
+def _result_text(content):
+    if isinstance(content, str): return content
+    out = []
+    for b in content or []:
+        if isinstance(b, dict) and b.get("type") == "text": out.append(b.get("text") or "")
+        elif isinstance(b, str): out.append(b)
+    return "\n".join(out)
+
+
+def new_session():
+    return dict(entrypoint=None, turns={}, users=[], files=set(), sidechain_prompts=0)
+
+
+def scan(s_ms, e_ms, session=None, pattern=transcripts.CLAUDE_GLOB):
+    """Stream the window's Claude Code transcripts (same glob and mtime prefilter as Phase 1).
+    Returns {sessionId: {entrypoint, turns: {key: turn}, users: [user event], files}}.
+    A turn = one assistant API reply keyed (message.id, requestId) with its text, tool_uses and usage."""
+    s_dt = dt.datetime.fromtimestamp(s_ms / 1000, PT) if s_ms is not None else None
+    files = [f for f in glob.glob(os.path.expanduser(pattern), recursive=True)
+             if s_dt is None or dt.datetime.fromtimestamp(os.path.getmtime(f), PT) >= s_dt]
+    sessions = collections.defaultdict(new_session)
+    for f in files:
+        with open(f, errors="ignore") as fh:
+            for line in fh:
+                if '"timestamp"' not in line or ('"assistant"' not in line and '"user"' not in line): continue
+                if session is not None and session not in line: continue
+                try: d = json.loads(line)
+                except Exception: continue
+                typ = d.get("type")
+                if typ not in ("assistant", "user") or not d.get("timestamp"): continue
+                sid = d.get("sessionId") or d.get("session_id")
+                if session is not None and sid != session: continue
+                try: t_ms = _ts_ms(d["timestamp"])
+                except Exception: continue
+                if s_ms is not None and not (s_ms <= t_ms < e_ms): continue
+                S = sessions[sid]; S["files"].add(f)
+                if d.get("entrypoint") and not S["entrypoint"]: S["entrypoint"] = d["entrypoint"]
+                m = d.get("message") or {}
+                if typ == "assistant":
+                    key = (m.get("id"), d.get("requestId"))
+                    T = S["turns"].get(key)
+                    if T is None:
+                        u = m.get("usage") or {}
+                        row = _usage_row(u) if u else None
+                        T = S["turns"][key] = dict(key=key, ts_ms=t_ms, model=m.get("model"), text="", tool_uses=[], usage=row,
+                                                   sidechain=bool(d.get("isSidechain")), file=f, uuid=d.get("uuid"))
+                    elif T["usage"] is None and m.get("usage"): T["usage"] = _usage_row(m["usage"])
+                    for b in _blocks(m.get("content")):
+                        if b.get("type") == "text" and len(T["text"]) < TEXT_KEEP: T["text"] += (b.get("text") or "")[:TEXT_KEEP]
+                        elif b.get("type") == "tool_use":
+                            inp = b.get("input"); inp_s = inp if isinstance(inp, str) else json.dumps(inp, sort_keys=True)
+                            T["tool_uses"].append(dict(id=b.get("id"), name=b.get("name") or "", input=inp if isinstance(inp, dict) else {}, input_s=inp_s[:INPUT_KEEP]))
+                else:
+                    blocks = _blocks(m.get("content")); results = []; texts = []
+                    for b in blocks:
+                        if b.get("type") == "tool_result":
+                            results.append(dict(tool_use_id=b.get("tool_use_id"), is_error=bool(b.get("is_error")), content=_result_text(b.get("content"))[:RESULT_KEEP]))
+                        elif b.get("type") == "text": texts.append(b.get("text") or "")
+                    text = "\n".join(texts).strip()
+                    if not results and not text: continue
+                    if d.get("isMeta") and not results: continue                  # harness meta lines are not prompts
+                    S["users"].append(dict(ts_ms=t_ms, text=text[:TEXT_KEEP], results=results, sidechain=bool(d.get("isSidechain")),
+                                          uuid=d.get("uuid"), turn_origin=d.get("turnOrigin")))
+    return dict(sessions), dict(files_seen=len(files))
+
+
+# ---- human-or-bot tagging (R2) ----
+def session_tag(S):
+    """alex_direct (interactive cli, no agent-prompt markers) | agent_relayed | unknown (plan 2B.1)."""
+    prompts = [u for u in S["users"] if u["text"] and not u["sidechain"] and not u["results"]]
+    if S["entrypoint"] in HEADLESS: return "agent_relayed"
+    marked = [bool(BOT_MARKERS.search(u["text"])) for u in prompts]
+    if marked and (marked[0] or all(marked)): return "agent_relayed"        # launched by an agent, or nothing but relays
+    if S["entrypoint"] == "cli" and prompts: return "alex_direct"           # a marker later on tags that prompt alone (tag_user_turns)
+    return "unknown"
+
+
+def tag_user_turns(S):
+    tag = session_tag(S); S["tag"] = tag
+    for u in S["users"]:
+        if u["results"] and not u["text"]: u["author"] = "tool"; continue
+        if u["sidechain"] or tag == "agent_relayed" or BOT_MARKERS.search(u["text"]) or u.get("turn_origin") in ("task_notification", "sdk", "scheduled", "peer"):
+            u["author"] = "bot"
+        elif tag == "alex_direct": u["author"] = "human"
+        else: u["author"] = "unknown"
+    return tag
+
+
+def tag_prompt_row(text):
+    """A claude-mem user_prompts row is human only when it passes the marker filter."""
+    return "bot" if BOT_MARKERS.search(text or "") else "human"
+
+
+# ---- pricing turns ----
+def price_turns(sessions, pricer):
+    for S in sessions.values():
+        for T in S["turns"].values():
+            rt = pricer.rate(T["model"]) if T["model"] else None
+            T["x1e6"] = costs.api_equiv_x1e6(T["usage"], rt) if (T["usage"] and rt) else None
+            T["model_status"] = "observed" if T["model"] else "assumed"
+
+
+def ordered_turns(S):
+    return sorted(S["turns"].values(), key=lambda T: T["ts_ms"])
+
+
+def turn_cost(turns):
+    """Sum of priced turns in micro-dollars; unpriced turns add nothing but are counted."""
+    return sum(T["x1e6"] or 0 for T in turns)
+
+
+# ---- human messages: transcripts first, claude-mem user_prompts only for sessions without a box transcript ----
+def load_prompt_rows(db, scope):
+    cols = "content_session_id, prompt_text, created_at_epoch, coalesce(origin_device_id,'local')"
+    if scope.kind == "session":
+        q = f"SELECT {cols} FROM user_prompts WHERE content_session_id = ?"; args = (scope.session,)
+    else:
+        q = f"SELECT {cols} FROM user_prompts WHERE created_at_epoch >= ? AND created_at_epoch < ?"; args = (scope.S, scope.E)
+    return [dict(session=r[0], text=r[1] or "", ts_ms=r[2], device=r[3]) for r in db.execute(q, args)]
+
+
+def human_messages(sessions, prompt_rows):
+    """Per content_session_id: [{ts_ms, text, author, source}] ordered. Sessions with a box transcript
+    use its tagged user turns; other sessions (Mac replica, remote) use the tagged user_prompts rows."""
+    msgs = collections.defaultdict(list); tags = collections.Counter()
+    for sid, S in sessions.items():
+        for u in S["users"]:
+            if u["author"] == "tool": continue
+            tags[u["author"]] += 1
+            msgs[sid].append(dict(ts_ms=u["ts_ms"], text=u["text"], author=u["author"], source="transcript"))
+    for r in prompt_rows:
+        if r["session"] in sessions: continue
+        a = tag_prompt_row(r["text"]); tags[a] += 1
+        msgs[r["session"]].append(dict(ts_ms=r["ts_ms"], text=r["text"], author=a, source="user_prompts", device=r["device"]))
+    for v in msgs.values(): v.sort(key=lambda m: m["ts_ms"])
+    return msgs, dict(human=tags["human"], bot=tags["bot"], unknown=tags["unknown"])
+
+
+# ---- episodes (plan 2B.1, 2B.2) ----
+def episode_id(session, first_ts):
+    return "EP-" + hashlib.sha1(f"{session}|{first_ts}".encode()).hexdigest()[:10]
+
+
+def find_episodes(msgs, phrase_hit=None):
+    """Frustrated human-tagged messages in one session with gaps ≤45 min form one episode. A human message
+    that matches a pattern's own human phrase (2B.3) is a candidate too; the pattern detector is its confirmation."""
+    eps = []
+    for sid, ms in msgs.items():
+        cur = None
+        for m in ms:
+            if m["author"] != "human" or not (is_frustrated(m["text"]) or (phrase_hit and phrase_hit(m["text"]))): continue
+            if cur and m["ts_ms"] - cur["messages"][-1]["ts_ms"] <= GAP_MIN * 60_000: cur["messages"].append(m)
+            else:
+                cur = dict(session=sid, messages=[m]); eps.append(cur)
+    for e in eps:
+        e["episode_id"] = episode_id(e["session"], e["messages"][0]["ts_ms"])
+        e["first_ts"] = e["messages"][0]["ts_ms"]; e["last_ts"] = e["messages"][-1]["ts_ms"]
+    return eps
+
+
+def episode_windows(ep, S, all_msgs):
+    """wasted = turns from the previous human prompt to the first frustrated message (cap 6h);
+    redo = turns in the 60 min after the last message. Same session only (MI:9)."""
+    if S is None: return [], [], None
+    prev = [m["ts_ms"] for m in all_msgs.get(ep["session"], []) if m["ts_ms"] < ep["first_ts"] and m["author"] in ("human", "bot", "unknown")]
+    start = max(prev) if prev else ep["first_ts"] - WASTED_CAP_MS
+    start = max(start, ep["first_ts"] - WASTED_CAP_MS)
+    turns = ordered_turns(S)
+    wasted = [T for T in turns if start <= T["ts_ms"] < ep["first_ts"]]
+    redo = [T for T in turns if ep["last_ts"] < T["ts_ms"] <= ep["last_ts"] + REDO_MS]
+    before = [T["ts_ms"] for T in turns if T["ts_ms"] < ep["first_ts"]]
+    last_agent = max(before) if before else None
+    return wasted, redo, last_agent
+
+
+def alex_minutes(ep, last_agent_ts):
+    """time since the last agent output before the complaint (cap 60) + episode span + 1 min per message (MI:10)."""
+    wait = min(ALEX_WAIT_CAP_MIN, (ep["first_ts"] - last_agent_ts) / 60_000) if last_agent_ts else 0
+    span = (ep["last_ts"] - ep["first_ts"]) / 60_000
+    return round(wait + span + len(ep["messages"]), 1)
+
+
+def pt_iso(ms):
+    return dt.datetime.fromtimestamp(ms / 1000, PT).isoformat(timespec="minutes")
+
+
+def day_pt(ms):
+    return dt.datetime.fromtimestamp(ms / 1000, PT).strftime("%Y-%m-%d")
+
+
+# ---- failure-signal turn spans (plan 2B.9) ----
+def failure_spans(S, msgs):
+    """Rework / Wrong turn = turns from the user message before the corrected work up to the
+    steer/reset/correction message; Recovery after miss = turns from the miss to the first successful
+    tool result after it; Looping is handled by S1. Returns {failure_type: set(keys)}."""
+    turns = ordered_turns(S); out = collections.defaultdict(set)
+    users = [u for u in S["users"] if u["text"] and not u["results"]]
+    for i, u in enumerate(users):
+        if CORRECTION.search(u["text"]):
+            prev = users[i - 1]["ts_ms"] if i else (u["ts_ms"] - WASTED_CAP_MS)
+            for T in turns:
+                if prev <= T["ts_ms"] < u["ts_ms"]: out["Rework"].add(T["key"])
+    miss_at = None
+    for u in S["users"]:
+        for r in u["results"]:
+            if miss_at is None and (r["is_error"] and MISS_RE.search(r["content"] or "")): miss_at = u["ts_ms"]
+            elif miss_at is not None and not r["is_error"]:
+                for T in turns:
+                    if miss_at <= T["ts_ms"] <= u["ts_ms"]: out["Recovery after miss"].add(T["key"])
+                miss_at = None
+    return out

package/openclaw/skills/agent-cost-report/scripts/acr/classify.py

@@ -0,0 +1,83 @@
+"""Optional cheap classifier pass (plan 2B.4; G5 and G8 settled): OFF by default, enabled per run with
+--classify, hard cap $2.00 per run, regular inference OPENROUTER_API_KEY only (never a management key,
+never read from a settings file). It only sees candidates the heuristics could not settle. Its own
+spend is reported separately ("classifier cost (separate)") and never added to agent cost.
+
+Run path: OpenRouter chat completions (OpenAI-compatible, https://openrouter.ai/docs/api-reference/chat-completion),
+urllib only. Input per candidate: the flagged text plus one message before and after, scrubbed, cut to
+1,500 characters. Output JSON {label: yes|no|unsure, pattern, reason (≤20 words)}.
+"""
+import json
+import os
+import random
+import urllib.request
+
+from . import behavior, costs
+
+DEFAULT_MODEL = "anthropic/claude-haiku-4.5"
+CAP_USD = 2.00
+URL = "https://openrouter.ai/api/v1/chat/completions"
+CANDIDATE_CHARS = 1500
+EST_IN_TOKENS = 1600   # plan 2B.4 sizing
+EST_OUT_TOKENS = 60
+QUESTIONS = {
+    "frustration": "Is this human message a genuine complaint about the agent's work? Answer yes or no.",
+    "P1_invented_gates": "Was this a real gate (something only Alex can do: cold Allow click, payment method, wet-ink signature, phone 2FA) or an invented one? yes = invented.",
+    "P4_over_engineering": "Was the extra scope asked for? yes = NOT asked for (over-engineering).",
+    "P5_not_asked": "Do the actions match the last human instruction? yes = they do NOT match.",
+    "P6_fake_output": "Is each number in this text sourced from a tool result shown? yes = unsourced.",
+    "P12_unclear": "Which pattern (P1..P11) does this complaint belong to, if any?",
+    "S2_hedging": "Was the answer already available to the agent when it hedged? yes = available (hedge counts).",
+    "praise": "Is this praise sincere (yes) or sarcastic (no)?",
+}
+
+
+class ClassifierError(RuntimeError):
+    pass
+
+
+def estimate_usd(n, rate):
+    return costs.usd(int(n * (EST_IN_TOKENS * rate["input_usd_per_mtok"] + EST_OUT_TOKENS * rate["output_usd_per_mtok"])))
+
+
+def _call(model, prompt, key, url=URL, timeout=60):
+    body = json.dumps(dict(model=model, max_tokens=120, temperature=0,
+                           messages=[dict(role="system", content="Reply with one JSON object: {\"label\": \"yes|no|unsure\", \"pattern\": \"...\", \"reason\": \"<=20 words\"}"),
+                                     dict(role="user", content=prompt)])).encode()
+    req = urllib.request.Request(url, data=body, headers={"Authorization": f"Bearer {key}", "Content-Type": "application/json"})
+    with urllib.request.urlopen(req, timeout=timeout) as resp: d = json.load(resp)
+    u = d.get("usage") or {}
+    txt = ((d.get("choices") or [{}])[0].get("message") or {}).get("content") or "{}"
+    try: out = json.loads(txt[txt.find("{"): txt.rfind("}") + 1])
+    except Exception: out = dict(label="unsure", pattern=None, reason="unparseable")
+    return out, int(u.get("prompt_tokens") or 0), int(u.get("completion_tokens") or 0)
+
+
+def run(candidates, rate, model=DEFAULT_MODEL, cap_usd=CAP_USD, key=None, call=_call, seed=0):
+    """candidates: [{id, kind, text, before, after}]. Returns (labels {id: {...}}, summary).
+    Prints the estimate first; over the cap it classifies a stratified random sample and scales up."""
+    key = key if key is not None else os.environ.get("OPENROUTER_API_KEY")
+    if not key: raise ClassifierError("OPENROUTER_API_KEY is not set (regular inference key, G5); classifier not run")
+    if not rate: raise ClassifierError(f"no list price for {model}; classifier not run")
+    est = estimate_usd(len(candidates), rate); sampled = False; chosen = list(candidates)
+    print(f"classifier: {len(candidates)} candidates, estimated ${est:.2f} at list, cap ${cap_usd:.2f}")
+    if est > cap_usd:
+        per = estimate_usd(1, rate) or 0.001; n = max(1, int(cap_usd / per * 0.9))
+        rnd = random.Random(seed); by_kind = {}
+        for c in candidates: by_kind.setdefault(c["kind"], []).append(c)
+        chosen = []
+        for kind, cs in by_kind.items():
+            k = max(1, round(n * len(cs) / len(candidates))); chosen += rnd.sample(cs, min(k, len(cs)))
+        sampled = True
+    labels = {}; spent = 0; in_tok = out_tok = 0; last = 0; stopped = False
+    cap_x1e6 = int(round(cap_usd * 1e6)); per_x1e6 = int(EST_IN_TOKENS * rate["input_usd_per_mtok"] + EST_OUT_TOKENS * rate["output_usd_per_mtok"])
+    for c in chosen:
+        if spent + max(per_x1e6, last) > cap_x1e6: stopped = True; break         # hard stop: never send a request the cap cannot pay for
+        prompt = f"{QUESTIONS.get(c['kind'], QUESTIONS['P12_unclear'])}\n\nBEFORE: {behavior.scrub(c.get('before',''), 400)}\nFLAGGED: {behavior.scrub(c['text'], CANDIDATE_CHARS)}\nAFTER: {behavior.scrub(c.get('after',''), 400)}"
+        out, i, o = call(model, prompt, key); in_tok += i; out_tok += o
+        last = int(i * rate["input_usd_per_mtok"] + o * rate["output_usd_per_mtok"]); spent += last
+        labels[c["id"]] = dict(label=out.get("label", "unsure"), pattern=out.get("pattern"), reason=str(out.get("reason", ""))[:120], label_source="classifier")
+    scale = (len(candidates) / len(labels)) if (sampled and labels) else 1.0
+    return labels, dict(ran=True, model=model, spend_usd=costs.usd(spent), cap_usd=cap_usd, sampled_n=len(labels) if sampled else 0,
+                        candidates_n=len(candidates), estimated_usd=est, scale=round(scale, 2), input_tokens=in_tok, output_tokens=out_tok, stopped_at_cap=stopped,
+                        note="estimated from a sample of %d" % len(labels) if sampled else None)

package/openclaw/skills/agent-cost-report/scripts/acr/costs.py

@@ -0,0 +1,121 @@
+"""Agent cost from measured tokens, observer cost kept apart, extrapolation (plan Phase 2.2).
+
+api_equiv() copied from /workspace/weekly-cost-workflow/weekly_report.py:91-105 with the Phase 1
+rate() (1h cache writes at the listed cache_write_1h, else 2 x input). Money is accumulated in
+integer micro-dollars (tokens x USD/MTok is exactly micro-dollars). The observer (note-taker) cost
+is priced at the input rate only (:70-73) and lives only in spend.observer_note_taker_est_usd.
+Extrapolation copied from :239-246. Unpriced = rate() None, output price None, or any negative price
+(OpenRouter lists -1 for a few variable routers): such rows are never multiplied.
+"""
+import collections
+
+from . import prices as prices_mod
+
+TOKEN_FIELDS = ("input", "output", "cache_write_5m", "cache_write_1h", "cache_read")
+PRICE_FIELDS = ("input_usd_per_mtok", "output_usd_per_mtok", "cache_read", "cache_write", "cache_write_1h")
+
+
+def usable_rate(rt):
+    """A rate is usable only when every price is present and non-negative."""
+    if not rt: return False
+    return all(rt.get(f) is not None and rt[f] >= 0 for f in PRICE_FIELDS)
+
+
+def api_equiv_x1e6(r, rt):
+    """copied from weekly_report.py:91-105 (integer micro-dollars); None when unpriced."""
+    if not usable_rate(rt): return None
+    i = rt["input_usd_per_mtok"]
+    return int(round(r["input"] * i + r["output"] * rt["output_usd_per_mtok"] + r["cache_write_5m"] * rt["cache_write"]
+                     + r["cache_write_1h"] * rt["cache_write_1h"] + r["cache_read"] * rt["cache_read"]))
+
+
+def price_block(rt):
+    """model_prices_usd_per_mtok for a line item / by_model row."""
+    if not rt: return None
+    return dict(input=rt["input_usd_per_mtok"], output=rt["output_usd_per_mtok"], cache_read=rt["cache_read"],
+                cache_write=rt["cache_write"], cache_write_1h=rt["cache_write_1h"], key=rt["key"], price_source=rt["price_source"])
+
+
+class Pricer:
+    """rate() with a per-model cache and the unpriced register."""
+    def __init__(self, prices):
+        self.models = prices["models"]; self._cache = {}
+        self.unpriced = collections.defaultdict(lambda: collections.defaultdict(collections.Counter))   # model -> role -> {calls, tokens}
+
+    def rate(self, model):
+        if model not in self._cache: self._cache[model] = prices_mod.rate(model, self.models)
+        return self._cache[model]
+
+    def usable(self, model):
+        return usable_rate(self.rate(model))
+
+    def reason(self, model):
+        rt = self.rate(model)
+        if rt is None: return "not in price list"
+        if rt.get("output_usd_per_mtok") is None: return "no output price listed"
+        return "negative (variable) price listed"
+
+    def observer_input_rate(self, model):
+        """USD/MTok input rate for the note-taker model, or None (then the tokens are registered as unpriced)."""
+        rt = self.rate(model)
+        if rt is None or rt["input_usd_per_mtok"] is None or rt["input_usd_per_mtok"] < 0: return None
+        return rt["input_usd_per_mtok"]
+
+    def unpriced_list(self):
+        return [dict(model=m, role=role, calls=c["calls"], tokens=c["tokens"], reason=self.reason(m))
+                for m, roles in sorted(self.unpriced.items()) for role, c in sorted(roles.items())]
+
+
+def _zero():
+    c = collections.Counter(); c.update({f: 0 for f in TOKEN_FIELDS}); return c
+
+
+def price_rows(rows, pricer):
+    """Accumulate usage rows per transcript session and per (src, model) (weekly_report.py:98-105).
+    Returns (by_session, by_model, stamps_by_session). Unpriced rows count tokens and calls but no dollars."""
+    by_session = collections.defaultdict(_zero); by_model = collections.defaultdict(_zero); stamps = collections.defaultdict(list)
+    for r in rows:
+        rt = pricer.rate(r["model"]); c = api_equiv_x1e6(r, rt)
+        for tgt in (by_session[r["session"]], by_model[(r["src"], r["model"])]):
+            for f in TOKEN_FIELDS: tgt[f] += r[f]
+            tgt["calls"] += 1
+            if c is None: tgt["unpriced_calls"] += 1
+            else: tgt["usd_x1e6"] += c
+        if c is None:
+            u = pricer.unpriced[r["model"] or "<none>"]["agent"]; u["calls"] += 1; u["tokens"] += sum(r[f] for f in TOKEN_FIELDS)
+        stamps[r["session"]].append(r["ts"])
+        # per-session dominant model (by output tokens) for the line item's `model` field
+        by_session[r["session"]]["model:" + (r["model"] or "")] += r["output"]
+    return by_session, by_model, stamps
+
+
+def dominant_model(counter):
+    ms = [(v, k[6:]) for k, v in counter.items() if k.startswith("model:")]
+    return max(ms)[1] if ms else None
+
+
+def usd(x1e6):
+    return round(x1e6 / 1e6, 2)
+
+
+def extrapolation(items):
+    """copied from weekly_report.py:239-246: ratio = measured agent USD per 1M observer tokens over sessions
+    with a transcript, applied to the observer tokens of sessions with none. Only those sessions are touched.
+    items: line-item dicts with has_transcript, observer_tokens, cost_x1e6 (measured micro-dollars)."""
+    # transcripts with no claude-mem session (orphan=True) have no observer tokens and stay out of the ratio (weekly_report.py:239-246 basis)
+    m_obs = sum(i["observer_tokens"] for i in items if i["has_transcript"] and not i.get("orphan"))
+    m_usd = sum(i["cost_x1e6"] for i in items if i["has_transcript"] and not i.get("orphan")) / 1e6
+    u_obs = sum(i["observer_tokens"] for i in items if not i["has_transcript"])
+    ratio = m_usd / m_obs * 1e6 if m_obs else None
+    total = 0
+    for i in items:
+        if not i["has_transcript"] and ratio is not None:
+            i["extrapolated_x1e6"] = int(round(i["observer_tokens"] * ratio)); total += i["extrapolated_x1e6"]
+        else:
+            i["extrapolated_x1e6"] = 0
+    n_un = sum(1 for i in items if not i["has_transcript"])
+    if n_un == 0 and items: return 0.0, "all sessions measured (no extrapolation needed)", ratio      # plan 5.4: say so, never drop the line silently
+    basis = (f"EXTRAPOLATED (low confidence): on this box, measured sessions cost ${ratio:.2f} API-equivalent per 1M observer tokens; "
+             f"applied to {u_obs:,} observer tokens from {n_un} sessions with no transcript here (remote devices). "
+             f"Assumes remote work looks like box work.") if ratio is not None else "n/a (no measured session to derive a ratio from)"
+    return (round(total / 1e6, 2) if ratio is not None else None), basis, ratio

package/openclaw/skills/agent-cost-report/scripts/acr/devices.py

@@ -0,0 +1,88 @@
+"""Phase 5: per-device transcript export and merge (plan 5.2), so Mac sessions can move from
+"extrapolated (low confidence)" to measured tokens without any transcript leaving the machine.
+
+Export (runs on the machine that owns the transcripts): the Phase 1 collector rows for the window plus
+that machine's local sdk_sessions map {memory_session_id -> content_session_id, project, started_at_epoch},
+read from a read-only snapshot of its local claude-mem.db. Only ids, timestamps, token counts and model
+names: no prompt text, no observation text, no settings, no file paths.
+
+Merge (runs on the box): rows join to box-side sessions on memory_session_id (fallback content_session_id);
+joined sessions flip from cost_basis extrapolated to estimated_usage with device=<label>. Whatever stays
+unmeasured is extrapolated again and keeps its low-confidence label. Rows that match no box session are
+counted as unmatched, like any other transcript.
+"""
+import datetime as dt
+import json
+import os
+import platform
+
+from . import period, snapshot
+
+ROW_FIELDS = ("src", "session", "sidechain", "model", "ts", "input", "output", "cache_write", "cache_write_1h", "cache_write_5m", "cache_read", "cost_usd_reported")
+FORBIDDEN = ("text", "prompt", "content", "title", "file", "cwd", "settings")
+
+
+def export(label, usage_doc, outdir, window_block, live_db=None):
+    """Write <outdir>/device-usage-<label>.json from a collect() document and the local DB. The DB
+    snapshot is removed afterwards so the export directory holds only the small file."""
+    rows = [dict({k: r.get(k) for k in ROW_FIELDS}, device=label) for r in usage_doc["rows"]]
+    snap = snapshot.snapshot(outdir, live=live_db); db = snapshot.open_snapshot(snap)
+    try:
+        ids = sorted({r["session"] for r in rows if r["session"]})
+        q = "select memory_session_id, content_session_id, project, started_at_epoch from sdk_sessions where "
+        if window_block.get("start_epoch_ms") is not None:
+            cur = db.execute(q + "started_at_epoch >= ? and started_at_epoch < ?", (window_block["start_epoch_ms"], window_block["end_epoch_ms"]))
+        else:
+            cur = db.execute(q + f"content_session_id in ({','.join('?' * len(ids))})", ids) if ids else []
+        sessions = {r[0]: dict(content_session_id=r[1], project=r[2], started_at_epoch=r[3]) for r in cur if r[0]}
+    finally:
+        db.close()
+        try: os.remove(snap)
+        except OSError: pass
+    doc = dict(device=label, host_label=platform.node(), exported_at_pt=period.now_pt().strftime("%Y-%m-%d %H:%M PT"), window=window_block,
+               rows=rows, sessions=sessions, contents="usage rows (ids, timestamps, token counts, model names) and the local session id map; no text",
+               behavior_export=None)   # per-session pattern counts / episode windows may be added later (plan 5.2, numbers only)
+    assert not any(k in r for r in rows for k in FORBIDDEN)
+    path = os.path.join(outdir, f"device-usage-{label}.json")
+    with open(path, "w") as fh: json.dump(doc, fh)
+    return path, doc
+
+
+def load(path):
+    with open(path) as fh: d = json.load(fh)
+    for k in ("device", "window", "rows", "sessions"):
+        if k not in d: raise ValueError(f"{path}: not a device-usage export (missing {k})")
+    bad = [k for r in d["rows"] for k in FORBIDDEN if k in r]
+    if bad: raise ValueError(f"{path}: export carries forbidden fields {sorted(set(bad))}")
+    return d
+
+
+def merge(rows, exports, sess, window_block):
+    """Append exported rows to `rows`, re-keyed to the box session's content_session_id when the export's
+    memory_session_id (or content id) is known on the box. Returns a summary per export."""
+    by_mem = {mid: v["content_session_id"] for mid, v in sess.items()}
+    by_cs = {v["content_session_id"] for v in sess.values()}
+    seen = {(r["session"], r["ts"], r["input"], r["output"], r["cache_read"]) for r in rows}
+    S, E = window_block.get("start_epoch_ms"), window_block.get("end_epoch_ms")           # None for a --session run (no period)
+    out = []
+    for d in exports:
+        label = d["device"]; mem_by_cs = {v["content_session_id"]: mid for mid, v in d["sessions"].items()}
+        joined = unmatched = dup = outside = 0
+        for r in d["rows"]:
+            if S is not None and not (S <= _ts_ms(r["ts"]) < E): outside += 1; continue    # a wrong-period export never inflates the headline
+            cs = r["session"]; mid = mem_by_cs.get(cs)
+            if mid in by_mem: cs2 = by_mem[mid]; joined += 1
+            elif cs in by_cs: cs2 = cs; joined += 1
+            else: cs2 = cs; unmatched += 1
+            key = (cs2, r["ts"], r["input"], r["output"], r["cache_read"])
+            if key in seen: dup += 1; continue
+            seen.add(key)
+            rows.append(dict(r, session=cs2, device=label, file=None, dir=f"device:{label}", cwd=None, export_memory_session_id=mid, export_session=cs))
+        same_window = (d["window"].get("start_pt"), d["window"].get("end_exclusive_pt")) == (window_block.get("start_pt"), window_block.get("end_exclusive_pt"))
+        out.append(dict(device=label, host_label=d.get("host_label"), exported_at_pt=d.get("exported_at_pt"), rows=len(d["rows"]), joined=joined, unmatched=unmatched, duplicates_skipped=dup,
+                        outside_window=outside, window=d["window"], window_matches_report=same_window))
+    return out
+
+
+def _ts_ms(iso):
+    return int(dt.datetime.fromisoformat(iso).timestamp() * 1000)