@useorgx/openclaw-plugin 0.4.9 → 0.7.2

package/dist/index.js

@@ -23,20 +23,26 @@ import { clearPersistedSnapshot, readPersistedSnapshot, writePersistedSnapshot,
 import { appendToOutbox, readOutboxSummary, } from "./outbox.js";
 import { getAgentContext, readAgentContexts } from "./agent-context-store.js";
 import { readAgentRuns, markAgentRunStopped } from "./agent-run-store.js";
-import { ensureGatewayWatchdog } from "./gateway-watchdog.js";
+import { ensureGatewayWatchdog, stopGatewayWatchdog } from "./gateway-watchdog.js";
 import { createMcpHttpHandler, } from "./mcp-http-handler.js";
 import { posthogCapture } from "./telemetry/posthog.js";
-import { readSkillPackState, refreshSkillPackState } from "./skill-pack-state.js";
-import { resolveConfig, resolveRuntimeUserId, } from "./config/resolution.js";
+import { readSkillPackState, refreshSkillPackState, rollbackSkillPackPolicy, updateSkillPackPolicy, } from "./skill-pack-state.js";
+import { resolveConfig, resolveDocsUrl, resolveRuntimeUserId, } from "./config/resolution.js";
 import { refreshResolvedConfig } from "./config/refresh.js";
 import { applyRuntimeApiKey, buildManualKeyConnectUrl as buildManualKeyConnectUrlForBase, fetchOrgxJson as fetchOrgxJsonRequest, isAuthRequiredError, } from "./auth/flows.js";
 import { registerOrgxCli } from "./cli/orgx.js";
 import { instrumentPluginApi } from "./services/instrumentation.js";
 import { registerSyncService } from "./services/background.js";
+import { stopDetachedProcess } from "./http/helpers/openclaw-cli.js";
 import { createOutboxReplayer } from "./sync/outbox-replay.js";
+import { buildLocalAgentMirrorsFromSnapshot, buildLocalSyncAgentsFromRuns, } from "./sync/local-agent-telemetry.js";
 import { registerCoreTools } from "./tools/core-tools.js";
 import { stableHash } from "./hash-utils.js";
+import { RETRO_ARTIFACT_SCHEMA_VERSION } from "./contracts/retro-schema.js";
+import { buildRetroWithLlm } from "./retro/domain-templates.js";
+import { computeRetroQualityRubricScore } from "./retro/quality-rubric.js";
 export { OrgXClient } from "./api.js";
+const ORGX_CANONICAL_BASE_URL = "https://www.useorgx.com";
 // =============================================================================
 // HELPERS
 // =============================================================================
@@ -333,6 +339,29 @@ export default function register(api) {
             toErrorMessage,
         });
     }
+    function looksLikeTransientFetchFailure(message) {
+        const normalized = message.toLowerCase();
+        return (normalized.includes("fetch failed") ||
+            normalized.includes("networkerror") ||
+            normalized.includes("econnrefused") ||
+            normalized.includes("enotfound") ||
+            normalized.includes("eai_again"));
+    }
+    function applyRuntimeBaseUrl(nextBaseUrl) {
+        const normalized = nextBaseUrl.trim().replace(/\/+$/, "");
+        if (!normalized)
+            return;
+        if (config.baseUrl === normalized && baseApiUrl === normalized)
+            return;
+        config.baseUrl = normalized;
+        baseApiUrl = normalized;
+        client.setCredentials({
+            apiKey: config.apiKey,
+            userId: config.userId,
+            baseUrl: config.baseUrl,
+        });
+        updateOnboardingState({ docsUrl: resolveDocsUrl(config.baseUrl) });
+    }
     function setRuntimeApiKey(input) {
         applyRuntimeApiKey({
             config,
@@ -353,6 +382,7 @@ export default function register(api) {
     let syncTimer = null;
     let syncInFlight = null;
     let syncServiceRunning = false;
+    let localAgentMirrors = [];
     let outboxReplayState = {
         status: "idle",
         lastReplayAttemptAt: null,
@@ -661,6 +691,24 @@ export default function register(api) {
                 const completedAt = stopped.stoppedAt ?? new Date().toISOString();
                 const success = !summary.hadError;
                 const correlationId = stopped.runId;
+                const retroTemplate = await buildRetroWithLlm({
+                    agentId: stopped.agentId,
+                    success,
+                    taskId: stopped.taskId,
+                    runId: stopped.runId,
+                    errorMessage: summary.errorMessage,
+                });
+                const retroSummary = retroTemplate.summary;
+                const retroQuality = computeRetroQualityRubricScore({
+                    success,
+                    hadError: summary.hadError,
+                    errorMessage: summary.errorMessage,
+                    tokens: summary.tokens,
+                    costUsd: summary.costUsd,
+                    decisionsCount: retroTemplate.decisions.length,
+                    followUpsCount: retroTemplate.followUps.length,
+                    whatWentWrongCount: retroTemplate.whatWentWrong.length,
+                });
                 const outcomePayload = {
                     initiative_id: initiativeId,
                     correlation_id: correlationId,
@@ -682,6 +730,7 @@ export default function register(api) {
                     },
                     steps: [],
                     success,
+                    quality_score: retroQuality.score,
                     human_interventions: 0,
                     errors: summary.errorMessage ? [summary.errorMessage] : [],
                     metadata: {
@@ -696,9 +745,6 @@ export default function register(api) {
                     ? "task"
                     : "initiative";
                 const retroEntityId = stopped.taskId ?? initiativeId;
-                const retroSummary = stopped.taskId
-                    ? `OpenClaw ${success ? "completed" : "blocked"} task ${stopped.taskId}.`
-                    : `OpenClaw run ${success ? "completed" : "blocked"} (session ${stopped.runId}).`;
                 const retroPayload = {
                     initiative_id: initiativeId,
                     correlation_id: correlationId,
@@ -708,21 +754,12 @@ export default function register(api) {
                     title: stopped.taskId ?? stopped.runId,
                     idempotency_key: `retro:${stopped.runId}`,
                     retro: {
+                        schema_version: RETRO_ARTIFACT_SCHEMA_VERSION,
                         summary: retroSummary,
-                        what_went_well: success ? ["Completed without runtime error."] : [],
-                        what_went_wrong: success
-                            ? []
-                            : [summary.errorMessage ?? "Session ended with error."],
-                        decisions: [],
-                        follow_ups: success
-                            ? []
-                            : [
-                                {
-                                    title: "Investigate OpenClaw session failure and unblock task",
-                                    priority: "p0",
-                                    reason: summary.errorMessage ?? "Session ended with error.",
-                                },
-                            ],
+                        what_went_well: retroTemplate.whatWentWell,
+                        what_went_wrong: retroTemplate.whatWentWrong,
+                        decisions: retroTemplate.decisions,
+                        follow_ups: retroTemplate.followUps,
                         signals: {
                             tokens: summary.tokens,
                             cost_usd: summary.costUsd,
@@ -731,8 +768,11 @@ export default function register(api) {
                             session_id: stopped.runId,
                             task_id: stopped.taskId,
                             workstream_id: stopped.workstreamId,
+                            domain: retroTemplate.domain,
                             provider: stopped.provider,
                             model: stopped.model,
+                            quality_score: retroQuality.score,
+                            quality_rubric_reasons: retroQuality.reasons,
                             source: "openclaw_agent_run_reconcile",
                         },
                     },
@@ -848,7 +888,11 @@ export default function register(api) {
                 await reconcileStoppedAgentRuns();
                 let snapshotError = null;
                 try {
-                    updateCachedSnapshot(await client.getOrgSnapshot());
+                    const snapshot = await client.getOrgSnapshot();
+                    updateCachedSnapshot(snapshot);
+                    localAgentMirrors = buildLocalAgentMirrorsFromSnapshot({
+                        agents: snapshot.agents,
+                    });
                 }
                 catch (err) {
                     if (isAuthFailure(err)) {
@@ -859,6 +903,24 @@ export default function register(api) {
                         error: snapshotError,
                     });
                 }
+                const localAgents = buildLocalSyncAgentsFromRuns({
+                    ...readAgentRuns(),
+                    mirrors: localAgentMirrors,
+                });
+                if (localAgents.length > 0) {
+                    try {
+                        await client.syncMemory({ agents: localAgents });
+                    }
+                    catch (err) {
+                        if (isAuthFailure(err)) {
+                            throw err;
+                        }
+                        api.log?.warn?.("[orgx] Local agent telemetry sync failed (continuing)", {
+                            error: toErrorMessage(err),
+                            count: localAgents.length,
+                        });
+                    }
+                }
                 // Best-effort: poll the canonical OrgX SkillPack so the dashboard/install path
                 // can apply it without blocking on an on-demand fetch.
                 try {
@@ -987,16 +1049,48 @@ export default function register(api) {
             lastError: null,
             nextAction: "connect",
         });
-        const started = await fetchOrgxJson("POST", "/api/plugin/openclaw/pairings", {
+        const pairingPayload = {
             installationId: config.installationId,
             pluginVersion: config.pluginVersion,
             openclawVersion: input.openclawVersion,
             platform: input.platform || process.platform,
             deviceName: input.deviceName,
-        }, 
-        // Pairing can hit a cold serverless boot + supabase insert + rate-limit checks.
-        // Give it more headroom than typical lightweight API calls.
-        { timeoutMs: 30_000 });
+        };
+        const requestPairing = (targetBaseApiUrl) => fetchOrgxJsonRequest({
+            baseApiUrl: targetBaseApiUrl,
+            method: "POST",
+            path: "/api/plugin/openclaw/pairings",
+            body: pairingPayload,
+            // Pairing can hit a cold serverless boot + supabase insert + rate-limit checks.
+            // Give it more headroom than typical lightweight API calls.
+            options: { timeoutMs: 30_000 },
+            toErrorMessage,
+        });
+        let started = await requestPairing(baseApiUrl);
+        const shouldRetryAgainstCanonical = !started.ok &&
+            started.status === 0 &&
+            looksLikeTransientFetchFailure(started.error) &&
+            baseApiUrl.replace(/\/+$/, "") !== ORGX_CANONICAL_BASE_URL;
+        if (shouldRetryAgainstCanonical) {
+            const initialStatus = started.ok ? 0 : started.status;
+            const initialError = started.ok ? "Pairing request failed" : started.error;
+            const fallbackStarted = await requestPairing(ORGX_CANONICAL_BASE_URL);
+            if (fallbackStarted.ok) {
+                api.log?.info?.("[orgx] Pairing start succeeded via canonical OrgX base URL", {
+                    previousBaseUrl: baseApiUrl,
+                    nextBaseUrl: ORGX_CANONICAL_BASE_URL,
+                });
+                applyRuntimeBaseUrl(ORGX_CANONICAL_BASE_URL);
+                started = fallbackStarted;
+            }
+            else {
+                started = {
+                    ok: false,
+                    status: fallbackStarted.status || initialStatus,
+                    error: `${initialError}; fallback via ${ORGX_CANONICAL_BASE_URL} failed: ${fallbackStarted.error}`,
+                };
+            }
+        }
         if (!started.ok) {
             if (isAuthRequiredError(started)) {
                 clearPairingState();
@@ -1021,7 +1115,10 @@ export default function register(api) {
                 };
             }
             const statusLabel = started.status ? ` (HTTP ${started.status})` : "";
-            const message = `Pairing start failed${statusLabel}: ${started.error}`;
+            const networkHint = started.status === 0
+                ? ` Could not reach OrgX at ${baseApiUrl}. Check network/VPN/firewall or update ORGX_BASE_URL.`
+                : "";
+            const message = `Pairing start failed${statusLabel}: ${started.error}${networkHint}`;
             updateOnboardingState({
                 status: "error",
                 hasApiKey: Boolean(config.apiKey),
@@ -1194,10 +1291,49 @@ export default function register(api) {
             keySource: "none",
         });
     }
+    async function stopTrackedAgentRunsOnPluginStop() {
+        const runs = Object.values(readAgentRuns().runs ?? {}).filter((run) => run?.status === "running");
+        let attempted = 0;
+        let stopped = 0;
+        let failed = 0;
+        let markedStopped = 0;
+        for (const run of runs) {
+            if (!run || typeof run !== "object")
+                continue;
+            attempted += 1;
+            let runStopped = false;
+            if (typeof run.pid === "number" && Number.isFinite(run.pid) && run.pid > 0) {
+                try {
+                    const result = await stopDetachedProcess(run.pid);
+                    runStopped = Boolean(result.stopped);
+                }
+                catch {
+                    runStopped = false;
+                }
+            }
+            else {
+                // No tracked PID means there is no local process to stop.
+                runStopped = true;
+            }
+            if (runStopped) {
+                stopped += 1;
+            }
+            else {
+                failed += 1;
+            }
+            const marked = markAgentRunStopped(run.runId);
+            if (marked) {
+                markedStopped += 1;
+            }
+        }
+        return { attempted, stopped, failed, markedStopped };
+    }
     registerSyncService({
         api,
         syncIntervalMs: config.syncIntervalMs,
         ensureGatewayWatchdog: (logger) => ensureGatewayWatchdog(logger),
+        stopGatewayWatchdog: () => stopGatewayWatchdog((api.log ?? {})),
+        stopTrackedAgentRuns: stopTrackedAgentRunsOnPluginStop,
         doSync,
         scheduleNextSync,
         setSyncServiceRunning: (running) => {
@@ -1236,6 +1372,8 @@ export default function register(api) {
         pickNonEmptyString,
         resolveReportingContext,
         readSkillPackState,
+        updateSkillPackPolicy,
+        rollbackSkillPackPolicy,
         randomUUID,
     });
     // ---------------------------------------------------------------------------

package/dist/local-openclaw.js

@@ -1,6 +1,7 @@
 import { homedir } from "node:os";
 import { join } from "node:path";
 import { readFile, stat, writeFile } from "node:fs/promises";
+import { callLlm } from "./http/helpers/llm-client.js";
 const ACTIVE_WINDOW_MS = 30 * 60_000;
 const LOCAL_SNAPSHOT_CACHE_TTL_MS = 1_500;
 let localSnapshotCache = null;
@@ -475,9 +476,9 @@ function groupEventsIntoTurns(events, maxTurns, limits) {
     return turns;
 }
 // ---------------------------------------------------------------------------
-// Rule-based turn summarization (fallback — LLM digest in Phase 1B)
+// Turn summarization — LLM with heuristic fallback
 // ---------------------------------------------------------------------------
-function summarizeTurn(turn, _agentLabel) {
+function heuristicSummarizeTurn(turn, _agentLabel) {
     const normalize = (value) => value.replace(/\s+/g, " ").trim();
     if (turn.errorMessage) {
         return `Error: ${normalize(turn.errorMessage)}`;
@@ -503,6 +504,28 @@ function summarizeTurn(turn, _agentLabel) {
     }
     return "Activity";
 }
+async function summarizeTurnWithLlm(turn, agentLabel) {
+    const parts = [];
+    if (turn.userPrompt)
+        parts.push(`User: ${turn.userPrompt}`);
+    if (turn.toolNames.length > 0)
+        parts.push(`Tools: ${turn.toolNames.join(", ")}`);
+    if (turn.assistantResponse)
+        parts.push(`Assistant: ${turn.assistantResponse}`);
+    if (turn.errorMessage)
+        parts.push(`Error: ${turn.errorMessage}`);
+    const compact = parts.join("\n").slice(0, 4000);
+    const response = await callLlm({
+        taskId: "turn_summary",
+        systemPrompt: "You summarize agent session turns for a dashboard activity feed. " +
+            "Write one clear sentence (max 120 chars) describing what happened. " +
+            "Focus on the action and outcome, not internal details. No markdown.",
+        userPrompt: compact,
+        maxTokens: 64,
+        temperature: 0.15,
+    }, () => heuristicSummarizeTurn(turn, agentLabel));
+    return response.result;
+}
 function isDigestSummaryStale(cached, fresh) {
     if (!cached)
         return true;
@@ -552,9 +575,9 @@ async function writeDigestCache(baseDir, agentId, sessionId, cache) {
 // ---------------------------------------------------------------------------
 // Turn → LiveActivityItem mapping
 // ---------------------------------------------------------------------------
-function turnToActivity(turn, session, cachedSummary, index) {
+async function turnToActivity(turn, session, cachedSummary, index) {
     const agentLabel = session.agentName ?? session.agentId ?? "OpenClaw";
-    const summary = cachedSummary ?? summarizeTurn(turn, agentLabel);
+    const summary = cachedSummary ?? await summarizeTurnWithLlm(turn, agentLabel);
     // Determine activity type
     let type = "delegation";
     if (turn.errorMessage) {
@@ -663,11 +686,11 @@ export async function toLocalLiveActivity(snapshot, limit = 200) {
                 const turn = turns[i];
                 const cached = cachedMap.get(turn.id) ?? null;
                 const agentLabel = session.agentName ?? session.agentId ?? "OpenClaw";
-                const computedSummary = summarizeTurn(turn, agentLabel);
+                const computedSummary = await summarizeTurnWithLlm(turn, agentLabel);
                 const fallbackSummary = isDigestSummaryStale(cached, computedSummary)
                     ? computedSummary
                     : cached;
-                allActivities.push(turnToActivity(turn, session, fallbackSummary, i));
+                allActivities.push(await turnToActivity(turn, session, fallbackSummary, i));
                 // Track for cache
                 if (isDigestSummaryStale(cached, computedSummary)) {
                     newCacheEntries.push({ turnId: turn.id, summary: fallbackSummary });

package/dist/mcp-client-setup.js

@@ -126,7 +126,7 @@ function upsertCodexMcpServerSection(input) {
     const currentText = input.current;
     const lines = currentText.split(/\r?\n/);
     const escapedKey = escapeRegExp(input.key);
-    const headerRegex = new RegExp(`^\\[mcp_servers\\.(?:"${escapedKey}"|${escapedKey})\\]\\s*$`);
+    const headerRegex = new RegExp(`^\\[mcp_servers\\.(?:"${escapedKey}"|'${escapedKey}'|${escapedKey})\\]\\s*$`);
     let headerIndex = -1;
     for (let i = 0; i < lines.length; i += 1) {
         if (headerRegex.test(lines[i].trim())) {
@@ -193,12 +193,12 @@ function removeCodexLegacyScopedMcpSections(input) {
     let index = 0;
     while (index < lines.length) {
         const trimmed = lines[index].trim();
-        const headerMatch = trimmed.match(/^\[mcp_servers\.(?:"([^"]+)"|([A-Za-z0-9_]+))\]\s*$/);
+        const headerMatch = trimmed.match(/^\[mcp_servers\.(?:"([^"]+)"|'([^']+)'|([A-Za-z0-9_]+))\]\s*$/);
         if (!headerMatch) {
             index += 1;
             continue;
         }
-        const key = (headerMatch[1] ?? headerMatch[2] ?? "").trim();
+        const key = (headerMatch[1] ?? headerMatch[2] ?? headerMatch[3] ?? "").trim();
         const isLegacyScoped = key !== input.baseKey &&
             key.startsWith(scopedPrefix);
         if (!isLegacyScoped) {

package/dist/mcp-http-handler.d.ts

@@ -45,6 +45,9 @@ export type RegisteredPrompt = {
     }>;
     messages: PromptMessage[];
 };
+type OrgxMcpScopeKey = "engineering" | "product" | "design" | "marketing" | "sales" | "operations" | "orchestration";
+export declare const ORGX_BASE_TOOLS: readonly ["orgx_status", "orgx_sync", "list_agent_configs", "get_agent_config", "orgx_emit_activity", "orgx_report_progress", "update_stream_progress", "orgx_register_artifact", "orgx_request_decision", "orgx_spawn_check", "orgx_quality_score", "orgx_proof_status", "orgx_record_outcome", "orgx_get_outcome_attribution", "orgx_verify_completion"];
+export declare const ORGX_MCP_ALLOWED_TOOLS_BY_SCOPE: Record<OrgxMcpScopeKey, string[]>;
 export declare function createMcpHttpHandler(input: {
     tools: Map<string, RegisteredTool>;
     prompts?: Map<string, RegisteredPrompt>;

package/dist/mcp-http-handler.js

@@ -5,73 +5,47 @@ const DEFAULT_PROTOCOL_VERSION = "2024-11-05";
 //
 // NOTE: This scopes only the tools exposed by this plugin (OrgX reporting + mutation).
 // It cannot restrict OpenClaw-native tools (filesystem, shell, etc).
-const ORGX_MCP_ALLOWED_TOOLS_BY_SCOPE = {
-    engineering: [
-        "orgx_status",
-        "orgx_sync",
-        "orgx_emit_activity",
-        "orgx_report_progress",
-        "orgx_register_artifact",
-        "orgx_request_decision",
-        "orgx_spawn_check",
-    ],
-    product: [
-        "orgx_status",
-        "orgx_sync",
-        "orgx_emit_activity",
-        "orgx_report_progress",
-        "orgx_register_artifact",
-        "orgx_request_decision",
-        "orgx_spawn_check",
-    ],
-    design: [
-        "orgx_status",
-        "orgx_sync",
-        "orgx_emit_activity",
-        "orgx_report_progress",
-        "orgx_register_artifact",
-        "orgx_request_decision",
-        "orgx_spawn_check",
-    ],
-    marketing: [
-        "orgx_status",
-        "orgx_sync",
-        "orgx_emit_activity",
-        "orgx_report_progress",
-        "orgx_register_artifact",
-        "orgx_request_decision",
-        "orgx_spawn_check",
-    ],
-    sales: [
-        "orgx_status",
-        "orgx_sync",
-        "orgx_emit_activity",
-        "orgx_report_progress",
-        "orgx_register_artifact",
-        "orgx_request_decision",
-        "orgx_spawn_check",
-    ],
+// Base tools available to all domain scopes
+export const ORGX_BASE_TOOLS = [
+    "orgx_status",
+    "orgx_sync",
+    "list_agent_configs",
+    "get_agent_config",
+    "orgx_emit_activity",
+    "orgx_report_progress",
+    "update_stream_progress",
+    "orgx_register_artifact",
+    "orgx_request_decision",
+    "orgx_spawn_check",
+    // Proof ladder tools (all domains)
+    "orgx_quality_score",
+    "orgx_proof_status",
+    "orgx_record_outcome",
+    "orgx_get_outcome_attribution",
+    "orgx_verify_completion",
+];
+export const ORGX_MCP_ALLOWED_TOOLS_BY_SCOPE = {
+    engineering: [...ORGX_BASE_TOOLS],
+    product: [...ORGX_BASE_TOOLS],
+    design: [...ORGX_BASE_TOOLS],
+    marketing: [...ORGX_BASE_TOOLS],
+    sales: [...ORGX_BASE_TOOLS],
     operations: [
-        "orgx_status",
-        "orgx_sync",
-        "orgx_emit_activity",
-        "orgx_report_progress",
-        "orgx_register_artifact",
-        "orgx_request_decision",
-        "orgx_spawn_check",
+        ...ORGX_BASE_TOOLS,
+        "update_agent_config",
         // Operations is allowed to do explicit changesets for remediation/runbooks.
         "orgx_apply_changeset",
+        // Stream reassignment is a targeted operational mutation.
+        "orgx_reassign_stream",
+        "orgx_reassign_streams",
     ],
     orchestration: [
-        "orgx_status",
-        "orgx_sync",
-        "orgx_emit_activity",
-        "orgx_report_progress",
-        "orgx_register_artifact",
-        "orgx_request_decision",
-        "orgx_spawn_check",
+        ...ORGX_BASE_TOOLS,
+        "update_agent_config",
         // Orchestrator is the primary mutation surface by design.
         "orgx_apply_changeset",
+        "orgx_reassign_stream",
+        "orgx_reassign_streams",
     ],
 };
 function isRecord(value) {

package/dist/next-up-queue-store.d.ts

@@ -6,10 +6,17 @@ export type NextUpPinnedEntry = {
     createdAt: string;
     updatedAt: string;
 };
+export type NextUpSuppressedEntry = {
+    initiativeId: string;
+    workstreamId: string;
+    createdAt: string;
+    updatedAt: string;
+};
 type PersistedNextUpQueue = {
-    version: 1;
+    version: 1 | 2;
     updatedAt: string;
     pins: NextUpPinnedEntry[];
+    suppressions: NextUpSuppressedEntry[];
 };
 export declare function readNextUpQueuePins(): PersistedNextUpQueue;
 export declare function upsertNextUpQueuePin(input: {
@@ -28,4 +35,12 @@ export declare function setNextUpQueuePinOrder(input: {
         workstreamId: string;
     }>;
 }): PersistedNextUpQueue;
+export declare function suppressNextUpQueueItem(input: {
+    initiativeId: string;
+    workstreamId: string;
+}): PersistedNextUpQueue;
+export declare function unsuppressNextUpQueueItem(input: {
+    initiativeId: string;
+    workstreamId: string;
+}): PersistedNextUpQueue;
 export {};