@2en/clawly-plugins 1.24.6 → 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 () => {
@@ -120,6 +123,19 @@ describe('offline-push', () => {
     expect(logs.filter((l) => l.msg.includes('notified'))).toHaveLength(0)
   })
 
+  test('sends push for cron session', async () => {
+    const {api, logs, handlers} = createMockApi()
+    registerOfflinePush(api)
+
+    await handlers.get('agent_end')!({}, {sessionKey: 'agent:clawly:cron:weather-check:run:abc123'})
+
+    expect(logs).toContainEqual({
+      level: 'info',
+      msg: expect.stringContaining('notified (session=agent:clawly:cron:weather-check:run:abc123)'),
+    })
+    expect(logs.filter((l) => l.msg.includes('skipped'))).toHaveLength(0)
+  })
+
   test('sends push when ctx is missing', async () => {
     const {api, logs, handlers} = createMockApi()
     registerOfflinePush(api)
@@ -188,6 +204,52 @@ describe('offline-push', () => {
 
     expect(lastPushOpts?.body).toBe('Your response is ready')
   })
+
+  test('body strips [[type:value]] placeholders', async () => {
+    const {api, handlers} = createMockApi()
+    registerOfflinePush(api)
+
+    await handlers.get('agent_end')!(
+      {
+        messages: [
+          {role: 'assistant', content: 'Here is your audio [[tts:/res/audio.mp3]] enjoy!'},
+        ],
+      },
+      {sessionKey: 'agent:clawly:main'},
+    )
+
+    expect(lastPushOpts?.body).toBe('Here is your audio  enjoy!')
+  })
+
+  test('body strips bare [[word]] placeholders', async () => {
+    const {api, handlers} = createMockApi()
+    registerOfflinePush(api)
+
+    await handlers.get('agent_end')!(
+      {
+        messages: [
+          {role: 'assistant', content: 'Got it [[reply_to_current]] I will remember that.'},
+        ],
+      },
+      {sessionKey: 'agent:clawly:main'},
+    )
+
+    expect(lastPushOpts?.body).toBe('Got it  I will remember that.')
+  })
+
+  test('body strips MEDIA:xxx placeholders', async () => {
+    const {api, handlers} = createMockApi()
+    registerOfflinePush(api)
+
+    await handlers.get('agent_end')!(
+      {
+        messages: [{role: 'assistant', content: 'Check this out MEDIA:/res/image.png pretty cool'}],
+      },
+      {sessionKey: 'agent:clawly:main'},
+    )
+
+    expect(lastPushOpts?.body).toBe('Check this out  pretty cool')
+  })
 })
 
 // ── getLastAssistantText / getLastAssistantPreview unit tests ────
@@ -303,6 +365,15 @@ describe('shouldSkipPushForMessage', () => {
     ).toBe('system prompt leak')
   })
 
+  test('skips system message leak', () => {
+    expect(shouldSkipPushForMessage('[System Message] Agent orchestration update')).toBe(
+      'system message leak',
+    )
+    expect(shouldSkipPushForMessage('Some text with [System Message] embedded')).toBe(
+      'system message leak',
+    )
+  })
+
   test('does not skip normal assistant messages', () => {
     expect(shouldSkipPushForMessage('Hey! How can I help you?')).toBeNull()
     expect(shouldSkipPushForMessage('Here is the weather report for today.')).toBeNull()

package/gateway/offline-push.ts

@@ -13,6 +13,11 @@ import type {PluginApi} from '../types'
 import {sendPushNotification} from './notification'
 import {isClientOnline} from './presence'
 
+/** Strip [[type:value]], [[word]], and MEDIA:xxx placeholders from text (canonical: apps/mobile/lib/stripPlaceholders.ts). */
+function stripPlaceholders(text: string): string {
+  return text.replace(/\[\[\w+(?::[^\]]+)?\]\]|MEDIA:\S+/g, '').trim()
+}
+
 /**
  * Extract the last assistant message's full text from a messages array.
  * Handles both string and `{type:'text', text}[]` content formats.
@@ -88,6 +93,9 @@ export function shouldSkipPushForMessage(text: string): string | null {
   // Agent echoed system prompt metadata — mobile hides as "systemPromptLeak"
   if (text.includes('Conversation info (untrusted metadata)')) return 'system prompt leak'
 
+  // Agent orchestration messages leaking into chat — mobile hides as "systemMessageLeak"
+  if (text.includes('[System Message]')) return 'system message leak'
+
   return null
 }
 
@@ -96,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)
@@ -114,14 +125,19 @@ export function registerOfflinePush(api: PluginApi) {
       const sessionKey = typeof ctx?.sessionKey === 'string' ? ctx.sessionKey : undefined
       const agentId = typeof ctx?.agentId === 'string' ? ctx.agentId : undefined
 
-      // Only send push for the main clawly mobile session — skip channel
-      // sessions (telegram, slack, discord, etc.) which have their own delivery.
-      if (sessionKey !== undefined && sessionKey !== 'agent:clawly:main') {
+      // Only send push for the main clawly mobile session and cron sessions —
+      // skip channel sessions (telegram, slack, discord, etc.) which have their own delivery.
+      if (
+        sessionKey !== undefined &&
+        sessionKey !== 'agent:clawly:main' &&
+        !sessionKey.startsWith('agent:clawly:cron:')
+      ) {
         api.logger.info(`offline-push: skipped (non-main session: ${sessionKey})`)
         return
       }
 
-      const cleaned = fullText?.replace(/HEARTBEAT_OK[\p{P}\s]*$/u, '').trim() ?? null
+      const noHeartbeat = fullText?.replace(/HEARTBEAT_OK[\p{P}\s]*$/u, '').trim() ?? null
+      const cleaned = noHeartbeat ? stripPlaceholders(noHeartbeat) : null
       const preview = cleaned && cleaned.length > 140 ? `${cleaned.slice(0, 140)}…` : cleaned
       const body = preview || 'Your response is ready'
 

package/gateway/plugins.ts

@@ -22,6 +22,7 @@ const PLUGIN_SENTINEL = 'openclaw.plugin.json'
 interface NpmViewCache {
   version: string
   versions: string[]
+  distTags: Record<string, string>
 }
 
 const npmCache = new LruCache<NpmViewCache>({maxSize: 5, ttlMs: 5 * 60 * 1000})
@@ -50,6 +51,10 @@ async function fetchNpmView(npmPkgName: string): Promise<NpmViewCache | null> {
     const entry: NpmViewCache = {
       version: typeof parsed.version === 'string' ? parsed.version : '',
       versions: Array.isArray(parsed.versions) ? parsed.versions : [],
+      distTags:
+        parsed['dist-tags'] && typeof parsed['dist-tags'] === 'object'
+          ? (parsed['dist-tags'] as Record<string, string>)
+          : {},
     }
     npmCache.set(npmPkgName, entry)
     return entry
@@ -144,6 +149,7 @@ export function registerPlugins(api: PluginApi) {
     api.logger.info(`plugins.version: checking ${pluginId} (${npmPkgName})`)
     let latestNpmVersion: string | null = null
     let allNpmVersions: string[] = []
+    let npmDistTags: Record<string, string> = {}
     let updateAvailable = false
     const errors: string[] = []
 
@@ -157,6 +163,7 @@ export function registerPlugins(api: PluginApi) {
       if (npm) {
         latestNpmVersion = npm.version
         allNpmVersions = npm.versions
+        npmDistTags = npm.distTags
         api.logger.info(
           `plugins.version: npm registry latest=${latestNpmVersion}, ${allNpmVersions.length} versions available`,
         )
@@ -182,6 +189,7 @@ export function registerPlugins(api: PluginApi) {
       npmPackageVersion,
       latestNpmVersion,
       allNpmVersions,
+      npmDistTags,
       updateAvailable,
       ...(errors.length ? {error: errors.join('; ')} : {}),
     })

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.6",
+  "version": "1.24.7-beta.1",
   "module": "index.ts",
   "type": "module",
   "repository": {