@useorgx/openclaw-plugin 0.7.23 → 0.7.24

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

@@ -9,6 +9,33 @@ const PLAY_QUEUE_LOOKUP_TIMEOUT_MS = (() => {
         return 350;
     return Math.max(200, Math.floor(parsed));
 })();
+function playOutcomeMessage(input) {
+    const workstreamLabel = input.workstreamTitle?.trim() || "this workstream";
+    switch (input.outcome) {
+        case "dispatch_pending":
+            return `Dispatching ${workstreamLabel}; waiting for slice start.`;
+        case "started":
+            return `Started ${workstreamLabel}.`;
+        case "fallback_started":
+            return `Started ${workstreamLabel} using the fallback runner.`;
+        case "slice_completed":
+            return `${workstreamLabel} completed before the queue refreshed.`;
+        case "slice_blocked":
+            return input.startReasonLabel?.trim() || `${workstreamLabel} needs input before it can continue.`;
+        case "slice_error":
+            return `${workstreamLabel} hit an error before it could keep running.`;
+        case "initiative_run_active":
+            return "Autopilot is already running for this initiative.";
+        case "no_dispatchable_task":
+            return input.startReasonLabel?.trim() || `No dispatchable task is available for ${workstreamLabel}.`;
+        case "spawn_guard_rate_limited":
+            return input.fallbackBlockedReason?.trim() || `${workstreamLabel} is rate limited right now.`;
+        case "spawn_guard_blocked":
+            return input.fallbackBlockedReason?.trim() || `${workstreamLabel} is blocked by the current execution policy.`;
+        default:
+            return input.startReasonLabel?.trim() || `Unable to dispatch ${workstreamLabel} right now.`;
+    }
+}
 const IN_PROGRESS_TASK_STATUSES = new Set([
     "in_progress",
     "inprogress",
@@ -412,6 +439,10 @@ export function registerMissionControlActionsRoutes(router, deps) {
                 query.get("projectId") ??
                 query.get("project_id") ??
                 null;
+            const queueWorkstreamTitle = matchedQueueItem?.workstreamTitle ?? null;
+            const queueStartReasonCode = matchedQueueItem?.startReasonCode ?? null;
+            const queueStartReasonLabel = matchedQueueItem?.startReasonLabel ?? null;
+            const queueDispatchableTask = matchedQueueItem?.dispatchableTask ?? null;
             const existingRun = deps.autoContinueRuns.get(initiativeId) ?? null;
             const existingActiveRunIds = Array.isArray(existingRun?.activeSliceRunIds)
                 ? (existingRun?.activeSliceRunIds)
@@ -428,6 +459,13 @@ export function registerMissionControlActionsRoutes(router, deps) {
                 const activeWorkstreamTitle = activeSlice?.workstreamTitle ?? null;
                 deps.sendJson(res, 409, {
                     ok: false,
+                    outcome: "initiative_run_active",
+                    reasonCode: "initiative_run_active",
+                    message: playOutcomeMessage({
+                        outcome: "initiative_run_active",
+                        workstreamTitle: queueWorkstreamTitle,
+                        startReasonLabel: queueStartReasonLabel,
+                    }),
                     code: "auto_continue_already_running",
                     error: activeWorkstreamId || activeWorkstreamTitle
                         ? `Auto-continue is already running for ${activeWorkstreamTitle ?? activeWorkstreamId}. Stop it before launching another Play run.`
@@ -436,10 +474,35 @@ export function registerMissionControlActionsRoutes(router, deps) {
                     activeRunIds: existingActiveRunIds,
                     activeWorkstreamId,
                     activeWorkstreamTitle,
+                    dispatchableTask: queueDispatchableTask,
                     error_location: "mission-control.next-up.play.concurrent_run",
                 });
                 return;
             }
+            if (matchedQueueItem?.canStartNow === false) {
+                const reasonCode = queueStartReasonCode && queueStartReasonCode.trim().length > 0
+                    ? queueStartReasonCode.trim()
+                    : "no_dispatchable_task";
+                const message = playOutcomeMessage({
+                    outcome: reasonCode,
+                    workstreamTitle: queueWorkstreamTitle,
+                    startReasonLabel: queueStartReasonLabel,
+                });
+                deps.sendJson(res, 409, {
+                    ok: false,
+                    outcome: reasonCode,
+                    reasonCode,
+                    message,
+                    code: reasonCode,
+                    error: message,
+                    initiativeId,
+                    workstreamId,
+                    agentId,
+                    dispatchableTask: queueDispatchableTask,
+                    error_location: "mission-control.next-up.play.preflight",
+                });
+                return;
+            }
             const run = await deps.startAutoContinueRun({
                 initiativeId,
                 workspaceId: requestedWorkspaceId,
@@ -491,7 +554,7 @@ export function registerMissionControlActionsRoutes(router, deps) {
                 // Give short-lived workers a brief window to flush output so Play can resolve
                 // in one request/response cycle without requiring extra manual ticks.
                 if (run.activeRunId) {
-                    await new Promise((resolve) => setTimeout(resolve, 140));
+                    await new Promise((resolve) => setTimeout(resolve, 500));
                     await deps.tickAutoContinueRun(run);
                 }
                 fallbackDispatch = await maybeDispatchFallback();
@@ -522,12 +585,20 @@ export function registerMissionControlActionsRoutes(router, deps) {
                         });
                         deps.sendJson(res, 202, {
                             ok: true,
+                            outcome: "dispatch_pending",
+                            reasonCode: "dispatch_pending",
+                            message: playOutcomeMessage({
+                                outcome: "dispatch_pending",
+                                workstreamTitle: queueWorkstreamTitle,
+                                startReasonLabel: queueStartReasonLabel,
+                            }),
                             run,
                             initiativeId,
                             workstreamId,
                             agentId,
                             ...playDispatchEnvelope("pending"),
                             sessionId: null,
+                            dispatchableTask: queueDispatchableTask,
                             slice: {
                                 scope,
                                 taskIds: matchedQueueItem?.sliceTaskIds ?? [],
@@ -566,12 +637,20 @@ export function registerMissionControlActionsRoutes(router, deps) {
                         : "slice_error";
                 deps.sendJson(res, 200, {
                     ok: true,
+                    outcome: finalizedDispatchMode,
+                    reasonCode: finalizedDispatchMode,
+                    message: playOutcomeMessage({
+                        outcome: finalizedDispatchMode,
+                        workstreamTitle: queueWorkstreamTitle,
+                        startReasonLabel: queueStartReasonLabel,
+                    }),
                     run,
                     initiativeId,
                     workstreamId,
                     agentId,
                     ...playDispatchEnvelope(finalizedDispatchMode),
                     sessionId: run.lastRunId,
+                    dispatchableTask: queueDispatchableTask,
                     slice: {
                         scope,
                         taskIds: matchedQueueItem?.sliceTaskIds ?? [],
@@ -589,12 +668,20 @@ export function registerMissionControlActionsRoutes(router, deps) {
             if (dispatchMode === "none" && run.status === "running" && !run.stopReason) {
                 deps.sendJson(res, 202, {
                     ok: true,
+                    outcome: "dispatch_pending",
+                    reasonCode: "dispatch_pending",
+                    message: playOutcomeMessage({
+                        outcome: "dispatch_pending",
+                        workstreamTitle: queueWorkstreamTitle,
+                        startReasonLabel: queueStartReasonLabel,
+                    }),
                     run,
                     initiativeId,
                     workstreamId,
                     agentId,
                     ...playDispatchEnvelope("pending"),
                     sessionId: null,
+                    dispatchableTask: queueDispatchableTask,
                     slice: {
                         scope,
                         taskIds: matchedQueueItem?.sliceTaskIds ?? [],
@@ -611,6 +698,15 @@ export function registerMissionControlActionsRoutes(router, deps) {
             }
             if (dispatchMode === "none") {
                 const fallbackBlockedReason = fallbackDispatch?.blockedReason ?? null;
+                const reasonCode = fallbackBlockedReason
+                    ? fallbackDispatch?.retryable
+                        ? "spawn_guard_rate_limited"
+                        : "spawn_guard_blocked"
+                    : run.stopReason === "blocked"
+                        ? "no_dispatchable_task"
+                        : run.stopReason === "completed"
+                            ? "no_dispatchable_task"
+                            : "dispatch_failed";
                 const reason = fallbackBlockedReason ??
                     (run.stopReason === "blocked"
                         ? "No dispatchable task is ready for this workstream yet."
@@ -619,29 +715,42 @@ export function registerMissionControlActionsRoutes(router, deps) {
                             : "Unable to dispatch this workstream right now.");
                 deps.sendJson(res, fallbackDispatch?.retryable ? 429 : 409, {
                     ok: false,
-                    code: fallbackBlockedReason
-                        ? fallbackDispatch?.retryable
-                            ? "spawn_guard_rate_limited"
-                            : "spawn_guard_blocked"
-                        : undefined,
+                    outcome: reasonCode,
+                    reasonCode,
+                    message: playOutcomeMessage({
+                        outcome: reasonCode,
+                        workstreamTitle: queueWorkstreamTitle,
+                        startReasonLabel: queueStartReasonLabel ?? reason,
+                        fallbackBlockedReason,
+                    }),
+                    code: reasonCode,
                     error: reason,
                     run,
                     initiativeId,
                     workstreamId,
                     agentId,
                     fallbackDispatch,
+                    dispatchableTask: queueDispatchableTask,
                     error_location: "mission-control.next-up.play.dispatch",
                 });
                 return;
             }
             deps.sendJson(res, 200, {
                 ok: true,
+                outcome: dispatchMode === "fallback" ? "fallback_started" : "started",
+                reasonCode: dispatchMode === "fallback" ? "fallback_started" : "started",
+                message: playOutcomeMessage({
+                    outcome: dispatchMode === "fallback" ? "fallback_started" : "started",
+                    workstreamTitle: queueWorkstreamTitle,
+                    startReasonLabel: queueStartReasonLabel,
+                }),
                 run,
                 initiativeId,
                 workstreamId,
                 agentId,
                 ...playDispatchEnvelope(dispatchMode),
                 sessionId: run.activeRunId ?? fallbackDispatch?.sessionId ?? null,
+                dispatchableTask: queueDispatchableTask,
                 slice: {
                     scope,
                     taskIds: matchedQueueItem?.sliceTaskIds ?? [],
@@ -1614,7 +1723,48 @@ export function registerMissionControlActionsRoutes(router, deps) {
                 initiativeId,
                 workstreamIds: allowedWorkstreamIds,
             });
-            deps.sendJson(res, 200, { ok: true, ...dispatchEnvelope, run });
+            await deps.tickAutoContinueRun(run);
+            const activeRunIds = Array.isArray(run.activeSliceRunIds)
+                ? run.activeSliceRunIds.filter((id) => typeof id === "string" && id.trim().length > 0)
+                : typeof run.activeRunId === "string" && run.activeRunId.trim().length > 0
+                    ? [run.activeRunId]
+                    : [];
+            if (activeRunIds.length > 0) {
+                await new Promise((resolve) => setTimeout(resolve, 500));
+                await deps.tickAutoContinueRun(run);
+            }
+            const reconciledActiveRunIds = Array.isArray(run.activeSliceRunIds)
+                ? run.activeSliceRunIds.filter((id) => typeof id === "string" && id.trim().length > 0)
+                : typeof run.activeRunId === "string" && run.activeRunId.trim().length > 0
+                    ? [run.activeRunId]
+                    : [];
+            const outcome = reconciledActiveRunIds.length > 0 || (run.status === "running" && !run.stopReason)
+                ? "started"
+                : run.stopReason === "blocked"
+                    ? "blocked"
+                    : run.stopReason === "completed"
+                        ? "completed"
+                        : run.stopReason === "error"
+                            ? "error"
+                            : "pending";
+            const message = outcome === "started"
+                ? "Autopilot enabled and running."
+                : outcome === "blocked"
+                    ? "Autopilot enabled, but it immediately needs your input."
+                    : outcome === "completed"
+                        ? "Autopilot enabled and immediately completed the available work."
+                        : outcome === "error"
+                            ? "Autopilot hit an error before it could keep running."
+                            : "Autopilot is starting.";
+            deps.sendJson(res, 200, {
+                ok: true,
+                outcome,
+                reasonCode: outcome === "blocked" ? "blocked" : outcome,
+                message,
+                ...dispatchEnvelope,
+                workstreamIds: allowedWorkstreamIds,
+                run,
+            });
         }
         catch (err) {
             sendRouteException(res, "mission-control.auto-continue.start.handler", err);

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

@@ -39,6 +39,15 @@ type NextUpQueueItem = {
     sliceTaskCount?: number | null;
     sliceMilestoneId?: string | null;
     milestoneBreakdown?: MilestoneBreakdownEntry[];
+    canStartNow?: boolean;
+    startReasonCode?: string | null;
+    startReasonLabel?: string | null;
+    dispatchableTask?: {
+        id: string;
+        title: string;
+        scope: "task" | "milestone" | "workstream";
+        milestoneId?: string | null;
+    } | null;
     isPinned?: boolean;
     pinnedRank?: number | null;
     compositeScore?: number;

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

@@ -464,6 +464,21 @@ function normalizeQueueItems(input) {
             ? runnerSourceHint ?? "inferred"
             : "fallback";
         const queueState = normalizeQueueState(record.queueState ?? record.queue_state);
+        const dispatchableTaskRecord = asRecord(record.dispatchableTask ?? record.dispatchable_task);
+        const dispatchableTaskId = asString(dispatchableTaskRecord?.id) ??
+            asString(record.dispatchableTaskId) ??
+            asString(record.dispatchable_task_id);
+        const dispatchableTaskTitle = asString(dispatchableTaskRecord?.title) ??
+            asString(record.dispatchableTaskTitle) ??
+            asString(record.dispatchable_task_title);
+        const dispatchableTaskScopeRaw = asString(dispatchableTaskRecord?.scope) ??
+            asString(record.dispatchableTaskScope) ??
+            asString(record.dispatchable_task_scope);
+        const dispatchableTaskScope = dispatchableTaskScopeRaw === "task" ||
+            dispatchableTaskScopeRaw === "milestone" ||
+            dispatchableTaskScopeRaw === "workstream"
+            ? dispatchableTaskScopeRaw
+            : null;
         const normalizedSliceScope = normalizeMissionControlStatus(asString(record.sliceScope) ?? asString(record.slice_scope));
         const sliceScope = normalizedSliceScope === "task" ||
             normalizedSliceScope === "milestone" ||
@@ -502,6 +517,24 @@ function normalizeQueueItems(input) {
                 ? Math.max(0, Math.floor(sliceTaskCountRaw))
                 : sliceTaskIds.length,
             sliceMilestoneId: asString(record.sliceMilestoneId) ?? asString(record.slice_milestone_id),
+            canStartNow: typeof record.canStartNow === "boolean"
+                ? record.canStartNow
+                : typeof record.can_start_now === "boolean"
+                    ? record.can_start_now
+                    : queueState === "queued" || queueState === "idle",
+            startReasonCode: asString(record.startReasonCode) ?? asString(record.start_reason_code),
+            startReasonLabel: asString(record.startReasonLabel) ?? asString(record.start_reason_label),
+            dispatchableTask: dispatchableTaskId && dispatchableTaskTitle && dispatchableTaskScope
+                ? {
+                    id: dispatchableTaskId,
+                    title: dispatchableTaskTitle,
+                    scope: dispatchableTaskScope,
+                    milestoneId: asString(dispatchableTaskRecord?.milestoneId) ??
+                        asString(dispatchableTaskRecord?.milestone_id) ??
+                        asString(record.dispatchableTaskMilestoneId) ??
+                        asString(record.dispatchable_task_milestone_id),
+                }
+                : null,
             isPinned: Boolean(record.isPinned ?? record.is_pinned),
             pinnedRank: asNumber(record.pinnedRank ?? record.pinned_rank),
             compositeScore: asNumber(record.compositeScore ?? record.composite_score) ?? undefined,

package/dist/stores/sqlite-state.d.ts

@@ -1,4 +1,4 @@
-import Database from "better-sqlite3";
+import type Database from "better-sqlite3";
 export declare function closeStateDb(): void;
 export declare function getStateDb(): Database.Database;
 export declare function readStateMeta<T>(key: string): T | null;

package/dist/stores/sqlite-state.js

@@ -1,11 +1,145 @@
-import Database from "better-sqlite3";
+import { execFileSync } from "node:child_process";
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { createRequire } from "node:module";
+import { fileURLToPath } from "node:url";
 import { getOrgxPluginConfigDir, getOrgxPluginConfigPath } from "../paths.js";
 import { ensureStoreDirSync, parseJsonSafe } from "./json-store.js";
 const STATE_DB_FILENAME = "orgx-state.sqlite";
 const USER_VERSION = 1;
+const BETTER_SQLITE3_REPAIR_MARKER = ".orgx-runtime-deps-version";
 let dbInstance = null;
 let dbInstancePath = "";
 let stateDbHooksRegistered = false;
+let databaseConstructor = null;
+let runtimeDepsRepairAttempted = false;
+const require = createRequire(import.meta.url);
+function currentModuleDir() {
+    return dirname(fileURLToPath(import.meta.url));
+}
+function findPluginRoot(startDir) {
+    let cursor = startDir;
+    while (true) {
+        const packageJsonPath = join(cursor, "package.json");
+        if (existsSync(packageJsonPath))
+            return cursor;
+        const parent = dirname(cursor);
+        if (parent === cursor)
+            return startDir;
+        cursor = parent;
+    }
+}
+function readExpectedRuntimeDepVersion(pluginRoot) {
+    try {
+        const raw = readFileSync(join(pluginRoot, "package.json"), "utf8");
+        const parsed = JSON.parse(raw);
+        return String(parsed?.dependencies?.["better-sqlite3"] || "").trim();
+    }
+    catch {
+        return "";
+    }
+}
+function writeRuntimeDepMarker(pluginRoot) {
+    const expected = readExpectedRuntimeDepVersion(pluginRoot);
+    if (!expected)
+        return;
+    try {
+        writeFileSync(join(pluginRoot, BETTER_SQLITE3_REPAIR_MARKER), expected, "utf8");
+    }
+    catch {
+        // best effort
+    }
+}
+function betterSqlite3Installed(pluginRoot) {
+    return existsSync(join(pluginRoot, "node_modules", "better-sqlite3", "package.json"));
+}
+function resolveBetterSqlite3InstallRoot(pluginRoot) {
+    try {
+        const packageJsonPath = require.resolve("better-sqlite3/package.json");
+        return dirname(dirname(dirname(packageJsonPath)));
+    }
+    catch {
+        return pluginRoot;
+    }
+}
+function isRecoverableBetterSqlite3Error(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return /could not locate the bindings file|cannot find module ['"]better-sqlite3['"]|no native build was found/i.test(message);
+}
+function resolveNpmCommand() {
+    const npmCliPath = join(dirname(process.execPath), "..", "lib", "node_modules", "npm", "bin", "npm-cli.js");
+    if (existsSync(npmCliPath)) {
+        return {
+            command: process.execPath,
+            argsPrefix: [npmCliPath],
+        };
+    }
+    return {
+        command: "npm",
+        argsPrefix: [],
+    };
+}
+function repairBetterSqlite3Binding(pluginRoot) {
+    const installRoot = resolveBetterSqlite3InstallRoot(pluginRoot);
+    const { command, argsPrefix } = resolveNpmCommand();
+    const args = betterSqlite3Installed(installRoot)
+        ? [...argsPrefix, "rebuild", "better-sqlite3", "--foreground-scripts"]
+        : [...argsPrefix, "install", "--omit=dev"];
+    try {
+        execFileSync(command, args, {
+            cwd: installRoot,
+            env: process.env,
+            stdio: "pipe",
+        });
+        writeRuntimeDepMarker(pluginRoot);
+    }
+    catch (error) {
+        const stderr = error &&
+            typeof error === "object" &&
+            "stderr" in error &&
+            Buffer.isBuffer(error.stderr)
+            ? error.stderr.toString("utf8").trim()
+            : "";
+        const stdout = error &&
+            typeof error === "object" &&
+            "stdout" in error &&
+            Buffer.isBuffer(error.stdout)
+            ? error.stdout.toString("utf8").trim()
+            : "";
+        const detail = stderr || stdout;
+        const suffix = detail ? ` (${detail})` : "";
+        throw new Error(`Failed to repair better-sqlite3 runtime dependency${suffix}`);
+    }
+}
+function resetDatabaseConstructorCache() {
+    try {
+        const resolved = require.resolve("better-sqlite3");
+        delete require.cache[resolved];
+    }
+    catch {
+        // best effort
+    }
+    databaseConstructor = null;
+}
+function loadDatabaseConstructor() {
+    if (databaseConstructor)
+        return databaseConstructor;
+    try {
+        databaseConstructor = require("better-sqlite3");
+        return databaseConstructor;
+    }
+    catch (error) {
+        if (!runtimeDepsRepairAttempted && isRecoverableBetterSqlite3Error(error)) {
+            runtimeDepsRepairAttempted = true;
+            const pluginRoot = findPluginRoot(currentModuleDir());
+            repairBetterSqlite3Binding(pluginRoot);
+            resetDatabaseConstructorCache();
+            databaseConstructor = require("better-sqlite3");
+            return databaseConstructor;
+        }
+        throw error;
+    }
+}
 function stateDbPath() {
     return getOrgxPluginConfigPath(STATE_DB_FILENAME);
 }
@@ -138,7 +272,24 @@ export function getStateDb() {
         closeStateDb();
     }
     ensureStateDbDir();
-    const db = new Database(nextPath);
+    let DatabaseCtor = loadDatabaseConstructor();
+    let db;
+    try {
+        db = new DatabaseCtor(nextPath);
+    }
+    catch (error) {
+        if (!runtimeDepsRepairAttempted && isRecoverableBetterSqlite3Error(error)) {
+            runtimeDepsRepairAttempted = true;
+            const pluginRoot = findPluginRoot(currentModuleDir());
+            repairBetterSqlite3Binding(pluginRoot);
+            resetDatabaseConstructorCache();
+            DatabaseCtor = loadDatabaseConstructor();
+            db = new DatabaseCtor(nextPath);
+        }
+        else {
+            throw error;
+        }
+    }
     initializeDatabase(db);
     dbInstance = db;
     dbInstancePath = nextPath;

package/package.json

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