@useorgx/openclaw-plugin 0.7.6 → 0.7.11

package/dist/http/index.js

@@ -106,8 +106,64 @@ async function resolveSkillPackOverrides(input) {
     }
 }
 function safeErrorMessage(err) {
-    const raw = err instanceof Error ? err.message : typeof err === "string" ? err : "";
-    const normalized = raw.trim().toLowerCase();
+    const raw = err instanceof Error
+        ? err.message
+        : typeof err === "string"
+            ? err
+            : err && typeof err === "object" && "message" in err && typeof err.message === "string"
+                ? (err.message ?? "")
+                : "";
+    const parseStructuredMessage = (value) => {
+        const trimmed = value.trim();
+        if (!trimmed)
+            return null;
+        const parseObjectMessage = (parsed) => {
+            if (!parsed || typeof parsed !== "object")
+                return null;
+            const root = parsed;
+            const nested = root.error && typeof root.error === "object" ? root.error : null;
+            const envelope = nested ?? root;
+            return ((typeof envelope.message === "string" && envelope.message.trim()) ||
+                (typeof envelope.detail === "string" && envelope.detail.trim()) ||
+                (!nested && typeof root.error === "string" && root.error.trim()) ||
+                null);
+        };
+        try {
+            const parsed = JSON.parse(trimmed);
+            const direct = parseObjectMessage(parsed);
+            if (direct)
+                return direct;
+        }
+        catch {
+            // Continue and try extracting embedded JSON payloads.
+        }
+        const firstBrace = trimmed.indexOf("{");
+        const lastBrace = trimmed.lastIndexOf("}");
+        if (firstBrace >= 0 && lastBrace > firstBrace) {
+            const candidate = trimmed.slice(firstBrace, lastBrace + 1);
+            try {
+                const parsed = JSON.parse(candidate);
+                return parseObjectMessage(parsed);
+            }
+            catch {
+                return null;
+            }
+        }
+        return null;
+    };
+    const stripStructuredNoise = (value) => value
+        .replace(/"requestId"\s*:\s*"[^"]*"/gi, "")
+        .replace(/"timestamp"\s*:\s*"[^"]*"/gi, "")
+        .replace(/"docsUrl"\s*:\s*"[^"]*"/gi, "")
+        .replace(/\brequest[_\s-]?id[:=]\s*[\w-]+/gi, "")
+        .replace(/\btimestamp[:=]\s*\S+/gi, "")
+        .replace(/\bdocsUrl[:=]\s*\S+/gi, "")
+        .replace(/[{}]/g, " ")
+        .replace(/\s{2,}/g, " ")
+        .trim();
+    const normalizedMessage = parseStructuredMessage(raw) ?? raw;
+    const sanitized = stripStructuredNoise(normalizedMessage);
+    const normalized = sanitized.toLowerCase();
     if (normalized.length > 0) {
         if (normalized.includes("signal is aborted") ||
             normalized.includes("aborterror") ||
@@ -121,7 +177,13 @@ function safeErrorMessage(err) {
         if (normalized.includes("failed to fetch") || normalized.includes("network")) {
             return "network request failed";
         }
-        return raw;
+        if (normalized.includes("internal_error") || normalized.includes("internal server error")) {
+            return "temporary server issue";
+        }
+        if (normalized.includes("failed to list decision") || normalized.includes("failed to load decision")) {
+            return "decision data temporarily unavailable";
+        }
+        return sanitized;
     }
     return "Unexpected error";
 }

package/dist/http/routes/live-misc.js

@@ -1,5 +1,6 @@
 import { resolveWorkspaceScope, workspaceScopeFromHeaders, } from "../helpers/workspace-scope.js";
 import { summarizeTaskStatuses } from "../../reporting/rollups.js";
+const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 function asRecord(input) {
     if (!input || typeof input !== "object" || Array.isArray(input))
         return null;
@@ -30,8 +31,15 @@ export function registerLiveMiscRoutes(router, deps) {
         const projectId = projectIdRaw?.trim() ?? "";
         if (!projectId)
             return null;
-        const ids = await deps.listInitiativeIdsForProject({ projectId });
-        return new Set(ids);
+        try {
+            const ids = await deps.listInitiativeIdsForProject({ projectId });
+            return new Set(ids);
+        }
+        catch {
+            // Scope discovery is best-effort. Continue with unscoped fallback data
+            // instead of hard-failing live surfaces.
+            return null;
+        }
     }
     router.add("POST", "live/activity/headline", async ({ req, res }) => {
         try {
@@ -447,9 +455,9 @@ export function registerLiveMiscRoutes(router, deps) {
             let totalActiveAgents = 0;
             for (const initiative of initiatives) {
                 totalActiveAgents += initiative.activeAgents;
-                // Try to get task statuses from graph
+                // Try to get task statuses from graph (skip local placeholder IDs like "agent:orgx")
                 let taskStatuses = [];
-                if (deps.buildMissionControlGraph) {
+                if (deps.buildMissionControlGraph && UUID_RE.test(initiative.id)) {
                     try {
                         const graphRaw = await deps.buildMissionControlGraph(initiative.id);
                         const graph = asRecord(graphRaw);

package/dist/http/routes/live-snapshot.js

@@ -13,7 +13,7 @@ const LIVE_SNAPSHOT_UPSTREAM_TIMEOUT_MS = (() => {
 const LIVE_SNAPSHOT_NEXT_UP_TIMEOUT_MS = (() => {
     const raw = Number(process.env.ORGX_LIVE_SNAPSHOT_NEXT_UP_TIMEOUT_MS ?? "");
     if (!Number.isFinite(raw))
-        return 1_200;
+        return 350;
     return Math.max(250, Math.min(15_000, Math.floor(raw)));
 })();
 async function withSoftTimeout(work, timeoutMs, label) {
@@ -280,9 +280,15 @@ export function registerLiveSnapshotRoutes(router, deps) {
         const agentContexts = contextStore.agents;
         const runContexts = contextStore.runs ?? {};
         const scopedAgentIds = deps.getScopedAgentIds(agentContexts);
-        const scopedProjectInitiativeIds = projectId && projectId.trim().length > 0
-            ? new Set(await deps.listInitiativeIdsForProject({ projectId: projectId.trim() }))
-            : null;
+        let scopedProjectInitiativeIds = null;
+        if (projectId && projectId.trim().length > 0) {
+            try {
+                scopedProjectInitiativeIds = new Set(await deps.listInitiativeIdsForProject({ projectId: projectId.trim() }));
+            }
+            catch (err) {
+                degraded.push(`workspace initiative scope unavailable (${deps.safeErrorMessage(err)})`);
+            }
+        }
         let outboxStatus;
         try {
             const diagnosticsOutbox = await deps.readDiagnosticsOutboxStatus();

package/dist/http/routes/mission-control-actions.js

@@ -456,6 +456,7 @@ export function registerMissionControlActionsRoutes(router, deps) {
                 ignoreSpawnGuardRateLimit: ignoreSpawnGuardRateLimit === true,
                 scope,
             });
+            deps.clearNextUpQueueCache(initiativeId);
             const dispatchId = randomUUID();
             const playDispatchEnvelope = (dispatchMode) => buildDispatchGatewayEnvelope({
                 dispatchId,
@@ -1593,6 +1594,7 @@ export function registerMissionControlActionsRoutes(router, deps) {
                 ignoreSpawnGuardRateLimit: ignoreSpawnGuardRateLimit === true,
                 scope: startScope,
             });
+            deps.clearNextUpQueueCache(initiativeId);
             const dispatchEnvelope = buildDispatchGatewayEnvelope({
                 dispatchMode: "server",
                 route: "mission-control.auto-continue.start",
@@ -1643,6 +1645,7 @@ export function registerMissionControlActionsRoutes(router, deps) {
                     // best effort
                 }
             }
+            deps.clearNextUpQueueCache(initiativeId);
             deps.sendJson(res, 200, { ok: true, run });
         }
         catch (err) {
@@ -1664,10 +1667,12 @@ export function registerMissionControlActionsRoutes(router, deps) {
                     return;
                 }
                 await deps.tickAutoContinueRun(run);
+                deps.clearNextUpQueueCache(initiativeId);
                 deps.sendJson(res, 200, { ok: true, initiativeId, run });
                 return;
             }
             await deps.tickAllAutoContinue();
+            deps.clearNextUpQueueCache(null);
             deps.sendJson(res, 200, { ok: true });
         }
         catch (err) {

package/dist/http/routes/mission-control-read.d.ts

@@ -5,6 +5,7 @@ type AutoContinueRunRecord = {
     status?: string;
     startedAt?: string;
     stoppedAt?: string | null;
+    updatedAt?: string | null;
     tokenBudget?: number | null;
     maxParallelSlices?: number;
     parallelMode?: string;

package/dist/http/routes/mission-control-read.js

@@ -838,11 +838,72 @@ export function registerMissionControlReadRoutes(router, deps) {
     const sendRouteException = (res, location, err) => {
         sendRouteError(res, 500, location, deps.safeErrorMessage(err));
     };
-    async function renderAutoContinueStatus(query, res) {
+    async function renderAutoContinueStatus(query, res, headerScope) {
+        const workspaceScope = resolveWorkspaceScope(query, headerScope, {
+            allowProjectScope: false,
+        });
+        if (workspaceScope.error) {
+            sendRouteError(res, 400, "mission-control.read.auto-continue.status.validation", workspaceScope.error);
+            return;
+        }
+        const scopedProjectId = workspaceScope.workspaceId;
         const initiativeId = query.get("initiative_id") ?? query.get("initiativeId") ?? "";
         const id = initiativeId.trim();
+        let scopedInitiatives = null;
+        if (scopedProjectId) {
+            try {
+                const ids = await deps.listInitiativeIdsForProject({ projectId: scopedProjectId });
+                scopedInitiatives = new Set(ids);
+            }
+            catch {
+                // best effort: if scope lookup is unavailable, fall back to unscoped run resolution.
+                scopedInitiatives = null;
+            }
+        }
+        const statusRank = (value) => {
+            const normalized = (value ?? "").trim().toLowerCase();
+            if (normalized === "running")
+                return 0;
+            if (normalized === "stopping")
+                return 1;
+            if (normalized === "blocked")
+                return 2;
+            if (normalized === "stopped")
+                return 3;
+            return 4;
+        };
+        const updatedEpoch = (value) => {
+            const parsed = Date.parse(value ?? "");
+            return Number.isFinite(parsed) ? parsed : 0;
+        };
         if (!id) {
-            sendRouteError(res, 400, "mission-control.read.auto-continue.status.validation", "Query parameter 'initiative_id' is required.");
+            const scopedRuns = Array.from(deps.autoContinueRuns.values()).filter((run) => {
+                const runInitiativeId = (run.initiativeId ?? "").trim();
+                if (!runInitiativeId)
+                    return false;
+                if (scopedInitiatives && !scopedInitiatives.has(runInitiativeId))
+                    return false;
+                return true;
+            });
+            scopedRuns.sort((left, right) => {
+                const statusDelta = statusRank(left.status) - statusRank(right.status);
+                if (statusDelta !== 0)
+                    return statusDelta;
+                return updatedEpoch(right.updatedAt) - updatedEpoch(left.updatedAt);
+            });
+            const run = scopedRuns[0] ?? null;
+            deps.sendJson(res, 200, {
+                ok: true,
+                initiativeId: run?.initiativeId ?? null,
+                run,
+                defaults: {
+                    tokenBudget: deps.defaultAutoContinueTokenBudget(),
+                    maxParallelSlices: typeof deps.defaultAutoContinueMaxParallelSlices === "function"
+                        ? deps.defaultAutoContinueMaxParallelSlices()
+                        : 1,
+                    tickMs: deps.autoContinueTickMs,
+                },
+            });
             return;
         }
         const run = deps.autoContinueRuns.get(id) ?? null;
@@ -1743,8 +1804,8 @@ export function registerMissionControlReadRoutes(router, deps) {
             items,
         });
     }
-    router.add("GET", "mission-control/auto-continue/status", async ({ query, res }) => renderAutoContinueStatus(query, res), "Get auto-continue status for an initiative");
-    router.add("HEAD", "mission-control/auto-continue/status", async ({ query, res }) => renderAutoContinueStatus(query, res), "Get auto-continue status for an initiative (HEAD)");
+    router.add("GET", "mission-control/auto-continue/status", async ({ query, res, req }) => renderAutoContinueStatus(query, res, workspaceScopeFromHeaders(req?.headers)), "Get auto-continue status for an initiative");
+    router.add("HEAD", "mission-control/auto-continue/status", async ({ query, res, req }) => renderAutoContinueStatus(query, res, workspaceScopeFromHeaders(req?.headers)), "Get auto-continue status for an initiative (HEAD)");
     router.add("GET", "mission-control/graph", async ({ query, res }) => renderMissionControlGraph(query, res), "Get mission-control dependency graph");
     router.add("HEAD", "mission-control/graph", async ({ query, res }) => renderMissionControlGraph(query, res), "Get mission-control dependency graph (HEAD)");
     router.add("GET", "mission-control/next-up", async ({ query, res, req }) => renderNextUpQueue(query, res, workspaceScopeFromHeaders(req?.headers)), "Get next-up queue");

package/dist/index.d.ts

@@ -48,7 +48,14 @@ export interface PluginAPI {
     }) => void, options?: {
         commands?: string[];
     }) => void;
-    registerHttpHandler: (handler: unknown) => void;
+    registerHttpRoute?: (route: {
+        path: string;
+        auth: "gateway" | "plugin";
+        match?: "exact" | "prefix";
+        handler: unknown;
+        replaceExisting?: boolean;
+    }) => void;
+    registerHttpHandler?: (handler: unknown) => void;
 }
 export interface ToolResult {
     content: Array<{

package/dist/index.js

@@ -1430,7 +1430,27 @@ export default function register(api) {
             return true;
         return await httpHandler(req, res);
     };
-    api.registerHttpHandler(compositeHttpHandler);
+    if (typeof api.registerHttpRoute === "function") {
+        api.registerHttpRoute({
+            path: "/orgx",
+            auth: "plugin",
+            match: "prefix",
+            handler: compositeHttpHandler,
+        });
+        api.registerHttpRoute({
+            path: "/workspace-hub",
+            auth: "plugin",
+            match: "prefix",
+            handler: compositeHttpHandler,
+        });
+    }
+    else if (typeof api.registerHttpHandler === "function") {
+        // Backward compatibility for OpenClaw builds before route-based plugin HTTP registration.
+        api.registerHttpHandler(compositeHttpHandler);
+    }
+    else {
+        throw new Error("OpenClaw plugin API does not expose an HTTP registration method.");
+    }
     api.log?.info?.("[orgx] Plugin registered", {
         baseUrl: config.baseUrl,
         hasApiKey: !!config.apiKey,

package/dist/mcp-http-handler.js

@@ -38,6 +38,8 @@ export const ORGX_MCP_ALLOWED_TOOLS_BY_SCOPE = {
         // Stream reassignment is a targeted operational mutation.
         "orgx_reassign_stream",
         "orgx_reassign_streams",
+        // Session resume (read-only visibility for operations).
+        "orgx_agent_sessions",
     ],
     orchestration: [
         ...ORGX_BASE_TOOLS,
@@ -46,6 +48,10 @@ export const ORGX_MCP_ALLOWED_TOOLS_BY_SCOPE = {
         "orgx_apply_changeset",
         "orgx_reassign_stream",
         "orgx_reassign_streams",
+        // Session resume tools.
+        "orgx_agent_sessions",
+        "orgx_resume_agent_session",
+        "orgx_clear_agent_session",
     ],
 };
 function isRecord(value) {

package/dist/openclaw.plugin.json

@@ -1,7 +1,7 @@
 {
   "id": "openclaw-plugin",
   "name": "OrgX Integration",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "description": "Connects Clawdbot to OrgX for agent orchestration, quality gates, and model routing",
   "entry": "./index.js",
   "author": "OrgX Team",

package/dist/tools/core-tools.d.ts

@@ -68,5 +68,32 @@ export interface RegisterCoreToolsDeps {
         auditId?: string;
     }) => import("../skill-pack-state.js").SkillPackState;
     randomUUID?: () => string;
+    sessionStore?: {
+        workstreamSessionStore: Map<string, {
+            sessionId: string;
+            workstreamId: string;
+            initiativeId: string;
+            sourceClient: string;
+            capturedAt: string;
+            fromRunId: string;
+        }>;
+        getWorkstreamSession: (workstreamId: string) => {
+            sessionId: string;
+            workstreamId: string;
+            initiativeId: string;
+            sourceClient: string;
+            capturedAt: string;
+            fromRunId: string;
+        } | null;
+        setWorkstreamSession: (workstreamId: string, entry: {
+            sessionId: string;
+            workstreamId: string;
+            initiativeId: string;
+            sourceClient: string;
+            capturedAt: string;
+            fromRunId: string;
+        }) => void;
+        clearWorkstreamSession: (initiativeId: string) => void;
+    };
 }
 export declare function registerCoreTools(deps: RegisterCoreToolsDeps): Map<string, RegisteredTool>;

package/dist/tools/core-tools.js

@@ -2266,5 +2266,94 @@ export function registerCoreTools(deps) {
             }
         },
     }, { optional: true });
+    // --- orgx_agent_sessions ---
+    registerMcpTool({
+        name: "orgx_agent_sessions",
+        description: "List active CLI session IDs stored for workstreams. Used for session resume support.",
+        parameters: {
+            type: "object",
+            properties: {
+                initiativeId: {
+                    type: "string",
+                    description: "Optional initiative ID filter.",
+                },
+            },
+            additionalProperties: false,
+        },
+        async execute(_callId, params = {}) {
+            const store = deps.sessionStore;
+            if (!store) {
+                return text("Session store not available.");
+            }
+            const entries = [];
+            for (const [, entry] of store.workstreamSessionStore.entries()) {
+                if (params.initiativeId && entry.initiativeId !== params.initiativeId)
+                    continue;
+                entries.push({ ...entry });
+            }
+            return json("Agent sessions:", {
+                count: entries.length,
+                sessions: entries,
+            });
+        },
+    }, { optional: true });
+    // --- orgx_resume_agent_session ---
+    registerMcpTool({
+        name: "orgx_resume_agent_session",
+        description: "Store or update a CLI session ID for a workstream so the next slice resumes it.",
+        parameters: {
+            type: "object",
+            properties: {
+                workstreamId: { type: "string", description: "Workstream UUID" },
+                sessionId: { type: "string", description: "CLI session UUID to resume" },
+                initiativeId: { type: "string", description: "Initiative UUID" },
+                sourceClient: { type: "string", description: "Source client (codex, claude-code)" },
+            },
+            required: ["workstreamId", "sessionId", "initiativeId"],
+            additionalProperties: false,
+        },
+        async execute(_callId, params = { workstreamId: "", sessionId: "", initiativeId: "" }) {
+            const store = deps.sessionStore;
+            if (!store) {
+                return text("Session store not available.");
+            }
+            if (!params.workstreamId || !params.sessionId || !params.initiativeId) {
+                return text("Missing required parameters: workstreamId, sessionId, initiativeId.");
+            }
+            store.setWorkstreamSession(params.workstreamId, {
+                sessionId: params.sessionId,
+                workstreamId: params.workstreamId,
+                initiativeId: params.initiativeId,
+                sourceClient: params.sourceClient ?? "unknown",
+                capturedAt: new Date().toISOString(),
+                fromRunId: "manual",
+            });
+            return text(`Session ${params.sessionId} stored for workstream ${params.workstreamId}.`);
+        },
+    }, { optional: true });
+    // --- orgx_clear_agent_session ---
+    registerMcpTool({
+        name: "orgx_clear_agent_session",
+        description: "Clear stored CLI session IDs for an initiative (forces fresh sessions on next dispatch).",
+        parameters: {
+            type: "object",
+            properties: {
+                initiativeId: { type: "string", description: "Initiative UUID" },
+            },
+            required: ["initiativeId"],
+            additionalProperties: false,
+        },
+        async execute(_callId, params = { initiativeId: "" }) {
+            const store = deps.sessionStore;
+            if (!store) {
+                return text("Session store not available.");
+            }
+            if (!params.initiativeId) {
+                return text("Missing required parameter: initiativeId.");
+            }
+            store.clearWorkstreamSession(params.initiativeId);
+            return text(`Sessions cleared for initiative ${params.initiativeId}.`);
+        },
+    }, { optional: true });
     return mcpToolRegistry;
 }

package/openclaw.plugin.json

@@ -1,7 +1,7 @@
 {
   "id": "openclaw-plugin",
   "name": "OrgX Integration",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "description": "Connects Clawdbot to OrgX for agent orchestration, quality gates, and model routing",
   "entry": "./dist/index.js",
   "author": "OrgX Team",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@useorgx/openclaw-plugin",
-  "version": "0.7.6",
+  "version": "0.7.11",
   "description": "OrgX plugin for OpenClaw — agent orchestration, quality gates, model routing, and live dashboard",
   "type": "module",
   "main": "./dist/index.js",

package/dashboard/dist/assets/BBpTN_SR.js

@@ -1 +0,0 @@
-import{r as l,a as c}from"./cNrhgGc1.js";import{b as g}from"./CPjsbbgZ.js";function f({authToken:s=null,embedMode:o=!1,enabled:n=!0}={}){var a;const i=l.useMemo(()=>["usage-control-plane",{authToken:s,embedMode:o}],[s,o]),e=c({queryKey:i,enabled:n,queryFn:async()=>{const t=await fetch("/orgx/api/usage/control-plane/summary",{headers:g({authToken:s,embedMode:o})}),r=await t.json().catch(()=>null);if(!t.ok){const u=(r&&typeof r=="object"&&"error"in r&&typeof r.error=="string"?r.error:null)??(r&&typeof r=="object"&&"message"in r&&typeof r.message=="string"?r.message:null)??`Failed to load usage summary (${t.status})`;throw new Error(u)}if(!r||typeof r!="object"||!("generatedAt"in r))throw new Error("Usage summary response is missing required fields.");return r},refetchInterval:6e4});return{summary:e.data??null,isLoading:e.isLoading,isFetching:e.isFetching,error:((a=e.error)==null?void 0:a.message)??null,refetch:e.refetch}}export{f as u};