@2en/clawly-plugins 1.26.0-beta.0 → 1.26.0-beta.1

package/auto-pair.ts

@@ -1,3 +1,4 @@
+import {captureEvent} from './gateway/posthog'
 import type {PluginApi} from './index'
 
 const AUTO_APPROVE_CLIENT_IDS = new Set(['openclaw-ios'])
@@ -49,6 +50,10 @@ export function registerAutoPair(api: PluginApi) {
           if (req.clientId && AUTO_APPROVE_CLIENT_IDS.has(req.clientId)) {
             const result = await sdk.approveDevicePairing(req.requestId)
             if (result) {
+              captureEvent('device.paired', {
+                client_id: req.clientId,
+                platform: result.device.platform ?? 'unknown',
+              })
               api.logger.info(
                 `auto-pair: approved device=${result.device.deviceId} ` +
                   `name=${result.device.displayName ?? 'unknown'} ` +

package/config-setup.ts

@@ -23,6 +23,7 @@ import {
 } from './model-gateway-setup'
 
 export interface ConfigPluginConfig {
+  instanceId?: string
   agentId?: string
   agentName?: string
   workspaceDir?: string
@@ -32,6 +33,10 @@ export interface ConfigPluginConfig {
   elevenlabsVoiceId?: string
   modelGatewayBaseUrl?: string
   modelGatewayToken?: string
+  otelToken?: string
+  otelDataset?: string
+  posthogApiKey?: string
+  posthogHost?: string
 }
 
 function toPC(api: PluginApi): ConfigPluginConfig {

package/gateway/analytics.ts

@@ -0,0 +1,83 @@
+/**
+ * Broad PostHog analytics — captures agent turns, LLM usage, and tool calls.
+ *
+ * Hooks:
+ * - agent_end     — tracks every agent turn completion (trigger, duration, success)
+ * - llm_output    — tracks LLM token usage per response (provider, model, tokens)
+ * - after_tool_call — tracks tool usage (tool name, duration, success)
+ *
+ * Cron-specific lifecycle events (created/executed/deleted) are handled by
+ * cron-telemetry.ts and are NOT duplicated here.
+ *
+ * Other modules (offline-push, auto-pair, plugins, clawhub2gateway) call
+ * captureEvent() directly for their domain-specific events.
+ */
+
+import type {PluginApi} from '../types'
+import {captureEvent} from './posthog'
+
+export function registerAnalytics(api: PluginApi) {
+  // ── agent_end: track every agent turn ───────────────────────────
+  api.on('agent_end', (event: Record<string, unknown>, ctx?: Record<string, unknown>) => {
+    const trigger = typeof ctx?.trigger === 'string' ? ctx.trigger : 'unknown'
+    const agentId = typeof ctx?.agentId === 'string' ? ctx.agentId : undefined
+    const sessionKey = typeof ctx?.sessionKey === 'string' ? ctx.sessionKey : undefined
+    const sessionId = typeof ctx?.sessionId === 'string' ? ctx.sessionId : undefined
+    const success = event.error == null
+    const durationMs = typeof event.durationMs === 'number' ? event.durationMs : undefined
+
+    captureEvent('agent.turn_completed', {
+      trigger,
+      ...(agentId ? {agent_id: agentId} : {}),
+      ...(sessionKey ? {session_key: sessionKey} : {}),
+      ...(sessionId ? {session_id: sessionId} : {}),
+      success,
+      ...(durationMs != null ? {duration_ms: durationMs} : {}),
+      ...(typeof event.error === 'string' ? {error: event.error} : {}),
+    })
+  })
+
+  // ── llm_output: track token usage ──────────────────────────────
+  api.on('llm_output', (event: Record<string, unknown>, ctx?: Record<string, unknown>) => {
+    const provider = typeof event.provider === 'string' ? event.provider : undefined
+    const model = typeof event.model === 'string' ? event.model : undefined
+    const usage = event.usage as Record<string, unknown> | undefined
+
+    if (!usage) return
+
+    const trigger = typeof ctx?.trigger === 'string' ? ctx.trigger : undefined
+    const sessionId = typeof ctx?.sessionId === 'string' ? ctx.sessionId : undefined
+
+    captureEvent('llm.response', {
+      ...(provider ? {provider} : {}),
+      ...(model ? {model} : {}),
+      ...(trigger ? {trigger} : {}),
+      ...(sessionId ? {session_id: sessionId} : {}),
+      ...(typeof usage.input === 'number' ? {tokens_input: usage.input} : {}),
+      ...(typeof usage.output === 'number' ? {tokens_output: usage.output} : {}),
+      ...(typeof usage.cacheRead === 'number' ? {tokens_cache_read: usage.cacheRead} : {}),
+      ...(typeof usage.cacheWrite === 'number' ? {tokens_cache_write: usage.cacheWrite} : {}),
+      ...(typeof usage.total === 'number' ? {tokens_total: usage.total} : {}),
+    })
+  })
+
+  // ── after_tool_call: track tool usage ──────────────────────────
+  api.on('after_tool_call', (event: Record<string, unknown>, ctx?: Record<string, unknown>) => {
+    const toolName = typeof event.toolName === 'string' ? event.toolName : undefined
+    if (!toolName) return
+
+    const sessionId = typeof ctx?.sessionId === 'string' ? ctx.sessionId : undefined
+    const success = event.error == null
+    const durationMs = typeof event.durationMs === 'number' ? event.durationMs : undefined
+
+    captureEvent('tool.called', {
+      tool_name: toolName,
+      success,
+      ...(sessionId ? {session_id: sessionId} : {}),
+      ...(durationMs != null ? {duration_ms: durationMs} : {}),
+      ...(typeof event.error === 'string' ? {error: event.error} : {}),
+    })
+  })
+
+  api.logger.info('analytics: registered agent_end + llm_output + after_tool_call hooks')
+}

package/gateway/clawhub2gateway.ts

@@ -20,6 +20,7 @@ import fs from 'node:fs/promises'
 import path from 'node:path'
 
 import type {PluginApi} from '../types'
+import {captureEvent} from './posthog'
 
 type JsonSchema = Record<string, unknown>
 
@@ -182,13 +183,21 @@ export function registerClawhub2gateway(api: PluginApi) {
           env,
         })
         const output = joinOutput(res.stdout, res.stderr)
+        const action = rpc.method.split('.').pop() ?? rpc.method
         if (res.code && res.code !== 0) {
+          captureEvent('clawhub.action', {action, success: false})
           respond(false, undefined, {
             code: 'command_failed',
             message: output || `clawhub exited with code ${res.code}`,
           })
           return
         }
+        captureEvent('clawhub.action', {
+          action,
+          success: true,
+          ...(params.slug ? {slug: params.slug} : {}),
+          ...(params.query ? {query: params.query} : {}),
+        })
         respond(true, {
           ok: true,
           output,
@@ -201,6 +210,12 @@ export function registerClawhub2gateway(api: PluginApi) {
           cwd: built.cwd,
         })
       } catch (err) {
+        const action = rpc.method.split('.').pop() ?? rpc.method
+        captureEvent('clawhub.action', {
+          action,
+          success: false,
+          error: err instanceof Error ? err.message : String(err),
+        })
         respond(false, undefined, {
           code: 'error',
           message: err instanceof Error ? err.message : String(err),

package/gateway/cron-delivery.ts

@@ -15,6 +15,7 @@
  */
 
 import type {PluginApi} from '../types'
+import {markCronDelivered, markCronDeliverySkipped} from './cron-telemetry'
 import {injectAssistantMessage, resolveSessionKey} from './inject'
 import {shouldSkipPushForMessage} from './offline-push'
 
@@ -51,6 +52,10 @@ export function registerCronDelivery(api: PluginApi) {
     const sessionKey = typeof ctx?.sessionKey === 'string' ? ctx.sessionKey : undefined
     const agentId = typeof ctx?.agentId === 'string' ? ctx.agentId : undefined
 
+    api.logger.info(
+      `cron-delivery[debug]: agent_end fired sessionKey=${sessionKey ?? 'undefined'} agentId=${agentId ?? 'undefined'} trigger=${String(ctx?.trigger ?? 'undefined')}`,
+    )
+
     // Only fire for cron sessions
     if (!sessionKey?.startsWith('agent:clawly:cron:')) return
 
@@ -59,6 +64,7 @@ export function registerCronDelivery(api: PluginApi) {
       const text = getRawLastAssistantText(event.messages)
       if (text == null) {
         api.logger.info('cron-delivery: skipped (no assistant message)')
+        if (sessionKey) markCronDeliverySkipped(sessionKey, 'no assistant message')
         return
       }
 
@@ -66,12 +72,14 @@ export function registerCronDelivery(api: PluginApi) {
       const reason = shouldSkipPushForMessage(text)
       if (reason) {
         api.logger.info(`cron-delivery: skipped (filtered: ${reason})`)
+        if (sessionKey) markCronDeliverySkipped(sessionKey, `filtered: ${reason}`)
         return
       }
 
       // Resolve main session key for this agent
       if (!agentId) {
         api.logger.error('cron-delivery: skipped (no agentId on ctx)')
+        if (sessionKey) markCronDeliverySkipped(sessionKey, 'no agentId')
         return
       }
 
@@ -86,13 +94,16 @@ export function registerCronDelivery(api: PluginApi) {
         api,
       )
 
+      if (sessionKey) markCronDelivered(sessionKey)
       api.logger.info(
         `cron-delivery: injected into ${mainSessionKey} (messageId=${result.messageId})`,
       )
     } catch (err) {
-      api.logger.error(`cron-delivery: ${err instanceof Error ? err.message : String(err)}`)
+      const msg = err instanceof Error ? err.message : String(err)
+      if (sessionKey) markCronDeliverySkipped(sessionKey, msg)
+      api.logger.error(`cron-delivery: ${msg}`)
     }
   })
 
-  api.logger.info('cron-delivery: registered agent_end hook')
+  api.logger.info('cron-delivery: registered agent_end hook (debug-instrumented)')
 }

package/gateway/cron-telemetry.test.ts

@@ -0,0 +1,407 @@
+import {afterEach, beforeEach, describe, expect, mock, test} from 'bun:test'
+import type {PluginApi} from '../types'
+import {
+  markCronDelivered,
+  markCronDeliverySkipped,
+  markCronPushSent,
+  markCronPushSkipped,
+  registerCronTelemetry,
+} from './cron-telemetry'
+
+// ── Mock OTel logger ─────────────────────────────────────────────
+
+type LogRecord = {
+  severityNumber: number
+  severityText: string
+  body: string
+  attributes: Record<string, unknown>
+}
+
+let otelRecords: LogRecord[] = []
+
+let posthogEvents: {event: string; properties?: Record<string, unknown>}[] = []
+
+mock.module('@opentelemetry/api-logs', () => ({
+  SeverityNumber: {INFO: 9},
+}))
+
+mock.module('./posthog', () => ({
+  captureEvent: (event: string, properties?: Record<string, unknown>) =>
+    posthogEvents.push({event, properties}),
+}))
+
+mock.module('./otel', () => ({
+  getOtelLogger: () => ({
+    emit: (record: LogRecord) => otelRecords.push(record),
+  }),
+}))
+
+// ── Helpers ──────────────────────────────────────────────────────
+
+type AfterToolCallHandler = (event: Record<string, unknown>) => void
+type AgentEndHandler = (event: Record<string, unknown>, ctx?: Record<string, unknown>) => void
+
+let afterToolCallHandler: AfterToolCallHandler
+let agentEndHandler: AgentEndHandler
+let logs: string[]
+
+function createMockApi(pluginConfig?: Record<string, unknown>): PluginApi {
+  logs = []
+  otelRecords = []
+  posthogEvents = []
+  return {
+    id: 'test',
+    name: 'Test',
+    pluginConfig,
+    runtime: {},
+    logger: {
+      info: (msg: string) => logs.push(msg),
+      warn: (msg: string) => logs.push(`WARN: ${msg}`),
+      error: (msg: string) => logs.push(`ERROR: ${msg}`),
+    },
+    registerGatewayMethod: () => {},
+    registerTool: () => {},
+    registerCommand: () => {},
+    registerChannel: () => {},
+    registerHttpRoute: () => {},
+    on: (hookName: string, handler: (...args: any[]) => any, _opts?: {priority?: number}) => {
+      if (hookName === 'after_tool_call') afterToolCallHandler = handler as AfterToolCallHandler
+      if (hookName === 'agent_end') agentEndHandler = handler as AgentEndHandler
+    },
+  }
+}
+
+// ── Tests ────────────────────────────────────────────────────────
+
+describe('cron-telemetry', () => {
+  beforeEach(() => {
+    registerCronTelemetry(createMockApi({instanceId: 'inst-001'}))
+  })
+
+  describe('after_tool_call — cron add', () => {
+    test('captures job creation with id, name, and schedule', () => {
+      afterToolCallHandler({
+        toolName: 'cron',
+        params: {
+          action: 'add',
+          job: {name: 'daily-check', schedule: '0 9 * * *'},
+        },
+        result: {id: 'job-123'},
+      })
+
+      expect(logs.some((l) => l.includes('job created') && l.includes('job-123'))).toBe(true)
+      expect(logs.some((l) => l.includes('daily-check'))).toBe(true)
+      expect(logs.some((l) => l.includes('0 9 * * *'))).toBe(true)
+    })
+
+    test('emits OTel LogRecord with structured attributes', () => {
+      afterToolCallHandler({
+        toolName: 'cron',
+        params: {
+          action: 'add',
+          job: {name: 'daily-check', schedule: '0 9 * * *'},
+        },
+        result: {id: 'job-123'},
+      })
+
+      expect(otelRecords).toHaveLength(1)
+      const r = otelRecords[0]
+      expect(r.body).toBe('cron.lifecycle.created')
+      expect(r.attributes['cron.lifecycle']).toBe('created')
+      expect(r.attributes['cron.job.id']).toBe('job-123')
+      expect(r.attributes['cron.job.name']).toBe('daily-check')
+      expect(r.attributes['cron.job.schedule']).toBe('0 9 * * *')
+    })
+
+    test('handles missing job name and schedule', () => {
+      afterToolCallHandler({
+        toolName: 'cron',
+        params: {action: 'add', job: {}},
+        result: {id: 'job-456'},
+      })
+
+      expect(otelRecords).toHaveLength(1)
+      expect(otelRecords[0].attributes['cron.job.id']).toBe('job-456')
+      expect(otelRecords[0].attributes['cron.job.name']).toBeUndefined()
+      expect(otelRecords[0].attributes['cron.job.schedule']).toBeUndefined()
+    })
+
+    test('ignores non-cron tools', () => {
+      afterToolCallHandler({
+        toolName: 'other-tool',
+        params: {action: 'add'},
+        result: {id: 'x'},
+      })
+
+      expect(otelRecords).toHaveLength(0)
+    })
+
+    test('ignores cron tool with non-add action', () => {
+      afterToolCallHandler({
+        toolName: 'cron',
+        params: {action: 'list'},
+        result: {},
+      })
+
+      expect(otelRecords).toHaveLength(0)
+    })
+  })
+
+  describe('after_tool_call — cron remove', () => {
+    test('captures job deletion with structured attributes', () => {
+      afterToolCallHandler({
+        toolName: 'cron',
+        params: {action: 'remove', id: 'job-789'},
+      })
+
+      expect(logs.some((l) => l.includes('job deleted') && l.includes('job-789'))).toBe(true)
+      expect(otelRecords).toHaveLength(1)
+      expect(otelRecords[0].attributes['cron.lifecycle']).toBe('deleted')
+      expect(otelRecords[0].attributes['cron.job.id']).toBe('job-789')
+    })
+
+    test('handles jobId param variant', () => {
+      afterToolCallHandler({
+        toolName: 'cron',
+        params: {action: 'remove', jobId: 'job-abc'},
+      })
+
+      expect(otelRecords[0].attributes['cron.job.id']).toBe('job-abc')
+    })
+  })
+
+  describe('agent_end — cron execution', () => {
+    test('captures successful cron execution with structured attributes', () => {
+      agentEndHandler({messages: []}, {trigger: 'cron', sessionKey: 'agent:clawly:cron:job-123'})
+
+      expect(
+        logs.some(
+          (l) => l.includes('job executed') && l.includes('job-123') && l.includes('success=true'),
+        ),
+      ).toBe(true)
+      expect(otelRecords).toHaveLength(1)
+      const a = otelRecords[0].attributes
+      expect(a['cron.lifecycle']).toBe('executed')
+      expect(a['cron.job.id']).toBe('job-123')
+      expect(a['cron.execution.success']).toBe(true)
+      expect(a['cron.delivery.app_message_sent']).toBe(false)
+      expect(a['cron.delivery.push_notification_sent']).toBe(false)
+      expect(a['instance.id']).toBe('inst-001')
+    })
+
+    test('captures failed cron execution', () => {
+      agentEndHandler(
+        {messages: [], error: 'timeout'},
+        {trigger: 'cron', sessionKey: 'agent:clawly:cron:job-456'},
+      )
+
+      expect(otelRecords[0].attributes['cron.execution.success']).toBe(false)
+      expect(otelRecords[0].attributes['cron.execution.error']).toBe('timeout')
+    })
+
+    test('ignores non-cron sessions', () => {
+      agentEndHandler({messages: []}, {trigger: 'user', sessionKey: 'agent:clawly:main'})
+
+      expect(otelRecords).toHaveLength(0)
+    })
+
+    test('ignores missing sessionKey', () => {
+      agentEndHandler({messages: []}, {trigger: 'cron'})
+
+      expect(otelRecords).toHaveLength(0)
+    })
+
+    test('detects cron session by sessionKey prefix even without trigger field', () => {
+      agentEndHandler({messages: []}, {sessionKey: 'agent:clawly:cron:job-notrigger'})
+
+      expect(otelRecords).toHaveLength(1)
+      expect(otelRecords[0].attributes['cron.lifecycle']).toBe('executed')
+      expect(otelRecords[0].attributes['cron.job.id']).toBe('job-notrigger')
+    })
+
+    test('reports durationMs when present', () => {
+      agentEndHandler(
+        {messages: [], durationMs: 1500},
+        {trigger: 'cron', sessionKey: 'agent:clawly:cron:job-x'},
+      )
+
+      expect(otelRecords[0].attributes['cron.execution.duration_ms']).toBe(1500)
+      expect(logs.some((l) => l.includes('duration=1500ms'))).toBe(true)
+    })
+  })
+
+  describe('cross-hook coordination flags', () => {
+    test('markCronDelivered sets appMessage flag', () => {
+      const sk = 'agent:clawly:cron:job-d1'
+      markCronDelivered(sk)
+
+      agentEndHandler({messages: []}, {trigger: 'cron', sessionKey: sk})
+
+      expect(otelRecords[0].attributes['cron.delivery.app_message_sent']).toBe(true)
+      expect(otelRecords[0].attributes['cron.delivery.push_notification_sent']).toBe(false)
+    })
+
+    test('markCronPushSent sets push flag', () => {
+      const sk = 'agent:clawly:cron:job-p1'
+      markCronPushSent(sk)
+
+      agentEndHandler({messages: []}, {trigger: 'cron', sessionKey: sk})
+
+      expect(otelRecords[0].attributes['cron.delivery.push_notification_sent']).toBe(true)
+      expect(otelRecords[0].attributes['cron.delivery.app_message_sent']).toBe(false)
+    })
+
+    test('both flags set when both hooks fire', () => {
+      const sk = 'agent:clawly:cron:job-both'
+      markCronDelivered(sk)
+      markCronPushSent(sk)
+
+      agentEndHandler({messages: []}, {trigger: 'cron', sessionKey: sk})
+
+      const a = otelRecords[0].attributes
+      expect(a['cron.delivery.app_message_sent']).toBe(true)
+      expect(a['cron.delivery.push_notification_sent']).toBe(true)
+    })
+
+    test('flags are cleaned up after consumption', () => {
+      const sk = 'agent:clawly:cron:job-cleanup'
+      markCronDelivered(sk)
+
+      // First call consumes
+      agentEndHandler({messages: []}, {trigger: 'cron', sessionKey: sk})
+
+      // Second call should have default flags
+      agentEndHandler({messages: []}, {trigger: 'cron', sessionKey: sk})
+      expect(otelRecords[1].attributes['cron.delivery.app_message_sent']).toBe(false)
+    })
+  })
+
+  describe('agent.id attribute', () => {
+    test('includes agent.id from ctx on executed events', () => {
+      agentEndHandler(
+        {messages: []},
+        {trigger: 'cron', sessionKey: 'agent:clawly:cron:job-aid', agentId: 'agent-42'},
+      )
+
+      expect(otelRecords[0].attributes['agent.id']).toBe('agent-42')
+    })
+
+    test('omits agent.id when ctx has no agentId', () => {
+      agentEndHandler({messages: []}, {trigger: 'cron', sessionKey: 'agent:clawly:cron:job-noid'})
+
+      expect(otelRecords[0].attributes['agent.id']).toBeUndefined()
+    })
+  })
+
+  describe('client.online attribute', () => {
+    test('includes client.online when push is skipped with clientOnline', () => {
+      const sk = 'agent:clawly:cron:job-online'
+      markCronPushSkipped(sk, 'client online', true)
+
+      agentEndHandler({messages: []}, {trigger: 'cron', sessionKey: sk})
+
+      expect(otelRecords[0].attributes['client.online']).toBe(true)
+    })
+
+    test('includes client.online=false when push is skipped offline', () => {
+      const sk = 'agent:clawly:cron:job-offline'
+      markCronPushSkipped(sk, 'filtered: empty assistant', false)
+
+      agentEndHandler({messages: []}, {trigger: 'cron', sessionKey: sk})
+
+      expect(otelRecords[0].attributes['client.online']).toBe(false)
+    })
+
+    test('omits client.online when not set', () => {
+      agentEndHandler(
+        {messages: []},
+        {trigger: 'cron', sessionKey: 'agent:clawly:cron:job-noonline'},
+      )
+
+      expect(otelRecords[0].attributes['client.online']).toBeUndefined()
+    })
+  })
+
+  describe('skip reason attributes', () => {
+    test('delivery skip reason is present when delivery is skipped', () => {
+      const sk = 'agent:clawly:cron:job-dskip'
+      markCronDeliverySkipped(sk, 'no assistant message')
+
+      agentEndHandler({messages: []}, {trigger: 'cron', sessionKey: sk})
+
+      const a = otelRecords[0].attributes
+      expect(a['cron.delivery.app_message_sent']).toBe(false)
+      expect(a['cron.delivery.app_message_skip_reason']).toBe('no assistant message')
+    })
+
+    test('push skip reason is present when push is skipped', () => {
+      const sk = 'agent:clawly:cron:job-pskip'
+      markCronPushSkipped(sk, 'send failed', false)
+
+      agentEndHandler({messages: []}, {trigger: 'cron', sessionKey: sk})
+
+      const a = otelRecords[0].attributes
+      expect(a['cron.delivery.push_notification_sent']).toBe(false)
+      expect(a['cron.delivery.push_skip_reason']).toBe('send failed')
+    })
+
+    test('no skip reasons when delivery and push succeed', () => {
+      const sk = 'agent:clawly:cron:job-success'
+      markCronDelivered(sk)
+      markCronPushSent(sk)
+
+      agentEndHandler({messages: []}, {trigger: 'cron', sessionKey: sk})
+
+      const a = otelRecords[0].attributes
+      expect(a['cron.delivery.app_message_sent']).toBe(true)
+      expect(a['cron.delivery.app_message_skip_reason']).toBeUndefined()
+      expect(a['cron.delivery.push_notification_sent']).toBe(true)
+      expect(a['cron.delivery.push_skip_reason']).toBeUndefined()
+    })
+
+    test('delivery skipped + push sent is consistent', () => {
+      const sk = 'agent:clawly:cron:job-mixed'
+      markCronDeliverySkipped(sk, 'no agentId')
+      markCronPushSent(sk)
+
+      agentEndHandler({messages: []}, {trigger: 'cron', sessionKey: sk})
+
+      const a = otelRecords[0].attributes
+      expect(a['cron.delivery.app_message_sent']).toBe(false)
+      expect(a['cron.delivery.app_message_skip_reason']).toBe('no agentId')
+      expect(a['cron.delivery.push_notification_sent']).toBe(true)
+      expect(a['cron.delivery.push_skip_reason']).toBeUndefined()
+    })
+  })
+
+  describe('PostHog events', () => {
+    test('emits posthog event for cron created', () => {
+      afterToolCallHandler({
+        toolName: 'cron',
+        params: {action: 'add', job: {name: 'test'}},
+        result: {id: 'job-ph1'},
+      })
+
+      expect(posthogEvents).toHaveLength(1)
+      expect(posthogEvents[0].event).toBe('cron.created')
+      expect(posthogEvents[0].properties?.['cron.job.id']).toBe('job-ph1')
+    })
+
+    test('emits posthog event for cron executed', () => {
+      agentEndHandler({messages: []}, {trigger: 'cron', sessionKey: 'agent:clawly:cron:job-ph2'})
+
+      expect(posthogEvents).toHaveLength(1)
+      expect(posthogEvents[0].event).toBe('cron.executed')
+    })
+
+    test('emits posthog event for cron deleted', () => {
+      afterToolCallHandler({
+        toolName: 'cron',
+        params: {action: 'remove', id: 'job-ph3'},
+      })
+
+      expect(posthogEvents).toHaveLength(1)
+      expect(posthogEvents[0].event).toBe('cron.deleted')
+    })
+  })
+})