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

package/cron-hook.ts

@@ -2,8 +2,8 @@
  * before_tool_call hook for cron (action=add) — ensures delivery fields are
  * always set correctly, even when the LLM omits them.
  *
- * Forces: delivery.mode = "none" (agent uses clawly_send_message tool)
- * Appends: delivery instructions to payload.message
+ * Forces: delivery.mode = "none" (delivery is handled by the cron-delivery
+ * agent_end hook which injects results into the main session via chat.inject)
  * Patches: payload.kind "systemEvent" → "agentTurn"
  *
  * The cron tool name is "cron" (not "cron.create"). The LLM passes
@@ -19,27 +19,14 @@ function isRecord(v: unknown): v is UnknownRecord {
   return typeof v === 'object' && v !== null && !Array.isArray(v)
 }
 
-const DELIVERY_SUFFIX = [
-  '',
-  '---',
-  'DELIVERY INSTRUCTIONS (mandatory):',
-  'When done, you MUST deliver your result to the user:',
-  '1. Call the clawly_send_message tool with role="assistant" and a brief, natural summary of your result.',
-].join('\n')
-
 function patchJob(job: UnknownRecord): UnknownRecord {
   const patched: UnknownRecord = {...job}
 
-  // Force delivery.mode = "none" — agent reports via tools explicitly
-  patched.delivery = {mode: 'none'}
-
-  // Append delivery instructions to payload.message
-  if (isRecord(job.payload) && typeof job.payload.message === 'string') {
-    patched.payload = {
-      ...job.payload,
-      message: job.payload.message + DELIVERY_SUFFIX,
-    }
-  }
+  // Force delivery.mode = "none" — delivery is handled by the cron-delivery
+  // agent_end hook (injects result into main session via chat.inject)
+  // Preserve other delivery fields (e.g. channel) if the agent set them
+  const existing = isRecord(job.delivery) ? job.delivery : {}
+  patched.delivery = {...existing, mode: 'none'}
 
   // Patch payload.kind: systemEvent → agentTurn
   if (isRecord(patched.payload) && (patched.payload as UnknownRecord).kind === 'systemEvent') {
@@ -73,5 +60,5 @@ export function registerCronHook(api: PluginApi) {
     return {params}
   })
 
-  api.logger.info('hook: registered before_tool_call for cron add delivery enforcement')
+  api.logger.info('hook: registered before_tool_call for cron add (none + agentTurn enforcement)')
 }

package/gateway/cron-delivery.ts

@@ -0,0 +1,99 @@
+/**
+ * Cron delivery via agent_end hook — injects cron session results into the
+ * main chat session programmatically via `chat.inject`.
+ *
+ * When a cron job completes in an isolated session, this hook:
+ * 1. Detects cron sessions via `ctx.sessionKey.startsWith('agent:clawly:cron:')`
+ * 2. Extracts the last assistant message (raw, preserving formatting)
+ * 3. Filters noise (empty, NO_REPLY, heartbeat-only, system message leak)
+ * 4. Resolves the main session key via `sessions.resolve`
+ * 5. Injects the result into the main session via `chat.inject`
+ *
+ * This runs independently of offline-push — both fire on agent_end but serve
+ * different purposes. `chat.inject` does NOT trigger a new agent_end (it's a
+ * transcript injection, not an agent turn), so no infinite loop risk.
+ */
+
+import type {PluginApi} from '../types'
+import {injectAssistantMessage, resolveSessionKey} from './inject'
+import {shouldSkipPushForMessage} from './offline-push'
+
+/**
+ * Extract the last assistant message's full text from a messages array.
+ * Preserves original formatting (newlines, whitespace) — unlike the
+ * collapsed version in offline-push used for notification previews.
+ */
+function getRawLastAssistantText(messages: unknown): string | null {
+  if (!Array.isArray(messages)) return null
+
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const msg = messages[i]
+    if (typeof msg !== 'object' || msg === null) continue
+    if ((msg as any).role !== 'assistant') continue
+
+    const content = (msg as any).content
+    if (typeof content === 'string') return content.trim()
+    if (Array.isArray(content)) {
+      const text = content
+        .filter((p: any) => typeof p === 'object' && p !== null && p.type === 'text')
+        .map((p: any) => p.text)
+        .join('')
+      return text.trim()
+    }
+    return null
+  }
+
+  return null
+}
+
+export function registerCronDelivery(api: PluginApi) {
+  api.on('agent_end', async (event: Record<string, unknown>, ctx?: Record<string, unknown>) => {
+    const sessionKey = typeof ctx?.sessionKey === 'string' ? ctx.sessionKey : undefined
+    const agentId = typeof ctx?.agentId === 'string' ? ctx.agentId : undefined
+
+    // Only fire for cron sessions
+    if (!sessionKey?.startsWith('agent:clawly:cron:')) return
+
+    try {
+      // Extract raw assistant text (preserving formatting)
+      const text = getRawLastAssistantText(event.messages)
+      if (text == null) {
+        api.logger.info('cron-delivery: skipped (no assistant message)')
+        return
+      }
+
+      // Filter noise — reuse the same logic as offline-push
+      const reason = shouldSkipPushForMessage(text)
+      if (reason) {
+        api.logger.info(`cron-delivery: skipped (filtered: ${reason})`)
+        return
+      }
+
+      // Resolve main session key for this agent
+      if (!agentId) {
+        api.logger.error('cron-delivery: skipped (no agentId on ctx)')
+        return
+      }
+
+      const mainSessionKey = await resolveSessionKey(agentId, api)
+
+      // Inject the cron result into the main session
+      const result = await injectAssistantMessage(
+        {
+          sessionKey: mainSessionKey,
+          message: text,
+          label: 'cron',
+        },
+        api,
+      )
+
+      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)}`)
+    }
+  })
+
+  api.logger.info('cron-delivery: registered agent_end hook')
+}

package/gateway/index.ts

@@ -2,6 +2,7 @@ import type {PluginApi} from '../types'
 import {registerAgentSend} from './agent'
 import {registerClawhub2gateway} from './clawhub2gateway'
 import {registerConfigRepair} from './config-repair'
+import {registerCronDelivery} from './cron-delivery'
 import {registerPairing} from './pairing'
 import {registerMemoryBrowser} from './memory'
 import {registerNotification} from './notification'
@@ -18,6 +19,7 @@ export function registerGateway(api: PluginApi) {
   registerClawhub2gateway(api)
   registerPlugins(api)
   registerOfflinePush(api)
+  registerCronDelivery(api)
   registerConfigRepair(api)
   registerPairing(api)
   registerVersion(api)

package/gateway/offline-push.test.ts

@@ -92,7 +92,10 @@ describe('offline-push', () => {
     await handlers.get('agent_end')!({}, {sessionKey: 'agent:clawly:main'})
 
     expect(logs.filter((l) => l.msg.includes('notified'))).toHaveLength(0)
-    expect(logs.filter((l) => l.msg.includes('skipped'))).toHaveLength(0)
+    expect(logs).toContainEqual({
+      level: 'info',
+      msg: expect.stringContaining('skipped (client online)'),
+    })
   })
 
   test('sends push for consecutive calls on same session', async () => {

package/gateway/offline-push.ts

@@ -104,7 +104,10 @@ export function registerOfflinePush(api: PluginApi) {
     try {
       // Skip if client is still connected — they got the response in real-time.
       const online = await isClientOnline()
-      if (online) return
+      if (online) {
+        api.logger.info('offline-push: skipped (client online)')
+        return
+      }
 
       // Extract full assistant text for filtering and preview.
       const fullText = getLastAssistantText(event.messages)

package/gateway/presence.test.ts

@@ -6,8 +6,8 @@ describe('isOnlineEntry', () => {
     expect(isOnlineEntry({host: 'openclaw-ios', reason: 'foreground'})).toBe(true)
   })
 
-  test('returns true for reason "connect" (backward compat)', () => {
-    expect(isOnlineEntry({host: 'openclaw-ios', reason: 'connect'})).toBe(true)
+  test('returns false for reason "connect" (gateway WS state, not reliable for app foreground)', () => {
+    expect(isOnlineEntry({host: 'openclaw-ios', reason: 'connect'})).toBe(false)
   })
 
   test('returns false for reason "background"', () => {

package/gateway/presence.ts

@@ -19,10 +19,12 @@ interface PresenceEntry {
   reason?: string
 }
 
-/** Returns true if the presence entry indicates the client is actively connected. */
+/** Returns true if the presence entry indicates the client is actively in the foreground.
+ *  Only trusts the explicit 'foreground' signal from the mobile app — 'connect'
+ *  (gateway WS state) can linger after the app backgrounds, causing false positives. */
 export function isOnlineEntry(entry: PresenceEntry | undefined): boolean {
   if (!entry) return false
-  return entry.reason === 'foreground' || entry.reason === 'connect'
+  return entry.reason === 'foreground'
 }
 
 /**

package/index.ts

@@ -25,7 +25,7 @@
  * - before_message_write — restores original /skill command in user messages (undoes gateway rewrite)
  * - tool_result_persist   — copies TTS audio to persistent outbound directory
  * - before_tool_call      — enforces delivery fields on cron.create
- * - agent_end             — sends push notification when client is offline
+ * - agent_end             — sends push notification when client is offline; injects cron results into main session
  * - gateway_start         — auto-approves device pairing for Clawly mobile clients (clientId: openclaw-ios)
  * - gateway_start         — registers auto-update cron job (0 3 * * *) for clawly-plugins
  */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@2en/clawly-plugins",
-  "version": "1.24.7-beta.0",
+  "version": "1.24.7-beta.1",
   "module": "index.ts",
   "type": "module",
   "repository": {