@ghl-ai/aw 0.1.37-beta.75 → 0.1.37-beta.77

package/hooks/capabilities/telemetry.mjs

@@ -124,6 +124,35 @@ function loadPricing() {
 // Loaded once per process (each hook event is a separate node invocation)
 const PRICING = loadPricing();
 
+// ── Cursor stdin normalizer ──────────────────────────────────────────────────
+// Cursor sends a different JSON shape than Claude Code. This function normalizes
+// it to the format our handlers expect, so all handlers work uniformly.
+//
+// Cursor stdin shape:
+//   { conversation_id, generation_id, model, text, hook_event_name,
+//     cursor_version, workspace_roots: ["/path/..."], attachments? }
+//
+// Claude Code stdin shape:
+//   { session_id, transcript_path, cwd, model, status, ... }
+
+function normalizeCursorInput(input) {
+  if (!input.conversation_id && !input.hook_event_name) return input;
+
+  const cwd = input.workspace_roots?.[0]
+    || process.env.CURSOR_PROJECT_DIR
+    || process.cwd();
+
+  return {
+    ...input,
+    session_id: input.conversation_id || input.session_id,
+    cwd,
+    model: (input.model && input.model !== 'default') ? input.model : null,
+    platform_version: input.cursor_version || input.platform_version || null,
+    _cursor_text: input.text || null,
+    _cursor_generation_id: input.generation_id || null,
+  };
+}
+
 // ── Helpers ──────────────────────────────────────────────────────────────────
 
 function resolveApiUrl() {
@@ -162,12 +191,13 @@ function resolveNamespace() {
   } catch { return null; }
 }
 
-function detectPlatform() {
+function detectPlatform(input) {
+  if (input?.hook_event_name || input?.cursor_version || input?.conversation_id) return 'cursor';
   if (process.env.CLAUDECODE) return 'claude-code';
   if (process.env.CURSOR_TRACE_ID || process.env.CURSOR_PROJECT_DIR) return 'cursor';
   if (Object.keys(process.env).some(k => k.startsWith('WINDSURF_'))) return 'windsurf';
   if (Object.keys(process.env).some(k => k.startsWith('CODEX_'))) return 'codex';
-  return 'claude-code'; // default assumption
+  return 'claude-code';
 }
 
 function computeProjectHash(cwd) {
@@ -387,6 +417,44 @@ function extractFromTranscript(transcriptPath) {
   }
 }
 
+/**
+ * Estimate token counts from Cursor's inline response text.
+ * Cursor doesn't provide token usage, so we estimate ~4 chars/token.
+ */
+function estimateFromCursorText(text, model) {
+  if (!text) return null;
+  const outputChars = text.length;
+  const outputTokens = Math.round(outputChars / 4);
+  const inputTokens = Math.round(outputTokens * 1.5); // rough estimate: inputs > outputs
+
+  const prUrls = new Set();
+  scanForPrUrls(text, prUrls);
+
+  const mcpToolsUsed = new Set();
+  const mcpRe = /mcp__\w+/g;
+  const mcpMatches = text.match(mcpRe);
+  if (mcpMatches) for (const m of mcpMatches) mcpToolsUsed.add(m.slice(0, 128));
+
+  return {
+    inputTokens,
+    outputTokens,
+    cacheCreation: 0,
+    cacheRead: 0,
+    totalTokens: inputTokens + outputTokens,
+    model: model || null,
+    command: null,
+    agentsUsed: [],
+    skillsApplied: [],
+    mcpToolsUsed: [...mcpToolsUsed],
+    toolTotal: 0,
+    toolPassed: 0,
+    toolFailed: 0,
+    prUrls: [...prUrls],
+    errorType: null,
+    errorMessage: null,
+  };
+}
+
 /** Scan text for GitHub PR URLs */
 function scanForPrUrls(text, prUrlSet) {
   if (!text) return;
@@ -577,9 +645,10 @@ async function pushPerfSummaries(cwd, transcript, deltaTotal, deltaCost, model,
 /**
  * SessionStart — write session metadata. No network.
  */
-export async function handleSessionStart(input) {
-  const sessionId = input.session_id || input.conversation_id || `s-${Date.now()}`;
-  const cwd = input.cwd || process.env.CLAUDE_PROJECT_DIR || process.env.CURSOR_PROJECT_DIR || process.cwd();
+export async function handleSessionStart(rawInput) {
+  const input = normalizeCursorInput(rawInput);
+  const sessionId = input.session_id || `s-${Date.now()}`;
+  const cwd = input.cwd || process.env.CLAUDE_PROJECT_DIR || process.cwd();
 
   // Refresh pricing from LiteLLM if stale (>24h). Non-blocking — if it fails,
   // existing cached pricing or hardcoded fallback is used.
@@ -589,7 +658,7 @@ export async function handleSessionStart(input) {
     session_id: sessionId,
     branch: getBranch(cwd),
     project_hash: computeProjectHash(cwd),
-    platform: detectPlatform(),
+    platform: detectPlatform(rawInput),
     platform_version: input.platform_version || null,
     namespace: resolveNamespace(),
     start_ts: new Date().toISOString(),
@@ -611,14 +680,19 @@ export async function handleSessionStart(input) {
  * Stop — read transcript, compute token delta, append costs.jsonl. No network.
  * Also scans for PR URLs and MCP tools.
  */
-export async function handleStop(input) {
-  const sessionId = input.session_id || input.conversation_id || 'unknown';
+export async function handleStop(rawInput) {
+  const input = normalizeCursorInput(rawInput);
+  const sessionId = input.session_id || 'unknown';
   const transcriptPath = input.transcript_path || process.env.CURSOR_TRANSCRIPT_PATH || null;
-  const cwd = input.cwd || process.env.CLAUDE_PROJECT_DIR || process.env.CURSOR_PROJECT_DIR || process.cwd();
+  const cwd = input.cwd || process.env.CLAUDE_PROJECT_DIR || process.cwd();
   const status = input.status || 'completed';
   const stdinModel = input.model || null;
 
-  const transcript = extractFromTranscript(transcriptPath);
+  // For Cursor: if no transcript file, estimate from inline text
+  let transcript = extractFromTranscript(transcriptPath);
+  if (!transcript && input._cursor_text) {
+    transcript = estimateFromCursorText(input._cursor_text, stdinModel);
+  }
   const model = stdinModel || transcript?.model || 'unknown';
 
   // ── Token delta via snapshot diffing ─────────────────────────────────────
@@ -668,7 +742,7 @@ export async function handleStop(input) {
       total_tokens: deltaTotal,
       cost_usd: Math.round(deltaCost * 1_000_000) / 1_000_000,
       status,
-      platform: detectPlatform(),
+      platform: detectPlatform(rawInput),
     };
     appendFileSync(costPath, JSON.stringify(record) + '\n');
   } catch { /* never block */ }
@@ -719,12 +793,109 @@ export async function handleStop(input) {
   await pushPerfSummaries(cwd, transcript, deltaTotal, deltaCost, model, input, session?.namespace);
 }
 
+/**
+ * AfterAgentResponse — Cursor-specific: fires after every agent response.
+ * Creates session if missing (Cursor's sessionStart is unreliable), then
+ * estimates tokens from the response text and appends to costs.jsonl.
+ * Identical logic to handleStop but triggered more reliably in Cursor.
+ */
+export async function handleAfterAgentResponse(rawInput) {
+  const input = normalizeCursorInput(rawInput);
+  const sessionId = input.session_id || 'unknown';
+  const cwd = input.cwd || process.cwd();
+  const stdinModel = input.model || null;
+
+  // Ensure session exists — Cursor's sessionStart hook can be flaky
+  let session = readSession(sessionId);
+  if (!session) {
+    await handleSessionStart(rawInput);
+    session = readSession(sessionId);
+    if (!session) return;
+  }
+
+  // Estimate tokens from Cursor's inline text
+  const transcript = input._cursor_text
+    ? estimateFromCursorText(input._cursor_text, stdinModel)
+    : null;
+  if (!transcript) return; // no text content = nothing to track
+
+  const model = stdinModel || transcript.model || session.model || 'unknown';
+
+  // ── Token delta via snapshot diffing (same as handleStop) ──────────────
+  mkdirSync(TELEMETRY_DIR, { recursive: true });
+  const snapPath = snapshotPath(sessionId);
+  let prevSnapshot = { input: 0, output: 0, cacheCreation: 0, cacheRead: 0 };
+  if (existsSync(snapPath)) {
+    try { prevSnapshot = JSON.parse(readFileSync(snapPath, 'utf8')); } catch { /* corrupted */ }
+  }
+
+  // For afterAgentResponse, each event is a new response — use absolute values as delta
+  const deltaInput = transcript.inputTokens || 0;
+  const deltaOutput = transcript.outputTokens || 0;
+  const deltaCacheCreation = 0;
+  const deltaCacheRead = 0;
+  const deltaTotal = deltaInput + deltaOutput;
+  const deltaCost = estimateCost(model, deltaInput, deltaOutput, deltaCacheCreation, deltaCacheRead);
+
+  // Update snapshot with cumulative totals
+  try {
+    writeFileSync(snapPath, JSON.stringify({
+      input: (prevSnapshot.input || 0) + deltaInput,
+      output: (prevSnapshot.output || 0) + deltaOutput,
+      cacheCreation: prevSnapshot.cacheCreation || 0,
+      cacheRead: prevSnapshot.cacheRead || 0,
+      ts: new Date().toISOString(),
+    }));
+  } catch { /* best effort */ }
+
+  // ── Append to costs.jsonl with incrementing entry_id ──────────────────
+  const entryId = (session.entry_id || 0) + 1;
+
+  try {
+    const costPath = costsJsonlPath(sessionId);
+    const record = {
+      entry_id: entryId,
+      ts: new Date().toISOString(),
+      session_id: sessionId,
+      model,
+      input_tokens: deltaInput,
+      output_tokens: deltaOutput,
+      cache_creation: 0,
+      cache_read: 0,
+      total_tokens: deltaTotal,
+      cost_usd: Math.round(deltaCost * 1_000_000) / 1_000_000,
+      status: 'completed',
+      platform: 'cursor',
+    };
+    appendFileSync(costPath, JSON.stringify(record) + '\n');
+  } catch { /* never block */ }
+
+  // ── Update session metadata ───────────────────────────────────────────
+  session.entry_id = entryId;
+  session.model = model !== 'unknown' ? model : session.model;
+  if (input.platform_version) session.platform_version = input.platform_version;
+
+  if (transcript.prUrls?.length) {
+    const existing = new Set(session.pr_urls || []);
+    for (const url of transcript.prUrls) existing.add(url);
+    session.pr_urls = [...existing];
+  }
+  if (transcript.mcpToolsUsed?.length) {
+    const existing = new Set(session.mcp_tools || []);
+    for (const tool of transcript.mcpToolsUsed) existing.add(tool);
+    session.mcp_tools = [...existing];
+  }
+
+  writeSession(sessionId, session);
+}
+
 /**
  * PreCompact — aggregate unflushed costs.jsonl entries, POST to API.
  * This is the heartbeat for long-running sessions.
  */
-export async function handlePreCompact(input) {
-  const sessionId = input.session_id || input.conversation_id || 'unknown';
+export async function handlePreCompact(rawInput) {
+  const input = normalizeCursorInput(rawInput);
+  const sessionId = input.session_id || 'unknown';
   const session = readSession(sessionId);
   if (!session) return; // no session metadata — nothing to flush
 
@@ -816,8 +987,9 @@ export async function handlePreCompact(input) {
 /**
  * SessionEnd — final flush + session duration + cleanup.
  */
-export async function handleSessionEnd(input) {
-  const sessionId = input.session_id || input.conversation_id || 'unknown';
+export async function handleSessionEnd(rawInput) {
+  const input = normalizeCursorInput(rawInput);
+  const sessionId = input.session_id || 'unknown';
   const session = readSession(sessionId);
   if (!session) return;
 

package/hooks/manifest.mjs

@@ -8,10 +8,11 @@ export const CAPABILITIES = {
     description: 'Token tracking, cost estimation, API push',
     module: '../capabilities/telemetry.mjs',
     hooks: {
-      'session-start': { handler: 'handleSessionStart', timeout: 5000 },
-      'stop':          { handler: 'handleStop', timeout: 10000 },
-      'pre-compact':   { handler: 'handlePreCompact', timeout: 15000 },
-      'session-end':   { handler: 'handleSessionEnd', timeout: 15000 },
+      'session-start':        { handler: 'handleSessionStart', timeout: 5000 },
+      'stop':                 { handler: 'handleStop', timeout: 10000 },
+      'after-agent-response': { handler: 'handleAfterAgentResponse', timeout: 10000 },
+      'pre-compact':          { handler: 'handlePreCompact', timeout: 15000 },
+      'session-end':          { handler: 'handleSessionEnd', timeout: 15000 },
     },
   },
   'activity-tracker': {

package/hooks/shared/after-agent-response.mjs

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+// after-agent-response.mjs — AfterAgentResponse dispatcher.
+// Fires after every Cursor agent response. Primary telemetry signal for Cursor.
+import { run } from './dispatch.mjs';
+run('after-agent-response');

package/integrate.mjs

@@ -519,6 +519,7 @@ export function installIdeHooks() {
     'shared/stop.mjs',
     'shared/pre-compact.mjs',
     'shared/session-end.mjs',
+    'shared/after-agent-response.mjs',
     'capabilities/telemetry.mjs',
   ];
 
@@ -545,10 +546,11 @@ export function installIdeHooks() {
 
   // Dispatcher commands — one per hook event
   const dispatchers = {
-    SessionStart: { cmd: `node "${join(hooksDir, 'shared', 'session-start.mjs')}"`, timeout: 10 },
-    Stop:         { cmd: `node "${join(hooksDir, 'shared', 'stop.mjs')}"`, timeout: 15 },
-    PreCompact:   { cmd: `node "${join(hooksDir, 'shared', 'pre-compact.mjs')}"`, timeout: 20 },
-    SessionEnd:   { cmd: `node "${join(hooksDir, 'shared', 'session-end.mjs')}"`, timeout: 20 },
+    SessionStart:      { cmd: `node "${join(hooksDir, 'shared', 'session-start.mjs')}"`, timeout: 10 },
+    Stop:              { cmd: `node "${join(hooksDir, 'shared', 'stop.mjs')}"`, timeout: 15 },
+    AfterAgentResponse:{ cmd: `node "${join(hooksDir, 'shared', 'after-agent-response.mjs')}"`, timeout: 15 },
+    PreCompact:        { cmd: `node "${join(hooksDir, 'shared', 'pre-compact.mjs')}"`, timeout: 20 },
+    SessionEnd:        { cmd: `node "${join(hooksDir, 'shared', 'session-end.mjs')}"`, timeout: 20 },
   };
 
   // ── Step 2: Claude Code — wire 4 events (merge, don't replace) ────
@@ -562,14 +564,17 @@ export function installIdeHooks() {
   }
   if (!claudeSettings.hooks) claudeSettings.hooks = {};
 
-  // Wire each dispatcher event
-  for (const [event, { cmd, timeout }] of Object.entries(dispatchers)) {
-    const statusMessages = {
-      SessionStart: 'Starting telemetry...',
-      Stop: 'Recording telemetry...',
-      PreCompact: 'Flushing telemetry...',
-      SessionEnd: 'Finalizing telemetry...',
-    };
+  // Claude Code events — skip AfterAgentResponse (Cursor-only)
+  const claudeCodeEvents = ['SessionStart', 'Stop', 'PreCompact', 'SessionEnd'];
+  const statusMessages = {
+    SessionStart: 'Starting telemetry...',
+    Stop: 'Recording telemetry...',
+    PreCompact: 'Flushing telemetry...',
+    SessionEnd: 'Finalizing telemetry...',
+  };
+
+  for (const event of claudeCodeEvents) {
+    const { cmd, timeout } = dispatchers[event];
 
     // Get existing hooks for this event, preserving non-aw entries
     const existingHooks = claudeSettings.hooks[event]?.[0]?.hooks || [];
@@ -577,7 +582,6 @@ export function installIdeHooks() {
       !h.command?.includes('.aw/hooks/') && !h.command?.includes('telemetry-stop.js')
     );
 
-    // Build new hook entry
     const awHook = {
       type: 'command',
       command: cmd,
@@ -618,6 +622,7 @@ export function installIdeHooks() {
   const cursorEventMap = {
     SessionStart: 'sessionStart',
     Stop: 'stop',
+    AfterAgentResponse: 'afterAgentResponse',
     PreCompact: 'preCompact',
     SessionEnd: 'sessionEnd',
   };
@@ -697,7 +702,7 @@ export function installIdeHooks() {
     } catch { /* best effort */ }
   }
 
-  fmt.logSuccess('IDE hooks installed — 4 events (Claude + Cursor) + 2 events (Codex) → ~/.aw/hooks/');
+  fmt.logSuccess('IDE hooks installed — 5 events (Claude + Cursor) + 2 events (Codex) → ~/.aw/hooks/');
 }
 
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ghl-ai/aw",
-  "version": "0.1.37-beta.75",
+  "version": "0.1.37-beta.77",
   "description": "Agentic Workspace CLI — pull, push & manage agents, skills and commands from the registry",
   "type": "module",
   "bin": "bin.js",