@useorgx/openclaw-plugin 0.4.6 → 0.4.8

package/dist/index.js

@@ -13,7 +13,7 @@
 import { OrgXClient } from "./api.js";
 import { createHttpHandler } from "./http-handler.js";
 import { applyOrgxAgentSuitePlan, computeOrgxAgentSuitePlan } from "./agent-suite.js";
-import { appendActivityItems } from "./activity-store.js";
+import { registerArtifact } from "./artifacts/register-artifact.js";
 import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 import { homedir } from "node:os";
@@ -39,6 +39,16 @@ function isUserScopedApiKey(apiKey) {
 }
 function resolveRuntimeUserId(apiKey, candidates) {
     if (isUserScopedApiKey(apiKey)) {
+        // For oxk_ keys, the OrgX API ignores X-Orgx-User-Id, but we still keep a UUID
+        // around for created_by_id on certain entity writes (e.g., work_artifacts).
+        for (const candidate of candidates) {
+            if (typeof candidate !== "string")
+                continue;
+            const trimmed = candidate.trim();
+            if (/^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(trimmed)) {
+                return trimmed;
+            }
+        }
         return "";
     }
     for (const candidate of candidates) {
@@ -1211,6 +1221,10 @@ export default function register(api) {
                         description: null,
                         agentId: stopped.agentId,
                         agentName: null,
+                        requesterAgentId: stopped.agentId ?? null,
+                        requesterAgentName: null,
+                        executorAgentId: stopped.agentId ?? null,
+                        executorAgentName: null,
                         runId: stopped.runId,
                         initiativeId,
                         timestamp,
@@ -1241,6 +1255,10 @@ export default function register(api) {
                         description: null,
                         agentId: stopped.agentId,
                         agentName: null,
+                        requesterAgentId: stopped.agentId ?? null,
+                        requesterAgentName: null,
+                        executorAgentId: stopped.agentId ?? null,
+                        executorAgentName: null,
                         runId: stopped.runId,
                         initiativeId,
                         timestamp,
@@ -1651,16 +1669,55 @@ export default function register(api) {
             return;
         }
         if (event.type === "artifact") {
-            // Artifacts are UI-level breadcrumbs and may not be supported by every
-            // OrgX deployment's `/api/entities` schema. Persist locally and drop from
-            // the outbox so progress reporting doesn't wedge on irreplayable items.
-            try {
-                if (event.activityItem) {
-                    appendActivityItems([event.activityItem]);
-                }
+            // Artifacts are first-class UX loop closure (activity stream + entity modals).
+            // Try to persist upstream; if this fails, keep the event queued for retry.
+            const payload = event.payload && typeof event.payload === "object" && !Array.isArray(event.payload)
+                ? event.payload
+                : {};
+            const name = pickStringField(payload, "name") ?? pickStringField(payload, "title") ?? "";
+            const artifactType = pickStringField(payload, "artifact_type") ?? "other";
+            const entityType = pickStringField(payload, "entity_type") ?? "";
+            const entityId = pickStringField(payload, "entity_id") ?? "";
+            const artifactId = pickStringField(payload, "artifact_id") ?? null;
+            const description = pickStringField(payload, "description") ?? undefined;
+            const externalUrl = pickStringField(payload, "url") ?? pickStringField(payload, "artifact_url") ?? null;
+            const content = pickStringField(payload, "content") ?? pickStringField(payload, "preview_markdown") ?? null;
+            const allowedEntityType = entityType === "initiative" ||
+                entityType === "milestone" ||
+                entityType === "task" ||
+                entityType === "decision" ||
+                entityType === "project"
+                ? entityType
+                : null;
+            if (!allowedEntityType || !entityId.trim() || !name.trim()) {
+                api.log?.warn?.("[orgx] Dropping invalid artifact outbox event", {
+                    eventId: event.id,
+                    entityType,
+                    entityId,
+                });
+                return;
             }
-            catch {
-                // best effort
+            const result = await registerArtifact(client, client.getBaseUrl(), {
+                artifact_id: artifactId,
+                entity_type: allowedEntityType,
+                entity_id: entityId,
+                name: name.trim(),
+                artifact_type: artifactType.trim() || "other",
+                description,
+                external_url: externalUrl,
+                preview_markdown: content,
+                status: "draft",
+                metadata: {
+                    source: "outbox_replay",
+                    outbox_event_id: event.id,
+                    ...(payload.metadata && typeof payload.metadata === "object" && !Array.isArray(payload.metadata)
+                        ? payload.metadata
+                        : {}),
+                },
+                validate_persistence: process.env.ORGX_VALIDATE_ARTIFACT_PERSISTENCE === "1",
+            });
+            if (!result.ok) {
+                throw new Error(result.persistence.last_error ?? "artifact registration failed");
             }
             return;
         }
@@ -1996,9 +2053,15 @@ export default function register(api) {
                     nextAction: "retry",
                 });
             }
+            const pairingUserIdRaw = typeof polled.data.supabaseUserId === "string"
+                ? polled.data.supabaseUserId
+                : typeof polled.data.userId === "string"
+                    ? polled.data.userId
+                    : null;
             setRuntimeApiKey({
                 apiKey: key,
                 source: "browser_pairing",
+                userId: resolveRuntimeUserId(key, [pairingUserIdRaw, config.userId]) || null,
                 workspaceName: polled.data.workspaceName ?? null,
                 keyPrefix: polled.data.keyPrefix ?? null,
             });
@@ -2749,6 +2812,10 @@ export default function register(api) {
             description: payload.next_step ?? null,
             agentId: null,
             agentName: null,
+            requesterAgentId: null,
+            requesterAgentName: null,
+            executorAgentId: null,
+            executorAgentName: null,
             runId: context.value.runId ?? null,
             initiativeId: context.value.initiativeId,
             timestamp: now,
@@ -2798,6 +2865,10 @@ export default function register(api) {
             description: `${payload.operations.length} operation${payload.operations.length === 1 ? "" : "s"}`,
             agentId: null,
             agentName: null,
+            requesterAgentId: null,
+            requesterAgentName: null,
+            executorAgentId: null,
+            executorAgentName: null,
             runId: context.value.runId ?? null,
             initiativeId: context.value.initiativeId,
             timestamp: now,
@@ -3077,13 +3148,22 @@ export default function register(api) {
     // --- orgx_register_artifact ---
     registerMcpTool({
         name: "orgx_register_artifact",
-        description: "Register a work output (PR, document, config change, report, etc.) with OrgX. Makes it visible in the dashboard.",
+        description: "Register a work output (PR, document, config change, report, etc.) as a work_artifact in OrgX. Makes it visible in the dashboard activity timeline and entity detail modals.",
         parameters: {
             type: "object",
             properties: {
                 initiative_id: {
                     type: "string",
-                    description: "Optional initiative UUID to attach this artifact to",
+                    description: "Convenience: initiative UUID. Used as entity_type='initiative', entity_id=<this> when entity_type/entity_id are not provided.",
+                },
+                entity_type: {
+                    type: "string",
+                    enum: ["initiative", "milestone", "task", "decision", "project"],
+                    description: "The type of entity this artifact is attached to",
+                },
+                entity_id: {
+                    type: "string",
+                    description: "UUID of the entity this artifact is attached to",
                 },
                 name: {
                     type: "string",
@@ -3091,8 +3171,7 @@ export default function register(api) {
                 },
                 artifact_type: {
                     type: "string",
-                    enum: ["pr", "commit", "document", "config", "report", "design", "other"],
-                    description: "Type of artifact",
+                    description: "Artifact type code (e.g., 'eng.diff_pack', 'pr', 'document'). Falls back to 'shared.project_handbook' if the type is not recognized by OrgX.",
                 },
                 description: {
                     type: "string",
@@ -3100,7 +3179,11 @@ export default function register(api) {
                 },
                 url: {
                     type: "string",
-                    description: "Link to the artifact (PR URL, file path, etc.)",
+                    description: "External link to the artifact (PR URL, file path, etc.)",
+                },
+                content: {
+                    type: "string",
+                    description: "Inline preview content (markdown/text). At least one of url or content is required.",
                 },
             },
             required: ["name", "artifact_type"],
@@ -3109,9 +3192,32 @@ export default function register(api) {
         async execute(_callId, params = { name: "", artifact_type: "other" }) {
             const now = new Date().toISOString();
             const id = `artifact:${randomUUID().slice(0, 8)}`;
-            const initiativeId = isUuid(params.initiative_id)
-                ? params.initiative_id
-                : inferReportingInitiativeId(params) ?? null;
+            // Resolve entity association: explicit entity_type+entity_id > initiative_id > inferred
+            let resolvedEntityType = null;
+            let resolvedEntityId = null;
+            if (params.entity_type && isUuid(params.entity_id)) {
+                resolvedEntityType = params.entity_type;
+                resolvedEntityId = params.entity_id;
+            }
+            else if (isUuid(params.initiative_id)) {
+                resolvedEntityType = "initiative";
+                resolvedEntityId = params.initiative_id;
+            }
+            else {
+                const inferred = inferReportingInitiativeId(params);
+                if (inferred) {
+                    resolvedEntityType = "initiative";
+                    resolvedEntityId = inferred;
+                }
+            }
+            if (!resolvedEntityType || !resolvedEntityId) {
+                return text("❌ Cannot register artifact: provide entity_type + entity_id, or initiative_id, so the artifact can be attached to an entity.");
+            }
+            if (!params.url && !params.content) {
+                return text("❌ Cannot register artifact: provide at least one of url or content.");
+            }
+            const baseUrl = client.getBaseUrl();
+            const artifactId = randomUUID();
             const activityItem = {
                 id,
                 type: "artifact_created",
@@ -3119,35 +3225,65 @@ export default function register(api) {
                 description: params.description ?? null,
                 agentId: null,
                 agentName: null,
+                requesterAgentId: null,
+                requesterAgentName: null,
+                executorAgentId: null,
+                executorAgentName: null,
                 runId: null,
-                initiativeId,
+                initiativeId: resolvedEntityType === "initiative" ? resolvedEntityId : null,
                 timestamp: now,
                 summary: params.url ?? null,
                 metadata: withProvenanceMetadata({
                     source: "orgx_register_artifact",
                     artifact_type: params.artifact_type,
                     url: params.url,
+                    entity_type: resolvedEntityType,
+                    entity_id: resolvedEntityId,
                 }),
             };
             try {
-                const entity = await client.createEntity("artifact", {
-                    title: params.name,
+                const result = await registerArtifact(client, baseUrl, {
+                    artifact_id: artifactId,
+                    entity_type: resolvedEntityType,
+                    entity_id: resolvedEntityId,
+                    name: params.name,
                     artifact_type: params.artifact_type,
-                    summary: params.description,
-                    initiative_id: initiativeId ?? undefined,
-                    artifact_url: params.url,
-                    status: "active",
+                    description: params.description ?? null,
+                    external_url: params.url ?? null,
+                    preview_markdown: params.content ?? null,
+                    status: "draft",
+                    metadata: {
+                        source: "orgx_register_artifact",
+                        artifact_id: artifactId,
+                    },
+                    validate_persistence: true,
+                });
+                if (!result.ok) {
+                    throw new Error(result.persistence.last_error ?? "Artifact registration failed");
+                }
+                activityItem.metadata = withProvenanceMetadata({
+                    ...activityItem.metadata,
+                    artifact_id: result.artifact_id,
+                    entity_type: resolvedEntityType,
+                    entity_id: resolvedEntityId,
                 });
-                return json(`Artifact registered: ${params.name} [${params.artifact_type}]`, entity);
+                return json(`Artifact registered: ${params.name} [${params.artifact_type}] → ${resolvedEntityType}/${resolvedEntityId} (id: ${result.artifact_id})`, result);
             }
-            catch {
+            catch (firstError) {
+                // Outbox fallback for offline/error scenarios
                 await appendToOutbox("artifacts", {
                     id,
                     type: "artifact",
                     timestamp: now,
                     payload: {
-                        ...params,
-                        initiative_id: initiativeId,
+                        artifact_id: artifactId,
+                        name: params.name,
+                        artifact_type: params.artifact_type,
+                        description: params.description,
+                        url: params.url,
+                        content: params.content,
+                        entity_type: resolvedEntityType,
+                        entity_id: resolvedEntityId,
                     },
                     activityItem,
                 });

package/dist/local-openclaw.js

@@ -580,6 +580,10 @@ function turnToActivity(turn, session, cachedSummary, index) {
         description: modelAlias,
         agentId: session.agentId,
         agentName: session.agentName,
+        requesterAgentId: session.agentId ?? null,
+        requesterAgentName: session.agentName ?? null,
+        executorAgentId: session.agentId ?? null,
+        executorAgentName: session.agentName ?? null,
         runId: session.sessionId ?? session.key,
         initiativeId: session.agentId ? `agent:${session.agentId}` : null,
         timestamp: turn.timestamp,
@@ -747,6 +751,10 @@ function makeSessionSummaryItem(session) {
         description: modelAlias ? `Local session (${modelAlias})` : "Local session",
         agentId: session.agentId,
         agentName: session.agentName,
+        requesterAgentId: session.agentId ?? null,
+        requesterAgentName: session.agentName ?? null,
+        executorAgentId: session.agentId ?? null,
+        executorAgentName: session.agentName ?? null,
         runId: session.sessionId ?? session.key,
         initiativeId: session.agentId ? `agent:${session.agentId}` : null,
         timestamp: session.updatedAt ?? new Date().toISOString(),

package/dist/mcp-client-setup.js

@@ -5,22 +5,6 @@ import { randomUUID } from "node:crypto";
 import { writeFileAtomicSync, writeJsonFileAtomicSync } from "./fs-utils.js";
 const ORGX_LOCAL_MCP_KEY = "orgx-openclaw";
 const ORGX_HOSTED_MCP_URL = "https://mcp.useorgx.com/mcp";
-const ORGX_LOCAL_MCP_SCOPES = [
-    "engineering",
-    "product",
-    "design",
-    "marketing",
-    "sales",
-    "operations",
-    "orchestration",
-];
-function scopedMcpServerKey(scope) {
-    return `${ORGX_LOCAL_MCP_KEY}-${scope}`;
-}
-function scopedMcpUrl(localMcpUrl, scope) {
-    const base = localMcpUrl.replace(/\/+$/, "");
-    return `${base}/${scope}`;
-}
 function escapeRegExp(value) {
     return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
@@ -59,6 +43,20 @@ function backupFileSync(path, mode) {
         return null;
     }
 }
+function removeLegacyScopedMcpServers(servers) {
+    const next = { ...servers };
+    let updated = false;
+    const scopedPrefix = `${ORGX_LOCAL_MCP_KEY}-`;
+    for (const key of Object.keys(next)) {
+        if (key === ORGX_LOCAL_MCP_KEY)
+            continue;
+        if (!key.startsWith(scopedPrefix))
+            continue;
+        delete next[key];
+        updated = true;
+    }
+    return { updated, next };
+}
 export function patchClaudeMcpConfig(input) {
     const currentServers = isRecord(input.current.mcpServers) ? input.current.mcpServers : {};
     const existingOrgx = isRecord(currentServers.orgx) ? currentServers.orgx : {};
@@ -88,41 +86,20 @@ export function patchClaudeMcpConfig(input) {
             ? existing.description
             : "OrgX platform via local OpenClaw plugin (no OAuth)",
     };
-    const updatedScopes = [];
-    const scopedEntries = {};
-    for (const scope of ORGX_LOCAL_MCP_SCOPES) {
-        const key = scopedMcpServerKey(scope);
-        const expectedUrl = scopedMcpUrl(input.localMcpUrl, scope);
-        const existingScoped = isRecord(currentServers[key]) ? currentServers[key] : {};
-        const priorUrl = typeof existingScoped.url === "string" ? existingScoped.url : "";
-        const priorType = typeof existingScoped.type === "string" ? existingScoped.type : "";
-        const nextScoped = {
-            ...existingScoped,
-            type: "http",
-            url: expectedUrl,
-            description: typeof existingScoped.description === "string" && existingScoped.description.trim().length > 0
-                ? existingScoped.description
-                : `OrgX platform via local OpenClaw plugin (${scope} scope)`,
-        };
-        scopedEntries[key] = nextScoped;
-        if (priorUrl !== expectedUrl || priorType !== "http") {
-            updatedScopes.push(scope);
-        }
-    }
-    const nextServers = {
+    const mergedServers = {
         ...currentServers,
         ...(shouldSetHostedOrgx ? { orgx: nextOrgxEntry } : {}),
         [ORGX_LOCAL_MCP_KEY]: nextEntry,
-        ...scopedEntries,
     };
+    const scopedCleanup = removeLegacyScopedMcpServers(mergedServers);
     const next = {
         ...input.current,
-        mcpServers: nextServers,
+        mcpServers: scopedCleanup.next,
     };
     const updatedLocal = priorUrl !== input.localMcpUrl || priorType !== "http";
     const updatedHosted = shouldSetHostedOrgx &&
         (existingOrgxUrl !== ORGX_HOSTED_MCP_URL || existingOrgxType !== "http");
-    const updated = updatedLocal || updatedHosted || updatedScopes.length > 0;
+    const updated = updatedLocal || updatedHosted || scopedCleanup.updated;
     return { updated, next };
 }
 export function patchCursorMcpConfig(input) {
@@ -133,30 +110,16 @@ export function patchCursorMcpConfig(input) {
         ...existing,
         url: input.localMcpUrl,
     };
-    const scopedEntries = {};
-    let updatedScopes = false;
-    for (const scope of ORGX_LOCAL_MCP_SCOPES) {
-        const key = scopedMcpServerKey(scope);
-        const expectedUrl = scopedMcpUrl(input.localMcpUrl, scope);
-        const existingScoped = isRecord(currentServers[key]) ? currentServers[key] : {};
-        const priorScopedUrl = typeof existingScoped.url === "string" ? existingScoped.url : "";
-        scopedEntries[key] = {
-            ...existingScoped,
-            url: expectedUrl,
-        };
-        if (priorScopedUrl !== expectedUrl)
-            updatedScopes = true;
-    }
-    const nextServers = {
+    const mergedServers = {
         ...currentServers,
         [ORGX_LOCAL_MCP_KEY]: nextEntry,
-        ...scopedEntries,
     };
+    const scopedCleanup = removeLegacyScopedMcpServers(mergedServers);
     const next = {
         ...input.current,
-        mcpServers: nextServers,
+        mcpServers: scopedCleanup.next,
     };
-    const updated = priorUrl !== input.localMcpUrl || updatedScopes;
+    const updated = priorUrl !== input.localMcpUrl || scopedCleanup.updated;
     return { updated, next };
 }
 function upsertCodexMcpServerSection(input) {
@@ -173,7 +136,9 @@ function upsertCodexMcpServerSection(input) {
     }
     const urlLine = `url = "${input.url}"`;
     if (headerIndex === -1) {
-        const suffix = ["", `[mcp_servers.\"${input.key}\"]`, urlLine, ""].join("\n");
+        const needsQuote = /[^A-Za-z0-9_]/.test(input.key);
+        const keyLiteral = needsQuote ? `"${input.key}"` : input.key;
+        const suffix = ["", `[mcp_servers.${keyLiteral}]`, urlLine, ""].join("\n");
         const normalized = currentText.endsWith("\n") ? currentText : `${currentText}\n`;
         return { updated: true, next: `${normalized}${suffix}` };
     }
@@ -221,29 +186,52 @@ function upsertCodexMcpServerSection(input) {
     }
     return { updated, next: `${lines.join("\n")}\n` };
 }
-export function patchCodexConfigToml(input) {
-    let current = input.current;
-    let updatedHosted = false;
-    // If the hosted OrgX entry is missing entirely, add a sensible default. This is
-    // a no-op if the user already has `orgx` pointed at staging or another URL.
-    const hostedHeaderRegex = /^\[mcp_servers\.(?:"orgx"|orgx)\]\s*$/;
-    {
-        const lines = current.split(/\r?\n/);
-        const hasHosted = lines.some((line) => hostedHeaderRegex.test(line.trim()));
-        if (!hasHosted) {
-            const hostedUrlLine = `url = "${ORGX_HOSTED_MCP_URL}"`;
-            const suffix = [
-                ...(current.trim().length === 0 ? [] : [""]),
-                "[mcp_servers.orgx]",
-                hostedUrlLine,
-                "",
-            ].join("\n");
-            const normalized = current.endsWith("\n") ? current : `${current}\n`;
-            current = `${normalized}${suffix}`;
-            updatedHosted = true;
+function removeCodexLegacyScopedMcpSections(input) {
+    const lines = input.current.split(/\r?\n/);
+    const scopedPrefix = `${input.baseKey}-`;
+    let updated = false;
+    let index = 0;
+    while (index < lines.length) {
+        const trimmed = lines[index].trim();
+        const headerMatch = trimmed.match(/^\[mcp_servers\.(?:"([^"]+)"|([A-Za-z0-9_]+))\]\s*$/);
+        if (!headerMatch) {
+            index += 1;
+            continue;
+        }
+        const key = (headerMatch[1] ?? headerMatch[2] ?? "").trim();
+        const isLegacyScoped = key !== input.baseKey &&
+            key.startsWith(scopedPrefix);
+        if (!isLegacyScoped) {
+            index += 1;
+            continue;
         }
+        let sectionEnd = lines.length;
+        for (let i = index + 1; i < lines.length; i += 1) {
+            if (lines[i].trim().startsWith("[")) {
+                sectionEnd = i;
+                break;
+            }
+        }
+        const start = index > 0 && lines[index - 1].trim() === "" ? index - 1 : index;
+        lines.splice(start, sectionEnd - start);
+        updated = true;
+        index = Math.max(0, start);
     }
+    return { updated, next: `${lines.join("\n")}\n` };
+}
+export function patchCodexConfigToml(input) {
+    let current = input.current;
     let updated = false;
+    // Ensure the hosted OrgX entry uses a direct `url` (streamable HTTP) so that
+    // `codex mcp login orgx` can perform OAuth.  Route through upsertCodexMcpServerSection
+    // so stale stdio-transport fields (command/args) are stripped automatically.
+    const hosted = upsertCodexMcpServerSection({
+        current,
+        key: "orgx",
+        url: ORGX_HOSTED_MCP_URL,
+    });
+    updated = updated || hosted.updated;
+    current = hosted.next;
     const base = upsertCodexMcpServerSection({
         current,
         key: ORGX_LOCAL_MCP_KEY,
@@ -251,16 +239,13 @@ export function patchCodexConfigToml(input) {
     });
     updated = updated || base.updated;
     current = base.next;
-    for (const scope of ORGX_LOCAL_MCP_SCOPES) {
-        const next = upsertCodexMcpServerSection({
-            current,
-            key: scopedMcpServerKey(scope),
-            url: scopedMcpUrl(input.localMcpUrl, scope),
-        });
-        updated = updated || next.updated;
-        current = next.next;
-    }
-    return { updated: updatedHosted || updated, next: current };
+    const removedScoped = removeCodexLegacyScopedMcpSections({
+        current,
+        baseKey: ORGX_LOCAL_MCP_KEY,
+    });
+    updated = updated || removedScoped.updated;
+    current = removedScoped.next;
+    return { updated, next: current };
 }
 export async function autoConfigureDetectedMcpClients(input) {
     const logger = input.logger ?? {};

package/dist/runtime-instance-store.js

@@ -85,7 +85,7 @@ function normalizeHookEvent(value) {
 }
 function toProviderLogo(sourceClient) {
     if (sourceClient === "codex")
-        return "codex";
+        return "openai";
     if (sourceClient === "claude-code")
         return "anthropic";
     if (sourceClient === "openclaw")
@@ -97,9 +97,9 @@ function toProviderLogo(sourceClient) {
 function normalizeProviderLogo(value, sourceClient) {
     const normalized = normalizeNullableString(value)?.toLowerCase();
     if (normalized === "codex")
-        return "codex";
+        return sourceClient === "codex" ? "openai" : "codex";
     if (normalized === "openai")
-        return sourceClient === "codex" ? "codex" : "openai";
+        return "openai";
     if (normalized === "anthropic")
         return "anthropic";
     if (normalized === "openclaw")

package/dist/worker-supervisor.js

@@ -4,6 +4,17 @@ function pickString(value) {
     const trimmed = value.trim();
     return trimmed.length > 0 ? trimmed : null;
 }
+function parseIgnoredMcpServers(raw) {
+    if (typeof raw !== "string")
+        return new Set(["codex_apps"]);
+    const trimmed = raw.trim();
+    if (!trimmed || trimmed.toLowerCase() === "none")
+        return new Set();
+    return new Set(trimmed
+        .split(",")
+        .map((entry) => entry.trim().toLowerCase())
+        .filter(Boolean));
+}
 export function detectMcpHandshakeFailure(logText) {
     const text = String(logText ?? "");
     const lower = text.toLowerCase();
@@ -28,6 +39,10 @@ export function detectMcpHandshakeFailure(logText) {
         signalLine?.match(/mcp client for\s+\[?([^\]]+)\]?\s+failed to start/i) ??
         null;
     const server = serverMatch ? pickString(serverMatch[1]) ?? null : null;
+    const ignoredServers = parseIgnoredMcpServers(process.env.ORGX_AUTOPILOT_MCP_HANDSHAKE_IGNORE_SERVERS);
+    if (server && ignoredServers.has(server.toLowerCase())) {
+        return null;
+    }
     return {
         kind: "mcp_handshake",
         server,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@useorgx/openclaw-plugin",
-  "version": "0.4.6",
+  "version": "0.4.8",
   "description": "OrgX plugin for OpenClaw — agent orchestration, quality gates, model routing, and live dashboard",
   "type": "module",
   "main": "./dist/index.js",
@@ -40,6 +40,11 @@
     "verify:clean-install": "node ./scripts/verify-clean-install.mjs",
     "verify:agent-suite": "npm run build:core && node ./scripts/verify-agent-suite-install.mjs",
     "verify:billing": "npm run build:core && node ./scripts/verify-billing-scenarios.mjs",
+    "verify:autopilot-e2e:local": "npm run build:core && node ./scripts/verify-autopilot-e2e-local.mjs",
+    "verify:autopilot-e2e:matrix": "npm run build:core && node ./scripts/verify-autopilot-e2e-matrix.mjs",
+    "verify:autopilot-e2e:entities": "npm run build:core && node ./scripts/verify-autopilot-e2e-entities.mjs",
+    "verify:autopilot-e2e:entities-matrix": "npm run build:core && node ./scripts/verify-autopilot-e2e-entities-matrix.mjs",
+    "verify:iwmt-cascade": "npm run build:core && node ./scripts/verify-iwmt-cascade-e2e.mjs",
     "e2e:auto-continue": "node ./scripts/e2e-auto-continue.mjs",
     "e2e:agent-suite": "npm run build:core && node ./scripts/e2e-agent-suite-kickoff-3x.mjs",
     "demo:record": "node ./scripts/record-demo.mjs",