@useorgx/openclaw-plugin 0.7.18 → 0.7.23

package/dist/http/routes/live-legacy.d.ts

@@ -13,6 +13,8 @@ type LocalLiveActivity = {
 };
 type LiveActivityPage = {
     activities: LiveActivityItem[];
+    total?: number;
+    storeUpdatedAt?: string;
     cursor?: string | null;
     nextCursor?: string | null;
     prevCursor?: string | null;
@@ -34,7 +36,7 @@ type RouteResLike = {
     on?: (event: string, listener: () => void) => void;
     once?: (event: string, listener: () => void) => void;
 };
-type RegisterLiveLegacyRoutesDeps<TRes extends RouteResLike> = {
+type RegisterLiveLegacyRoutesDeps<TReq extends RouteReqLike, TRes extends RouteResLike> = {
     getLiveSessions: (input: {
         initiative: string | null;
         projectId: string | null;
@@ -82,6 +84,15 @@ type RegisterLiveLegacyRoutesDeps<TRes extends RouteResLike> = {
         sessionKey: string | null;
         runId: string | null;
     }) => Promise<Record<string, unknown> | null>;
+    summarizeActivityHeadline: (input: {
+        text: string;
+        title: string | null;
+        type: string | null;
+    }) => Promise<{
+        headline: string;
+        source: string;
+        model: string | null;
+    }>;
     sendJson: (res: TRes, status: number, payload: unknown) => void;
     safeErrorMessage: (err: unknown) => string;
     sendHtml: (res: TRes, status: number, html: string) => void;
@@ -112,6 +123,12 @@ type RegisterLiveLegacyRoutesDeps<TRes extends RouteResLike> = {
     };
     isUserScopedApiKey: (apiKey: string) => boolean;
     streamIdleTimeoutMs: number;
+    renderLiveStreamV2?: (input: {
+        path: string;
+        query: URLSearchParams;
+        req: TReq;
+        res: TRes;
+    }) => Promise<void>;
 };
-export declare function registerLiveLegacyRoutes<TReq extends RouteReqLike, TRes extends RouteResLike>(router: Router<Record<string, never>, TReq, TRes>, deps: RegisterLiveLegacyRoutesDeps<TRes>): void;
+export declare function registerLiveLegacyRoutes<TReq extends RouteReqLike, TRes extends RouteResLike>(router: Router<Record<string, never>, TReq, TRes>, deps: RegisterLiveLegacyRoutesDeps<TReq, TRes>): void;
 export {};

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

@@ -1,3 +1,4 @@
+import { resolveWorkspaceScope } from "../helpers/workspace-scope.js";
 export function registerLiveLegacyRoutes(router, deps) {
     function toContextBundle(value) {
         return {
@@ -5,26 +6,40 @@ export function registerLiveLegacyRoutes(router, deps) {
             runs: value.runs ?? {},
         };
     }
-    function parseWorkspaceScope(query) {
-        const candidates = [
-            query.get("workspace_id"),
-            query.get("workspaceId"),
-            query.get("command_center_id"),
-            query.get("commandCenterId"),
-            query.get("center"),
-            query.get("project_id"),
-            query.get("projectId"),
-        ];
-        for (const candidate of candidates) {
-            if (typeof candidate !== "string")
-                continue;
-            const normalized = candidate.trim();
-            if (!normalized || normalized.toLowerCase() === "all")
-                continue;
-            return normalized;
+    function readActivityMetadataValue(metadata, keys) {
+        if (!metadata)
+            return null;
+        for (const key of keys) {
+            const value = metadata[key];
+            if (typeof value === "string" && value.trim().length > 0) {
+                return value.trim();
+            }
         }
         return null;
     }
+    function resolveActivityInitiativeId(item) {
+        const direct = item.initiativeId?.trim();
+        if (direct)
+            return direct;
+        const metadata = item.metadata && typeof item.metadata === "object" && !Array.isArray(item.metadata)
+            ? item.metadata
+            : null;
+        return readActivityMetadataValue(metadata, [
+            "initiativeId",
+            "initiative_id",
+            "initiative",
+        ]);
+    }
+    function filterActivityByInitiativeIds(items, initiativeIds) {
+        if (!initiativeIds)
+            return items;
+        if (initiativeIds.size === 0)
+            return [];
+        return items.filter((item) => {
+            const initiativeId = resolveActivityInitiativeId(item);
+            return initiativeId ? initiativeIds.has(initiativeId) : false;
+        });
+    }
     const sendDeprecated = (res, endpoint, replacement) => {
         deps.sendJson(res, 410, {
             error: `${endpoint} is deprecated`,
@@ -44,11 +59,26 @@ export function registerLiveLegacyRoutes(router, deps) {
         const since = query.get("since");
         const until = query.get("until");
         const cursor = query.get("cursor");
-        const projectId = parseWorkspaceScope(query);
+        const projectId = resolveWorkspaceScope(query, null, { allowProjectScope: true }).workspaceId ??
+            null;
         const limitRaw = query.get("limit") ? Number(query.get("limit")) : undefined;
         const limit = Number.isFinite(limitRaw)
             ? Math.max(1, Math.floor(Number(limitRaw)))
             : 200;
+        const scopedInitiativeIds = projectId
+            ? new Set((await deps.listInitiativeIdsForProject({ projectId }))
+                .map((value) => value.trim())
+                .filter((value) => value.length > 0))
+            : null;
+        if (scopedInitiativeIds && scopedInitiativeIds.size === 0) {
+            deps.sendJson(res, 200, {
+                activities: [],
+                total: 0,
+                nextCursor: null,
+                storeUpdatedAt: null,
+            });
+            return;
+        }
         let page = deps.listActivityPage({
             limit,
             runId: run,
@@ -60,7 +90,7 @@ export function registerLiveLegacyRoutes(router, deps) {
             const ctx = toContextBundle(deps.readAgentContexts());
             page = {
                 ...page,
-                activities: deps.applyAgentContextsToActivity(page.activities, ctx),
+                activities: filterActivityByInitiativeIds(deps.applyAgentContextsToActivity(page.activities, ctx), scopedInitiativeIds),
             };
         }
         const warmKey = `${projectId ?? ""}::${run ?? ""}::${since ?? ""}::${until ?? ""}`;
@@ -94,7 +124,7 @@ export function registerLiveLegacyRoutes(router, deps) {
                     const ctx = toContextBundle(deps.readAgentContexts());
                     page = {
                         ...page,
-                        activities: deps.applyAgentContextsToActivity(page.activities, ctx),
+                        activities: filterActivityByInitiativeIds(deps.applyAgentContextsToActivity(page.activities, ctx), scopedInitiativeIds),
                     };
                 }
             }
@@ -102,6 +132,12 @@ export function registerLiveLegacyRoutes(router, deps) {
                 // best effort
             }
         }
+        if (scopedInitiativeIds) {
+            page = {
+                ...page,
+                total: page.activities.length,
+            };
+        }
         deps.sendJson(res, 200, page);
     }
     router.add("GET", "live/activity/page", async ({ query, res }) => renderLiveActivityPage(query, res), "Paginated live activity");
@@ -114,9 +150,41 @@ export function registerLiveLegacyRoutes(router, deps) {
     router.add("GET", "live/activity", async ({ query, res }) => renderLiveActivity(query, res), "Legacy live activity endpoint");
     router.add("HEAD", "live/activity", async ({ query, res }) => renderLiveActivity(query, res), "Legacy live activity endpoint (HEAD)");
     async function renderLiveActivityDetail(query, res) {
-        sendDeprecated(res, "/orgx/api/live/activity/detail", "/orgx/api/live/snapshot-v2");
-        void query;
-        return;
+        try {
+            const turnId = (query.get("turnId") ?? "").trim();
+            if (!turnId) {
+                deps.sendJson(res, 400, { error: "turnId is required" });
+                return;
+            }
+            const sessionKey = (query.get("sessionKey") ?? "").trim() || null;
+            const runId = (query.get("run") ?? query.get("runId") ?? "").trim() || null;
+            const detail = await deps.loadLocalTurnDetail({ turnId, sessionKey, runId });
+            if (!detail) {
+                deps.sendJson(res, 404, { error: "activity detail not found" });
+                return;
+            }
+            const summary = typeof detail.summary === "string" && detail.summary.trim().length > 0
+                ? detail.summary.trim()
+                : null;
+            if (!summary) {
+                deps.sendJson(res, 200, { detail, headline: null, headlineSource: null, headlineModel: null });
+                return;
+            }
+            const headline = await deps.summarizeActivityHeadline({
+                text: summary,
+                title: null,
+                type: "activity",
+            });
+            deps.sendJson(res, 200, {
+                detail,
+                headline: headline.headline,
+                headlineSource: headline.source,
+                headlineModel: headline.model,
+            });
+        }
+        catch (err) {
+            deps.sendJson(res, 500, { error: deps.safeErrorMessage(err) });
+        }
     }
     router.add("GET", "live/activity/detail", async ({ query, res }) => renderLiveActivityDetail(query, res), "Detailed activity turn view");
     router.add("HEAD", "live/activity/detail", async ({ query, res }) => renderLiveActivityDetail(query, res), "Detailed activity turn view (HEAD)");
@@ -246,10 +314,25 @@ export function registerLiveLegacyRoutes(router, deps) {
         });
     }, "Reject unsupported methods for live/terminal/open");
     async function renderLiveStream(query, req, res) {
-        sendDeprecated(res, "/orgx/api/live/stream", "/orgx/api/live/snapshot-v2");
-        void query;
-        void req;
-        return;
+        if (typeof deps.renderLiveStreamV2 === "function") {
+            await deps.renderLiveStreamV2({
+                path: "live/stream",
+                query,
+                req,
+                res,
+            });
+            return;
+        }
+        const suffix = query.toString();
+        const location = suffix
+            ? `/orgx/api/live/stream-v2?${suffix}`
+            : "/orgx/api/live/stream-v2";
+        res.writeHead(307, {
+            Location: location,
+            Deprecation: "true",
+            Link: `</orgx/api/live/stream-v2>; rel="successor-version"`,
+        });
+        res.end();
     }
     router.add("GET", "live/stream", async ({ query, req, res }) => renderLiveStream(query, req, res), "Proxy live SSE stream");
     router.add("HEAD", "live/stream", async ({ query, req, res }) => renderLiveStream(query, req, res), "Proxy live SSE stream (HEAD)");

package/dist/http/routes/live-snapshot.d.ts

@@ -15,8 +15,11 @@ type SnapshotPersistState = {
 };
 type LiveSnapshotRoutesDeps<TReq, TRes> = {
     parsePositiveInt: (raw: string | null, fallback: number, max?: number) => number;
-    readSnapshotResponseCache: (key: string) => Record<string, unknown> | null;
+    readSnapshotResponseCache: (key: string, options?: {
+        allowStale?: boolean;
+    }) => Record<string, unknown> | null;
     writeSnapshotResponseCache: (key: string, payload: Record<string, unknown>) => void;
+    getSnapshotCacheGeneration: () => number;
     safeErrorMessage: (err: unknown) => string;
     readAgentContexts: () => AgentContextState;
     getScopedAgentIds: (contexts: Record<string, AgentLaunchContext>) => Set<string>;
@@ -141,6 +144,17 @@ type LiveSnapshotRoutesDeps<TReq, TRes> = {
         lastTransitionAt: string;
     } | null;
     sendJson: (res: TRes, status: number, payload: unknown) => void;
+    securityHeaders: Record<string, string>;
+    corsHeaders: Record<string, string>;
 };
-export declare function registerLiveSnapshotRoutes<TReq, TRes>(router: Router<Record<string, never>, TReq, TRes>, deps: LiveSnapshotRoutesDeps<TReq, TRes>): void;
+export declare function registerLiveSnapshotRoutes<TReq extends {
+    on?: (event: string, listener: () => void) => void;
+}, TRes extends {
+    write?: (chunk: string | Buffer) => boolean | void;
+    end: (chunk?: string | Buffer) => void;
+    writeHead: (statusCode: number, headers?: Record<string, string>) => unknown;
+    writableEnded?: boolean;
+    on?: (event: string, listener: () => void) => void;
+    once?: (event: string, listener: () => void) => void;
+}>(router: Router<Record<string, never>, TReq, TRes>, deps: LiveSnapshotRoutesDeps<TReq, TRes>): void;
 export {};

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

@@ -16,6 +16,8 @@ const LIVE_SNAPSHOT_NEXT_UP_TIMEOUT_MS = (() => {
         return 350;
     return Math.max(250, Math.min(15_000, Math.floor(raw)));
 })();
+const LIVE_STREAM_REFRESH_INTERVAL_MS = 1_500;
+const LIVE_STREAM_KEEPALIVE_MS = 20_000;
 async function withSoftTimeout(work, timeoutMs, label) {
     let timer = null;
     try {
@@ -59,6 +61,12 @@ function emptyOutboxStatus() {
         lastReplayError: null,
     };
 }
+function writeSseEvent(res, event, payload) {
+    if (typeof res.write !== "function")
+        return;
+    res.write(`event: ${event}\n`);
+    res.write(`data: ${JSON.stringify(payload ?? null)}\n\n`);
+}
 function filterSessionsByInitiative(sessions, initiative) {
     if (!initiative || initiative.trim().length === 0)
         return sessions;
@@ -230,6 +238,7 @@ export function registerLiveSnapshotRoutes(router, deps) {
         return `${base}:${normalized}`;
     };
     const headerScopeFromRequest = (req) => workspaceScopeFromHeaders(req?.headers);
+    const snapshotInflight = new Map();
     function parseSnapshotQuery(query, headerScope) {
         const sessionsLimit = deps.parsePositiveInt(query.get("sessionsLimit") ?? query.get("sessions_limit"), 320, 1000);
         const activityLimit = deps.parsePositiveInt(query.get("activityLimit") ?? query.get("activity_limit"), 600, 2000);
@@ -269,6 +278,24 @@ export function registerLiveSnapshotRoutes(router, deps) {
         });
         return false;
     };
+    function withSnapshotMeta(payload, input) {
+        const existingMeta = payload.meta && typeof payload.meta === "object" && !Array.isArray(payload.meta)
+            ? payload.meta
+            : {};
+        return {
+            ...payload,
+            meta: {
+                ...existingMeta,
+                generatedAt: (typeof payload.generatedAt === "string" && payload.generatedAt) ||
+                    (typeof existingMeta.generatedAt === "string" && existingMeta.generatedAt) ||
+                    new Date().toISOString(),
+                stale: input.stale,
+                staleReason: input.stale ? input.staleReason ?? "upstream_unavailable" : null,
+                sequence: deps.getSnapshotCacheGeneration(),
+                cacheKey: input.cacheKey,
+            },
+        };
+    }
     async function buildSnapshotBundle(query, headerScope) {
         const parsed = parseSnapshotQuery(query, headerScope);
         const { sessionsLimit, activityLimit, decisionsLimit, initiative, projectId, run, since, decisionStatus, includeIdle, scopeError, } = parsed;
@@ -583,34 +610,21 @@ export function registerLiveSnapshotRoutes(router, deps) {
             decisionsRaw: decisions,
         };
     }
-    async function renderSnapshot(path, query, res, headerScope) {
-        if (!validateWorkspaceScope(query, res, "live.snapshot.validation", headerScope))
-            return;
-        const snapshotCacheKey = `${path}?${query.toString()}`;
-        const cachedSnapshot = deps.readSnapshotResponseCache(snapshotCacheKey);
-        if (cachedSnapshot) {
-            deps.sendJson(res, 200, cachedSnapshot);
-            return;
-        }
+    async function buildSnapshotPayload(version, path, query, headerScope) {
         const bundle = await buildSnapshotBundle(query, headerScope);
         const parsed = parseSnapshotQuery(query, headerScope);
-        deps.writeSnapshotResponseCache(snapshotCacheKey, bundle.payload);
-        deps.writeSnapshotResponseCache("live-snapshot", bundle.payload);
-        deps.writeSnapshotResponseCache(snapshotAliasKey("live-snapshot", parsed.projectId), bundle.payload);
-        deps.sendJson(res, 200, bundle.payload);
-    }
-    async function renderSnapshotV2(path, query, res, headerScope) {
-        if (!validateWorkspaceScope(query, res, "live.snapshot-v2.validation", headerScope))
-            return;
         const snapshotCacheKey = `${path}?${query.toString()}`;
-        const cachedSnapshot = deps.readSnapshotResponseCache(snapshotCacheKey);
-        if (cachedSnapshot) {
-            deps.sendJson(res, 200, cachedSnapshot);
-            return;
+        if (version === "v1") {
+            const payload = withSnapshotMeta(bundle.payload, {
+                cacheKey: snapshotCacheKey,
+                stale: false,
+            });
+            deps.writeSnapshotResponseCache(snapshotCacheKey, payload);
+            deps.writeSnapshotResponseCache("live-snapshot", payload);
+            deps.writeSnapshotResponseCache(snapshotAliasKey("live-snapshot", parsed.projectId), payload);
+            return payload;
         }
-        const bundle = await buildSnapshotBundle(query, headerScope);
-        const parsed = parseSnapshotQuery(query, headerScope);
-        const payload = {
+        const payload = withSnapshotMeta({
             ...bundle.v2,
             sessions: bundle.payload.sessions,
             activity: bundle.payload.activity,
@@ -622,12 +636,140 @@ export function registerLiveSnapshotRoutes(router, deps) {
             outbox: bundle.payload.outbox,
             chat: bundle.payload.chat,
             degraded: bundle.payload.degraded,
-        };
+        }, {
+            cacheKey: snapshotCacheKey,
+            stale: false,
+        });
         deps.writeSnapshotResponseCache(snapshotCacheKey, payload);
         deps.writeSnapshotResponseCache("live-snapshot-v2", payload);
         deps.writeSnapshotResponseCache(snapshotAliasKey("live-snapshot-v2", parsed.projectId), payload);
+        return payload;
+    }
+    async function getSnapshotPayload(version, path, query, headerScope) {
+        const snapshotCacheKey = `${path}?${query.toString()}`;
+        const cachedSnapshot = deps.readSnapshotResponseCache(snapshotCacheKey);
+        if (cachedSnapshot)
+            return cachedSnapshot;
+        const inFlight = snapshotInflight.get(snapshotCacheKey);
+        if (inFlight)
+            return await inFlight;
+        const work = buildSnapshotPayload(version, path, query, headerScope)
+            .catch((err) => {
+            const staleSnapshot = deps.readSnapshotResponseCache(snapshotCacheKey, {
+                allowStale: true,
+            });
+            if (staleSnapshot) {
+                return withSnapshotMeta(staleSnapshot, {
+                    cacheKey: snapshotCacheKey,
+                    stale: true,
+                    staleReason: deps.safeErrorMessage(err),
+                });
+            }
+            throw err;
+        })
+            .finally(() => {
+            snapshotInflight.delete(snapshotCacheKey);
+        });
+        snapshotInflight.set(snapshotCacheKey, work);
+        return await work;
+    }
+    async function renderSnapshot(path, query, res, headerScope) {
+        if (!validateWorkspaceScope(query, res, "live.snapshot.validation", headerScope))
+            return;
+        const payload = await getSnapshotPayload("v1", path, query, headerScope);
         deps.sendJson(res, 200, payload);
     }
+    async function renderSnapshotV2(path, query, res, headerScope) {
+        if (!validateWorkspaceScope(query, res, "live.snapshot-v2.validation", headerScope))
+            return;
+        const payload = await getSnapshotPayload("v2", path, query, headerScope);
+        deps.sendJson(res, 200, payload);
+    }
+    async function renderSnapshotStreamV2(path, query, req, res, headerScope) {
+        if (!validateWorkspaceScope(query, res, "live.stream-v2.validation", headerScope))
+            return;
+        const streamHeaders = {
+            ...deps.securityHeaders,
+            ...deps.corsHeaders,
+            "Content-Type": "text/event-stream; charset=utf-8",
+            "Cache-Control": "no-cache, no-transform",
+            Connection: "keep-alive",
+            "X-Accel-Buffering": "no",
+        };
+        res.writeHead(200, streamHeaders);
+        if (typeof res.write !== "function") {
+            res.end();
+            return;
+        }
+        let closed = false;
+        let lastGeneration = -1;
+        let refreshTimer = null;
+        let keepaliveTimer = null;
+        const cleanup = () => {
+            if (closed)
+                return;
+            closed = true;
+            if (refreshTimer) {
+                clearInterval(refreshTimer);
+                refreshTimer = null;
+            }
+            if (keepaliveTimer) {
+                clearInterval(keepaliveTimer);
+                keepaliveTimer = null;
+            }
+            try {
+                if (!res.writableEnded)
+                    res.end();
+            }
+            catch {
+                // ignore
+            }
+        };
+        req.on?.("close", cleanup);
+        res.on?.("close", cleanup);
+        res.once?.("finish", cleanup);
+        const emitSnapshot = async () => {
+            if (closed)
+                return;
+            try {
+                const payload = await getSnapshotPayload("v2", path, query, headerScope);
+                if (closed)
+                    return;
+                lastGeneration = deps.getSnapshotCacheGeneration();
+                writeSseEvent(res, "snapshot", payload);
+            }
+            catch (err) {
+                writeSseEvent(res, "error", {
+                    error: deps.safeErrorMessage(err),
+                });
+            }
+        };
+        await emitSnapshot();
+        refreshTimer = setInterval(() => {
+            if (closed) {
+                cleanup();
+                return;
+            }
+            const generation = deps.getSnapshotCacheGeneration();
+            if (generation === lastGeneration)
+                return;
+            void emitSnapshot();
+        }, LIVE_STREAM_REFRESH_INTERVAL_MS);
+        refreshTimer.unref?.();
+        keepaliveTimer = setInterval(() => {
+            if (closed || typeof res.write !== "function") {
+                cleanup();
+                return;
+            }
+            try {
+                res.write(`: ping ${Date.now()}\n\n`);
+            }
+            catch {
+                cleanup();
+            }
+        }, LIVE_STREAM_KEEPALIVE_MS);
+        keepaliveTimer.unref?.();
+    }
     async function renderSliceNarrative(path, query, res, headerScope) {
         if (!validateWorkspaceScope(query, res, "live.snapshot.slice-narrative.validation", headerScope))
             return;
@@ -914,6 +1056,8 @@ export function registerLiveSnapshotRoutes(router, deps) {
     router.add("HEAD", "live/snapshot", async ({ path, query, res, req }) => renderSnapshot(path, query, res, headerScopeFromRequest(req)), "Live snapshot (HEAD)");
     router.add("GET", "live/snapshot-v2", async ({ path, query, res, req }) => renderSnapshotV2(path, query, res, headerScopeFromRequest(req)), "Live snapshot (v2 projections)");
     router.add("HEAD", "live/snapshot-v2", async ({ path, query, res, req }) => renderSnapshotV2(path, query, res, headerScopeFromRequest(req)), "Live snapshot (v2 projections, HEAD)");
+    router.add("GET", "live/stream-v2", async ({ path, query, req, res }) => renderSnapshotStreamV2(path, query, req, res, headerScopeFromRequest(req)), "Live snapshot stream (v2)");
+    router.add("HEAD", "live/stream-v2", async ({ path, query, req, res }) => renderSnapshotV2(path, query, res, headerScopeFromRequest(req)), "Live snapshot stream (v2, HEAD)");
     router.add("GET", "slices/*", async ({ path, query, res, req }) => renderSliceNarrative(path, query, res, headerScopeFromRequest(req)), "Slice narrative/timeline projections");
     router.add("HEAD", "slices/*", async ({ path, query, res, req }) => renderSliceNarrative(path, query, res, headerScopeFromRequest(req)), "Slice narrative/timeline projections (HEAD)");
     router.add("POST", "slices/*", async ({ path, query, req, res }) => executeSliceAction(path, query, req, res, headerScopeFromRequest(req)), "Slice action contracts");

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

@@ -399,6 +399,19 @@ export function registerMissionControlActionsRoutes(router, deps) {
                 : null;
             const maxParallelSlices = normalizeMaxParallelSlices(requestedMaxParallelSlicesRaw, queuePreferredParallel ?? 1);
             const parallelMode = normalizeParallelMode(requestedParallelModeRaw);
+            const requestedWorkspaceId = deps.pickString(payload, [
+                "workspaceId",
+                "workspace_id",
+                "command_center_id",
+                "projectId",
+                "project_id",
+            ]) ??
+                query.get("workspaceId") ??
+                query.get("workspace_id") ??
+                query.get("command_center_id") ??
+                query.get("projectId") ??
+                query.get("project_id") ??
+                null;
             const existingRun = deps.autoContinueRuns.get(initiativeId) ?? null;
             const existingActiveRunIds = Array.isArray(existingRun?.activeSliceRunIds)
                 ? (existingRun?.activeSliceRunIds)
@@ -429,6 +442,7 @@ export function registerMissionControlActionsRoutes(router, deps) {
             }
             const run = await deps.startAutoContinueRun({
                 initiativeId,
+                workspaceId: requestedWorkspaceId,
                 agentId,
                 agentName: requestedAgentName,
                 tokenBudget,
@@ -1566,8 +1580,22 @@ export function registerMissionControlActionsRoutes(router, deps) {
             const startScope = startScopeRaw === "milestone" || startScopeRaw === "workstream"
                 ? startScopeRaw
                 : "task";
+            const requestedWorkspaceId = deps.pickString(payload, [
+                "workspaceId",
+                "workspace_id",
+                "command_center_id",
+                "projectId",
+                "project_id",
+            ]) ??
+                query.get("workspaceId") ??
+                query.get("workspace_id") ??
+                query.get("command_center_id") ??
+                query.get("projectId") ??
+                query.get("project_id") ??
+                null;
             const run = await deps.startAutoContinueRun({
                 initiativeId,
+                workspaceId: requestedWorkspaceId,
                 agentId,
                 agentName: await deps.resolveAgentDisplayName(agentId, null),
                 tokenBudget,

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

@@ -38,6 +38,7 @@ type NextUpQueueItem = {
     sliceTaskIds?: string[];
     sliceTaskCount?: number | null;
     sliceMilestoneId?: string | null;
+    milestoneBreakdown?: MilestoneBreakdownEntry[];
     isPinned?: boolean;
     pinnedRank?: number | null;
     compositeScore?: number;
@@ -55,9 +56,26 @@ type SliceRunnerAgent = {
 type NextUpQueue = {
     items: NextUpQueueItem[];
     degraded: string[];
+    summary?: {
+        visibleTotal: number;
+        stateCounts: Record<NextUpQueueItem["queueState"], number>;
+    };
+};
+type MilestoneBreakdownTask = {
+    id: string;
+    title: string;
+    status: string;
+};
+type MilestoneBreakdownEntry = {
+    id: string;
+    title: string;
+    tasks: MilestoneBreakdownTask[];
+    totalTasks: number;
+    doneTasks: number;
 };
 type RegisterMissionControlReadRoutesDeps<TRes> = {
     autoContinueRuns: Map<string, AutoContinueRunRecord>;
+    restoreAutoContinueRun?: (initiativeId: string) => Promise<AutoContinueRunRecord | null>;
     defaultAutoContinueTokenBudget: () => number | null;
     defaultAutoContinueMaxParallelSlices?: () => number;
     autoContinueTickMs: number;