📦 new: proactive messaging, update checker, landing page, and CI overhaul

.github/workflows/release.yml

@@ -20,7 +20,7 @@ jobs:
           fetch-depth: 0
 
       - name: Create Release
-        uses: wgtechlabs/release-build-flow-action@140fc1588bdbf4a9e6fc992592f1f37a85a5404e # v1.4.2
+        uses: wgtechlabs/release-build-flow-action@5c5896446fd0631b74a3c94d589ad733a94dbfae # v1.4.3
         with:
           github-token: ${{ secrets.GH_PAT }}
           monorepo: 'true'

.husky/validate-commit-msg.mjs

@@ -22,7 +22,7 @@ if (/^Merge /.test(firstLine) || /^Revert /.test(firstLine)) process.exit(0);
 // Clean Commit convention pattern
 // Format: <emoji> <type>[!][(<scope>)]: <description>
 const pattern =
-  /^(📦|🔧|🗑\uFE0F?|🔒|⚙\uFE0F?|☕|🧪|📖|🚀) (new|update|remove|security|setup|chore|test|docs|release)(!?)( \([a-z0-9][a-z0-9-]*\))?: .{1,72}$/u;
+  /^(📦|🔧|🗑\uFE0F?|🔒|⚙\uFE0F?|☕|🧪|📖|🚀) (new|update|remove|security|setup|chore|test|docs|release)(!?)( \([a-zA-Z0-9][a-zA-Z0-9-]*\))?: .{1,72}$/u;
 
 // Only new, update, remove, security may use the breaking change marker
 const breakingMatch = firstLine.match(pattern);

Dockerfile

@@ -9,12 +9,14 @@ COPY packages/compactor/package.json ./packages/compactor/
 COPY packages/config/package.json ./packages/config/
 COPY packages/core/package.json ./packages/core/
 COPY packages/delegation/package.json ./packages/delegation/
+COPY packages/gateway/package.json ./packages/gateway/
 COPY packages/heartware/package.json ./packages/heartware/
 COPY packages/intercom/package.json ./packages/intercom/
 COPY packages/learning/package.json ./packages/learning/
 COPY packages/logger/package.json ./packages/logger/
 COPY packages/matcher/package.json ./packages/matcher/
 COPY packages/memory/package.json ./packages/memory/
+COPY packages/nudge/package.json ./packages/nudge/
 COPY packages/plugins/package.json ./packages/plugins/
 COPY packages/pulse/package.json ./packages/pulse/
 COPY packages/queue/package.json ./packages/queue/

packages/config/src/types.ts

@@ -147,6 +147,20 @@ export const TinyClawConfigSchema = z.object({
       removeDuplicateLines: z.boolean().optional(),
     }).optional(),
   }).optional(),
+
+  /** Nudge / proactive messaging settings */
+  nudge: z.object({
+    /** Master switch — disables all nudges when false. Default: true */
+    enabled: z.boolean().optional(),
+    /** Quiet hours start (24h format, e.g. '22:00'). */
+    quietHoursStart: z.string().regex(/^\d{2}:\d{2}$/).optional(),
+    /** Quiet hours end (24h format, e.g. '08:00'). */
+    quietHoursEnd: z.string().regex(/^\d{2}:\d{2}$/).optional(),
+    /** Max nudges per hour. Default: 5 */
+    maxPerHour: z.number().int().positive().optional(),
+    /** Categories to suppress (opt-out). */
+    suppressedCategories: z.array(z.string()).optional(),
+  }).optional(),
 }).passthrough();
 
 /**

packages/core/src/loop.ts

@@ -79,15 +79,28 @@ function containsInjectionPatterns(text: string): boolean {
   return INJECTION_PATTERNS.some(pattern => pattern.test(text));
 }
 
+/**
+ * Internal system userIds (pulse, companion, etc.) are trusted and should
+ * never be subjected to prompt injection sanitization.
+ */
+const INTERNAL_USER_PREFIXES = ['pulse:', 'companion:', 'system:'];
+
+function isInternalUser(userId: string): boolean {
+  return INTERNAL_USER_PREFIXES.some(prefix => userId.startsWith(prefix));
+}
+
 /**
  * Sanitize a user/friend message for prompt injection defense.
  * - For **owner** messages: no sanitization (owner is trusted).
+ * - For **internal** messages (pulse, companion): no sanitization (system-generated).
  * - For **friend** messages: if injection patterns are detected, wrap in
  *   boundary markers so the LLM treats it as untrusted content.
  */
 function sanitizeMessage(text: string, userId: string, ownerId: string | undefined): string {
   // Owner is fully trusted — no sanitization
   if (ownerId && isOwner(userId, ownerId)) return text;
+  // Internal system users are trusted — no sanitization
+  if (isInternalUser(userId)) return text;
   // No owner set yet — pre-claim, treat cautiously
   if (!ownerId) return text;
 
@@ -787,7 +800,11 @@ export async function agentLoop(
     logger.debug('LLM Response:', { type: response.type, contentLength: response.content?.length, content: response.content?.slice(0, 200) });
 
     if (response.type === 'text') {
-      const toolCall = extractToolCallFromText(response.content || '');
+      const rawToolCall = extractToolCallFromText(response.content || '');
+      // Only treat as a tool call if the extracted name matches a registered tool.
+      // This prevents the LLM's stray JSON from being misinterpreted as tool
+      // invocations, which was causing a "Working on that... Done!" loop.
+      const toolCall = rawToolCall && tools.some(t => t.name === rawToolCall.name) ? rawToolCall : null;
 
       if (toolCall) {
         jsonToolReplies += 1;
@@ -945,23 +962,22 @@ export async function agentLoop(
           continue;
         }
 
-        // For write operations, just return the summary
-        const responseText = summarizeToolResults([toolCall], toolResults);
-
-        if (onStream) {
-          onStream({ type: 'text', content: responseText });
-          onStream({ type: 'done' });
-        }
-
-        db.saveMessage(userId, 'user', message);
-        db.saveMessage(userId, 'assistant', responseText);
-        recordEpisodic(responseText);
-
-        setTimeout(() => {
-          learning.analyze(message, responseText, history);
-        }, 100);
+        // For write operations, feed the result back to the LLM so it
+        // can craft a natural, conversational response instead of the
+        // generic "Done!" that was causing a feedback loop in the history.
+        const writeResult = toolResults[0]?.result || 'completed';
+        const writeSummary = summarizeToolResults([toolCall], toolResults);
+        messages.push({
+          role: 'assistant',
+          content: `I used ${toolCall.name} and the result was: ${writeResult}`,
+        });
+        messages.push({
+          role: 'user',
+          content: 'Now respond naturally to my original message. Briefly confirm the action you took and be conversational.',
+        });
 
-        return responseText;
+        // Continue the loop to get LLM's natural response
+        continue;
       }
 
       // Stream the text response

packages/delegation/src/background.ts

@@ -8,7 +8,7 @@
 
 import type { Provider, Tool, Message } from '@tinyclaw/types';
 import { logger } from '@tinyclaw/logger';
-import type { DelegationStore, DelegationQueue } from './store.js';
+import type { DelegationStore, DelegationQueue, DelegationIntercom } from './store.js';
 import type {
   BackgroundRunner,
   BackgroundTaskRecord,
@@ -39,6 +39,7 @@ export function createBackgroundRunner(
   queue: DelegationQueue,
   timeoutEstimator?: TimeoutEstimator,
   templates?: TemplateManager,
+  intercom?: DelegationIntercom,
 ): BackgroundRunner {
   /** In-flight AbortControllers keyed by taskId. */
   const controllers = new Map<string, AbortController>();
@@ -137,6 +138,13 @@ export function createBackgroundRunner(
               db.updateBackgroundTask(taskId, 'completed', result.response, Date.now());
               lifecycle.recordTaskResult(agentId, true);
 
+              // Emit intercom event for nudge system
+              intercom?.emit('task:completed', userId, {
+                taskId,
+                agentId,
+                summary: result.response?.slice(0, 200),
+              });
+
               // Auto-create/update template on success
               if (templates) {
                 try {
@@ -161,6 +169,13 @@ export function createBackgroundRunner(
             } else {
               db.updateBackgroundTask(taskId, 'failed', result.response, Date.now());
               lifecycle.recordTaskResult(agentId, false);
+
+              // Emit intercom event for nudge system
+              intercom?.emit('task:failed', userId, {
+                taskId,
+                agentId,
+                error: result.response?.slice(0, 200),
+              });
             }
 
             // Auto-dismiss sub-agent once all its tasks are done — moves to History.
@@ -179,6 +194,13 @@ export function createBackgroundRunner(
             lifecycle.recordTaskResult(agentId, false);
             logger.error('Background task failed', { taskId, error: errorMsg });
 
+            // Emit intercom event for nudge system
+            intercom?.emit('task:failed', userId, {
+              taskId,
+              agentId,
+              error: errorMsg,
+            });
+
             // Auto-dismiss sub-agent on failure — move to History
             const allTasks = db.getUserBackgroundTasks(userId);
             const hasRunningTasks = allTasks.some(

packages/delegation/src/tools.ts

@@ -14,7 +14,7 @@
 
 import type { Tool, Provider, QueryTier } from '@tinyclaw/types';
 import { logger } from '@tinyclaw/logger';
-import type { DelegationStore, DelegationQueue } from './store.js';
+import type { DelegationStore, DelegationQueue, DelegationIntercom } from './store.js';
 import type {
   DelegationV2Config,
   LifecycleManager,
@@ -74,6 +74,8 @@ function filterToolsForSubAgent(
 
 export interface DelegationToolsConfig extends DelegationV2Config {
   queue: DelegationQueue;
+  /** Optional intercom for emitting task lifecycle events (nudge system). */
+  intercom?: DelegationIntercom;
 }
 
 export function createDelegationTools(config: DelegationToolsConfig): {
@@ -99,7 +101,7 @@ export function createDelegationTools(config: DelegationToolsConfig): {
 
   const lifecycle = createLifecycleManager(db);
   const templates = createTemplateManager(db);
-  const background = createBackgroundRunner(db, lifecycle, queue, timeoutEstimator, templates);
+  const background = createBackgroundRunner(db, lifecycle, queue, timeoutEstimator, templates, config.intercom);
 
   // Helper: build orientation for the current user
   function getOrientation(userId: string): OrientationContext {

packages/gateway/README.md

@@ -0,0 +1,35 @@
+# @tinyclaw/gateway
+
+Outbound message gateway for proactive messaging across channels.
+
+Routes messages from the agent system to users via their connected channel (Web UI, Discord, Friends Chat, etc.) using userId prefix-based routing.
+
+## Usage
+
+```ts
+import { createGateway } from '@tinyclaw/gateway';
+
+const gateway = createGateway();
+
+// Register a channel sender
+gateway.register('web', {
+  name: 'Web UI',
+  async send(userId, message) {
+    // Push via SSE to the browser
+  },
+});
+
+// Send a proactive message
+await gateway.send('web:owner', {
+  content: 'Your background task is complete!',
+  priority: 'normal',
+  source: 'background_task',
+});
+
+// Broadcast to all channels
+await gateway.broadcast({
+  content: 'System update available',
+  priority: 'low',
+  source: 'system',
+});
+```

packages/gateway/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@tinyclaw/gateway",
+  "private": true,
+  "version": "1.1.0",
+  "description": "Outbound message gateway for proactive messaging across channels",
+  "license": "GPL-3.0",
+  "author": "Waren Gonzaga",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/warengonzaga/tinyclaw.git",
+    "directory": "packages/gateway"
+  },
+  "homepage": "https://github.com/warengonzaga/tinyclaw/tree/main/packages/gateway#readme",
+  "bugs": {
+    "url": "https://github.com/warengonzaga/tinyclaw/issues"
+  },
+  "keywords": ["tinyclaw", "gateway", "outbound", "messaging"],
+  "scripts": {
+    "build": "tsc -p tsconfig.json"
+  },
+  "dependencies": {
+    "@tinyclaw/types": "workspace:*",
+    "@tinyclaw/logger": "workspace:*"
+  }
+}