clauddy 1.28.0 → 1.28.1

package/README.md

@@ -286,7 +286,7 @@ Settings saved from the UI live in `~/.claude-usage-monitor/config.json`, so you
   "alertThresholds": [80, 95], // notify when session/week cross these % (two levels)
   "fireThreshold": 90, // session % at which the pet catches fire (maxed out stays 100)
   "pollIntervalMs": 4000, // how often local logs are re-read
-  "activeThresholdMs": 20000, // "active" if Claude wrote to its logs within this window
+  "activeThresholdMs": 20000, // fallback "active" window, for a log whose tail doesn't say whether a turn is open
   "sleepThresholdMs": 300000, // "sleeping" after this much idle time (5 min)
   "codex": { "enabled": false }, // set by Settings → Codex → Connect
   "cursor": { "enabled": false }, // set by Settings → Cursor → Connect

package/cursor.js

@@ -8,7 +8,10 @@ const os = require('node:os')
 // comes from the agent transcripts under ~/.cursor/projects, which log each
 // tool call much like Claude Code's own logs.
 const API = 'https://api2.cursor.sh/aiserver.v1.DashboardService/'
-const ACTIVE_MS = 60000 // a transcript touched within the last minute = Cursor working
+const ACTIVE_MS = 60000 // a transcript that says nothing counts only while it's this fresh
+// an unfinished turn this long without a write was abandoned (Cursor closed mid-run)
+const OPEN_TURN_MS = 30 * 60000
+const RECENT_TRANSCRIPTS = 8
 const FETCH_MS = 5 * 60000 // a monthly budget moves slowly; don't hammer the API
 const RETRY_MS = 60000
 const TAIL_BYTES = 64 * 1024
@@ -169,7 +172,8 @@ const ACTIVITY = {
   AskQuestion: 'waiting',
 }
 
-// what the newest transcript lines say: a finished turn means nothing is running
+// what the newest transcript lines say: a finished turn means nothing is
+// running (null), an open one names its scene, and undefined means no telling
 function activityOf(lines) {
   for (let i = lines.length - 1; i >= 0; i--) {
     let o
@@ -186,7 +190,7 @@ function activityOf(lines) {
     }
     if (o.role === 'user') return 'working' // just asked: the agent is thinking
   }
-  return 'working'
+  return undefined
 }
 
 const dirs = (dir) => {
@@ -232,22 +236,29 @@ function tailLines(file, size) {
   return lines.filter(Boolean)
 }
 
+// A turn stays open while a long command runs or the model thinks, without a
+// write, so an open turn in any recent transcript is Cursor at work. A
+// transcript with nothing to say counts only while it's fresh.
 function readActivity(now) {
-  let latest = null
+  const recent = []
+  let lastSeen = null
   for (const file of transcripts()) {
     try {
       const st = fs.statSync(file)
-      if (!latest || st.mtimeMs > latest.st.mtimeMs) latest = { file, st }
+      if (lastSeen == null || st.mtimeMs > lastSeen) lastSeen = st.mtimeMs
+      if (now - st.mtimeMs < OPEN_TURN_MS) recent.push({ file, st })
     } catch {}
   }
-  if (!latest) return { active: false, activity: null, lastSeen: null }
-  const lastSeen = latest.st.mtimeMs
-  if (now - lastSeen >= ACTIVE_MS) return { active: false, activity: null, lastSeen }
-  let activity = 'working'
-  try {
-    activity = activityOf(tailLines(latest.file, latest.st.size))
-  } catch {}
-  return { active: activity != null, activity, lastSeen }
+  recent.sort((a, b) => b.st.mtimeMs - a.st.mtimeMs)
+  for (const { file, st } of recent.slice(0, RECENT_TRANSCRIPTS)) {
+    let said
+    try {
+      said = activityOf(tailLines(file, st.size))
+    } catch {}
+    const activity = said === undefined ? (now - st.mtimeMs < ACTIVE_MS ? 'working' : null) : said
+    if (activity) return { active: true, activity, lastSeen }
+  }
+  return { active: false, activity: null, lastSeen }
 }
 
 // The poll's view of Cursor: activity from disk every tick, limits from the

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "clauddy",
   "desktopName": "clauddy.desktop",
-  "version": "1.28.0",
+  "version": "1.28.1",
   "description": "A cute desktop pet that tracks your Claude Code usage",
   "main": "main.js",
   "bin": {

package/usage.js

@@ -224,23 +224,30 @@ const ACTIVITY_BY_TOOL = {
   AskUserQuestion: 'waiting',
 }
 
-// Classify what Claude Code is doing right now by reading the tail of the most
-// recently touched session log: the latest tool_use → an activity, plan mode
-// (permission-mode) wins over everything. Returns null when there's no signal.
-function detectActivity(file) {
-  let raw
+// the last lines of a session log (the recent tail is plenty), or null
+function tailLines(file) {
   try {
     const fd = fs.openSync(file, 'r')
-    const size = fs.fstatSync(fd).size
-    const len = Math.min(size, 65536) // last 64KB is plenty for the recent tail
-    const buf = Buffer.alloc(len)
-    fs.readSync(fd, buf, 0, len, size - len)
-    fs.closeSync(fd)
-    raw = buf.toString('utf8')
+    try {
+      const size = fs.fstatSync(fd).size
+      const len = Math.min(size, 65536)
+      const buf = Buffer.alloc(len)
+      fs.readSync(fd, buf, 0, len, size - len)
+      return buf.toString('utf8').split('\n').filter(Boolean)
+    } finally {
+      fs.closeSync(fd)
+    }
   } catch {
     return null
   }
-  const lines = raw.split('\n').filter(Boolean)
+}
+
+// Classify what Claude Code is doing right now by reading the tail of the most
+// recently touched session log: the latest tool_use → an activity, plan mode
+// (permission-mode) wins over everything. Returns null when there's no signal.
+function detectActivity(file) {
+  const lines = tailLines(file)
+  if (!lines) return null
   let activity = null
   let permMode = null
   for (let i = lines.length - 1; i >= 0 && i >= lines.length - 80; i--) {
@@ -265,6 +272,60 @@ function detectActivity(file) {
   return activity
 }
 
+// User lines that open no turn: slash commands and their output, `!` shell
+// input, background-task notices, the compaction summary, meta attachments
+const NO_TURN =
+  /^\s*(<command-name>|<command-message>|<local-command-|<bash-|<task-notification>|This session is being continued)/
+const DONE_STOPS = new Set(['end_turn', 'stop_sequence', 'refusal'])
+const textOf = (content) =>
+  typeof content === 'string'
+    ? content
+    : Array.isArray(content)
+      ? content.map((b) => (b && b.type === 'text' ? b.text : '')).join(' ')
+      : ''
+
+// Is a turn still open? Claude Code writes nothing while a command runs or the
+// model thinks, so a quiet log proves nothing; how it ends does. A final answer
+// (and the turn_duration line after it) or an interruption closes the turn; a
+// tool call, a tool result or a prompt leaves it open. Returns true, false, or
+// null when the tail doesn't say.
+function turnOpen(lines) {
+  for (let i = lines.length - 1; i >= 0; i--) {
+    let o
+    try {
+      o = JSON.parse(lines[i])
+    } catch {
+      continue
+    }
+    if (o.isSidechain) continue
+    if (o.type === 'system') {
+      if (o.subtype === 'turn_duration') return false
+      continue
+    }
+    if (o.type === 'assistant') {
+      const stop = o.message?.stop_reason
+      if (!stop) continue
+      return !DONE_STOPS.has(stop)
+    }
+    if (o.type === 'user') {
+      const content = o.message?.content
+      if (Array.isArray(content) && content.some((b) => b?.type === 'tool_result')) return true
+      if (o.isMeta || o.isCompactSummary) continue
+      const text = textOf(content)
+      if (text.includes('[Request interrupted by user')) return false
+      if (NO_TURN.test(text)) continue
+      return true
+    }
+  }
+  return null
+}
+
+// a turn left open this long without a write was abandoned (a closed
+// terminal, a crash) — or a permission prompt nobody answered
+const OPEN_TURN_MS = 30 * 60000
+// parallel sessions and subagents each keep a log; a handful covers them
+const RECENT_LOGS = 8
+
 // Plan presets (token budgets ~= 100%). Calibrated for Max 5x from the official
 // panel (5h ~24% at 152M tokens, weekly ~62% at 2.14B); Pro/Max20x scaled by the
 // plan multiplier. ESTIMATES — Anthropic doesn't publish exact numbers.
@@ -371,11 +432,31 @@ function getUsage(config) {
   const weekPct = weeklyBudget ? Math.min(100, (weekTokens / weeklyBudget) * 100) : 0
 
   const lastActivityMs = lastMtime ? now - lastMtime : Infinity
-  const active = lastActivityMs <= (config.activeThresholdMs || 20000)
-  const sleeping = lastActivityMs >= (config.sleepThresholdMs || 300000)
+  // Working means a turn is open in one of the recent logs, even when a long
+  // command or a slow answer has kept it quiet for minutes. A log with nothing
+  // to say falls back to the old rule: written in the last few seconds.
+  let openFile = null
+  const recentLogs = files
+    .filter((f) => now - f.st.mtimeMs <= OPEN_TURN_MS)
+    .sort((a, b) => b.st.mtimeMs - a.st.mtimeMs)
+    .slice(0, RECENT_LOGS)
+  let newestSays = null
+  for (const [i, f] of recentLogs.entries()) {
+    const lines = tailLines(f.full)
+    const open = lines ? turnOpen(lines) : null
+    if (i === 0) newestSays = open
+    if (open) {
+      openFile = f.full
+      break
+    }
+  }
+  const quietRule = newestSays === null && lastActivityMs <= (config.activeThresholdMs || 20000)
+  const active = !!openFile || quietRule
+  const sleeping = !active && lastActivityMs >= (config.sleepThresholdMs || 300000)
 
   // what Claude is doing right now (only meaningful while active)
-  const activity = active && newestFile ? detectActivity(newestFile) : null
+  const activeFile = openFile || (quietRule ? newestFile : null)
+  const activity = activeFile ? detectActivity(activeFile) || (openFile ? 'working' : null) : null
 
   const byModelArr = [...byModel.entries()]
     .map(([label, tokens]) => ({ label, tokens }))
@@ -422,5 +503,6 @@ module.exports = {
   projectLabel,
   tokensOf,
   detectActivity,
+  turnOpen,
   PLAN_BUDGETS,
 }