claude-finops 0.7.2 → 0.8.0

package/finops/etl.py

@@ -5,6 +5,7 @@ Entities: account -> billing_period -> project -> session -> prompt -> request
 transcripts are stored as NULL and rendered as "Unavailable from connected Claude
 data" by the UI.
 """
+import hashlib
 import json
 import os
 import re
@@ -18,6 +19,20 @@ from .pricing import Pricing
 from .paths import ROOT, DB_PATH
 DEFAULT_SOURCE = os.path.expanduser("~/.claude/projects")
 
+SCHEMA_VERSION = 3   # 3: cross-session request_id dedup (resumed sessions copy history)
+
+
+def needs_rebuild(db_path):
+    if not os.path.exists(db_path):
+        return True
+    try:
+        con = sqlite3.connect(db_path)
+        row = con.execute("SELECT value FROM meta WHERE key='schema_version'").fetchone()
+        con.close()
+    except sqlite3.Error:
+        return True
+    return not row or row[0] != str(SCHEMA_VERSION)
+
 SCHEMA = """
 PRAGMA journal_mode=WAL;
 
@@ -88,6 +103,8 @@ CREATE TABLE requests (
   context_tokens INTEGER,    -- input + cache read + cache write  (prompt side)
   est_cost_usd REAL,
   est_cost_no_cache_usd REAL,
+  priced_as TEXT,            -- price list used; differs from model for long context
+  unpriced_long_context INTEGER DEFAULT 0,  -- over the window with no [1m] price to use
   latency_ms REAL,
   tool_call_count INTEGER DEFAULT 0,
   is_sidechain INTEGER DEFAULT 0,
@@ -134,6 +151,9 @@ SLASH = re.compile(r"^\s*/([a-z0-9][\w:-]*)(?=\s|$)", re.I)
 CMD_NAME = re.compile(r"<command-name>/?([\w:-]+)</command-name>")
 WS = re.compile(r"\s+")
 
+INJECTED_PREFIXES = ("<task-notification", "<local-command-stdout", "<local-command-caveat",
+                     "<bash-input", "<bash-stdout", "<bash-stderr", "<system-reminder")
+
 
 def _ts(s):
     if not s:
@@ -191,6 +211,9 @@ class Loader:
         self.projects = {}
         self.agent = None
         self.pending_skill = None
+        self.pending_results = {}
+        self.group = None
+        self.seen_request_ids = set()   # dedup request_id across sessions (resumed sessions)
 
     # ---------- infrastructure ----------
     def build(self, verbose=True):
@@ -233,6 +256,7 @@ class Loader:
             ("pricing_updated", str(self.pricing.updated)),
             ("pricing_source", str(self.pricing.source)),
             ("cost_basis", "estimated"),
+            ("schema_version", str(SCHEMA_VERSION)),
         ):
             self.db.execute("INSERT INTO meta VALUES (?,?)", (k, v))
         self.db.commit()
@@ -287,6 +311,8 @@ class Loader:
         session_id = agent["parent"] if agent else os.path.splitext(os.path.basename(path))[0]
         self.agent = agent
         self.pending_skill = None
+        self.pending_results = {}     # tool_use_id -> result chars, applied once the row exists
+        self.group = None
         cwd = next((r.get("cwd") for r in rows if r.get("cwd")), None)
         pid = self.project_id(slug, cwd)
         title = next((r.get("aiTitle") for r in rows if r.get("type") == "ai-title"), None)
@@ -301,37 +327,64 @@ class Loader:
 
         cur_prompt = None
         prev_time = None
-
-        for r in rows:
-            typ = r.get("type")
-            ts = r.get("timestamp")
-            t = _ts(ts)
-
-            if typ == "user":
-                msg = r.get("message") or {}
-                self.record_results(r, msg)
-                # tool results and meta lines are not human prompts
-                if r.get("toolUseResult") is not None or r.get("isMeta"):
+        self.group = None          # {"key", "lines": [...], "prev_time", "prompt_id"}
+
+        def flush():
+            if self.group:
+                self.insert_request(self.group["lines"], session_id, pid, self.group["prompt_id"],
+                                    self.group["prev_time"])
+                self.group = None
+
+        try:
+            for r in rows:
+                typ = r.get("type")
+                ts = r.get("timestamp")
+                t = _ts(ts)
+
+                if typ == "user":
+                    msg = r.get("message") or {}
+                    self.record_results(r, msg)
+                    # tool results and meta lines are not human prompts, and must not
+                    # split a request that is still waiting on its tool results
+                    if r.get("toolUseResult") is not None or r.get("isMeta"):
+                        prev_time = t or prev_time
+                        continue
+                    text = _text_of(msg.get("content"))
+                    if text.lstrip().startswith(INJECTED_PREFIXES):
+                        prev_time = t or prev_time
+                        continue
+                    if agent:
+                        prev_time = t or prev_time
+                        continue
+                    if not text.strip():
+                        prev_time = t or prev_time
+                        continue
+                    flush()
+                    cur_prompt = self.insert_prompt(r, text, session_id, pid)
                     prev_time = t or prev_time
-                    continue
-                text = _text_of(msg.get("content"))
-                if agent:
-                    prev_time = t or prev_time
-                    continue
-                if not text.strip():
-                    prev_time = t or prev_time
-                    continue
-                cur_prompt = self.insert_prompt(r, text, session_id, pid)
-                prev_time = t or prev_time
 
-            elif typ == "assistant":
-                if agent and cur_prompt is None:
-                    cur_prompt = self.parent_prompt(session_id, r.get("timestamp"))
-                self.insert_request(r, session_id, pid, cur_prompt, prev_time)
-                prev_time = t or prev_time
+                elif typ == "assistant":
+                    if agent and cur_prompt is None:
+                        cur_prompt = self.parent_prompt(session_id, r.get("timestamp"))
+                    key = (r.get("requestId") or (r.get("message") or {}).get("id") or r.get("uuid"))
+                    if self.group and self.group["key"] == key:
+                        self.group["lines"].append(r)
+                    else:
+                        flush()
+                        self.pending_skill = None   # never apply a stale skill id to a new group
+                        self.group = {"key": key, "lines": [r], "prev_time": prev_time,
+                                      "prompt_id": cur_prompt}
+                    prev_time = t or prev_time
 
-            elif typ in ("attachment", "system"):
-                prev_time = t or prev_time
+                elif typ in ("attachment", "system"):
+                    prev_time = t or prev_time
+        finally:
+            flush()
+            # any result whose tool_calls row was inserted by an earlier flush
+            for tool_use_id, n in self.pending_results.items():
+                self.db.execute("UPDATE tool_calls SET result_chars=? WHERE tool_use_id=?",
+                                (n, tool_use_id))
+            self.pending_results = {}
 
     def parent_prompt(self, session_id, ts):
         row = self.db.execute("SELECT id FROM prompts WHERE session_id=? AND ts<=? "
@@ -341,19 +394,34 @@ class Loader:
     def record_results(self, r, msg):
         """Size of tool results, and of skill bodies injected as meta messages."""
         content = msg.get("content")
-        if r.get("isMeta") and getattr(self, "pending_skill", None):
-            self.db.execute("UPDATE tool_calls SET result_chars=result_chars+? WHERE id=?",
-                            (len(_text_of(content)), self.pending_skill))
-            self.pending_skill = None
-            return
+        if r.get("isMeta"):
+            if self.group:
+                # the Skill's body can arrive before the group holding its tool_use
+                # flushes; stash it under that block's tool_use_id so insert_request
+                # applies it once the tool_calls row exists.
+                tool_use_id = None
+                for ln in self.group["lines"]:
+                    for c in ((ln.get("message") or {}).get("content") or []):
+                        if isinstance(c, dict) and c.get("type") == "tool_use" and c.get("name") == "Skill":
+                            tool_use_id = c.get("id")
+                if tool_use_id:
+                    n = len(_text_of(content))
+                    self.pending_results[tool_use_id] = self.pending_results.get(tool_use_id, 0) + n
+                return
+            if getattr(self, "pending_skill", None):
+                self.db.execute("UPDATE tool_calls SET result_chars=result_chars+? WHERE id=?",
+                                (len(_text_of(content)), self.pending_skill))
+                self.pending_skill = None
+                return
         if not isinstance(content, list):
             return
         for c in content:
             if isinstance(c, dict) and c.get("type") == "tool_result":
                 body = c.get("content")
                 n = len(body) if isinstance(body, str) else _result_chars(body)
-                self.db.execute("UPDATE tool_calls SET result_chars=? WHERE tool_use_id=?",
-                                (n, c.get("tool_use_id")))
+                # the tool_calls row for this id may not exist yet: its request is
+                # still an open group and is only inserted when it flushes
+                self.pending_results[c.get("tool_use_id")] = n
 
     def insert_prompt(self, r, text, session_id, pid):
         cat, conf, ev = classify(text)
@@ -363,19 +431,23 @@ class Loader:
             src = f"slash:/{m.group(1)}"
             cat = cat if cat != "other" else "automation"
         ts = r.get("timestamp")
-        norm = WS.sub(" ", text.strip().lower())[:500]
+        norm = WS.sub(" ", text.strip().lower())
+        norm_hash = hashlib.sha1(norm.encode("utf-8")).hexdigest()[:16]
         cur = self.db.execute(
             "INSERT INTO prompts (uuid, session_id, project_id, ts, day, text, char_len,"
             " word_len, category, category_confidence, category_evidence, source, norm_hash)"
             " VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?)",
             (r.get("uuid"), session_id, pid, ts, (ts or "")[:10], text, len(text),
-             len(text.split()), cat, conf, json.dumps(ev), src, str(hash(norm))))
+             len(text.split()), cat, conf, json.dumps(ev), src, norm_hash))
         return cur.lastrowid
 
-    def insert_request(self, r, session_id, pid, prompt_id, prev_time):
+    def insert_request(self, lines, session_id, pid, prompt_id, prev_time):
+        first, last = lines[0], lines[-1]
+        r = last                                  # stop_reason / usage from the final line
         msg = r.get("message") or {}
         u = msg.get("usage") or {}
         model = msg.get("model") or "unknown"
+        speed = u.get("speed")
         inp = int(u.get("input_tokens") or 0)
         out = int(u.get("output_tokens") or 0)
         think = int((u.get("output_tokens_details") or {}).get("thinking_tokens") or 0)
@@ -389,11 +461,33 @@ class Loader:
         billable = inp + out + cr + cw
         context = inp + cr + cw
 
-        cost = self.pricing.estimate(model, inp, out, cr, c5, c1)
-        no_cache_part, cache_part = self.pricing.uncached_baseline(model, cr, c5, c1)
+        # Price against the variant the context proves was used, not just the name in
+        # the transcript: anything above the standard window was the long-context
+        # variant and is billed at a premium.
+        priced_as, unpriced_long = self.pricing.effective_model(model, context, speed=speed)
+        cost = self.pricing.estimate(priced_as, inp, out, cr, c5, c1)
+        no_cache_part, cache_part = self.pricing.uncached_baseline(priced_as, cr, c5, c1)
         cost_no_cache = cost - cache_part + no_cache_part
 
-        ts = r.get("timestamp")
+        tools, seen = [], set()
+        for ln in lines:
+            for c in ((ln.get("message") or {}).get("content") or []):
+                if isinstance(c, dict) and c.get("type") == "tool_use" and c.get("id") not in seen:
+                    seen.add(c.get("id"))
+                    tools.append(c)
+
+        if billable == 0 and not tools:
+            return
+
+        request_id = first.get("requestId") or msg.get("id")
+        if request_id and request_id in self.seen_request_ids:
+            # resumed sessions copy earlier history verbatim, including request_ids
+            # already inserted from another session; keep only the first occurrence.
+            return
+        if request_id:
+            self.seen_request_ids.add(request_id)
+
+        ts = first.get("timestamp")               # the request started at its first line
         t = _ts(ts)
         latency = None
         if t and prev_time:
@@ -401,25 +495,24 @@ class Loader:
             if 0 <= d <= 900_000:    # ignore idle gaps > 15 min, they are not latency
                 latency = d
 
-        tools = [c for c in (msg.get("content") or [])
-                 if isinstance(c, dict) and c.get("type") == "tool_use"]
-
         cur = self.db.execute(
             "INSERT INTO requests (uuid, request_id, session_id, project_id, prompt_id,"
             " ts, day, hour, model, model_known, effort, service_tier, stop_reason,"
             " input_tokens, output_tokens, thinking_tokens, cache_read_tokens,"
             " cache_write_5m, cache_write_1h, cache_write_tokens, billable_tokens,"
-            " context_tokens, est_cost_usd, est_cost_no_cache_usd, latency_ms,"
+            " context_tokens, est_cost_usd, est_cost_no_cache_usd,"
+            " priced_as, unpriced_long_context, latency_ms,"
             " tool_call_count, is_sidechain, agent_id, agent_type, agent_desc)"
-            " VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)",
-            (r.get("uuid"), r.get("requestId"), session_id, pid, prompt_id, ts,
-             (ts or "")[:10], (t.hour if t else None), model,
-             1 if self.pricing.is_known(model) else 0, r.get("effort"),
+            " VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)",
+            (first.get("uuid"), request_id, session_id, pid,
+             prompt_id, ts, (ts or "")[:10], (t.hour if t else None), model,
+             1 if self.pricing.is_known(model) else 0, first.get("effort"),
              u.get("service_tier"), msg.get("stop_reason"), inp, out, think, cr,
-             c5, c1, cw, billable, context, cost, cost_no_cache, latency,
-             len(tools), 1 if (r.get("isSidechain") or self.agent) else 0,
+             c5, c1, cw, billable, context, cost, cost_no_cache,
+             priced_as, 1 if unpriced_long else 0, latency,
+             len(tools), 1 if (first.get("isSidechain") or self.agent) else 0,
              *((self.agent["id"], self.agent["type"], self.agent["desc"]) if self.agent
-               else (None, "inline" if r.get("isSidechain") else None, None))))
+               else (None, "inline" if first.get("isSidechain") else None, None))))
         rpk = cur.lastrowid
 
         day = (ts or "")[:10]
@@ -449,6 +542,10 @@ class Loader:
                 " VALUES (?,?,?,?,?,?,?,?,?,?,?)",
                 (rpk, session_id, pid, prompt_id, ts, day, name, target, c.get("id"),
                  kind, server))
+            tool_use_id = c.get("id")
+            if tool_use_id in self.pending_results:
+                self.db.execute("UPDATE tool_calls SET result_chars=? WHERE tool_use_id=?",
+                                (self.pending_results.pop(tool_use_id), tool_use_id))
             if kind == "skill":
                 self.pending_skill = self.db.execute("SELECT last_insert_rowid()").fetchone()[0]
             if name in FILE_TOOLS and isinstance(args, dict) and args.get("file_path"):

package/finops/integrate.py

@@ -1,16 +1,14 @@
-"""Live advice inside Claude Code itself: a prompt hook and a statusline.
+"""A statusline inside Claude Code itself, showing model and context usage.
 
-The dashboard can only advise you if you are looking at it. These two run where
-the decision is actually made — the terminal you are typing in.
+  claude-finops --statusline    reads a statusline payload on stdin, prints model + context %
+  claude-finops --install-statusline   wire it into settings
+  claude-finops --hook          retired no-op, kept so existing installs do not error
+  claude-finops --install-hook  prints that the hook is retired and does nothing else
 
-  claude-finops --hook          reads a UserPromptSubmit payload on stdin
-  claude-finops --statusline    reads a statusline payload on stdin
-  claude-finops --install-hook / --install-statusline   wire them into settings
-
-Both are on the path of every prompt, so both are built to be boring: fail
-silent, never block, never take long. A hook that erases someone's prompt
-because a database was locked is a far worse bug than missing advice, so the
-hook never returns a blocking exit code — it exits 0 whatever happens.
+The prompt hook that used to "suggest a cheaper model" is retired: that
+suggestion had no basis — it would have meant repricing work that never ran.
+The statusline is on the path of every prompt, so it is built to be boring:
+fail silent, never block, never take long.
 """
 import json
 import os
@@ -47,49 +45,28 @@ def _dig(d, *paths, default=None):
     return default
 
 
-def _payload_common(d):
-    return (_dig(d, "model", "session.model", "model.id", "model.display_name"),
-            _dig(d, "transcript_path", "session.transcript_path", "transcriptPath"))
-
-
 # -------------------------------------------------------------------- hook ----
 
 def hook():
-    """UserPromptSubmit: judge the prompt in hand, before it is paid for.
-
-    Advice goes to the user as `systemMessage`, not into Claude's context: it is
-    for the person deciding which model to use, and feeding it to the model
-    would just spend tokens telling it about its own price.
-    """
+    """UserPromptSubmit: kept as a no-op so existing installed hooks do not error."""
     try:
-        d = _stdin_json()
-        prompt = _dig(d, "user_prompt", "prompt", default="")
-        model, transcript = _payload_common(d)
-        from .advisor import advise
-        a = advise(model=model, transcript=transcript, prompt=prompt)
-        if a:
-            print(json.dumps({"systemMessage": f"finops: {a['line']}  →  {a['command']}"}))
+        _stdin_json()
     except Exception:
-        pass          # never let advice interfere with the prompt
+        pass
     return 0
 
 
 # -------------------------------------------------------------- statusline ----
 
 def statusline():
-    """One line, refreshed constantly, so: what you are on, and what to try."""
+    """One line, refreshed constantly: model and context usage."""
     try:
         d = _stdin_json()
-        model, transcript = _payload_common(d)
         pct = _dig(d, "context.percentUsed", "context.percent_used")
         name = _dig(d, "model.display_name", "session.model", "model") or "claude"
         bits = [str(name)]
         if isinstance(pct, (int, float)):
             bits.append(f"{pct:.0f}% ctx")
-        from .advisor import advise
-        a = advise(model=model, transcript=transcript)
-        if a:
-            bits.append(a["short"])
         print(" · ".join(bits))
     except Exception:
         print("")     # an empty statusline beats a stack trace under the prompt
@@ -126,26 +103,14 @@ def _save_settings(data):
 
 
 def install_hook(remove=False):
-    cmd = f"{_command()} --hook"
-    s = _load_settings()
-    hooks = s.setdefault("hooks", {}).setdefault("UserPromptSubmit", [])
-    for group in hooks:                       # drop any earlier copy of ours
-        group["hooks"] = [h for h in group.get("hooks", [])
-                          if "--hook" not in str(h.get("command", ""))
-                          or "finops" not in str(h.get("command", ""))]
-    hooks[:] = [g for g in hooks if g.get("hooks")]
-    if not remove:
-        hooks.append({"matcher": "", "hooks": [{"type": "command", "command": cmd,
-                                                "timeout": 10}]})
-    if not hooks:
-        s["hooks"].pop("UserPromptSubmit", None)
-        if not s["hooks"]:
-            s.pop("hooks")
-    _save_settings(s)
-    print(("Removed" if remove else "Installed") + f" the prompt hook in {SETTINGS}")
-    if not remove:
-        print("  It suggests a cheaper model when your own history backs one, before the turn runs.")
-        print("  Start a new Claude Code session to pick it up.  Undo: claude-finops --uninstall-hook")
+    """The prompt hook is retired: it never had a basis for its "cheaper model"
+    suggestion (that would mean repricing work that had not run yet). It is kept
+    as a no-op (see hook() above) so existing installs do not error, but nothing
+    new is installed here.
+    """
+    print("The finops prompt hook has been retired — it made suggestions with no "
+          "basis in your data. Nothing was installed or changed.")
+    print("The statusline (claude-finops --install-statusline) still shows model and context %.")
 
 
 def install_statusline(remove=False):
@@ -164,5 +129,5 @@ def install_statusline(remove=False):
     _save_settings(s)
     print(("Removed" if remove else "Installed") + f" the statusline in {SETTINGS}")
     if not remove:
-        print("  Shows the model, context pressure, and a cheaper model when one is warranted.")
+        print("  Shows the model and context usage percentage.")
         print("  Undo: claude-finops --uninstall-statusline")

package/finops/pricing.py

@@ -5,6 +5,7 @@ produced here is an ESTIMATE. Callers must label it as such.
 """
 import json
 import os
+import re
 
 from .paths import ROOT, PRICING_PATH
 
@@ -13,6 +14,11 @@ M = 1_000_000.0
 
 FREE = {"display_name": None, "tier": "free", "input": 0.0, "output": 0.0, "cache_read": 0.0,
         "cache_write_5m": 0.0, "cache_write_1h": 0.0}
+UNPRICED = dict(FREE, tier="unpriced")
+
+# provider prefixes (bedrock/vertex regions), dated and @version suffixes, bedrock ":0"
+_PREFIX = re.compile(r"^(?:[a-z]{2}(?:-[a-z]+)?\.)?anthropic\.")
+_SUFFIX = re.compile(r"(?:-\d{8}|@\d{8}|-v\d+:\d+|:\d+)+$")
 
 
 class Pricing:
@@ -20,21 +26,40 @@ class Pricing:
         with open(path) as fh:
             self.raw = json.load(fh)
         self.models = self.raw.get("models", {})
-        self.default = self.raw.get("default_model_pricing", {})
+        self.aliases = self.raw.get("aliases", {})
+        self.default = {}          # kept for callers; unknown ids are UNPRICED now
         self.updated = self.raw.get("updated")
         self.source = self.raw.get("source")
 
-    def rates(self, model):
+    def normalize(self, model):
+        """Canonical price-table key for any id Claude Code may record."""
+        if not model:
+            return "unknown"
         if model in self.models:
-            return self.models[model]
+            return model
+        m = _PREFIX.sub("", model)
+        m = _SUFFIX.sub("", m)
+        m = self.aliases.get(m, m)
+        if m in self.models:
+            return m
+        # a dated key in the table for an undated id: claude-haiku-4-5 -> ...-20251001
+        for k in self.models:
+            if k.startswith(m + "-") and re.fullmatch(r"\d{8}", k[len(m) + 1:]):
+                return k
+        return m
+
+    def rates(self, model):
+        m = self.normalize(model)
+        if m in self.models:
+            return self.models[m]
         # An unlisted non-Claude model reached through Claude Code (e.g. a local Ollama or
         # free OpenRouter model via a claude-qwen launcher) has no Anthropic price: $0.
-        if model and not model.startswith("claude") and model not in ("unknown",):
+        if m and not m.startswith("claude") and m != "unknown":
             return FREE
-        return self.default
+        return UNPRICED
 
     def is_known(self, model):
-        return model in self.models
+        return self.normalize(model) in self.models
 
     def display_name(self, model):
         return self.rates(model).get("display_name") or model
@@ -45,6 +70,32 @@ class Pricing:
     def context_window(self, model):
         return self.rates(model).get("context_window")
 
+    def effective_model(self, model, context_tokens=0, speed=None):
+        """The price list that actually applied, given how much context was sent.
+
+        A request whose prompt side exceeds the model's standard context window cannot
+        have been served by the standard variant — it was the long-context one, which
+        is billed at a premium. The transcript records only the base model name, so
+        pricing off that name alone understates every long-context request. Fast mode
+        is billed at its own rate; a `[1m]` premium applies only when the table lists
+        one for this model.
+
+        Returns (model_id_to_price_with, unpriced_long_context). The flag is set when
+        the context clearly exceeded the window but no `[1m]` entry exists to price it
+        with, so callers can surface it rather than quietly bill it at the low rate.
+        """
+        m = self.normalize(model)
+        if speed == "fast" and f"{m}[fast]" in self.models:
+            return f"{m}[fast]", False
+        r = self.models.get(m)
+        win = (r or {}).get("context_window") or 0
+        if not r or not win or not context_tokens or context_tokens <= win:
+            return m, False
+        alt = f"{m}[1m]"
+        if alt in self.models:
+            return alt, False
+        return m, True
+
     def estimate(self, model, input_tokens=0, output_tokens=0, cache_read=0,
                  cache_write_5m=0, cache_write_1h=0):
         """Return estimated USD for one request."""

package/finops/procs.py

@@ -18,11 +18,13 @@ HOME = os.path.expanduser("~")
 REG = os.path.join(HOME, ".claude", "sessions")
 PROJECTS = os.path.join(HOME, ".claude", "projects")
 
-ACTIONS = {
-    "interrupt": (getattr(signal, "CTRL_C_EVENT", signal.SIGINT) if os.name == "nt" else signal.SIGINT, "Interrupted the current turn (like pressing Esc/Ctrl-C)."),
-    "close": (signal.SIGTERM, "Asked the session to exit. Resume it later with `claude --resume`."),
-    "kill": (getattr(signal, "SIGKILL", signal.SIGTERM), "Force-killed the process."),
-}
+ACTIONS = {}
+if os.name != "nt":
+    # On Windows, CTRL_C_EVENT signals the whole console process group, not just
+    # the target process, so there is no safe way to interrupt just one session.
+    ACTIONS["interrupt"] = (signal.SIGINT, "Interrupted the current turn (like pressing Esc/Ctrl-C).")
+ACTIONS["close"] = (signal.SIGTERM, "Asked the session to exit. Resume it later with `claude --resume`.")
+ACTIONS["kill"] = (getattr(signal, "SIGKILL", signal.SIGTERM), "Force-killed the process.")
 
 
 def _ps():