@useorgx/openclaw-plugin 0.3.1 → 0.4.0

package/dist/http-handler.js

@@ -23,10 +23,13 @@ import { spawn } from "node:child_process";
 import { createHash, randomUUID } from "node:crypto";
 import { formatStatus, formatAgents, formatActivity, formatInitiatives, getOnboardingState, } from "./dashboard-api.js";
 import { loadLocalOpenClawSnapshot, loadLocalTurnDetail, toLocalLiveActivity, toLocalLiveAgents, toLocalLiveInitiatives, toLocalSessionTree, } from "./local-openclaw.js";
+import { appendToOutbox } from "./outbox.js";
 import { defaultOutboxAdapter } from "./adapters/outbox.js";
 import { readAgentContexts, upsertAgentContext } from "./agent-context-store.js";
 import { getAgentRun, markAgentRunStopped, readAgentRuns, upsertAgentRun, } from "./agent-run-store.js";
 import { readByokKeys, writeByokKeys } from "./byok-store.js";
+import { computeMilestoneRollup, computeWorkstreamRollup, } from "./reporting/rollups.js";
+import { listRuntimeInstances, resolveRuntimeHookToken, upsertRuntimeInstanceFromHook, } from "./runtime-instance-store.js";
 // =============================================================================
 // Helpers
 // =============================================================================
@@ -37,6 +40,10 @@ function safeErrorMessage(err) {
         return err;
     return "Unexpected error";
 }
+function isUnauthorizedOrgxError(err) {
+    const message = safeErrorMessage(err).toLowerCase();
+    return message.includes("401") || message.includes("unauthorized");
+}
 function isUserScopedApiKey(apiKey) {
     return apiKey.trim().toLowerCase().startsWith("oxk_");
 }
@@ -476,6 +483,110 @@ function mergeActivities(base, extra, limit) {
     }
     return deduped;
 }
+function normalizeRuntimeSourceForReporting(value) {
+    if (value === "codex")
+        return "codex";
+    if (value === "claude-code")
+        return "claude-code";
+    if (value === "api")
+        return "api";
+    return "openclaw";
+}
+function normalizeHookPhase(value) {
+    const normalized = (value ?? "").trim().toLowerCase();
+    if (normalized === "intent")
+        return "intent";
+    if (normalized === "execution")
+        return "execution";
+    if (normalized === "blocked")
+        return "blocked";
+    if (normalized === "review")
+        return "review";
+    if (normalized === "handoff")
+        return "handoff";
+    if (normalized === "completed")
+        return "completed";
+    return "execution";
+}
+function normalizeRuntimeSource(value) {
+    const normalized = typeof value === "string" ? value.trim().toLowerCase() : "";
+    if (normalized === "openclaw")
+        return "openclaw";
+    if (normalized === "codex")
+        return "codex";
+    if (normalized === "claude-code")
+        return "claude-code";
+    if (normalized === "api")
+        return "api";
+    return "unknown";
+}
+function runtimeMatchMaps(instances) {
+    const byRunId = new Map();
+    const byAgentInitiative = new Map();
+    for (const instance of instances) {
+        if (instance.runId && !byRunId.has(instance.runId)) {
+            byRunId.set(instance.runId, instance);
+        }
+        const agentId = instance.agentId?.trim() ?? "";
+        const initiativeId = instance.initiativeId?.trim() ?? "";
+        if (!agentId || !initiativeId)
+            continue;
+        const key = `${agentId}:${initiativeId}`;
+        if (!byAgentInitiative.has(key)) {
+            byAgentInitiative.set(key, instance);
+        }
+    }
+    return { byRunId, byAgentInitiative };
+}
+function enrichSessionsWithRuntime(input, instances) {
+    if (!Array.isArray(input.nodes) || input.nodes.length === 0)
+        return input;
+    if (instances.length === 0)
+        return input;
+    const { byRunId, byAgentInitiative } = runtimeMatchMaps(instances);
+    const nodes = input.nodes.map((node) => {
+        const byRun = node.runId ? byRunId.get(node.runId) ?? null : null;
+        const byAgent = !byRun && node.agentId && node.initiativeId
+            ? byAgentInitiative.get(`${node.agentId}:${node.initiativeId}`) ?? null
+            : null;
+        const match = byRun ?? byAgent;
+        if (!match)
+            return node;
+        return {
+            ...node,
+            runtimeClient: normalizeRuntimeSource(match.sourceClient),
+            runtimeLabel: match.displayName,
+            runtimeProvider: match.providerLogo,
+            instanceId: match.id,
+            lastHeartbeatAt: match.lastHeartbeatAt ?? null,
+        };
+    });
+    return { ...input, nodes };
+}
+function enrichActivityWithRuntime(input, instances) {
+    if (!Array.isArray(input) || input.length === 0)
+        return [];
+    if (instances.length === 0)
+        return input;
+    const { byRunId, byAgentInitiative } = runtimeMatchMaps(instances);
+    return input.map((item) => {
+        const byRun = item.runId ? byRunId.get(item.runId) ?? null : null;
+        const byAgent = !byRun && item.agentId && item.initiativeId
+            ? byAgentInitiative.get(`${item.agentId}:${item.initiativeId}`) ?? null
+            : null;
+        const match = byRun ?? byAgent;
+        if (!match)
+            return item;
+        return {
+            ...item,
+            runtimeClient: normalizeRuntimeSource(match.sourceClient),
+            runtimeLabel: match.displayName,
+            runtimeProvider: match.providerLogo,
+            instanceId: match.id,
+            lastHeartbeatAt: match.lastHeartbeatAt ?? null,
+        };
+    });
+}
 const ACTIVITY_HEADLINE_TIMEOUT_MS = 4_000;
 const ACTIVITY_HEADLINE_CACHE_TTL_MS = 12 * 60 * 60_000;
 const ACTIVITY_HEADLINE_CACHE_MAX = 1_000;
@@ -694,7 +805,7 @@ function contentType(filePath) {
 // =============================================================================
 const CORS_HEADERS = {
     "Access-Control-Allow-Methods": "GET, POST, PATCH, OPTIONS",
-    "Access-Control-Allow-Headers": "Content-Type, Authorization, X-OrgX-Api-Key, X-API-Key, X-OrgX-User-Id",
+    "Access-Control-Allow-Headers": "Content-Type, Authorization, X-OrgX-Api-Key, X-API-Key, X-OrgX-User-Id, X-OrgX-Hook-Token, X-Hook-Token",
     Vary: "Origin",
 };
 const SECURITY_HEADERS = {
@@ -772,10 +883,14 @@ function resolveSafeDistPath(subPath) {
 // =============================================================================
 // Helpers
 // =============================================================================
+const IMMUTABLE_FILE_CACHE = new Map();
+const IMMUTABLE_FILE_CACHE_MAX = 128;
 function sendJson(res, status, data) {
     const body = JSON.stringify(data);
     res.writeHead(status, {
         "Content-Type": "application/json; charset=utf-8",
+        // Avoid browser/proxy caching for live dashboards.
+        "Cache-Control": "no-store",
         ...SECURITY_HEADERS,
         ...CORS_HEADERS,
     });
@@ -783,9 +898,32 @@ function sendJson(res, status, data) {
 }
 function sendFile(res, filePath, cacheControl) {
     try {
+        const shouldCacheImmutable = cacheControl.includes("immutable");
+        if (shouldCacheImmutable) {
+            const cached = IMMUTABLE_FILE_CACHE.get(filePath);
+            if (cached) {
+                res.writeHead(200, {
+                    "Content-Type": cached.contentType,
+                    "Cache-Control": cacheControl,
+                    ...SECURITY_HEADERS,
+                    ...CORS_HEADERS,
+                });
+                res.end(cached.content);
+                return;
+            }
+        }
         const content = readFileSync(filePath);
+        const type = contentType(filePath);
+        if (shouldCacheImmutable) {
+            if (IMMUTABLE_FILE_CACHE.size >= IMMUTABLE_FILE_CACHE_MAX) {
+                const firstKey = IMMUTABLE_FILE_CACHE.keys().next().value;
+                if (firstKey)
+                    IMMUTABLE_FILE_CACHE.delete(firstKey);
+            }
+            IMMUTABLE_FILE_CACHE.set(filePath, { content, contentType: type });
+        }
         res.writeHead(200, {
-            "Content-Type": contentType(filePath),
+            "Content-Type": type,
             "Cache-Control": cacheControl,
             ...SECURITY_HEADERS,
             ...CORS_HEADERS,
@@ -1068,6 +1206,15 @@ function parseBooleanQuery(raw) {
         normalized === "yes" ||
         normalized === "on");
 }
+function stableHash(value) {
+    return createHash("sha256").update(value).digest("hex");
+}
+function idempotencyKey(parts) {
+    const raw = parts.filter((part) => typeof part === "string" && part.length > 0).join(":");
+    const cleaned = raw.replace(/[^a-zA-Z0-9:_-]/g, "-").slice(0, 84);
+    const suffix = stableHash(raw).slice(0, 20);
+    return `${cleaned}:${suffix}`.slice(0, 120);
+}
 const DEFAULT_DURATION_HOURS = {
     initiative: 40,
     workstream: 16,
@@ -1444,6 +1591,17 @@ function isInProgressStatus(status) {
         normalized === "running" ||
         normalized === "queued");
 }
+function isDispatchableWorkstreamStatus(status) {
+    const normalized = status.toLowerCase();
+    if (!normalized)
+        return true;
+    return !(normalized === "blocked" ||
+        normalized === "done" ||
+        normalized === "completed" ||
+        normalized === "cancelled" ||
+        normalized === "archived" ||
+        normalized === "deleted");
+}
 function isDoneStatus(status) {
     const normalized = status.toLowerCase();
     return (normalized === "done" ||
@@ -1865,9 +2023,226 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
     const dashboardEnabled = config.dashboardEnabled ??
         true;
     const outboxAdapter = adapters?.outbox ?? defaultOutboxAdapter;
+    const openclawAdapter = adapters?.openclaw ?? {};
+    const listAgents = openclawAdapter.listAgents ?? listOpenClawAgents;
+    const spawnAgentTurn = openclawAdapter.spawnAgentTurn ?? spawnOpenClawAgentTurn;
+    const stopProcess = openclawAdapter.stopDetachedProcess ?? stopDetachedProcess;
+    const pidAlive = openclawAdapter.isPidAlive ?? isPidAlive;
+    async function emitActivitySafe(input) {
+        const initiativeId = input.initiativeId?.trim() ?? "";
+        if (!initiativeId)
+            return;
+        const message = input.message.trim();
+        if (!message)
+            return;
+        try {
+            await client.emitActivity({
+                initiative_id: initiativeId,
+                run_id: input.runId ?? undefined,
+                correlation_id: input.runId
+                    ? undefined
+                    : (input.correlationId?.trim() || `openclaw-${Date.now()}`),
+                source_client: "openclaw",
+                message,
+                phase: input.phase,
+                progress_pct: typeof input.progressPct === "number" && Number.isFinite(input.progressPct)
+                    ? Math.max(0, Math.min(100, Math.round(input.progressPct)))
+                    : undefined,
+                level: input.level,
+                next_step: input.nextStep,
+                metadata: input.metadata,
+            });
+        }
+        catch {
+            // Fall back to local outbox so activity is still visible in Mission Control/Activity.
+            try {
+                const timestamp = new Date().toISOString();
+                const runId = input.runId?.trim() ||
+                    input.correlationId?.trim() ||
+                    null;
+                const activityItem = {
+                    id: randomUUID(),
+                    type: input.phase === "completed"
+                        ? "run_completed"
+                        : input.phase === "blocked"
+                            ? "run_failed"
+                            : "run_started",
+                    title: message,
+                    description: input.nextStep ?? null,
+                    agentId: (typeof input.metadata?.agent_id === "string"
+                        ? input.metadata.agent_id
+                        : null) ?? null,
+                    agentName: (typeof input.metadata?.agent_name === "string"
+                        ? input.metadata.agent_name
+                        : null) ?? null,
+                    runId,
+                    initiativeId,
+                    timestamp,
+                    phase: input.phase,
+                    summary: message,
+                    metadata: {
+                        ...(input.metadata ?? {}),
+                        source: "openclaw_local_fallback",
+                    },
+                };
+                await appendToOutbox(initiativeId, {
+                    id: randomUUID(),
+                    type: "progress",
+                    timestamp,
+                    payload: {
+                        phase: input.phase,
+                        message,
+                        level: input.level ?? "info",
+                        runId,
+                        initiativeId,
+                        nextStep: input.nextStep ?? null,
+                        metadata: input.metadata ?? null,
+                    },
+                    activityItem,
+                });
+            }
+            catch {
+                // best effort
+            }
+        }
+    }
+    async function syncParentRollupsForTask(input) {
+        const initiativeId = input.initiativeId?.trim() ?? "";
+        const taskId = input.taskId?.trim() ?? "";
+        if (!initiativeId || !taskId)
+            return;
+        let tasks = [];
+        try {
+            const response = await client.listEntities("task", {
+                initiative_id: initiativeId,
+                limit: 4000,
+            });
+            tasks = Array.isArray(response?.data)
+                ? response.data
+                : [];
+        }
+        catch {
+            return;
+        }
+        const task = tasks.find((row) => String(row.id ?? "").trim() === taskId) ?? null;
+        const resolvedMilestoneId = (input.milestoneId?.trim() || "") ||
+            (task ? pickString(task, ["milestone_id", "milestoneId"]) ?? "" : "");
+        const resolvedWorkstreamId = (input.workstreamId?.trim() || "") ||
+            (task ? pickString(task, ["workstream_id", "workstreamId"]) ?? "" : "");
+        if (resolvedMilestoneId) {
+            const milestoneTaskStatuses = tasks
+                .filter((row) => pickString(row, ["milestone_id", "milestoneId"]) === resolvedMilestoneId)
+                .map((row) => pickString(row, ["status"]) ?? "todo");
+            const rollup = computeMilestoneRollup(milestoneTaskStatuses);
+            try {
+                await client.applyChangeset({
+                    initiative_id: initiativeId,
+                    correlation_id: input.correlationId?.trim() || undefined,
+                    source_client: "openclaw",
+                    idempotency_key: idempotencyKey([
+                        "openclaw",
+                        "rollup",
+                        "milestone",
+                        resolvedMilestoneId,
+                        rollup.status,
+                        String(rollup.progressPct),
+                        String(rollup.done),
+                        String(rollup.total),
+                    ]),
+                    operations: [
+                        {
+                            op: "milestone.update",
+                            milestone_id: resolvedMilestoneId,
+                            status: rollup.status,
+                        },
+                    ],
+                });
+            }
+            catch {
+                // best effort
+            }
+        }
+        if (resolvedWorkstreamId) {
+            const workstreamTaskStatuses = tasks
+                .filter((row) => pickString(row, ["workstream_id", "workstreamId"]) === resolvedWorkstreamId)
+                .map((row) => pickString(row, ["status"]) ?? "todo");
+            const rollup = computeWorkstreamRollup(workstreamTaskStatuses);
+            try {
+                await client.updateEntity("workstream", resolvedWorkstreamId, {
+                    status: rollup.status,
+                });
+            }
+            catch {
+                // best effort
+            }
+        }
+    }
     const autoContinueRuns = new Map();
+    const localInitiativeStatusOverrides = new Map();
     let autoContinueTickInFlight = false;
     const AUTO_CONTINUE_TICK_MS = 2_500;
+    const setLocalInitiativeStatusOverride = (initiativeId, status) => {
+        const normalizedId = initiativeId.trim();
+        if (!normalizedId)
+            return;
+        localInitiativeStatusOverrides.set(normalizedId, {
+            status,
+            updatedAt: new Date().toISOString(),
+        });
+    };
+    const clearLocalInitiativeStatusOverride = (initiativeId) => {
+        const normalizedId = initiativeId.trim();
+        if (!normalizedId)
+            return;
+        localInitiativeStatusOverrides.delete(normalizedId);
+    };
+    const applyLocalInitiativeOverrides = (rows) => {
+        const seenIds = new Set();
+        const next = rows.map((row) => {
+            const id = pickString(row, ["id"]);
+            if (!id)
+                return row;
+            seenIds.add(id);
+            const override = localInitiativeStatusOverrides.get(id);
+            if (!override)
+                return row;
+            return {
+                ...row,
+                status: override.status,
+                updated_at: pickString(row, ["updated_at", "updatedAt"]) ?? override.updatedAt,
+            };
+        });
+        for (const [id, override] of localInitiativeStatusOverrides.entries()) {
+            if (seenIds.has(id))
+                continue;
+            next.push({
+                id,
+                title: `Initiative ${id.slice(0, 8)}`,
+                name: `Initiative ${id.slice(0, 8)}`,
+                summary: null,
+                status: override.status,
+                progress_pct: null,
+                created_at: override.updatedAt,
+                updated_at: override.updatedAt,
+            });
+        }
+        return next;
+    };
+    const applyLocalInitiativeOverrideToGraph = (graph) => {
+        const override = localInitiativeStatusOverrides.get(graph.initiative.id) ?? null;
+        if (!override)
+            return graph;
+        return {
+            ...graph,
+            initiative: {
+                ...graph.initiative,
+                status: override.status,
+            },
+            nodes: graph.nodes.map((node) => node.type === "initiative" && node.id === graph.initiative.id
+                ? { ...node, status: override.status }
+                : node),
+        };
+    };
     function normalizeTokenBudget(value, fallback) {
         if (typeof value === "number" && Number.isFinite(value)) {
             return Math.max(1_000, Math.round(value));
@@ -2067,6 +2442,59 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
             // best effort
         }
     }
+    async function dispatchFallbackWorkstreamTurn(input) {
+        const now = new Date().toISOString();
+        const sessionId = randomUUID();
+        const message = [
+            `Initiative: ${input.initiativeTitle}`,
+            `Workstream: ${input.workstreamTitle}`,
+            "",
+            "Continue this workstream from the latest context.",
+            "Identify and execute the next concrete task, then provide a concise progress summary.",
+        ].join("\n");
+        await emitActivitySafe({
+            initiativeId: input.initiativeId,
+            correlationId: sessionId,
+            phase: "execution",
+            level: "info",
+            message: `Next Up dispatched ${input.workstreamTitle}.`,
+            metadata: {
+                event: "next_up_manual_dispatch_started",
+                agent_id: input.agentId,
+                session_id: sessionId,
+                workstream_id: input.workstreamId,
+                workstream_title: input.workstreamTitle,
+                fallback: true,
+            },
+        });
+        upsertAgentContext({
+            agentId: input.agentId,
+            initiativeId: input.initiativeId,
+            initiativeTitle: input.initiativeTitle,
+            workstreamId: input.workstreamId,
+            taskId: null,
+        });
+        const spawned = spawnAgentTurn({
+            agentId: input.agentId,
+            sessionId,
+            message,
+        });
+        upsertAgentRun({
+            runId: sessionId,
+            agentId: input.agentId,
+            pid: spawned.pid,
+            message,
+            provider: null,
+            model: null,
+            initiativeId: input.initiativeId,
+            initiativeTitle: input.initiativeTitle,
+            workstreamId: input.workstreamId,
+            taskId: null,
+            startedAt: now,
+            status: "running",
+        });
+        return { sessionId, pid: spawned.pid };
+    }
     async function tickAutoContinueRun(run) {
         if (run.status !== "running" && run.status !== "stopping")
             return;
@@ -2075,7 +2503,7 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
         if (run.activeRunId) {
             const record = getAgentRun(run.activeRunId);
             const pid = record?.pid ?? null;
-            if (pid && isPidAlive(pid)) {
+            if (pid && pidAlive(pid)) {
                 return;
             }
             // Run finished (or pid missing). Mark stopped and auto-complete the task.
@@ -2104,6 +2532,34 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
                         run.lastError = safeErrorMessage(err);
                     }
                 }
+                if (record.taskId) {
+                    await syncParentRollupsForTask({
+                        initiativeId: run.initiativeId,
+                        taskId: record.taskId,
+                        workstreamId: record.workstreamId,
+                        correlationId: record.runId,
+                    });
+                }
+                await emitActivitySafe({
+                    initiativeId: run.initiativeId,
+                    correlationId: record.runId,
+                    phase: summary.hadError ? "blocked" : "completed",
+                    level: summary.hadError ? "warn" : "info",
+                    message: record.taskId
+                        ? `Auto-continue ${summary.hadError ? "blocked" : "completed"} task ${record.taskId}.`
+                        : `Auto-continue run finished (${summary.hadError ? "blocked" : "completed"}).`,
+                    metadata: {
+                        event: "auto_continue_task_finished",
+                        agent_id: record.agentId,
+                        session_id: record.runId,
+                        task_id: record.taskId,
+                        workstream_id: record.workstreamId,
+                        tokens: summary.tokens,
+                        cost_usd: summary.costUsd,
+                        had_error: summary.hadError,
+                        error_message: summary.errorMessage,
+                    },
+                });
                 run.lastRunId = record.runId;
                 run.lastTaskId = record.taskId ?? run.lastTaskId;
                 run.activeRunId = null;
@@ -2147,7 +2603,7 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
         // 3) Pick next-up task and dispatch.
         let graph;
         try {
-            graph = await buildMissionControlGraph(client, run.initiativeId);
+            graph = applyLocalInitiativeOverrideToGraph(await buildMissionControlGraph(client, run.initiativeId));
         }
         catch (err) {
             await stopAutoContinueRun({
@@ -2194,7 +2650,7 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
             }
             if (node.workstreamId) {
                 const ws = nodeById.get(node.workstreamId);
-                if (ws && !isInProgressStatus(ws.status)) {
+                if (ws && !isDispatchableWorkstreamStatus(ws.status)) {
                     continue;
                 }
             }
@@ -2237,6 +2693,21 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
         ]
             .filter((line) => typeof line === "string")
             .join("\n");
+        if (nextTaskNode.workstreamId) {
+            const workstreamNode = nodeById.get(nextTaskNode.workstreamId);
+            if (workstreamNode &&
+                !isInProgressStatus(workstreamNode.status) &&
+                isDispatchableWorkstreamStatus(workstreamNode.status)) {
+                try {
+                    await client.updateEntity("workstream", workstreamNode.id, {
+                        status: "active",
+                    });
+                }
+                catch {
+                    // best effort
+                }
+            }
+        }
         try {
             await client.updateEntity("task", nextTaskNode.id, {
                 status: "in_progress",
@@ -2250,6 +2721,31 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
             });
             return;
         }
+        await syncParentRollupsForTask({
+            initiativeId: run.initiativeId,
+            taskId: nextTaskNode.id,
+            workstreamId: nextTaskNode.workstreamId,
+            milestoneId: nextTaskNode.milestoneId,
+            correlationId: sessionId,
+        });
+        await emitActivitySafe({
+            initiativeId: run.initiativeId,
+            correlationId: sessionId,
+            phase: "execution",
+            level: "info",
+            message: `Auto-continue started task ${nextTaskNode.id}.`,
+            metadata: {
+                event: "auto_continue_task_started",
+                agent_id: agentId,
+                session_id: sessionId,
+                task_id: nextTaskNode.id,
+                task_title: nextTaskNode.title,
+                workstream_id: nextTaskNode.workstreamId,
+                workstream_title: workstreamTitle,
+                milestone_id: nextTaskNode.milestoneId,
+                milestone_title: milestoneTitle,
+            },
+        });
         upsertAgentContext({
             agentId,
             initiativeId: run.initiativeId,
@@ -2257,7 +2753,7 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
             workstreamId: nextTaskNode.workstreamId,
             taskId: nextTaskNode.id,
         });
-        const spawned = spawnOpenClawAgentTurn({
+        const spawned = spawnAgentTurn({
             agentId,
             sessionId,
             message,
@@ -2319,6 +2815,528 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
             autoContinueTickInFlight = false;
         }
     }
+    function isInitiativeActiveStatus(status) {
+        const normalized = (status ?? "").trim().toLowerCase();
+        if (!normalized)
+            return false;
+        return !(normalized === "completed" ||
+            normalized === "done" ||
+            normalized === "archived" ||
+            normalized === "deleted" ||
+            normalized === "cancelled");
+    }
+    function runningAutoContinueForWorkstream(initiativeId, workstreamId) {
+        const run = autoContinueRuns.get(initiativeId) ?? null;
+        if (!run)
+            return null;
+        if (run.status !== "running" && run.status !== "stopping")
+            return null;
+        if (!Array.isArray(run.allowedWorkstreamIds) || run.allowedWorkstreamIds.length === 0) {
+            return run;
+        }
+        return run.allowedWorkstreamIds.includes(workstreamId) ? run : null;
+    }
+    async function resolveAutoContinueUpgradeGate(agentId) {
+        let requiresPremiumAutoContinue = false;
+        try {
+            const agents = await listAgents();
+            const agentEntry = agents.find((entry) => String(entry.id ?? "").trim() === agentId) ??
+                null;
+            const agentModel = agentEntry && typeof agentEntry.model === "string"
+                ? agentEntry.model
+                : null;
+            requiresPremiumAutoContinue = modelImpliesByok(agentModel);
+        }
+        catch {
+            // ignore
+        }
+        if (!requiresPremiumAutoContinue)
+            return null;
+        const billingStatus = await fetchBillingStatusSafe(client);
+        if (!billingStatus || billingStatus.plan !== "free")
+            return null;
+        const pricingUrl = `${client.getBaseUrl().replace(/\/+$/, "")}/pricing`;
+        return {
+            code: "upgrade_required",
+            error: "Auto-continue for BYOK agents requires a paid OrgX plan. Upgrade, then retry.",
+            currentPlan: billingStatus.plan,
+            requiredPlan: "starter",
+            actions: {
+                checkout: "/orgx/api/billing/checkout",
+                portal: "/orgx/api/billing/portal",
+                pricing: pricingUrl,
+            },
+        };
+    }
+    async function startAutoContinueRun(input) {
+        const now = new Date().toISOString();
+        const existing = autoContinueRuns.get(input.initiativeId) ?? null;
+        const run = existing ??
+            {
+                initiativeId: input.initiativeId,
+                agentId: input.agentId,
+                includeVerification: false,
+                allowedWorkstreamIds: null,
+                tokenBudget: defaultAutoContinueTokenBudget(),
+                tokensUsed: 0,
+                status: "running",
+                stopReason: null,
+                stopRequested: false,
+                startedAt: now,
+                stoppedAt: null,
+                updatedAt: now,
+                lastError: null,
+                lastTaskId: null,
+                lastRunId: null,
+                activeTaskId: null,
+                activeRunId: null,
+                activeTaskTokenEstimate: null,
+            };
+        run.agentId = input.agentId;
+        run.includeVerification = input.includeVerification;
+        run.allowedWorkstreamIds = input.allowedWorkstreamIds;
+        run.tokenBudget = normalizeTokenBudget(input.tokenBudget, run.tokenBudget || defaultAutoContinueTokenBudget());
+        run.status = "running";
+        run.stopReason = null;
+        run.stopRequested = false;
+        run.startedAt = now;
+        run.stoppedAt = null;
+        run.updatedAt = now;
+        run.lastError = null;
+        autoContinueRuns.set(input.initiativeId, run);
+        try {
+            await client.updateEntity("initiative", input.initiativeId, { status: "active" });
+        }
+        catch {
+            // best effort
+        }
+        try {
+            await updateInitiativeAutoContinueState({
+                initiativeId: input.initiativeId,
+                run,
+            });
+        }
+        catch {
+            // best effort
+        }
+        return run;
+    }
+    async function buildNextUpQueue(input) {
+        const degraded = [];
+        const requestedInitiativeId = input?.initiativeId?.trim() || null;
+        const initiativeTitleById = new Map();
+        const initiativeStatusById = new Map();
+        const initiativePriorityById = new Map();
+        const snapshotInitiatives = formatInitiatives(getSnapshot());
+        for (const initiative of snapshotInitiatives) {
+            const id = initiative.id?.trim();
+            if (!id)
+                continue;
+            initiativeTitleById.set(id, initiative.title);
+            initiativeStatusById.set(id, initiative.status || "active");
+        }
+        const initiativeResult = await listEntitiesSafe(client, "initiative", { limit: 500 });
+        if (initiativeResult.warning)
+            degraded.push(initiativeResult.warning);
+        const initiatives = initiativeResult.items;
+        for (const entity of initiatives) {
+            const record = entity;
+            const id = pickString(record, ["id"]);
+            if (!id)
+                continue;
+            const title = pickString(record, ["title", "name"]);
+            const status = pickString(record, ["status"]);
+            const priority = pickString(record, ["priority", "priority_label", "priorityLabel"]);
+            if (title)
+                initiativeTitleById.set(id, title);
+            if (status)
+                initiativeStatusById.set(id, status);
+            if (priority)
+                initiativePriorityById.set(id, priority);
+        }
+        for (const [initiativeId, override] of localInitiativeStatusOverrides.entries()) {
+            initiativeStatusById.set(initiativeId, override.status);
+        }
+        const queueRank = (state) => {
+            if (state === "running")
+                return 0;
+            if (state === "queued")
+                return 1;
+            if (state === "blocked")
+                return 2;
+            return 3;
+        };
+        const sortQueueItems = (a, b) => {
+            const queueDelta = queueRank(a.queueState) - queueRank(b.queueState);
+            if (queueDelta !== 0)
+                return queueDelta;
+            const priorityRank = (value) => {
+                const normalized = (value ?? "").trim().toLowerCase();
+                if (!normalized)
+                    return 4;
+                if (normalized === "critical" || normalized === "p0" || normalized === "urgent")
+                    return 0;
+                if (normalized === "high" || normalized === "p1")
+                    return 1;
+                if (normalized === "medium" || normalized === "normal" || normalized === "p2")
+                    return 2;
+                if (normalized === "low" || normalized === "p3")
+                    return 3;
+                return 4;
+            };
+            const aInitiativePriority = priorityRank(initiativePriorityById.get(a.initiativeId));
+            const bInitiativePriority = priorityRank(initiativePriorityById.get(b.initiativeId));
+            if (aInitiativePriority !== bInitiativePriority) {
+                return aInitiativePriority - bInitiativePriority;
+            }
+            const aPriority = typeof a.nextTaskPriority === "number" ? a.nextTaskPriority : 999;
+            const bPriority = typeof b.nextTaskPriority === "number" ? b.nextTaskPriority : 999;
+            if (aPriority !== bPriority)
+                return aPriority - bPriority;
+            const aDue = a.nextTaskDueAt ? Date.parse(a.nextTaskDueAt) : Number.POSITIVE_INFINITY;
+            const bDue = b.nextTaskDueAt ? Date.parse(b.nextTaskDueAt) : Number.POSITIVE_INFINITY;
+            if (aDue !== bDue)
+                return aDue - bDue;
+            const init = a.initiativeTitle.localeCompare(b.initiativeTitle);
+            if (init !== 0)
+                return init;
+            return a.workstreamTitle.localeCompare(b.workstreamTitle);
+        };
+        const buildSessionFallbackQueue = async () => {
+            let sessionTree = null;
+            try {
+                sessionTree = await client.getLiveSessions({
+                    initiative: requestedInitiativeId,
+                    limit: 500,
+                });
+            }
+            catch (err) {
+                degraded.push(`live sessions fallback unavailable (${safeErrorMessage(err)})`);
+            }
+            if (!sessionTree) {
+                try {
+                    const localTree = toLocalSessionTree(await loadLocalOpenClawSnapshot(400), 400);
+                    sessionTree = applyAgentContextsToSessionTree(localTree, readAgentContexts().agents);
+                }
+                catch (err) {
+                    degraded.push(`local sessions fallback unavailable (${safeErrorMessage(err)})`);
+                    return [];
+                }
+            }
+            sessionTree = applyAgentContextsToSessionTree(sessionTree, readAgentContexts().agents);
+            const grouped = new Map();
+            const parseEpoch = (value) => {
+                const parsed = value ? Date.parse(value) : Number.NaN;
+                return Number.isFinite(parsed) ? parsed : 0;
+            };
+            for (const node of sessionTree.nodes ?? []) {
+                const initiativeId = (node.initiativeId ?? "").trim();
+                const workstreamId = (node.workstreamId ?? "").trim();
+                if (!initiativeId || !workstreamId)
+                    continue;
+                if (requestedInitiativeId && initiativeId !== requestedInitiativeId)
+                    continue;
+                const initiativeStatus = initiativeStatusById.get(initiativeId) ?? "active";
+                if (!isInitiativeActiveStatus(initiativeStatus))
+                    continue;
+                const key = `${initiativeId}:${workstreamId}`;
+                const epoch = parseEpoch(node.updatedAt ?? node.lastEventAt ?? node.startedAt);
+                const existing = grouped.get(key);
+                if (!existing) {
+                    grouped.set(key, {
+                        initiativeId,
+                        workstreamId,
+                        initiativeTitle: initiativeTitleById.get(initiativeId) ??
+                            node.groupLabel ??
+                            initiativeId,
+                        initiativeStatus,
+                        workstreamTitle: `Workstream ${workstreamId.slice(0, 8)}`,
+                        statuses: new Set([node.status]),
+                        blockers: Array.isArray(node.blockers) ? [...node.blockers] : [],
+                        latest: node,
+                        latestEpoch: epoch,
+                    });
+                    continue;
+                }
+                existing.statuses.add(node.status);
+                if (Array.isArray(node.blockers)) {
+                    for (const blocker of node.blockers) {
+                        if (typeof blocker !== "string" || blocker.trim().length === 0)
+                            continue;
+                        if (!existing.blockers.includes(blocker))
+                            existing.blockers.push(blocker);
+                    }
+                }
+                if (epoch >= existing.latestEpoch) {
+                    existing.latest = node;
+                    existing.latestEpoch = epoch;
+                }
+            }
+            const fallbackItems = [];
+            for (const entry of grouped.values()) {
+                const statusValues = Array.from(entry.statuses).map((status) => status.toLowerCase());
+                const hasBlocked = statusValues.some((status) => status === "blocked" || status === "failed") ||
+                    entry.blockers.length > 0;
+                const hasRunning = statusValues.some((status) => isInProgressStatus(status));
+                const hasQueued = statusValues.some((status) => status === "queued" || status === "pending");
+                const queueState = hasRunning
+                    ? "running"
+                    : hasBlocked
+                        ? "blocked"
+                        : hasQueued
+                            ? "queued"
+                            : "idle";
+                const runnerAgentId = (entry.latest.agentId ?? "").trim() || "main";
+                const runnerAgentName = (entry.latest.agentName ?? "").trim() ||
+                    initiativeTitleById.get(`agent:${runnerAgentId}`) ||
+                    runnerAgentId;
+                fallbackItems.push({
+                    initiativeId: entry.initiativeId,
+                    initiativeTitle: entry.initiativeTitle,
+                    initiativeStatus: entry.initiativeStatus,
+                    workstreamId: entry.workstreamId,
+                    workstreamTitle: entry.workstreamTitle,
+                    workstreamStatus: hasBlocked ? "blocked" : hasRunning ? "active" : hasQueued ? "queued" : "idle",
+                    nextTaskId: entry.latest.id ?? null,
+                    nextTaskTitle: (entry.latest.lastEventSummary ?? "").trim() ||
+                        (entry.latest.title ?? "").trim() ||
+                        null,
+                    nextTaskPriority: null,
+                    nextTaskDueAt: null,
+                    runnerAgentId,
+                    runnerAgentName,
+                    runnerSource: "fallback",
+                    queueState,
+                    blockReason: hasBlocked
+                        ? entry.blockers[0] ?? (statusValues.includes("failed") ? "Latest run failed" : "Workstream blocked")
+                        : null,
+                    autoContinue: null,
+                });
+            }
+            fallbackItems.sort(sortQueueItems);
+            return fallbackItems;
+        };
+        const scopedInitiatives = initiatives.filter((entity) => {
+            const record = entity;
+            const id = pickString(record, ["id"]);
+            if (!id)
+                return false;
+            if (requestedInitiativeId && id !== requestedInitiativeId)
+                return false;
+            const status = pickString(record, ["status"]);
+            return isInitiativeActiveStatus(status);
+        });
+        const agentCatalogById = new Map();
+        try {
+            const catalog = await listAgents();
+            for (const entry of catalog) {
+                if (!entry || typeof entry !== "object")
+                    continue;
+                const id = typeof entry.id === "string" ? entry.id.trim() : "";
+                if (!id)
+                    continue;
+                const name = typeof entry.name === "string" && entry.name.trim().length > 0
+                    ? entry.name.trim()
+                    : id;
+                agentCatalogById.set(id, { id, name });
+            }
+        }
+        catch (err) {
+            degraded.push(`agent catalog unavailable (${safeErrorMessage(err)})`);
+        }
+        const liveAgentsByInitiative = new Map();
+        try {
+            const data = await client.getLiveAgents({
+                initiative: requestedInitiativeId,
+                includeIdle: true,
+            });
+            for (const raw of Array.isArray(data.agents) ? data.agents : []) {
+                if (!raw || typeof raw !== "object")
+                    continue;
+                const row = raw;
+                const initiativeId = pickString(row, ["initiativeId", "initiative_id"]);
+                if (!initiativeId)
+                    continue;
+                const id = pickString(row, ["id", "agentId", "agent_id"]) ??
+                    pickString(row, ["name", "agentName", "agent_name"]) ??
+                    "";
+                const name = pickString(row, ["name", "agentName", "agent_name"]) ??
+                    id;
+                if (!id || !name)
+                    continue;
+                const list = liveAgentsByInitiative.get(initiativeId) ?? [];
+                list.push({
+                    id,
+                    name,
+                    domain: pickString(row, ["domain", "role"]),
+                });
+                liveAgentsByInitiative.set(initiativeId, list);
+            }
+        }
+        catch (err) {
+            degraded.push(`live agents unavailable (${safeErrorMessage(err)})`);
+        }
+        const items = [];
+        for (const initiativeEntity of scopedInitiatives) {
+            const initiativeRecord = initiativeEntity;
+            const initiativeId = pickString(initiativeRecord, ["id"]);
+            if (!initiativeId)
+                continue;
+            const initiativeTitle = pickString(initiativeRecord, ["title", "name"]) ?? initiativeId;
+            const initiativeStatus = pickString(initiativeRecord, ["status"]) ?? "active";
+            let graph;
+            try {
+                graph = applyLocalInitiativeOverrideToGraph(await buildMissionControlGraph(client, initiativeId));
+            }
+            catch (err) {
+                degraded.push(`graph unavailable for ${initiativeId} (${safeErrorMessage(err)})`);
+                continue;
+            }
+            const nodeById = new Map(graph.nodes.map((node) => [node.id, node]));
+            const workstreamNodes = graph.nodes.filter((node) => node.type === "workstream");
+            const runningWorkstreams = new Set();
+            const taskIsReady = (task) => task.dependencyIds.every((depId) => {
+                const dependency = nodeById.get(depId);
+                return dependency ? isDoneStatus(dependency.status) : true;
+            });
+            const taskHasBlockedParent = (task) => {
+                const milestone = task.milestoneId ? nodeById.get(task.milestoneId) ?? null : null;
+                const workstream = task.workstreamId ? nodeById.get(task.workstreamId) ?? null : null;
+                return (milestone?.status?.toLowerCase() === "blocked" ||
+                    workstream?.status?.toLowerCase() === "blocked");
+            };
+            for (const workstream of workstreamNodes) {
+                const todoTasks = graph.recentTodos
+                    .map((taskId) => nodeById.get(taskId))
+                    .filter((node) => node?.type === "task" &&
+                    node.workstreamId === workstream.id &&
+                    isTodoStatus(node.status));
+                const readyTask = todoTasks.find((task) => taskIsReady(task) && !taskHasBlockedParent(task));
+                const candidateTask = readyTask ?? todoTasks[0] ?? null;
+                const autoContinueRun = runningAutoContinueForWorkstream(initiativeId, workstream.id);
+                let queueState = autoContinueRun ? "running" : "queued";
+                let blockReason = null;
+                if (!autoContinueRun && !readyTask && candidateTask) {
+                    queueState = "blocked";
+                    const blockedDeps = candidateTask.dependencyIds
+                        .map((depId) => nodeById.get(depId))
+                        .filter((dependency) => Boolean(dependency && !isDoneStatus(dependency.status)))
+                        .map((dependency) => dependency.title);
+                    if (blockedDeps.length > 0) {
+                        blockReason = `Waiting on ${blockedDeps.slice(0, 2).join(", ")}${blockedDeps.length > 2 ? "…" : ""}`;
+                    }
+                    else if (taskHasBlockedParent(candidateTask)) {
+                        blockReason = "Parent milestone or workstream is blocked";
+                    }
+                    else if (!taskIsReady(candidateTask)) {
+                        blockReason = "Task prerequisites are not complete";
+                    }
+                }
+                if (!candidateTask && !autoContinueRun) {
+                    continue;
+                }
+                runningWorkstreams.add(workstream.id);
+                const assignedAgent = workstream.assignedAgents[0] ?? null;
+                const inferredAgent = graph.initiative.assignedAgents[0] ??
+                    liveAgentsByInitiative.get(initiativeId)?.[0] ??
+                    (autoContinueRun?.agentId
+                        ? {
+                            id: autoContinueRun.agentId,
+                            name: agentCatalogById.get(autoContinueRun.agentId)?.name ?? autoContinueRun.agentId,
+                            domain: null,
+                        }
+                        : null);
+                const runnerSource = assignedAgent
+                    ? "assigned"
+                    : inferredAgent
+                        ? "inferred"
+                        : "fallback";
+                const resolvedRunner = assignedAgent ?? inferredAgent;
+                const runnerAgentId = resolvedRunner?.id ?? autoContinueRun?.agentId ?? "main";
+                const runnerAgentName = resolvedRunner?.name ??
+                    agentCatalogById.get(runnerAgentId)?.name ??
+                    runnerAgentId;
+                items.push({
+                    initiativeId,
+                    initiativeTitle,
+                    initiativeStatus,
+                    workstreamId: workstream.id,
+                    workstreamTitle: workstream.title,
+                    workstreamStatus: workstream.status,
+                    nextTaskId: candidateTask?.id ??
+                        (autoContinueRun?.activeTaskId?.trim() || null),
+                    nextTaskTitle: candidateTask?.title ??
+                        (autoContinueRun?.activeTaskId
+                            ? nodeById.get(autoContinueRun.activeTaskId)?.title ?? null
+                            : null),
+                    nextTaskPriority: candidateTask?.priorityNum ?? null,
+                    nextTaskDueAt: candidateTask?.dueDate ?? null,
+                    runnerAgentId,
+                    runnerAgentName,
+                    runnerSource,
+                    queueState,
+                    blockReason,
+                    autoContinue: autoContinueRun
+                        ? {
+                            status: autoContinueRun.status,
+                            activeTaskId: autoContinueRun.activeTaskId,
+                            activeRunId: autoContinueRun.activeRunId,
+                            stopReason: autoContinueRun.stopReason,
+                            updatedAt: autoContinueRun.updatedAt,
+                        }
+                        : null,
+                });
+            }
+            const run = autoContinueRuns.get(initiativeId);
+            if (run &&
+                (run.status === "running" || run.status === "stopping") &&
+                Array.isArray(run.allowedWorkstreamIds) &&
+                run.allowedWorkstreamIds.length > 0) {
+                for (const workstreamId of run.allowedWorkstreamIds) {
+                    if (runningWorkstreams.has(workstreamId))
+                        continue;
+                    const workstream = nodeById.get(workstreamId);
+                    if (!workstream || workstream.type !== "workstream")
+                        continue;
+                    items.push({
+                        initiativeId,
+                        initiativeTitle,
+                        initiativeStatus,
+                        workstreamId: workstream.id,
+                        workstreamTitle: workstream.title,
+                        workstreamStatus: workstream.status,
+                        nextTaskId: run.activeTaskId,
+                        nextTaskTitle: run.activeTaskId
+                            ? nodeById.get(run.activeTaskId)?.title ?? null
+                            : null,
+                        nextTaskPriority: null,
+                        nextTaskDueAt: null,
+                        runnerAgentId: run.agentId,
+                        runnerAgentName: agentCatalogById.get(run.agentId)?.name ?? run.agentId,
+                        runnerSource: "inferred",
+                        queueState: "running",
+                        blockReason: null,
+                        autoContinue: {
+                            status: run.status,
+                            activeTaskId: run.activeTaskId,
+                            activeRunId: run.activeRunId,
+                            stopReason: run.stopReason,
+                            updatedAt: run.updatedAt,
+                        },
+                    });
+                }
+            }
+        }
+        if (items.length === 0) {
+            const fallbackItems = await buildSessionFallbackQueue();
+            if (fallbackItems.length > 0) {
+                degraded.push("Using session-derived Next Up fallback.");
+                items.push(...fallbackItems);
+            }
+        }
+        items.sort(sortQueueItems);
+        return { items, degraded };
+    }
     const autoContinueTimer = setInterval(() => {
         void tickAllAutoContinue();
     }, AUTO_CONTINUE_TICK_MS);
@@ -2363,6 +3381,7 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
             const runCheckpointRestoreMatch = route.match(/^runs\/([^/]+)\/checkpoints\/([^/]+)\/restore$/);
             const isDelegationPreflight = route === "delegation/preflight";
             const isMissionControlAutoAssignmentRoute = route === "mission-control/assignments/auto";
+            const isMissionControlNextUpPlayRoute = route === "mission-control/next-up/play";
             const isMissionControlAutoContinueStartRoute = route === "mission-control/auto-continue/start";
             const isMissionControlAutoContinueStopRoute = route === "mission-control/auto-continue/stop";
             const isEntitiesRoute = route === "entities";
@@ -2553,7 +3572,7 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
                     let requiresPremiumLaunch = Boolean(provider) || modelImpliesByok(requestedModel);
                     if (!requiresPremiumLaunch) {
                         try {
-                            const agents = await listOpenClawAgents();
+                            const agents = await listAgents();
                             const agentEntry = agents.find((entry) => String(entry.id ?? "").trim() === agentId) ??
                                 null;
                             const agentModel = agentEntry && typeof agentEntry.model === "string"
@@ -2610,6 +3629,46 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
                         });
                         return true;
                     }
+                    if (initiativeId) {
+                        try {
+                            await client.updateEntity("initiative", initiativeId, { status: "active" });
+                        }
+                        catch {
+                            // best effort
+                        }
+                    }
+                    if (taskId) {
+                        try {
+                            await client.updateEntity("task", taskId, { status: "in_progress" });
+                        }
+                        catch {
+                            // best effort
+                        }
+                        await syncParentRollupsForTask({
+                            initiativeId,
+                            taskId,
+                            workstreamId,
+                            correlationId: sessionId,
+                        });
+                    }
+                    await emitActivitySafe({
+                        initiativeId,
+                        correlationId: sessionId,
+                        phase: "execution",
+                        message: taskId
+                            ? `Launched agent ${agentId} for task ${taskId}.`
+                            : `Launched agent ${agentId}.`,
+                        level: "info",
+                        metadata: {
+                            event: "agent_launch",
+                            agent_id: agentId,
+                            session_id: sessionId,
+                            workstream_id: workstreamId,
+                            task_id: taskId,
+                            provider,
+                            model: requestedModel,
+                        },
+                    });
                     let routedProvider = null;
                     let routedModel = null;
                     if (provider) {
@@ -2628,7 +3687,7 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
                         workstreamId,
                         taskId,
                     });
-                    const spawned = spawnOpenClawAgentTurn({
+                    const spawned = spawnAgentTurn({
                         agentId,
                         sessionId,
                         message,
@@ -2692,7 +3751,7 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
                         sendJson(res, 409, { ok: false, error: "Run has no tracked pid" });
                         return true;
                     }
-                    const result = await stopDetachedProcess(record.pid);
+                    const result = await stopProcess(record.pid);
                     const updated = markAgentRunStopped(runId);
                     sendJson(res, 200, {
                         ok: true,
@@ -2752,7 +3811,7 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
                         modelImpliesByok(record.model ?? null);
                     if (!requiresPremiumRestart) {
                         try {
-                            const agents = await listOpenClawAgents();
+                            const agents = await listAgents();
                             const agentEntry = agents.find((entry) => String(entry.id ?? "").trim() === record.agentId) ?? null;
                             const agentModel = agentEntry && typeof agentEntry.model === "string"
                                 ? agentEntry.model
@@ -2802,7 +3861,7 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
                         workstreamId: record.workstreamId,
                         taskId: record.taskId,
                     });
-                    const spawned = spawnOpenClawAgentTurn({
+                    const spawned = spawnAgentTurn({
                         agentId: record.agentId,
                         sessionId,
                         message,
@@ -2836,6 +3895,135 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
                 }
                 return true;
             }
+            if (method === "POST" && isMissionControlNextUpPlayRoute) {
+                try {
+                    const payload = await parseJsonRequest(req);
+                    const initiativeId = (pickString(payload, ["initiativeId", "initiative_id"]) ??
+                        searchParams.get("initiativeId") ??
+                        searchParams.get("initiative_id") ??
+                        "")
+                        .trim();
+                    const workstreamId = (pickString(payload, ["workstreamId", "workstream_id"]) ??
+                        searchParams.get("workstreamId") ??
+                        searchParams.get("workstream_id") ??
+                        "")
+                        .trim();
+                    if (!initiativeId || !workstreamId) {
+                        sendJson(res, 400, {
+                            ok: false,
+                            error: "initiativeId and workstreamId are required",
+                        });
+                        return true;
+                    }
+                    let agentIdRaw = (pickString(payload, ["agentId", "agent_id"]) ??
+                        searchParams.get("agentId") ??
+                        searchParams.get("agent_id") ??
+                        "")
+                        .trim();
+                    const queue = await buildNextUpQueue({ initiativeId });
+                    const matchedQueueItem = queue.items.find((item) => item.workstreamId === workstreamId) ?? null;
+                    if (!agentIdRaw && matchedQueueItem?.runnerAgentId) {
+                        agentIdRaw = matchedQueueItem.runnerAgentId;
+                    }
+                    const agentId = agentIdRaw || "main";
+                    if (!/^[a-zA-Z0-9_-]+$/.test(agentId)) {
+                        sendJson(res, 400, {
+                            ok: false,
+                            error: "agentId must be a simple identifier (letters, numbers, _ or -).",
+                        });
+                        return true;
+                    }
+                    const upgradeGate = await resolveAutoContinueUpgradeGate(agentId);
+                    if (upgradeGate) {
+                        sendJson(res, 402, {
+                            ok: false,
+                            ...upgradeGate,
+                        });
+                        return true;
+                    }
+                    const tokenBudget = pickNumber(payload, [
+                        "tokenBudget",
+                        "token_budget",
+                        "tokenBudgetTokens",
+                        "token_budget_tokens",
+                        "maxTokens",
+                        "max_tokens",
+                    ]) ??
+                        searchParams.get("tokenBudget") ??
+                        searchParams.get("token_budget") ??
+                        searchParams.get("tokenBudgetTokens") ??
+                        searchParams.get("token_budget_tokens") ??
+                        searchParams.get("maxTokens") ??
+                        searchParams.get("max_tokens") ??
+                        null;
+                    const includeVerificationRaw = payload.includeVerification ??
+                        payload.include_verification ??
+                        searchParams.get("includeVerification") ??
+                        searchParams.get("include_verification") ??
+                        null;
+                    const includeVerification = typeof includeVerificationRaw === "boolean"
+                        ? includeVerificationRaw
+                        : parseBooleanQuery(typeof includeVerificationRaw === "string"
+                            ? includeVerificationRaw
+                            : null);
+                    const run = await startAutoContinueRun({
+                        initiativeId,
+                        agentId,
+                        tokenBudget,
+                        includeVerification,
+                        allowedWorkstreamIds: [workstreamId],
+                    });
+                    // Play should feel immediate. Run one dispatch tick synchronously so the
+                    // user gets an actual launch (or a concrete error) in this response.
+                    await tickAutoContinueRun(run);
+                    let fallbackDispatch = null;
+                    if (!run.activeRunId &&
+                        matchedQueueItem &&
+                        matchedQueueItem.runnerSource === "fallback") {
+                        fallbackDispatch = await dispatchFallbackWorkstreamTurn({
+                            initiativeId,
+                            initiativeTitle: matchedQueueItem.initiativeTitle,
+                            workstreamId,
+                            workstreamTitle: matchedQueueItem.workstreamTitle,
+                            agentId,
+                        });
+                    }
+                    const dispatchMode = run.activeRunId
+                        ? "task"
+                        : fallbackDispatch
+                            ? "fallback"
+                            : "none";
+                    if (dispatchMode === "none") {
+                        const reason = run.stopReason === "blocked"
+                            ? "No dispatchable task is ready for this workstream yet."
+                            : run.stopReason === "completed"
+                                ? "No queued task is available for this workstream."
+                                : "Unable to dispatch this workstream right now.";
+                        sendJson(res, 409, {
+                            ok: false,
+                            error: reason,
+                            run,
+                            initiativeId,
+                            workstreamId,
+                            agentId,
+                        });
+                        return true;
+                    }
+                    sendJson(res, 200, {
+                        ok: true,
+                        run,
+                        initiativeId,
+                        workstreamId,
+                        agentId,
+                        dispatchMode,
+                        sessionId: run.activeRunId ?? fallbackDispatch?.sessionId ?? null,
+                    });
+                }
+                catch (err) {
+                    sendJson(res, 500, { ok: false, error: safeErrorMessage(err) });
+                }
+                return true;
+            }
             if (method === "POST" && isMissionControlAutoContinueStartRoute) {
                 try {
                     const payload = await parseJsonRequest(req);
@@ -2861,37 +4049,13 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
                         });
                         return true;
                     }
-                    let requiresPremiumAutoContinue = false;
-                    try {
-                        const agents = await listOpenClawAgents();
-                        const agentEntry = agents.find((entry) => String(entry.id ?? "").trim() === agentId) ??
-                            null;
-                        const agentModel = agentEntry && typeof agentEntry.model === "string"
-                            ? agentEntry.model
-                            : null;
-                        requiresPremiumAutoContinue = modelImpliesByok(agentModel);
-                    }
-                    catch {
-                        // ignore
-                    }
-                    if (requiresPremiumAutoContinue) {
-                        const billingStatus = await fetchBillingStatusSafe(client);
-                        if (billingStatus && billingStatus.plan === "free") {
-                            const pricingUrl = `${client.getBaseUrl().replace(/\/+$/, "")}/pricing`;
-                            sendJson(res, 402, {
-                                ok: false,
-                                code: "upgrade_required",
-                                error: "Auto-continue for BYOK agents requires a paid OrgX plan. Upgrade, then retry.",
-                                currentPlan: billingStatus.plan,
-                                requiredPlan: "starter",
-                                actions: {
-                                    checkout: "/orgx/api/billing/checkout",
-                                    portal: "/orgx/api/billing/portal",
-                                    pricing: pricingUrl,
-                                },
-                            });
-                            return true;
-                        }
+                    const upgradeGate = await resolveAutoContinueUpgradeGate(agentId);
+                    if (upgradeGate) {
+                        sendJson(res, 402, {
+                            ok: false,
+                            ...upgradeGate,
+                        });
+                        return true;
                     }
                     const tokenBudget = pickNumber(payload, [
                         "tokenBudget",
@@ -2935,53 +4099,13 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
                             .filter(Boolean),
                     ]);
                     const allowedWorkstreamIds = workstreamFilter.length > 0 ? workstreamFilter : null;
-                    const now = new Date().toISOString();
-                    const existing = autoContinueRuns.get(initiativeId) ?? null;
-                    const run = existing ??
-                        {
-                            initiativeId,
-                            agentId,
-                            includeVerification: false,
-                            allowedWorkstreamIds: null,
-                            tokenBudget: defaultAutoContinueTokenBudget(),
-                            tokensUsed: 0,
-                            status: "running",
-                            stopReason: null,
-                            stopRequested: false,
-                            startedAt: now,
-                            stoppedAt: null,
-                            updatedAt: now,
-                            lastError: null,
-                            lastTaskId: null,
-                            lastRunId: null,
-                            activeTaskId: null,
-                            activeRunId: null,
-                            activeTaskTokenEstimate: null,
-                        };
-                    run.agentId = agentId;
-                    run.includeVerification = includeVerification;
-                    run.allowedWorkstreamIds = allowedWorkstreamIds;
-                    run.tokenBudget = normalizeTokenBudget(tokenBudget, run.tokenBudget || defaultAutoContinueTokenBudget());
-                    run.status = "running";
-                    run.stopReason = null;
-                    run.stopRequested = false;
-                    run.startedAt = now;
-                    run.stoppedAt = null;
-                    run.updatedAt = now;
-                    run.lastError = null;
-                    autoContinueRuns.set(initiativeId, run);
-                    try {
-                        await client.updateEntity("initiative", initiativeId, { status: "active" });
-                    }
-                    catch {
-                        // best effort
-                    }
-                    try {
-                        await updateInitiativeAutoContinueState({ initiativeId, run });
-                    }
-                    catch {
-                        // best effort
-                    }
+                    const run = await startAutoContinueRun({
+                        initiativeId,
+                        agentId,
+                        tokenBudget,
+                        includeVerification,
+                        allowedWorkstreamIds,
+                    });
                     sendJson(res, 200, { ok: true, run });
                 }
                 catch (err) {
@@ -3200,11 +4324,38 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
                     const entityAction = decodeURIComponent(entityActionMatch[3]);
                     const payload = await parseJsonRequest(req);
                     if (entityAction === "delete") {
-                        // Delete via status update
-                        const entity = await client.updateEntity(entityType, entityId, {
-                            status: "deleted",
-                        });
-                        sendJson(res, 200, { ok: true, entity });
+                        // Delete via status update. Initiatives use `archived` in OrgX.
+                        const deleteStatus = entityType.trim().toLowerCase() === "initiative"
+                            ? "archived"
+                            : "deleted";
+                        try {
+                            const entity = await client.updateEntity(entityType, entityId, {
+                                status: deleteStatus,
+                            });
+                            if (entityType.trim().toLowerCase() === "initiative") {
+                                clearLocalInitiativeStatusOverride(entityId);
+                            }
+                            sendJson(res, 200, { ok: true, entity, deletedAsStatus: deleteStatus });
+                        }
+                        catch (err) {
+                            if (entityType.trim().toLowerCase() === "initiative" &&
+                                isUnauthorizedOrgxError(err)) {
+                                setLocalInitiativeStatusOverride(entityId, deleteStatus);
+                                sendJson(res, 200, {
+                                    ok: true,
+                                    localFallback: true,
+                                    warning: safeErrorMessage(err),
+                                    entity: {
+                                        id: entityId,
+                                        type: entityType,
+                                        status: deleteStatus,
+                                    },
+                                    deletedAsStatus: deleteStatus,
+                                });
+                                return true;
+                            }
+                            throw err;
+                        }
                     }
                     else {
                         // Map action to status update
@@ -3223,11 +4374,34 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
                             });
                             return true;
                         }
-                        const entity = await client.updateEntity(entityType, entityId, {
-                            status: newStatus,
-                            ...(payload.force ? { force: true } : {}),
-                        });
-                        sendJson(res, 200, { ok: true, entity });
+                        try {
+                            const entity = await client.updateEntity(entityType, entityId, {
+                                status: newStatus,
+                                ...(payload.force ? { force: true } : {}),
+                            });
+                            if (entityType.trim().toLowerCase() === "initiative") {
+                                clearLocalInitiativeStatusOverride(entityId);
+                            }
+                            sendJson(res, 200, { ok: true, entity });
+                        }
+                        catch (err) {
+                            if (entityType.trim().toLowerCase() === "initiative" &&
+                                isUnauthorizedOrgxError(err)) {
+                                setLocalInitiativeStatusOverride(entityId, newStatus);
+                                sendJson(res, 200, {
+                                    ok: true,
+                                    localFallback: true,
+                                    warning: safeErrorMessage(err),
+                                    entity: {
+                                        id: entityId,
+                                        type: entityType,
+                                        status: newStatus,
+                                    },
+                                });
+                                return true;
+                            }
+                            throw err;
+                        }
                     }
                 }
                 catch (err) {
@@ -3244,6 +4418,7 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
                 !(runActionMatch && method === "POST") &&
                 !(isDelegationPreflight && method === "POST") &&
                 !(isMissionControlAutoAssignmentRoute && method === "POST") &&
+                !(isMissionControlNextUpPlayRoute && method === "POST") &&
                 !(isEntitiesRoute && method === "POST") &&
                 !(isEntitiesRoute && method === "PATCH") &&
                 !(entityActionMatch && method === "POST") &&
@@ -3338,7 +4513,7 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
                 case "agents/catalog": {
                     try {
                         const [openclawAgents, localSnapshot] = await Promise.all([
-                            listOpenClawAgents(),
+                            listAgents(),
                             loadLocalOpenClawSnapshot(240).catch(() => null),
                         ]);
                         const localById = new Map();
@@ -3425,6 +4600,108 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
                 case "onboarding":
                     sendJson(res, 200, getOnboardingState(await onboarding.getStatus()));
                     return true;
+                case "hooks/runtime": {
+                    if (method !== "POST") {
+                        sendJson(res, 405, { ok: false, error: "Use POST /orgx/api/hooks/runtime" });
+                        return true;
+                    }
+                    const expectedHookToken = resolveRuntimeHookToken();
+                    const providedHookToken = pickHeaderString(req.headers, ["x-orgx-hook-token", "x-hook-token"]) ??
+                        searchParams.get("hook_token") ??
+                        searchParams.get("token");
+                    if (!providedHookToken || providedHookToken.trim() !== expectedHookToken) {
+                        sendJson(res, 401, {
+                            ok: false,
+                            error: "Invalid hook token",
+                        });
+                        return true;
+                    }
+                    try {
+                        const payloadRecord = await parseJsonRequest(req);
+                        const payload = {
+                            source_client: pickString(payloadRecord, ["source_client", "sourceClient"]) ??
+                                "unknown",
+                            event: pickString(payloadRecord, ["event", "hook_event"]) ?? "heartbeat",
+                            run_id: pickString(payloadRecord, ["run_id", "runId", "session_id", "sessionId"]),
+                            correlation_id: pickString(payloadRecord, ["correlation_id", "correlationId"]),
+                            initiative_id: pickString(payloadRecord, ["initiative_id", "initiativeId"]),
+                            workstream_id: pickString(payloadRecord, ["workstream_id", "workstreamId"]),
+                            task_id: pickString(payloadRecord, ["task_id", "taskId"]),
+                            agent_id: pickString(payloadRecord, ["agent_id", "agentId"]),
+                            agent_name: pickString(payloadRecord, ["agent_name", "agentName"]),
+                            phase: pickString(payloadRecord, ["phase"]),
+                            progress_pct: pickNumber(payloadRecord, ["progress_pct", "progressPct"]) ??
+                                null,
+                            message: pickString(payloadRecord, ["message", "summary"]),
+                            metadata: payloadRecord.metadata && typeof payloadRecord.metadata === "object"
+                                ? payloadRecord.metadata
+                                : null,
+                            timestamp: pickString(payloadRecord, ["timestamp", "time", "ts"]),
+                        };
+                        const instance = upsertRuntimeInstanceFromHook(payload);
+                        const fallbackPhaseByEvent = {
+                            session_start: "intent",
+                            heartbeat: "execution",
+                            progress: "execution",
+                            task_update: "execution",
+                            session_stop: "completed",
+                            error: "blocked",
+                        };
+                        const phase = normalizeHookPhase(payload.phase ??
+                            fallbackPhaseByEvent[instance.event] ??
+                            "execution");
+                        const level = instance.event === "error" ? "error" : phase === "blocked" ? "warn" : "info";
+                        const message = payload.message ??
+                            `${instance.displayName} ${instance.event.replace(/_/g, " ")}`;
+                        let forwarded = false;
+                        let forwardError = null;
+                        if (instance.initiativeId) {
+                            try {
+                                await client.emitActivity({
+                                    initiative_id: instance.initiativeId,
+                                    run_id: instance.runId ?? undefined,
+                                    correlation_id: instance.runId
+                                        ? undefined
+                                        : (instance.correlationId ?? undefined),
+                                    source_client: normalizeRuntimeSourceForReporting(instance.sourceClient),
+                                    message,
+                                    phase,
+                                    progress_pct: instance.progressPct ?? undefined,
+                                    level,
+                                    metadata: {
+                                        source: "runtime_hook_relay",
+                                        hook_event: instance.event,
+                                        instance_id: instance.id,
+                                        runtime_client: instance.sourceClient,
+                                        task_id: instance.taskId,
+                                        workstream_id: instance.workstreamId,
+                                        ...(instance.metadata ?? {}),
+                                    },
+                                });
+                                forwarded = true;
+                            }
+                            catch (err) {
+                                forwardError = safeErrorMessage(err);
+                            }
+                        }
+                        sendJson(res, 200, {
+                            ok: true,
+                            instance_id: instance.id,
+                            state: instance.state,
+                            last_seen_at: instance.lastHeartbeatAt ?? instance.lastEventAt,
+                            run_id: instance.runId ?? null,
+                            forwarded,
+                            forward_error: forwardError,
+                        });
+                    }
+                    catch (err) {
+                        sendJson(res, 500, {
+                            ok: false,
+                            error: safeErrorMessage(err),
+                        });
+                    }
+                    return true;
+                }
                 case "mission-control/auto-continue/status": {
                     const initiativeId = searchParams.get("initiative_id") ??
                         searchParams.get("initiativeId") ??
@@ -3612,7 +4889,7 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
                     agentId = agentId.trim();
                     if (!agentId) {
                         try {
-                            const agents = await listOpenClawAgents();
+                            const agents = await listAgents();
                             const defaultAgent = agents.find((entry) => Boolean(entry.isDefault)) ?? agents[0] ?? null;
                             const candidate = defaultAgent && typeof defaultAgent.id === "string" ? defaultAgent.id.trim() : "";
                             if (candidate)
@@ -3658,7 +4935,7 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
                         return true;
                     }
                     try {
-                        const graph = await buildMissionControlGraph(client, initiativeId.trim());
+                        const graph = applyLocalInitiativeOverrideToGraph(await buildMissionControlGraph(client, initiativeId.trim()));
                         sendJson(res, 200, graph);
                     }
                     catch (err) {
@@ -3668,6 +4945,29 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
                     }
                     return true;
                 }
+                case "mission-control/next-up": {
+                    const initiativeIdRaw = searchParams.get("initiative_id") ??
+                        searchParams.get("initiativeId") ??
+                        "";
+                    const initiativeId = initiativeIdRaw.trim() || null;
+                    try {
+                        const queue = await buildNextUpQueue({ initiativeId });
+                        sendJson(res, 200, {
+                            ok: true,
+                            generatedAt: new Date().toISOString(),
+                            total: queue.items.length,
+                            items: queue.items,
+                            degraded: queue.degraded,
+                        });
+                    }
+                    catch (err) {
+                        sendJson(res, 500, {
+                            ok: false,
+                            error: safeErrorMessage(err),
+                        });
+                    }
+                    return true;
+                }
                 case "entities": {
                     if (method === "POST") {
                         try {
@@ -3716,10 +5016,15 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
                         return true;
                     }
                     if (method === "PATCH") {
+                        let payload = {};
+                        let type = null;
+                        let id = null;
+                        let requestedStatus = null;
                         try {
-                            const payload = await parseJsonRequest(req);
-                            const type = pickString(payload, ["type"]);
-                            const id = pickString(payload, ["id"]);
+                            payload = await parseJsonRequest(req);
+                            type = pickString(payload, ["type"]);
+                            id = pickString(payload, ["id"]);
+                            requestedStatus = pickString(payload, ["status"]);
                             if (!type || !id) {
                                 sendJson(res, 400, {
                                     error: "Both 'type' and 'id' are required for PATCH.",
@@ -3729,37 +5034,91 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
                             const updates = { ...payload };
                             delete updates.type;
                             delete updates.id;
-                            const entity = await client.updateEntity(type, id, normalizeEntityMutationPayload(updates));
+                            const normalizedType = type.trim().toLowerCase();
+                            const normalizedUpdates = normalizeEntityMutationPayload(updates);
+                            const entity = await client.updateEntity(type, id, normalizedUpdates);
+                            if (normalizedType === "initiative") {
+                                clearLocalInitiativeStatusOverride(id);
+                            }
                             sendJson(res, 200, { ok: true, entity });
                         }
                         catch (err) {
+                            if (type?.trim().toLowerCase() === "initiative" &&
+                                id &&
+                                requestedStatus &&
+                                isUnauthorizedOrgxError(err)) {
+                                setLocalInitiativeStatusOverride(id, requestedStatus);
+                                sendJson(res, 200, {
+                                    ok: true,
+                                    localFallback: true,
+                                    warning: safeErrorMessage(err),
+                                    entity: {
+                                        id,
+                                        type,
+                                        status: requestedStatus,
+                                    },
+                                });
+                                return true;
+                            }
                             sendJson(res, 500, {
                                 error: safeErrorMessage(err),
                             });
                         }
                         return true;
                     }
+                    const type = searchParams.get("type");
+                    if (!type) {
+                        sendJson(res, 400, {
+                            error: "Query parameter 'type' is required for GET /entities.",
+                        });
+                        return true;
+                    }
+                    const status = searchParams.get("status") ?? undefined;
+                    const initiativeId = searchParams.get("initiative_id") ?? undefined;
+                    const limit = searchParams.get("limit")
+                        ? Number(searchParams.get("limit"))
+                        : undefined;
                     try {
-                        const type = searchParams.get("type");
-                        if (!type) {
-                            sendJson(res, 400, {
-                                error: "Query parameter 'type' is required for GET /entities.",
-                            });
-                            return true;
-                        }
-                        const status = searchParams.get("status") ?? undefined;
-                        const initiativeId = searchParams.get("initiative_id") ?? undefined;
-                        const limit = searchParams.get("limit")
-                            ? Number(searchParams.get("limit"))
-                            : undefined;
                         const data = await client.listEntities(type, {
                             status,
                             initiative_id: initiativeId,
                             limit: Number.isFinite(limit) ? limit : undefined,
                         });
+                        if (type.trim().toLowerCase() === "initiative") {
+                            const payload = data;
+                            const rows = Array.isArray(payload.data)
+                                ? payload.data.filter((row) => Boolean(row && typeof row === "object"))
+                                : [];
+                            sendJson(res, 200, {
+                                ...payload,
+                                data: applyLocalInitiativeOverrides(rows),
+                            });
+                            return true;
+                        }
                         sendJson(res, 200, data);
                     }
                     catch (err) {
+                        if (type.trim().toLowerCase() === "initiative" &&
+                            isUnauthorizedOrgxError(err)) {
+                            const snapshotInitiatives = formatInitiatives(getSnapshot())
+                                .map((item) => ({
+                                id: item.id,
+                                title: item.title,
+                                name: item.title,
+                                summary: null,
+                                status: item.status,
+                                progress_pct: item.progress ?? null,
+                                created_at: null,
+                                updated_at: null,
+                            }))
+                                .filter((item) => initiativeId ? item.id === initiativeId : true);
+                            sendJson(res, 200, {
+                                data: applyLocalInitiativeOverrides(snapshotInitiatives),
+                                localFallback: true,
+                                warning: safeErrorMessage(err),
+                            });
+                            return true;
+                        }
                         sendJson(res, 500, {
                             error: safeErrorMessage(err),
                         });
@@ -4017,12 +5376,22 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
                     catch (err) {
                         degraded.push(`outbox unavailable (${safeErrorMessage(err)})`);
                     }
+                    let runtimeInstances = listRuntimeInstances({ limit: 320 });
+                    if (initiative && initiative.trim().length > 0) {
+                        runtimeInstances = runtimeInstances.filter((instance) => instance.initiativeId === initiative);
+                    }
+                    if (run && run.trim().length > 0) {
+                        runtimeInstances = runtimeInstances.filter((instance) => instance.runId === run || instance.correlationId === run);
+                    }
+                    sessions = enrichSessionsWithRuntime(sessions, runtimeInstances);
+                    activity = enrichActivityWithRuntime(activity, runtimeInstances);
                     sendJson(res, 200, {
                         sessions,
                         activity,
                         handoffs,
                         decisions,
                         agents,
+                        runtimeInstances,
                         outbox: outboxStatus,
                         generatedAt: new Date().toISOString(),
                         degraded: degraded.length > 0 ? degraded : undefined,
@@ -4237,7 +5606,30 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
                             id,
                             limit: Number.isFinite(limit) ? limit : undefined,
                         });
-                        sendJson(res, 200, data);
+                        const payload = data;
+                        const initiatives = Array.isArray(payload.initiatives)
+                            ? payload.initiatives.map((entry) => {
+                                if (!entry || typeof entry !== "object")
+                                    return entry;
+                                const row = entry;
+                                const initiativeId = pickString(row, ["id"]);
+                                if (!initiativeId)
+                                    return entry;
+                                const override = localInitiativeStatusOverrides.get(initiativeId) ?? null;
+                                if (!override)
+                                    return entry;
+                                return {
+                                    ...row,
+                                    status: override.status,
+                                    updatedAt: pickString(row, ["updatedAt", "updated_at"]) ??
+                                        override.updatedAt,
+                                };
+                            })
+                            : payload.initiatives;
+                        sendJson(res, 200, {
+                            ...payload,
+                            initiatives,
+                        });
                     }
                     catch (err) {
                         try {
@@ -4251,9 +5643,49 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
                             if (id && id.trim().length > 0) {
                                 initiatives = initiatives.filter((item) => item.id === id);
                             }
+                            initiatives = initiatives.map((item) => {
+                                const override = localInitiativeStatusOverrides.get(item.id) ?? null;
+                                if (!override)
+                                    return item;
+                                return {
+                                    ...item,
+                                    status: override.status,
+                                    updatedAt: item.updatedAt ?? override.updatedAt,
+                                };
+                            });
+                            const requestedId = id?.trim() ?? "";
+                            if (requestedId.length > 0) {
+                                const override = localInitiativeStatusOverrides.get(requestedId) ?? null;
+                                if (override && !initiatives.some((item) => item.id === requestedId)) {
+                                    initiatives.push({
+                                        id: requestedId,
+                                        title: `Initiative ${requestedId.slice(0, 8)}`,
+                                        status: override.status,
+                                        updatedAt: override.updatedAt,
+                                        sessionCount: 0,
+                                        activeAgents: 0,
+                                    });
+                                }
+                            }
+                            else {
+                                for (const [initiativeId, override] of localInitiativeStatusOverrides.entries()) {
+                                    if (initiatives.some((item) => item.id === initiativeId))
+                                        continue;
+                                    initiatives.push({
+                                        id: initiativeId,
+                                        title: `Initiative ${initiativeId.slice(0, 8)}`,
+                                        status: override.status,
+                                        updatedAt: override.updatedAt,
+                                        sessionCount: 0,
+                                        activeAgents: 0,
+                                    });
+                                }
+                            }
                             sendJson(res, 200, {
                                 initiatives: initiatives.slice(0, limit),
                                 total: initiatives.length,
+                                localFallback: true,
+                                warning: safeErrorMessage(err),
                             });
                         }
                         catch (localErr) {
@@ -4313,17 +5745,26 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
                     let closed = false;
                     let streamOpened = false;
                     let idleTimer = null;
+                    let heartbeatTimer = null;
+                    let heartbeatBackpressure = false;
                     const clearIdleTimer = () => {
                         if (idleTimer) {
                             clearTimeout(idleTimer);
                             idleTimer = null;
                         }
                     };
+                    const clearHeartbeatTimer = () => {
+                        if (heartbeatTimer) {
+                            clearInterval(heartbeatTimer);
+                            heartbeatTimer = null;
+                        }
+                    };
                     const closeStream = () => {
                         if (closed)
                             return;
                         closed = true;
                         clearIdleTimer();
+                        clearHeartbeatTimer();
                         streamAbortController.abort();
                         if (reader) {
                             void reader.cancel().catch(() => undefined);
@@ -4373,6 +5814,32 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
                             ...CORS_HEADERS,
                         });
                         streamOpened = true;
+                        // Heartbeat comments keep intermediary proxies from timing out idle SSE.
+                        // They also prevent the dashboard from flickering into reconnect mode
+                        // during long quiet periods.
+                        heartbeatTimer = setInterval(() => {
+                            if (closed || heartbeatBackpressure)
+                                return;
+                            try {
+                                // Keepalive comment line (single newline to avoid terminating an upstream event mid-chunk).
+                                const accepted = write(Buffer.from(`: ping ${Date.now()}\n`, "utf8"));
+                                resetIdleTimer();
+                                if (accepted === false) {
+                                    heartbeatBackpressure = true;
+                                    if (typeof res.once === "function") {
+                                        res.once("drain", () => {
+                                            heartbeatBackpressure = false;
+                                            if (!closed)
+                                                resetIdleTimer();
+                                        });
+                                    }
+                                }
+                            }
+                            catch {
+                                closeStream();
+                            }
+                        }, 20_000);
+                        heartbeatTimer.unref?.();
                         if (!upstream.body) {
                             closeStream();
                             return true;