@clawtrail/context-graph-openclaw 0.7.5 → 0.8.1

package/dist/rules/openclaw-rules.js

@@ -1,5 +1,5 @@
-import { compositeConfidence, wilsonScoreLower } from '@clawtrail/context-graph';
-import { extensionToLanguage } from '../util/hash.js';
+import { compositeConfidence, wilsonScoreLower, } from "@clawtrail/context-graph";
+import { extensionToLanguage } from "../util/hash.js";
 // ── Helpers ─────────────────────────────────────────────────────────
 /** Get age in ms of the latest event in a list, relative to now */
 function latestAge(events) {
@@ -14,13 +14,13 @@ function countByStatus(events, status) {
 }
 // ── CLI Agent Rules (kept for coding agents — dynamic confidence) ──
 export const CanFixBuild = {
-    id: 'cg:CanFixBuild',
-    name: 'Can Fix Build',
-    description: 'Agent recovered a failing build within the same session',
+    id: "cg:CanFixBuild",
+    name: "Can Fix Build",
+    description: "Agent recovered a failing build within the same session",
     evaluate(ctx) {
-        const buildRuns = ctx.events.filter((e) => e.type === 'BUILD_RUN');
-        const failed = buildRuns.filter((e) => e.status === 'FAILED' || e.data.exit_code !== 0);
-        const succeeded = buildRuns.filter((e) => e.status === 'SUCCEEDED' && e.data.exit_code === 0);
+        const buildRuns = ctx.events.filter((e) => e.type === "BUILD_RUN");
+        const failed = buildRuns.filter((e) => e.status === "FAILED" || e.data.exit_code !== 0);
+        const succeeded = buildRuns.filter((e) => e.status === "SUCCEEDED" && e.data.exit_code === 0);
         const recoveries = [];
         for (const fail of failed) {
             const recovery = succeeded.find((s) => s.ts > fail.ts);
@@ -30,23 +30,24 @@ export const CanFixBuild = {
         if (recoveries.length === 0)
             return [];
         const { confidence } = compositeConfidence(recoveries.length, failed.length - recoveries.length, latestAge(recoveries));
-        return [{
-                claimType: 'cg:CanFixBuild',
+        return [
+            {
+                claimType: "cg:CanFixBuild",
                 confidence,
                 scope: (failed[0]?.data.tool || recoveries[0]?.data.tool),
                 evidenceHashes: [...failed, ...recoveries].map((e) => e.event_hash),
-            }];
+            },
+        ];
     },
 };
 export const CanFixTests = {
-    id: 'cg:CanFixTests',
-    name: 'Can Fix Tests',
-    description: 'Agent recovered failing tests within the same session',
+    id: "cg:CanFixTests",
+    name: "Can Fix Tests",
+    description: "Agent recovered failing tests within the same session",
     evaluate(ctx) {
-        const testRuns = ctx.events.filter((e) => e.type === 'TEST_RUN');
-        const failed = testRuns.filter((e) => e.status === 'FAILED' ||
-            (e.data.failed > 0));
-        const succeeded = testRuns.filter((e) => e.status === 'SUCCEEDED' && e.data.failed === 0);
+        const testRuns = ctx.events.filter((e) => e.type === "TEST_RUN");
+        const failed = testRuns.filter((e) => e.status === "FAILED" || e.data.failed > 0);
+        const succeeded = testRuns.filter((e) => e.status === "SUCCEEDED" && e.data.failed === 0);
         const recoveries = [];
         for (const fail of failed) {
             const recovery = succeeded.find((s) => s.ts > fail.ts);
@@ -56,30 +57,34 @@ export const CanFixTests = {
         if (recoveries.length === 0)
             return [];
         const { confidence } = compositeConfidence(recoveries.length, failed.length - recoveries.length, latestAge(recoveries));
-        return [{
-                claimType: 'cg:CanFixTests',
+        return [
+            {
+                claimType: "cg:CanFixTests",
                 confidence,
                 scope: (failed[0]?.data.framework || recoveries[0]?.data.framework),
                 evidenceHashes: [...failed, ...recoveries].map((e) => e.event_hash),
-            }];
+            },
+        ];
     },
 };
 export const CanRunTests = {
-    id: 'cg:CanRunTests',
-    name: 'Can Run Tests',
-    description: 'Agent successfully ran tests multiple times',
+    id: "cg:CanRunTests",
+    name: "Can Run Tests",
+    description: "Agent successfully ran tests multiple times",
     evaluate(ctx) {
-        const successful = ctx.events.filter((e) => e.type === 'TEST_RUN' && e.status === 'SUCCEEDED');
+        const successful = ctx.events.filter((e) => e.type === "TEST_RUN" && e.status === "SUCCEEDED");
         if (successful.length < 2)
             return [];
-        const allTestRuns = ctx.events.filter((e) => e.type === 'TEST_RUN');
-        const frameworks = [...new Set(successful.map((e) => e.data.framework))];
+        const allTestRuns = ctx.events.filter((e) => e.type === "TEST_RUN");
+        const frameworks = [
+            ...new Set(successful.map((e) => e.data.framework)),
+        ];
         return frameworks.map((fw) => {
             const fwEvents = allTestRuns.filter((e) => e.data.framework === fw);
-            const fwSucceeded = fwEvents.filter((e) => e.status === 'SUCCEEDED').length;
+            const fwSucceeded = fwEvents.filter((e) => e.status === "SUCCEEDED").length;
             const { confidence } = compositeConfidence(fwSucceeded, fwEvents.length - fwSucceeded, latestAge(fwEvents));
             return {
-                claimType: 'cg:CanRunTests',
+                claimType: "cg:CanRunTests",
                 confidence,
                 scope: fw,
                 evidenceHashes: fwEvents.map((e) => e.event_hash),
@@ -88,34 +93,39 @@ export const CanRunTests = {
     },
 };
 export const CanRecoverFromError = {
-    id: 'cg:CanRecoverFromError',
-    name: 'Can Recover From Error',
-    description: 'Agent recovered from an error by succeeding on the same artifact',
+    id: "cg:CanRecoverFromError",
+    name: "Can Recover From Error",
+    description: "Agent recovered from an error by succeeding on the same artifact",
     evaluate(ctx) {
-        const errors = ctx.events.filter((e) => e.type === 'ERROR');
+        const errors = ctx.events.filter((e) => e.type === "ERROR");
         const recoveries = [];
         for (const err of errors) {
-            const laterSuccess = ctx.events.find((e) => e.ts > err.ts && e.status === 'SUCCEEDED');
+            const laterSuccess = ctx.events.find((e) => e.ts > err.ts && e.status === "SUCCEEDED");
             if (laterSuccess)
                 recoveries.push({ error: err, success: laterSuccess });
         }
         if (recoveries.length === 0)
             return [];
         const { confidence } = compositeConfidence(recoveries.length, errors.length - recoveries.length, latestAge(recoveries.map((r) => r.success)));
-        return [{
-                claimType: 'cg:CanRecoverFromError',
+        return [
+            {
+                claimType: "cg:CanRecoverFromError",
                 confidence,
-                evidenceHashes: recoveries.flatMap((r) => [r.error.event_hash, r.success.event_hash]),
-            }];
+                evidenceHashes: recoveries.flatMap((r) => [
+                    r.error.event_hash,
+                    r.success.event_hash,
+                ]),
+            },
+        ];
     },
 };
 export const CanWriteCode = {
-    id: 'cg:CanWrite',
-    name: 'Can Write Code',
-    description: 'Agent wrote files in specific languages',
+    id: "cg:CanWrite",
+    name: "Can Write Code",
+    description: "Agent wrote files in specific languages",
     evaluate(ctx) {
-        const writes = ctx.events.filter((e) => e.type === 'FILE_WRITE' && e.status === 'SUCCEEDED');
-        const allWrites = ctx.events.filter((e) => e.type === 'FILE_WRITE');
+        const writes = ctx.events.filter((e) => e.type === "FILE_WRITE" && e.status === "SUCCEEDED");
+        const allWrites = ctx.events.filter((e) => e.type === "FILE_WRITE");
         const extCounts = new Map();
         for (const w of writes) {
             const ext = w.data.path_extension;
@@ -129,7 +139,7 @@ export const CanWriteCode = {
             const totalForExt = allWrites.filter((e) => e.data.path_extension === ext).length;
             const { confidence } = compositeConfidence(hashes.length, totalForExt - hashes.length, latestAge(writes.filter((e) => e.data.path_extension === ext)));
             return {
-                claimType: 'cg:CanWrite',
+                claimType: "cg:CanWrite",
                 confidence,
                 scope: extensionToLanguage(ext),
                 evidenceHashes: hashes,
@@ -138,16 +148,16 @@ export const CanWriteCode = {
     },
 };
 export const CanUseFramework = {
-    id: 'cg:CanUseFramework',
-    name: 'Can Use Framework',
-    description: 'Agent used specific test/build frameworks',
+    id: "cg:CanUseFramework",
+    name: "Can Use Framework",
+    description: "Agent used specific test/build frameworks",
     evaluate(ctx) {
         const frameworks = new Map();
         for (const e of ctx.events) {
             let fw;
-            if (e.type === 'TEST_RUN')
+            if (e.type === "TEST_RUN")
                 fw = e.data.framework;
-            if (e.type === 'BUILD_RUN')
+            if (e.type === "BUILD_RUN")
                 fw = e.data.tool;
             if (fw) {
                 if (!frameworks.has(fw))
@@ -156,10 +166,10 @@ export const CanUseFramework = {
             }
         }
         return [...frameworks.entries()].map(([fw, events]) => {
-            const succeeded = countByStatus(events, 'SUCCEEDED');
+            const succeeded = countByStatus(events, "SUCCEEDED");
             const { confidence } = compositeConfidence(succeeded, events.length - succeeded, latestAge(events));
             return {
-                claimType: 'cg:CanUseFramework',
+                claimType: "cg:CanUseFramework",
                 confidence,
                 scope: fw,
                 evidenceHashes: events.map((e) => e.event_hash),
@@ -168,16 +178,16 @@ export const CanUseFramework = {
     },
 };
 export const CanUseTool = {
-    id: 'cg:CanUseTool',
-    name: 'Can Use Tool',
-    description: 'Agent used specific shell tools',
+    id: "cg:CanUseTool",
+    name: "Can Use Tool",
+    description: "Agent used specific shell tools",
     evaluate(ctx) {
         const tools = new Map();
         for (const e of ctx.events) {
-            if (e.type === 'SHELL_COMMAND' || e.type === 'TOOL_CALL') {
+            if (e.type === "SHELL_COMMAND" || e.type === "TOOL_CALL") {
                 const toolName = (e.data.cmd_display || e.data.tool);
                 if (toolName) {
-                    const baseTool = toolName.split(' ')[0];
+                    const baseTool = toolName.split(" ")[0];
                     if (!tools.has(baseTool))
                         tools.set(baseTool, []);
                     tools.get(baseTool).push(e);
@@ -185,10 +195,10 @@ export const CanUseTool = {
             }
         }
         return [...tools.entries()].map(([tool, events]) => {
-            const succeeded = countByStatus(events, 'SUCCEEDED');
+            const succeeded = countByStatus(events, "SUCCEEDED");
             const { confidence } = compositeConfidence(succeeded, events.length - succeeded, latestAge(events));
             return {
-                claimType: 'cg:CanUseTool',
+                claimType: "cg:CanUseTool",
                 confidence,
                 scope: tool,
                 evidenceHashes: events.map((e) => e.event_hash),
@@ -197,20 +207,22 @@ export const CanUseTool = {
     },
 };
 export const CanCallApis = {
-    id: 'cg:CanCallApis',
-    name: 'Can Call APIs',
-    description: 'Agent successfully called HTTP APIs',
+    id: "cg:CanCallApis",
+    name: "Can Call APIs",
+    description: "Agent successfully called HTTP APIs",
     evaluate(ctx) {
-        const httpCalls = ctx.events.filter((e) => e.type === 'HTTP_REQUEST');
+        const httpCalls = ctx.events.filter((e) => e.type === "HTTP_REQUEST");
         if (httpCalls.length < 2)
             return [];
-        const hosts = [...new Set(httpCalls.map((e) => e.data.host_hash))];
+        const hosts = [
+            ...new Set(httpCalls.map((e) => e.data.host_hash)),
+        ];
         return hosts.map((h) => {
             const hostEvents = httpCalls.filter((e) => e.data.host_hash === h);
-            const succeeded = countByStatus(hostEvents, 'SUCCEEDED');
+            const succeeded = countByStatus(hostEvents, "SUCCEEDED");
             const { confidence } = compositeConfidence(succeeded, hostEvents.length - succeeded, latestAge(hostEvents));
             return {
-                claimType: 'cg:CanCallApis',
+                claimType: "cg:CanCallApis",
                 confidence,
                 scope: h,
                 evidenceHashes: hostEvents.map((e) => e.event_hash),
@@ -219,21 +231,21 @@ export const CanCallApis = {
     },
 };
 export const CanHandleHttpErrors = {
-    id: 'cg:CanHandleHttpErrors',
-    name: 'Can Handle HTTP Errors',
-    description: 'Agent retried or recovered from HTTP errors',
+    id: "cg:CanHandleHttpErrors",
+    name: "Can Handle HTTP Errors",
+    description: "Agent retried or recovered from HTTP errors",
     evaluate(ctx) {
-        const httpCalls = ctx.events.filter((e) => e.type === 'HTTP_REQUEST');
+        const httpCalls = ctx.events.filter((e) => e.type === "HTTP_REQUEST");
         const failed = httpCalls.filter((e) => {
             const sc = e.data.status_code;
-            return e.status === 'FAILED' || (sc !== undefined && sc >= 400);
+            return e.status === "FAILED" || (sc !== undefined && sc >= 400);
         });
         let recoveryCount = 0;
         const evidenceHashes = [];
         for (const fail of failed) {
             const recovery = httpCalls.find((s) => s.ts > fail.ts &&
                 s.data.host_hash === fail.data.host_hash &&
-                s.status === 'SUCCEEDED');
+                s.status === "SUCCEEDED");
             if (recovery) {
                 recoveryCount++;
                 evidenceHashes.push(fail.event_hash, recovery.event_hash);
@@ -242,112 +254,290 @@ export const CanHandleHttpErrors = {
         if (recoveryCount === 0)
             return [];
         const { confidence } = compositeConfidence(recoveryCount, failed.length - recoveryCount, latestAge(httpCalls));
-        return [{
-                claimType: 'cg:CanHandleHttpErrors',
+        return [
+            {
+                claimType: "cg:CanHandleHttpErrors",
                 confidence,
                 evidenceHashes,
-            }];
+            },
+        ];
     },
 };
 // ── Platform Agent Rules (NEW — for AGENT_ACTION events) ───────────
 export const CanCreateContent = {
-    id: 'cg:CanCreateContent',
-    name: 'Can Create Content',
-    description: 'Agent created discussions or other content on the platform',
+    id: "cg:CanCreateContent",
+    name: "Can Create Content",
+    description: "Agent created discussions or other content on the platform",
     evaluate(ctx) {
-        const actions = ctx.events.filter((e) => e.type === 'AGENT_ACTION');
-        const creates = actions.filter((e) => e.data.action === 'create_discussion' || e.data.action === 'create');
+        const actions = ctx.events.filter((e) => e.type === "AGENT_ACTION");
+        const creates = actions.filter((e) => e.data.action === "create_discussion" || e.data.action === "create");
         if (creates.length === 0)
             return [];
-        const succeeded = countByStatus(creates, 'SUCCEEDED');
+        const succeeded = countByStatus(creates, "SUCCEEDED");
         const { confidence } = compositeConfidence(succeeded, creates.length - succeeded, latestAge(creates));
-        return [{
-                claimType: 'cg:CanCreateContent',
+        return [
+            {
+                claimType: "cg:CanCreateContent",
                 confidence,
-                scope: 'discussions',
+                scope: "discussions",
                 evidenceHashes: creates.map((e) => e.event_hash),
-            }];
+            },
+        ];
     },
 };
 export const CanEngageCommunity = {
-    id: 'cg:CanEngageCommunity',
-    name: 'Can Engage Community',
-    description: 'Agent engaged with the community through votes, comments, and subscriptions',
+    id: "cg:CanEngageCommunity",
+    name: "Can Engage Community",
+    description: "Agent engaged with the community through votes, comments, and subscriptions",
     evaluate(ctx) {
-        const actions = ctx.events.filter((e) => e.type === 'AGENT_ACTION');
-        const engagementTypes = new Set(['vote', 'comment', 'subscribe', 'follow', 'upvote', 'downvote']);
+        const actions = ctx.events.filter((e) => e.type === "AGENT_ACTION");
+        const engagementTypes = new Set([
+            "vote",
+            "comment",
+            "subscribe",
+            "follow",
+            "upvote",
+            "downvote",
+        ]);
         const engagements = actions.filter((e) => engagementTypes.has(e.data.action));
         if (engagements.length === 0)
             return [];
-        const succeeded = countByStatus(engagements, 'SUCCEEDED');
-        const uniqueTypes = new Set(engagements.map((e) => e.data.action)).size;
+        const succeeded = countByStatus(engagements, "SUCCEEDED");
+        const uniqueTypes = new Set(engagements.map((e) => e.data.action))
+            .size;
         // Diversity bonus: more action types → higher confidence
         const wilson = wilsonScoreLower(succeeded, engagements.length);
         const diversityBonus = Math.min(0.1, uniqueTypes * 0.02);
         const confidence = Math.min(1, wilson + diversityBonus);
-        return [{
-                claimType: 'cg:CanEngageCommunity',
+        return [
+            {
+                claimType: "cg:CanEngageCommunity",
                 confidence,
                 scope: `${uniqueTypes}_types`,
                 evidenceHashes: engagements.map((e) => e.event_hash),
-            }];
+            },
+        ];
     },
 };
 export const CanRespondToNotifications = {
-    id: 'cg:CanRespondToNotifications',
-    name: 'Can Respond To Notifications',
-    description: 'Agent processed and responded to notifications',
+    id: "cg:CanRespondToNotifications",
+    name: "Can Respond To Notifications",
+    description: "Agent processed and responded to notifications",
     evaluate(ctx) {
-        const actions = ctx.events.filter((e) => e.type === 'AGENT_ACTION');
-        const responses = actions.filter((e) => e.data.action === 'reply' ||
-            e.data.action === 'respond' ||
-            e.data.action === 'check_notifications' ||
-            e.data.action === 'process_notification');
+        const actions = ctx.events.filter((e) => e.type === "AGENT_ACTION");
+        const responses = actions.filter((e) => e.data.action === "reply" ||
+            e.data.action === "respond" ||
+            e.data.action === "check_notifications" ||
+            e.data.action === "process_notification");
         if (responses.length === 0)
             return [];
-        const succeeded = countByStatus(responses, 'SUCCEEDED');
+        const succeeded = countByStatus(responses, "SUCCEEDED");
         const { confidence } = compositeConfidence(succeeded, responses.length - succeeded, latestAge(responses));
-        return [{
-                claimType: 'cg:CanRespondToNotifications',
+        return [
+            {
+                claimType: "cg:CanRespondToNotifications",
                 confidence,
                 evidenceHashes: responses.map((e) => e.event_hash),
-            }];
+            },
+        ];
     },
 };
 export const CanMakeDecisions = {
-    id: 'cg:CanMakeDecisions',
-    name: 'Can Make Decisions',
-    description: 'Agent logged decisions with reasoning',
+    id: "cg:CanMakeDecisions",
+    name: "Can Make Decisions",
+    description: "Agent logged decisions with reasoning",
     evaluate(ctx) {
-        const actions = ctx.events.filter((e) => e.type === 'AGENT_ACTION');
+        const actions = ctx.events.filter((e) => e.type === "AGENT_ACTION");
         const withReasoning = actions.filter((e) => e.data.reasoning_hash != null);
         if (withReasoning.length === 0)
             return [];
         const total = actions.length;
         const { confidence } = compositeConfidence(withReasoning.length, total - withReasoning.length, latestAge(withReasoning));
-        return [{
-                claimType: 'cg:CanMakeDecisions',
+        return [
+            {
+                claimType: "cg:CanMakeDecisions",
                 confidence,
                 scope: `${withReasoning.length}_of_${total}`,
                 evidenceHashes: withReasoning.map((e) => e.event_hash),
-            }];
+            },
+        ];
     },
 };
 export const IsConsistentlyActive = {
-    id: 'cg:IsConsistentlyActive',
-    name: 'Is Consistently Active',
-    description: 'Agent performed actions throughout the session window',
+    id: "cg:IsConsistentlyActive",
+    name: "Is Consistently Active",
+    description: "Agent performed actions throughout the session window",
     evaluate(ctx) {
-        const actions = ctx.events.filter((e) => e.type === 'AGENT_ACTION' && e.status === 'SUCCEEDED');
+        const actions = ctx.events.filter((e) => e.type === "AGENT_ACTION" && e.status === "SUCCEEDED");
         if (actions.length < 2)
             return [];
         const { confidence } = compositeConfidence(actions.length, 0, latestAge(actions));
-        return [{
-                claimType: 'cg:IsConsistentlyActive',
+        return [
+            {
+                claimType: "cg:IsConsistentlyActive",
                 confidence,
                 scope: `${actions.length}_actions`,
                 evidenceHashes: actions.map((e) => e.event_hash),
-            }];
+            },
+        ];
+    },
+};
+// ── Web & Browsing Rules (NEW — for WEB_SEARCH / WEB_FETCH / BROWSER_ACTION) ─
+export const CanBrowseWeb = {
+    id: "cg:CanBrowseWeb",
+    name: "Can Browse Web",
+    description: "Agent successfully browsed the web (search, fetch, or browser automation)",
+    evaluate(ctx) {
+        const webEvents = ctx.events.filter((e) => e.type === "WEB_SEARCH" ||
+            e.type === "WEB_FETCH" ||
+            e.type === "BROWSER_ACTION");
+        const succeeded = webEvents.filter((e) => e.status === "SUCCEEDED");
+        if (succeeded.length < 2)
+            return [];
+        // Scope to most-visited host
+        const hostCounts = new Map();
+        for (const e of succeeded) {
+            const host = e.data.host_display || "unknown";
+            hostCounts.set(host, (hostCounts.get(host) || 0) + 1);
+        }
+        const topHost = [...hostCounts.entries()].sort((a, b) => b[1] - a[1])[0]?.[0];
+        const { confidence } = compositeConfidence(succeeded.length, webEvents.length - succeeded.length, latestAge(succeeded));
+        return [
+            {
+                claimType: "cg:CanBrowseWeb",
+                confidence,
+                scope: topHost,
+                evidenceHashes: succeeded.map((e) => e.event_hash),
+            },
+        ];
+    },
+};
+export const CanSearchWeb = {
+    id: "cg:CanSearchWeb",
+    name: "Can Search Web",
+    description: "Agent formulated and executed web search queries",
+    evaluate(ctx) {
+        const searches = ctx.events.filter((e) => e.type === "WEB_SEARCH");
+        const succeeded = searches.filter((e) => e.status === "SUCCEEDED");
+        if (succeeded.length < 2)
+            return [];
+        // Scope to search provider if consistent
+        const providers = [
+            ...new Set(succeeded
+                .map((e) => e.data.provider)
+                .filter(Boolean)),
+        ];
+        const { confidence } = compositeConfidence(succeeded.length, searches.length - succeeded.length, latestAge(succeeded));
+        return [
+            {
+                claimType: "cg:CanSearchWeb",
+                confidence,
+                scope: providers.length === 1 ? providers[0] : undefined,
+                evidenceHashes: succeeded.map((e) => e.event_hash),
+            },
+        ];
+    },
+};
+// ── Messaging Rules (NEW — for MESSAGE_SEND events) ─────────────────
+export const CanSendMessages = {
+    id: "cg:CanSendMessages",
+    name: "Can Send Messages",
+    description: "Agent sent messages across chat platforms",
+    evaluate(ctx) {
+        const msgs = ctx.events.filter((e) => e.type === "MESSAGE_SEND");
+        const succeeded = msgs.filter((e) => e.status === "SUCCEEDED");
+        if (succeeded.length < 2)
+            return [];
+        // One claim per channel platform
+        const channels = new Map();
+        for (const e of succeeded) {
+            const ch = e.data.channel || "unknown";
+            if (!channels.has(ch))
+                channels.set(ch, []);
+            channels.get(ch).push(e);
+        }
+        return [...channels.entries()].map(([ch, events]) => {
+            const totalForCh = msgs.filter((e) => (e.data.channel || "unknown") === ch).length;
+            const { confidence } = compositeConfidence(events.length, totalForCh - events.length, latestAge(events));
+            return {
+                claimType: "cg:CanSendMessages",
+                confidence,
+                scope: ch,
+                evidenceHashes: events.map((e) => e.event_hash),
+            };
+        });
+    },
+};
+// ── Document Analysis Rules (NEW — for DOCUMENT_ANALYSIS events) ────
+export const CanAnalyzeDocuments = {
+    id: "cg:CanAnalyzeDocuments",
+    name: "Can Analyze Documents",
+    description: "Agent analyzed PDF or image documents",
+    evaluate(ctx) {
+        const docs = ctx.events.filter((e) => e.type === "DOCUMENT_ANALYSIS");
+        const succeeded = docs.filter((e) => e.status === "SUCCEEDED");
+        if (succeeded.length < 2)
+            return [];
+        // One claim per doc type
+        const types = new Map();
+        for (const e of succeeded) {
+            const dt = e.data.doc_type || "unknown";
+            if (!types.has(dt))
+                types.set(dt, []);
+            types.get(dt).push(e);
+        }
+        return [...types.entries()].map(([dt, events]) => {
+            const totalForType = docs.filter((e) => (e.data.doc_type || "unknown") === dt).length;
+            const { confidence } = compositeConfidence(events.length, totalForType - events.length, latestAge(events));
+            return {
+                claimType: "cg:CanAnalyzeDocuments",
+                confidence,
+                scope: dt,
+                evidenceHashes: events.map((e) => e.event_hash),
+            };
+        });
+    },
+};
+// ── Multi-Agent Coordination Rules (NEW — for MULTI_AGENT_ACTION events) ─
+export const CanCoordinateAgents = {
+    id: "cg:CanCoordinateAgents",
+    name: "Can Coordinate Agents",
+    description: "Agent spawned or communicated with other agents",
+    evaluate(ctx) {
+        const agentActions = ctx.events.filter((e) => e.type === "MULTI_AGENT_ACTION" &&
+            (e.data.action === "spawn" || e.data.action === "send"));
+        const succeeded = agentActions.filter((e) => e.status === "SUCCEEDED");
+        if (succeeded.length < 2)
+            return [];
+        const { confidence } = compositeConfidence(succeeded.length, agentActions.length - succeeded.length, latestAge(succeeded));
+        return [
+            {
+                claimType: "cg:CanCoordinateAgents",
+                confidence,
+                evidenceHashes: succeeded.map((e) => e.event_hash),
+            },
+        ];
+    },
+};
+// ── Verified Actions Rule (NEW — for server-verified AGENT_ACTION events) ─
+export const HasVerifiedActions = {
+    id: "cg:HasVerifiedActions",
+    name: "Has Verified Actions",
+    description: "Agent has server-verified platform actions (auto-logged, not self-reported)",
+    evaluate(ctx) {
+        const actions = ctx.events.filter((e) => e.type === "AGENT_ACTION");
+        const verified = actions.filter((e) => e.data.source === "auto");
+        if (verified.length === 0)
+            return [];
+        const { confidence } = compositeConfidence(verified.length, 0, latestAge(verified));
+        return [
+            {
+                claimType: "cg:HasVerifiedActions",
+                confidence,
+                scope: `${verified.length}_of_${actions.length}_verified`,
+                evidenceHashes: verified.map((e) => e.event_hash),
+            },
+        ];
     },
 };
 /** All OpenClaw rules for easy registration */
@@ -368,5 +558,16 @@ export const openclawRules = [
     CanRespondToNotifications,
     CanMakeDecisions,
     IsConsistentlyActive,
+    // Web & browsing rules (fire for WEB_SEARCH / WEB_FETCH / BROWSER_ACTION events)
+    CanBrowseWeb,
+    CanSearchWeb,
+    // Messaging rules (fire for MESSAGE_SEND events)
+    CanSendMessages,
+    // Document analysis rules (fire for DOCUMENT_ANALYSIS events)
+    CanAnalyzeDocuments,
+    // Multi-agent coordination rules (fire for MULTI_AGENT_ACTION events)
+    CanCoordinateAgents,
+    // Trust signal rules (fire for verified AGENT_ACTION events)
+    HasVerifiedActions,
 ];
 //# sourceMappingURL=openclaw-rules.js.map