agentgate 0.1.8 → 0.2.0

package/README.md

@@ -109,7 +109,31 @@ curl -H "Authorization: Bearer rms_your_key" \
   https://your-server.com/api/skill > SKILL.md
 ```
 
+### Webhook Notifications
+
+agentgate can notify your agent when queue items are completed, failed, or rejected — closing the feedback loop so your agent knows immediately when requests are processed.
+
+**Setup in Admin UI:**
+1. Go to **Advanced → Clawdbot Notifications**
+2. Enter your OpenClaw/Clawdbot webhook URL (e.g., `https://your-gateway.example.com/hooks/wake`)
+3. Enter the hooks token from your OpenClaw config
+4. Choose events: `completed`, `failed`, `rejected`
+
+**Features:**
+- **Real-time notifications** — Instant webhook on each approval/rejection
+- **Notification status** — See ✓ notified / ⚠ failed on each queue entry
+- **Retry individual** — Resend failed notifications one at a time
+- **Batch catch-up** — "Retry All" sends missed notifications in one batched message
+
+**Webhook payload:**
+```json
+{
+  "text": "✅ [agentgate] Queue #abc123 completed\n→ github/monteslu\n→ https://github.com/...\nOriginal: \"Create PR for fix\"",
+  "mode": "now"
+}
+```
 
+Compatible with OpenClaw's `/hooks/wake` endpoint. See [OpenClaw webhook docs](https://docs.openclaw.ai/automation/webhook).
 
 ## API Key Management
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentgate",
-  "version": "0.1.8",
+  "version": "0.2.0",
   "type": "module",
   "description": "API gateway for AI agents with human-in-the-loop write approval",
   "main": "src/index.js",

package/public/style.css

@@ -582,3 +582,12 @@ body > p:first-of-type {
   background: rgba(99, 102, 241, 0.3);
   color: white;
 }
+
+/* Success message */
+.success-message {
+  background: rgba(16, 185, 129, 0.15);
+  color: #34d399;
+  padding: 12px 16px;
+  border-radius: 8px;
+  border: 1px solid rgba(16, 185, 129, 0.3);
+}

package/src/index.js

@@ -2,7 +2,7 @@ import express from 'express';
 import cookieParser from 'cookie-parser';
 import { fileURLToPath } from 'url';
 import { dirname, join } from 'path';
-import { validateApiKey, getAccountsByService, getCookieSecret } from './lib/db.js';
+import { validateApiKey, getAccountsByService, getCookieSecret, getSetting } from './lib/db.js';
 import { connectHsync } from './lib/hsyncManager.js';
 import githubRoutes, { serviceInfo as githubInfo } from './routes/github.js';
 import blueskyRoutes, { serviceInfo as blueskyInfo } from './routes/bluesky.js';
@@ -126,7 +126,7 @@ app.get('/api/readme', apiKeyAuth, (req, res) => {
       description: 'For write operations (POST/PUT/DELETE), you must submit requests to the write queue. A human will review and approve or reject your request. You cannot execute write operations directly.',
       workflow: [
         '1. Submit your write request(s) with a comment explaining your intent',
-        '2. Poll the status endpoint to check if approved/rejected',
+        '2. Wait for webhook notification OR poll the status endpoint',
         '3. If rejected, check rejection_reason and adjust your approach',
         '4. If approved and completed, results contain the API responses',
         '5. If failed, results show which request failed and why'
@@ -205,6 +205,27 @@ app.get('/api/readme', apiKeyAuth, (req, res) => {
         }
       }
     },
+    notifications: (() => {
+      const config = getSetting('notifications');
+      const enabled = config?.clawdbot?.enabled || false;
+      return {
+        enabled,
+        description: enabled
+          ? 'Webhook notifications are ENABLED. You will receive automatic notifications when queue items complete, fail, or are rejected. No need to poll.'
+          : 'Webhook notifications are NOT configured. You must poll the status endpoint to check request status.',
+        setup: 'Configure in Admin UI under Advanced → Clawdbot Notifications',
+        webhookFormat: {
+          description: 'POST to your webhook URL with JSON body',
+          payload: {
+            text: 'Notification message with status, service, result URL, and original comment',
+            mode: 'now'
+          },
+          example: '✅ [agentgate] Queue #abc123 completed\\n→ github/monteslu\\n→ https://github.com/...\\nOriginal: "Create PR"'
+        },
+        events: enabled ? (config.clawdbot.events || ['completed', 'failed']) : ['completed', 'failed', 'rejected'],
+        compatible: 'OpenClaw/Clawdbot /hooks/wake endpoint'
+      };
+    })(),
     skill: {
       description: 'Generate a SKILL.md file for OpenClaw/AgentSkills compatible systems',
       endpoint: 'GET /api/skill',

package/src/lib/db.js

@@ -42,10 +42,34 @@ db.exec(`
     submitted_by TEXT,
     submitted_at TEXT DEFAULT CURRENT_TIMESTAMP,
     reviewed_at TEXT,
-    completed_at TEXT
+    completed_at TEXT,
+    notified INTEGER DEFAULT 0,
+    notified_at TEXT,
+    notify_error TEXT
   );
 `);
 
+// Migrate write_queue table to add notification columns
+try {
+  const queueInfo = db.prepare('PRAGMA table_info(write_queue)').all();
+  const hasNotified = queueInfo.some(col => col.name === 'notified');
+
+  if (queueInfo.length > 0 && !hasNotified) {
+    console.log('Migrating write_queue table to add notification columns...');
+    db.exec(`
+      ALTER TABLE write_queue ADD COLUMN notified INTEGER DEFAULT 0;
+      ALTER TABLE write_queue ADD COLUMN notified_at TEXT;
+      ALTER TABLE write_queue ADD COLUMN notify_error TEXT;
+    `);
+    console.log('Migration complete.');
+  }
+} catch (err) {
+  // Columns might already exist or table doesn't exist yet
+  if (!err.message.includes('duplicate column')) {
+    console.error('Error migrating write_queue:', err.message);
+  }
+}
+
 // Initialize api_keys table with migration support for old schema
 // Old schema had: id, name, key, created_at
 // New schema has: id, name, key_prefix, key_hash, created_at
@@ -228,7 +252,8 @@ export function getQueueEntry(id) {
   return {
     ...row,
     requests: JSON.parse(row.requests),
-    results: row.results ? JSON.parse(row.results) : null
+    results: row.results ? JSON.parse(row.results) : null,
+    notified: Boolean(row.notified)
   };
 }
 
@@ -242,7 +267,39 @@ export function listQueueEntries(status) {
   return rows.map(row => ({
     ...row,
     requests: JSON.parse(row.requests),
-    results: row.results ? JSON.parse(row.results) : null
+    results: row.results ? JSON.parse(row.results) : null,
+    notified: Boolean(row.notified)
+  }));
+}
+
+export function updateQueueNotification(id, success, error = null) {
+  if (success) {
+    db.prepare(`
+      UPDATE write_queue
+      SET notified = 1, notified_at = CURRENT_TIMESTAMP, notify_error = NULL
+      WHERE id = ?
+    `).run(id);
+  } else {
+    db.prepare(`
+      UPDATE write_queue
+      SET notified = 0, notify_error = ?
+      WHERE id = ?
+    `).run(error, id);
+  }
+}
+
+export function listUnnotifiedEntries() {
+  const rows = db.prepare(`
+    SELECT * FROM write_queue
+    WHERE status IN ('completed', 'failed', 'rejected')
+      AND notified = 0
+    ORDER BY completed_at DESC
+  `).all();
+  return rows.map(row => ({
+    ...row,
+    requests: JSON.parse(row.requests),
+    results: row.results ? JSON.parse(row.results) : null,
+    notified: false
   }));
 }
 

package/src/lib/notifier.js

@@ -0,0 +1,286 @@
+import { getSetting, updateQueueNotification } from './db.js';
+
+/**
+ * Send a notification to Clawdbot webhook when queue items complete/fail
+ */
+
+const DEFAULT_RETRY_ATTEMPTS = 3;
+const DEFAULT_RETRY_DELAY_MS = 5000;
+
+/**
+ * Find the most relevant result to display (usually last one with a URL, or first failure)
+ */
+function findRelevantResult(results, forError = false) {
+  if (!results?.length) return null;
+  
+  if (forError) {
+    // For errors, find the first non-ok result
+    return results.find(r => !r.ok) || results[results.length - 1];
+  }
+  
+  // For success, find the last result with a useful URL (PR, issue, etc.)
+  // Search backwards to get the most relevant one (e.g., PR URL, not branch ref)
+  for (let i = results.length - 1; i >= 0; i--) {
+    const r = results[i];
+    if (r.body?.html_url || r.body?.url) {
+      return r;
+    }
+  }
+  
+  // Fallback to last result
+  return results[results.length - 1];
+}
+
+/**
+ * Format the notification text for a queue entry
+ */
+function formatNotification(entry) {
+  const emoji = entry.status === 'completed' ? '✅' :
+    entry.status === 'failed' ? '❌' : '🚫';
+
+  let text = `${emoji} [agentgate] Queue #${entry.id} ${entry.status}`;
+  text += `\n→ ${entry.service}/${entry.account_name}`;
+
+  // Include key result info (e.g., PR URL, issue URL)
+  if (entry.status === 'completed' && entry.results?.length) {
+    const relevantResult = findRelevantResult(entry.results, false);
+    if (relevantResult?.body) {
+      // GitHub PR/Issue
+      if (relevantResult.body.html_url) {
+        text += `\n→ ${relevantResult.body.html_url}`;
+      }
+      // Other useful fields
+      else if (relevantResult.body.url) {
+        text += `\n→ ${relevantResult.body.url}`;
+      }
+    }
+  }
+
+  // Include error info for failures
+  if (entry.status === 'failed' && entry.results?.length) {
+    const failingResult = findRelevantResult(entry.results, true);
+    if (failingResult.error) {
+      text += `\n→ Error: ${failingResult.error}`;
+    } else if (failingResult.body?.message) {
+      text += `\n→ Error: ${failingResult.body.message}`;
+    } else if (!failingResult.ok && failingResult.status) {
+      text += `\n→ Error: HTTP ${failingResult.status}`;
+    }
+  }
+
+  // Include rejection reason
+  if (entry.status === 'rejected' && entry.rejection_reason) {
+    text += `\n→ Reason: ${entry.rejection_reason}`;
+  }
+
+  // Original comment/intent
+  if (entry.comment) {
+    // Truncate long comments
+    const comment = entry.comment.length > 100
+      ? entry.comment.substring(0, 100) + '...'
+      : entry.comment;
+    text += `\nOriginal: "${comment}"`;
+  }
+
+  return text;
+}
+
+/**
+ * Sleep helper
+ */
+function sleep(ms) {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+/**
+ * Send notification to Clawdbot
+ * @param {object} entry - The queue entry to notify about
+ * @returns {Promise<{success: boolean, error?: string}>}
+ */
+export async function notifyClawdbot(entry) {
+  const config = getSetting('notifications');
+
+  if (!config?.clawdbot?.enabled) {
+    return { success: true, skipped: true };
+  }
+
+  const { url, token, events, retryAttempts, retryDelayMs } = config.clawdbot;
+
+  // Check if this event type should be notified
+  const allowedEvents = events || ['completed', 'failed'];
+  if (!allowedEvents.includes(entry.status)) {
+    return { success: true, skipped: true };
+  }
+
+  if (!url || !token) {
+    const error = 'Clawdbot notification config incomplete (missing url or token)';
+    updateQueueNotification(entry.id, false, error);
+    return { success: false, error };
+  }
+
+  const payload = {
+    text: formatNotification(entry),
+    mode: 'now'
+  };
+
+  const maxAttempts = retryAttempts || DEFAULT_RETRY_ATTEMPTS;
+  const delay = retryDelayMs || DEFAULT_RETRY_DELAY_MS;
+  let lastError = null;
+
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    try {
+      const response = await fetch(url, {
+        method: 'POST',
+        headers: {
+          'Authorization': `Bearer ${token}`,
+          'Content-Type': 'application/json'
+        },
+        body: JSON.stringify(payload)
+      });
+
+      if (response.ok) {
+        // Success
+        updateQueueNotification(entry.id, true, null);
+        return { success: true };
+      }
+
+      // Non-OK response
+      const text = await response.text().catch(() => '');
+      lastError = `HTTP ${response.status}: ${text.substring(0, 100)}`;
+
+    } catch (err) {
+      lastError = err.message;
+    }
+
+    // Retry after delay (unless last attempt)
+    if (attempt < maxAttempts) {
+      await sleep(delay);
+    }
+  }
+
+  // All retries failed
+  updateQueueNotification(entry.id, false, lastError);
+  return { success: false, error: lastError };
+}
+
+/**
+ * Retry notification for a specific queue entry
+ */
+export async function retryNotification(entryId, getQueueEntry) {
+  const entry = getQueueEntry(entryId);
+  if (!entry) {
+    return { success: false, error: 'Queue entry not found' };
+  }
+
+  // Only retry for completed/failed/rejected entries
+  if (!['completed', 'failed', 'rejected'].includes(entry.status)) {
+    return { success: false, error: 'Can only notify for completed/failed/rejected entries' };
+  }
+
+  return notifyClawdbot(entry);
+}
+
+/**
+ * Format a short summary line for batch notifications
+ */
+function formatBatchLine(entry) {
+  const emoji = entry.status === 'completed' ? '✅' :
+    entry.status === 'failed' ? '❌' : '🚫';
+
+  let line = `${emoji} #${entry.id.substring(0, 8)} - ${entry.service}/${entry.account_name}`;
+
+  // Add brief result info
+  if (entry.status === 'completed') {
+    const relevantResult = findRelevantResult(entry.results, false);
+    if (relevantResult?.body?.html_url) {
+      line += ` - ${relevantResult.body.html_url}`;
+    }
+  } else if (entry.status === 'failed') {
+    const failingResult = findRelevantResult(entry.results, true);
+    const err = failingResult?.error || failingResult?.body?.message || (failingResult && !failingResult.ok ? `HTTP ${failingResult.status || '?'}` : 'Unknown error');
+    line += ` - ${err.substring(0, 50)}`;
+  } else if (entry.status === 'rejected') {
+    line += ` - ${(entry.rejection_reason || 'rejected').substring(0, 50)}`;
+  }
+
+  return line;
+}
+
+/**
+ * Send a single batched notification for multiple queue entries
+ * @param {object[]} entries - Array of queue entries to notify about
+ * @returns {Promise<{success: boolean, error?: string}>}
+ */
+export async function notifyClawdbotBatch(entries) {
+  const config = getSetting('notifications');
+
+  if (!config?.clawdbot?.enabled) {
+    return { success: true, skipped: true };
+  }
+
+  const { url, token, retryAttempts, retryDelayMs } = config.clawdbot;
+
+  if (!url || !token) {
+    const error = 'Clawdbot notification config incomplete (missing url or token)';
+    for (const entry of entries) {
+      updateQueueNotification(entry.id, false, error);
+    }
+    return { success: false, error };
+  }
+
+  // Build batched message
+  const completed = entries.filter(e => e.status === 'completed').length;
+  const failed = entries.filter(e => e.status === 'failed').length;
+  const rejected = entries.filter(e => e.status === 'rejected').length;
+
+  const counts = [];
+  if (completed) counts.push(`${completed} completed`);
+  if (failed) counts.push(`${failed} failed`);
+  if (rejected) counts.push(`${rejected} rejected`);
+
+  let text = `📬 [agentgate] Catch-up: ${entries.length} item${entries.length > 1 ? 's' : ''} (${counts.join(', ')})\n\n`;
+  text += entries.map(formatBatchLine).join('\n');
+
+  const payload = { text, mode: 'now' };
+
+  const maxAttempts = retryAttempts || DEFAULT_RETRY_ATTEMPTS;
+  const delay = retryDelayMs || DEFAULT_RETRY_DELAY_MS;
+  let lastError = null;
+
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    try {
+      const response = await fetch(url, {
+        method: 'POST',
+        headers: {
+          'Authorization': `Bearer ${token}`,
+          'Content-Type': 'application/json'
+        },
+        body: JSON.stringify(payload)
+      });
+
+      if (response.ok) {
+        // Success - mark all as notified
+        for (const entry of entries) {
+          updateQueueNotification(entry.id, true, null);
+        }
+        return { success: true };
+      }
+
+      const respText = await response.text().catch(() => '');
+      lastError = `HTTP ${response.status}: ${respText.substring(0, 100)}`;
+
+    } catch (err) {
+      lastError = err.message;
+    }
+
+    if (attempt < maxAttempts) {
+      await sleep(delay);
+    }
+  }
+
+  // All retries failed
+  for (const entry of entries) {
+    updateQueueNotification(entry.id, false, lastError);
+  }
+  return { success: false, error: lastError };
+}

package/src/lib/queueExecutor.js

@@ -1,4 +1,5 @@
-import { getAccountCredentials, setAccountCredentials, updateQueueStatus } from './db.js';
+import { getAccountCredentials, setAccountCredentials, updateQueueStatus, getQueueEntry } from './db.js';
+import { notifyClawdbot } from './notifier.js';
 
 // Service base URLs
 const SERVICE_URLS = {
@@ -270,6 +271,17 @@ function buildHeaders(service, token, customHeaders = {}) {
   return headers;
 }
 
+// Helper to update status and send notification
+function finalizeEntry(entryId, status, results) {
+  updateQueueStatus(entryId, status, { results });
+
+  // Send notification to Clawdbot (async, don't block)
+  const updatedEntry = getQueueEntry(entryId);
+  notifyClawdbot(updatedEntry).catch(err => {
+    console.error('[notifier] Failed to notify Clawdbot:', err.message);
+  });
+}
+
 // Execute a single queued entry (batch of requests)
 export async function executeQueueEntry(entry) {
   const results = [];
@@ -290,7 +302,7 @@ export async function executeQueueEntry(entry) {
           ok: false,
           error: `Failed to get access token for ${service}/${account_name}`
         });
-        updateQueueStatus(entry.id, 'failed', { results });
+        finalizeEntry(entry.id, 'failed', results);
         return { success: false, results };
       }
 
@@ -302,7 +314,7 @@ export async function executeQueueEntry(entry) {
           ok: false,
           error: `Unknown service or invalid configuration: ${service}`
         });
-        updateQueueStatus(entry.id, 'failed', { results });
+        finalizeEntry(entry.id, 'failed', results);
         return { success: false, results };
       }
 
@@ -346,7 +358,7 @@ export async function executeQueueEntry(entry) {
 
       // Stop on first failure
       if (!response.ok) {
-        updateQueueStatus(entry.id, 'failed', { results });
+        finalizeEntry(entry.id, 'failed', results);
         return { success: false, results };
       }
 
@@ -356,12 +368,12 @@ export async function executeQueueEntry(entry) {
         ok: false,
         error: err.message
       });
-      updateQueueStatus(entry.id, 'failed', { results });
+      finalizeEntry(entry.id, 'failed', results);
       return { success: false, results };
     }
   }
 
   // All requests succeeded
-  updateQueueStatus(entry.id, 'completed', { results });
+  finalizeEntry(entry.id, 'completed', results);
   return { success: true, results };
 }

package/src/routes/ui.js

@@ -3,10 +3,12 @@ import {
   listAccounts, getSetting, setSetting, deleteSetting,
   setAdminPassword, verifyAdminPassword, hasAdminPassword,
   listQueueEntries, getQueueEntry, updateQueueStatus, clearQueueByStatus, deleteQueueEntry, getPendingQueueCount, getQueueCounts,
-  listApiKeys, createApiKey, deleteApiKey
+  listApiKeys, createApiKey, deleteApiKey,
+  listUnnotifiedEntries
 } from '../lib/db.js';
 import { connectHsync, disconnectHsync, getHsyncUrl, isHsyncConnected } from '../lib/hsyncManager.js';
 import { executeQueueEntry } from '../lib/queueExecutor.js';
+import { notifyClawdbot, retryNotification } from '../lib/notifier.js';
 import { registerAllRoutes, renderAllCards } from './ui/index.js';
 
 const router = Router();
@@ -121,8 +123,9 @@ router.get('/', (req, res) => {
   const hsyncUrl = getHsyncUrl();
   const hsyncConnected = isHsyncConnected();
   const pendingQueueCount = getPendingQueueCount();
+  const notificationsConfig = getSetting('notifications');
 
-  res.send(renderPage(accounts, { hsyncConfig, hsyncUrl, hsyncConnected, pendingQueueCount }));
+  res.send(renderPage(accounts, { hsyncConfig, hsyncUrl, hsyncConnected, pendingQueueCount, notificationsConfig }));
 });
 
 // Register all service routes (github, bluesky, reddit, etc.)
@@ -149,6 +152,79 @@ router.post('/hsync/delete', async (req, res) => {
   res.redirect('/ui');
 });
 
+// Notification settings
+router.post('/notifications/setup', (req, res) => {
+  const { url, token, events } = req.body;
+  if (!url) {
+    return res.status(400).send('Webhook URL required');
+  }
+
+  // Parse events - could be comma-separated string or array
+  let eventList = ['completed', 'failed'];
+  if (events) {
+    eventList = Array.isArray(events) ? events : events.split(',').map(e => e.trim());
+  }
+
+  setSetting('notifications', {
+    clawdbot: {
+      enabled: true,
+      url: url.replace(/\/$/, ''),
+      token: token || '',
+      events: eventList,
+      retryAttempts: 3,
+      retryDelayMs: 5000
+    }
+  });
+  res.redirect('/ui');
+});
+
+router.post('/notifications/delete', (req, res) => {
+  deleteSetting('notifications');
+  res.redirect('/ui');
+});
+
+router.post('/notifications/test', async (req, res) => {
+  const wantsJson = req.headers.accept?.includes('application/json');
+  const config = getSetting('notifications');
+
+  if (!config?.clawdbot?.enabled || !config.clawdbot.url || !config.clawdbot.token) {
+    const error = 'Notifications not configured';
+    return wantsJson
+      ? res.status(400).json({ success: false, error })
+      : res.status(400).send(error);
+  }
+
+  try {
+    const response = await fetch(config.clawdbot.url, {
+      method: 'POST',
+      headers: {
+        'Authorization': `Bearer ${config.clawdbot.token}`,
+        'Content-Type': 'application/json'
+      },
+      body: JSON.stringify({
+        text: '🧪 [agentgate] Test notification - webhook is working!',
+        mode: 'now'
+      })
+    });
+
+    if (response.ok) {
+      return wantsJson
+        ? res.json({ success: true })
+        : res.redirect('/ui?notification_test=success');
+    } else {
+      const text = await response.text().catch(() => '');
+      const error = `HTTP ${response.status}: ${text.substring(0, 100)}`;
+      return wantsJson
+        ? res.status(400).json({ success: false, error })
+        : res.redirect('/ui?notification_test=failed');
+    }
+  } catch (err) {
+    return wantsJson
+      ? res.status(500).json({ success: false, error: err.message })
+      : res.redirect('/ui?notification_test=failed');
+  }
+});
+
 // Write Queue Management
 router.get('/queue', (req, res) => {
   const filter = req.query.filter || 'all';
@@ -159,7 +235,8 @@ router.get('/queue', (req, res) => {
     entries = listQueueEntries(filter);
   }
   const counts = getQueueCounts();
-  res.send(renderQueuePage(entries, filter, counts));
+  const unnotified = listUnnotifiedEntries();
+  res.send(renderQueuePage(entries, filter, counts, unnotified.length));
 });
 
 router.post('/queue/:id/approve', async (req, res) => {
@@ -196,7 +273,7 @@ router.post('/queue/:id/approve', async (req, res) => {
   res.redirect('/ui/queue');
 });
 
-router.post('/queue/:id/reject', (req, res) => {
+router.post('/queue/:id/reject', async (req, res) => {
   const { id } = req.params;
   const { reason } = req.body;
   const wantsJson = req.headers.accept?.includes('application/json');
@@ -216,7 +293,12 @@ router.post('/queue/:id/reject', (req, res) => {
 
   updateQueueStatus(id, 'rejected', { rejection_reason: reason || 'No reason provided' });
 
+  // Send notification to Clawdbot
   const updated = getQueueEntry(id);
+  notifyClawdbot(updated).catch(err => {
+    console.error('[notifier] Failed to notify Clawdbot:', err.message);
+  });
+
   const counts = getQueueCounts();
 
   if (wantsJson) {
@@ -266,6 +348,41 @@ router.delete('/queue/:id', (req, res) => {
   res.redirect('/ui/queue');
 });
 
+// Retry notification for a specific queue entry
+router.post('/queue/:id/notify', async (req, res) => {
+  const { id } = req.params;
+  const wantsJson = req.headers.accept?.includes('application/json');
+
+  const result = await retryNotification(id, getQueueEntry);
+  const updated = getQueueEntry(id);
+
+  if (wantsJson) {
+    return res.json({ success: result.success, error: result.error, entry: updated });
+  }
+  res.redirect('/ui/queue');
+});
+
+// Retry all failed notifications
+router.post('/queue/notify-all', async (req, res) => {
+  const wantsJson = req.headers.accept?.includes('application/json');
+  const unnotified = listUnnotifiedEntries();
+
+  if (unnotified.length === 0) {
+    return wantsJson
+      ? res.json({ success: true, count: 0 })
+      : res.redirect('/ui/queue');
+  }
+
+  // Batch into single notification
+  const { notifyClawdbotBatch } = await import('../lib/notifier.js');
+  const result = await notifyClawdbotBatch(unnotified);
+
+  if (wantsJson) {
+    return res.json({ success: result.success, error: result.error, count: unnotified.length });
+  }
+  res.redirect('/ui/queue');
+});
+
 // API Keys Management
 router.get('/keys', (req, res) => {
   const keys = listApiKeys();
@@ -320,7 +437,8 @@ router.delete('/keys/:id', (req, res) => {
 
 // HTML Templates
 
-function renderPage(accounts, { hsyncConfig, hsyncUrl, hsyncConnected, pendingQueueCount }) {
+function renderPage(accounts, { hsyncConfig, hsyncUrl, hsyncConnected, pendingQueueCount, notificationsConfig }) {
+  const clawdbotConfig = notificationsConfig?.clawdbot;
   return `<!DOCTYPE html>
 <html>
 <head>
@@ -402,6 +520,64 @@ curl -X POST http://localhost:${PORT}/api/queue/github/personal/submit \\
       </div>
     </details>
   </div>
+
+  <div class="card">
+    <details ${clawdbotConfig?.enabled ? 'open' : ''}>
+      <summary>Clawdbot Notifications ${clawdbotConfig?.enabled ? '<span class="status configured">Configured</span>' : ''}</summary>
+      <div style="margin-top: 16px;">
+        <div id="notification-feedback"></div>
+        ${clawdbotConfig?.enabled ? `
+          <p>Webhook URL: <strong>${clawdbotConfig.url}</strong></p>
+          <p>Events: <code>${(clawdbotConfig.events || ['completed', 'failed']).join(', ')}</code></p>
+          <div style="display: flex; gap: 8px; margin-top: 12px;">
+            <button type="button" class="btn-primary btn-sm" id="test-notification-btn" onclick="testNotification()">Send Test</button>
+            <form method="POST" action="/ui/notifications/delete" style="margin: 0;">
+              <button type="submit" class="btn-danger btn-sm">Disable</button>
+            </form>
+          </div>
+          <script>
+            async function testNotification() {
+              const btn = document.getElementById('test-notification-btn');
+              const feedback = document.getElementById('notification-feedback');
+              btn.disabled = true;
+              btn.textContent = 'Sending...';
+              feedback.innerHTML = '';
+              
+              try {
+                const res = await fetch('/ui/notifications/test', {
+                  method: 'POST',
+                  headers: { 'Accept': 'application/json' }
+                });
+                const data = await res.json();
+                
+                if (data.success) {
+                  feedback.innerHTML = '<div class="success-message" style="margin-bottom: 16px;">✓ Test notification sent!</div>';
+                } else {
+                  feedback.innerHTML = '<div class="error-message" style="margin-bottom: 16px;">✗ ' + (data.error || 'Failed to send') + '</div>';
+                }
+              } catch (err) {
+                feedback.innerHTML = '<div class="error-message" style="margin-bottom: 16px;">✗ ' + err.message + '</div>';
+              }
+              
+              btn.disabled = false;
+              btn.textContent = 'Send Test';
+            }
+          </script>
+        ` : `
+          <p class="help">Send notifications to <a href="https://docs.clawd.bot" target="_blank">Clawdbot</a> when queue items are completed, failed, or rejected.</p>
+          <form method="POST" action="/ui/notifications/setup">
+            <label>Webhook URL</label>
+            <input type="text" name="url" placeholder="https://your-gateway.example.com/hooks/wake" required>
+            <label>Token</label>
+            <input type="password" name="token" placeholder="Clawdbot hooks token" required>
+            <label>Events (comma-separated)</label>
+            <input type="text" name="events" placeholder="completed, failed, rejected" value="completed, failed, rejected">
+            <button type="submit" class="btn-primary">Enable Notifications</button>
+          </form>
+        `}
+      </div>
+    </details>
+  </div>
 </body>
 </html>`;
 }
@@ -455,7 +631,7 @@ function renderSetupPasswordPage(error = '') {
 </html>`;
 }
 
-function renderQueuePage(entries, filter, counts) {
+function renderQueuePage(entries, filter, counts, unnotifiedCount = 0) {
   const escapeHtml = (str) => {
     if (typeof str !== 'string') str = JSON.stringify(str, null, 2);
     return str.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;');
@@ -525,8 +701,28 @@ function renderQueuePage(entries, filter, counts) {
       `;
     }
 
+    // Notification status (only show for completed/failed/rejected)
+    let notificationSection = '';
+    if (['completed', 'failed', 'rejected'].includes(entry.status)) {
+      const notifyStatus = entry.notified
+        ? `<span class="notify-status notify-sent" title="Notified at ${formatDate(entry.notified_at)}">✓ Notified</span>`
+        : entry.notify_error
+          ? `<span class="notify-status notify-failed" title="${escapeHtml(entry.notify_error)}">⚠ Notify failed</span>`
+          : '<span class="notify-status notify-pending">— Not notified</span>';
+
+      const retryBtn = !entry.notified
+        ? `<button type="button" class="btn-sm btn-link" onclick="retryNotify('${entry.id}')" id="retry-${entry.id}">Retry</button>`
+        : '';
+
+      notificationSection = `
+        <div class="notification-status" id="notify-status-${entry.id}">
+          ${notifyStatus} ${retryBtn}
+        </div>
+      `;
+    }
+
     return `
-      <div class="card queue-entry" id="entry-${entry.id}" data-status="${entry.status}">
+      <div class="card queue-entry" id="entry-${entry.id}" data-status="${entry.status}" data-notified="${entry.notified ? '1' : '0'}">
         <div style="display: flex; justify-content: space-between; align-items: flex-start; margin-bottom: 12px;">
           <div class="entry-header">
             <strong>${entry.service}</strong> / ${entry.account_name}
@@ -552,6 +748,7 @@ function renderQueuePage(entries, filter, counts) {
         </details>
 
         ${resultSection}
+        ${notificationSection}
         ${actions}
       </div>
     `;
@@ -704,6 +901,46 @@ function renderQueuePage(entries, filter, counts) {
       padding: 60px 40px;
     }
     .empty-state p { color: #6b7280; margin: 0; font-size: 16px; }
+    .notification-status {
+      margin-top: 12px;
+      padding-top: 12px;
+      border-top: 1px solid rgba(255, 255, 255, 0.1);
+      display: flex;
+      align-items: center;
+      gap: 12px;
+      font-size: 13px;
+    }
+    .notify-status {
+      padding: 4px 10px;
+      border-radius: 6px;
+      font-weight: 500;
+    }
+    .notify-sent {
+      background: rgba(16, 185, 129, 0.15);
+      color: #34d399;
+      border: 1px solid rgba(16, 185, 129, 0.3);
+    }
+    .notify-failed {
+      background: rgba(245, 158, 11, 0.15);
+      color: #fbbf24;
+      border: 1px solid rgba(245, 158, 11, 0.3);
+    }
+    .notify-pending {
+      background: rgba(156, 163, 175, 0.15);
+      color: #9ca3af;
+      border: 1px solid rgba(156, 163, 175, 0.3);
+    }
+    .btn-link {
+      background: none;
+      border: none;
+      color: #818cf8;
+      cursor: pointer;
+      text-decoration: underline;
+      padding: 4px 8px;
+      font-size: 13px;
+    }
+    .btn-link:hover { color: #a5b4fc; }
+    .btn-link:disabled { color: #6b7280; cursor: not-allowed; text-decoration: none; }
   </style>
 </head>
 <body>
@@ -716,6 +953,7 @@ function renderQueuePage(entries, filter, counts) {
   <div class="filter-bar" id="filter-bar">
     ${filterLinks}
     <div class="clear-section">
+      ${unnotifiedCount > 0 ? `<button type="button" class="btn-sm btn-primary" onclick="retryAllNotifications()" id="retry-all-btn">Retry ${unnotifiedCount} Notification${unnotifiedCount > 1 ? 's' : ''}</button>` : ''}
       ${filter === 'completed' && counts.completed > 0 ? '<button type="button" class="btn-sm btn-danger" onclick="clearByStatus(\'completed\')">Clear Completed</button>' : ''}
       ${filter === 'failed' && counts.failed > 0 ? '<button type="button" class="btn-sm btn-danger" onclick="clearByStatus(\'failed\')">Clear Failed</button>' : ''}
       ${filter === 'rejected' && counts.rejected > 0 ? '<button type="button" class="btn-sm btn-danger" onclick="clearByStatus(\'rejected\')">Clear Rejected</button>' : ''}
@@ -894,6 +1132,9 @@ function renderQueuePage(entries, filter, counts) {
 
           // Hide the clear button if nothing left to clear
           btn.style.display = 'none';
+
+          // Update retry notifications button
+          updateRetryAllButton();
         }
 
         btn.disabled = false;
@@ -930,6 +1171,89 @@ function renderQueuePage(entries, filter, counts) {
         alert('Error: ' + err.message);
       }
     }
+
+    function updateRetryAllButton() {
+      // Count remaining unnotified entries in DOM
+      const unnotified = document.querySelectorAll('.queue-entry[data-notified="0"]').length;
+      const btn = document.getElementById('retry-all-btn');
+      
+      if (unnotified === 0) {
+        if (btn) btn.remove();
+      } else if (btn) {
+        btn.textContent = 'Retry ' + unnotified + ' Notification' + (unnotified > 1 ? 's' : '');
+      }
+    }
+
+    async function retryAllNotifications() {
+      const btn = document.getElementById('retry-all-btn');
+      if (btn) {
+        btn.disabled = true;
+        btn.textContent = 'Sending...';
+      }
+
+      try {
+        const res = await fetch('/ui/queue/notify-all', {
+          method: 'POST',
+          headers: { 'Accept': 'application/json' }
+        });
+        const data = await res.json();
+
+        if (data.success) {
+          // Refresh the page to show updated status
+          window.location.reload();
+        } else {
+          alert(data.error || 'Failed to send notifications');
+          if (btn) {
+            btn.disabled = false;
+            btn.textContent = 'Retry Notifications';
+          }
+        }
+      } catch (err) {
+        alert('Error: ' + err.message);
+        if (btn) {
+          btn.disabled = false;
+          btn.textContent = 'Retry Notifications';
+        }
+      }
+    }
+
+    async function retryNotify(id) {
+      const btn = document.getElementById('retry-' + id);
+      if (btn) {
+        btn.disabled = true;
+        btn.textContent = 'Sending...';
+      }
+
+      try {
+        const res = await fetch('/ui/queue/' + id + '/notify', {
+          method: 'POST',
+          headers: { 'Accept': 'application/json' }
+        });
+        const data = await res.json();
+
+        const statusEl = document.getElementById('notify-status-' + id);
+        if (data.success && data.entry?.notified) {
+          // Update to show success
+          if (statusEl) {
+            statusEl.innerHTML = '<span class="notify-status notify-sent">✓ Notified</span>';
+          }
+          const entryEl = document.getElementById('entry-' + id);
+          if (entryEl) entryEl.dataset.notified = '1';
+        } else {
+          // Show error
+          const error = data.error || 'Failed to send';
+          if (statusEl) {
+            statusEl.innerHTML = '<span class="notify-status notify-failed" title="' + escapeHtml(error) + '">⚠ Notify failed</span> <button type="button" class="btn-sm btn-link" onclick="retryNotify(\\''+id+'\\')">Retry</button>';
+          }
+        }
+      } catch (err) {
+        alert('Error: ' + err.message);
+        if (btn) {
+          btn.disabled = false;
+          btn.textContent = 'Retry';
+        }
+      }
+    }
   </script>
 </body>
 </html>`;