@useorgx/openclaw-plugin 0.4.8 → 0.4.9

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

@@ -0,0 +1,206 @@
+export function registerLiveMiscRoutes(router, deps) {
+    router.add("POST", "live/activity/headline", async ({ req, res }) => {
+        try {
+            const payload = await deps.parseJsonRequest(req);
+            const text = deps.pickString(payload, ["text", "summary", "detail", "content"]);
+            if (!text) {
+                deps.sendJson(res, 400, { error: "text is required" });
+                return;
+            }
+            const title = deps.pickString(payload, ["title", "name"]);
+            const type = deps.pickString(payload, ["type", "kind"]);
+            const result = await deps.summarizeActivityHeadline({
+                text,
+                title,
+                type,
+            });
+            deps.sendJson(res, 200, {
+                headline: result.headline,
+                source: result.source,
+                model: result.model,
+            });
+        }
+        catch (err) {
+            deps.sendJson(res, 500, {
+                error: deps.safeErrorMessage(err),
+            });
+        }
+    }, "Summarize an activity headline");
+    router.add("*", "live/activity/headline", ({ res }) => {
+        deps.sendJson(res, 405, { error: "Use POST /orgx/api/live/activity/headline" });
+    }, "Reject unsupported methods for live/activity/headline");
+    async function renderLiveAgents(query, res) {
+        try {
+            const initiative = query.get("initiative");
+            const includeIdleRaw = query.get("include_idle");
+            const includeIdle = includeIdleRaw === null ? undefined : includeIdleRaw !== "false";
+            const data = await deps.getLiveAgents({
+                initiative,
+                includeIdle,
+            });
+            deps.sendJson(res, 200, data);
+        }
+        catch (err) {
+            try {
+                const initiative = query.get("initiative");
+                const includeIdleRaw = query.get("include_idle");
+                const includeIdle = includeIdleRaw === null ? undefined : includeIdleRaw !== "false";
+                const localSnapshot = await deps.loadLocalOpenClawSnapshot(240);
+                const local = deps.toLocalLiveAgents(localSnapshot);
+                let agents = local.agents;
+                if (initiative && initiative.trim().length > 0) {
+                    agents = agents.filter((agent) => agent.initiativeId === initiative);
+                }
+                if (includeIdle === false) {
+                    agents = agents.filter((agent) => agent.status !== "idle");
+                }
+                const summary = agents.reduce((acc, agent) => {
+                    acc[agent.status] = (acc[agent.status] ?? 0) + 1;
+                    return acc;
+                }, {});
+                deps.sendJson(res, 200, { agents, summary });
+            }
+            catch (localErr) {
+                deps.sendJson(res, 500, {
+                    error: deps.safeErrorMessage(err),
+                    localFallbackError: deps.safeErrorMessage(localErr),
+                });
+            }
+        }
+    }
+    router.add("GET", "live/agents", async ({ query, res }) => renderLiveAgents(query, res), "Get live agents");
+    router.add("HEAD", "live/agents", async ({ query, res }) => renderLiveAgents(query, res), "Get live agents (HEAD)");
+    async function renderLiveInitiatives(query, res) {
+        try {
+            const id = query.get("id");
+            const limit = query.get("limit") ? Number(query.get("limit")) : undefined;
+            const data = await deps.getLiveInitiatives({
+                id,
+                limit: Number.isFinite(limit) ? limit : undefined,
+            });
+            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 = deps.pickString(row, ["id"]);
+                    if (!initiativeId)
+                        return entry;
+                    const override = deps.localInitiativeStatusOverrides.get(initiativeId) ?? null;
+                    if (!override)
+                        return entry;
+                    return {
+                        ...row,
+                        status: override.status,
+                        updatedAt: deps.pickString(row, ["updatedAt", "updated_at"]) ?? override.updatedAt,
+                    };
+                })
+                : payload.initiatives;
+            deps.sendJson(res, 200, {
+                ...payload,
+                initiatives,
+            });
+        }
+        catch (err) {
+            try {
+                const id = query.get("id");
+                const limitRaw = query.get("limit") ? Number(query.get("limit")) : undefined;
+                const limit = Number.isFinite(limitRaw) ? Math.max(1, Number(limitRaw)) : 100;
+                const local = deps.toLocalLiveInitiatives(await deps.loadLocalOpenClawSnapshot(240));
+                let initiatives = local.initiatives;
+                if (id && id.trim().length > 0) {
+                    initiatives = initiatives.filter((item) => item.id === id);
+                }
+                initiatives = initiatives.map((item) => {
+                    const override = deps.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 = deps.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 deps.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,
+                        });
+                    }
+                }
+                deps.sendJson(res, 200, {
+                    initiatives: initiatives.slice(0, limit),
+                    total: initiatives.length,
+                    localFallback: true,
+                    warning: deps.safeErrorMessage(err),
+                });
+            }
+            catch (localErr) {
+                deps.sendJson(res, 500, {
+                    error: deps.safeErrorMessage(err),
+                    localFallbackError: deps.safeErrorMessage(localErr),
+                });
+            }
+        }
+    }
+    router.add("GET", "live/initiatives", async ({ query, res }) => renderLiveInitiatives(query, res), "Get live initiatives");
+    router.add("HEAD", "live/initiatives", async ({ query, res }) => renderLiveInitiatives(query, res), "Get live initiatives (HEAD)");
+    async function renderLiveDecisions(query, res) {
+        try {
+            const status = query.get("status") ?? "pending";
+            const limit = query.get("limit") ? Number(query.get("limit")) : 100;
+            const data = await deps.getLiveDecisions({
+                status,
+                limit: Number.isFinite(limit) ? limit : 100,
+            });
+            const decisions = data.decisions
+                .map(deps.mapDecisionEntity)
+                .sort((a, b) => b.waitingMinutes - a.waitingMinutes);
+            deps.sendJson(res, 200, {
+                decisions,
+                total: data.total,
+            });
+        }
+        catch {
+            deps.sendJson(res, 200, {
+                decisions: [],
+                total: 0,
+            });
+        }
+    }
+    router.add("GET", "live/decisions", async ({ query, res }) => renderLiveDecisions(query, res), "Get live decisions");
+    router.add("HEAD", "live/decisions", async ({ query, res }) => renderLiveDecisions(query, res), "Get live decisions (HEAD)");
+    async function renderHandoffs(res) {
+        try {
+            const data = await deps.getHandoffs();
+            deps.sendJson(res, 200, data);
+        }
+        catch {
+            deps.sendJson(res, 200, { handoffs: [] });
+        }
+    }
+    router.add("GET", "handoffs", async ({ res }) => renderHandoffs(res), "Get handoffs");
+    router.add("HEAD", "handoffs", async ({ res }) => renderHandoffs(res), "Get handoffs (HEAD)");
+}

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

@@ -0,0 +1,90 @@
+import type { HandoffSummary, LiveActivityItem, SessionTreeResponse } from "../../types.js";
+import type { RuntimeInstanceRecord } from "../../runtime-instance-store.js";
+import type { OutboxSummary } from "../../outbox.js";
+import type { AgentLaunchContext, RunLaunchContext } from "../../agent-context-store.js";
+import type { Router } from "../router.js";
+type LocalSnapshot = Awaited<ReturnType<typeof import("../../local-openclaw.js").loadLocalOpenClawSnapshot>>;
+type AgentContextState = {
+    agents: Record<string, AgentLaunchContext>;
+    runs?: Record<string, RunLaunchContext>;
+};
+type SnapshotPersistState = {
+    lastFingerprint: string;
+    lastPersistAt: number;
+};
+type LiveSnapshotRoutesDeps<TRes> = {
+    parsePositiveInt: (raw: string | null, fallback: number) => number;
+    readSnapshotResponseCache: (key: string) => Record<string, unknown> | null;
+    writeSnapshotResponseCache: (key: string, payload: Record<string, unknown>) => void;
+    safeErrorMessage: (err: unknown) => string;
+    readAgentContexts: () => AgentContextState;
+    getScopedAgentIds: (contexts: Record<string, AgentLaunchContext>) => Set<string>;
+    readDiagnosticsOutboxStatus: () => Promise<Record<string, unknown> | null>;
+    readOutboxSummary: () => Promise<OutboxSummary>;
+    readOutboxItems: () => Promise<LiveActivityItem[]>;
+    loadLocalOpenClawSnapshot: (limit: number) => Promise<LocalSnapshot>;
+    toLocalSessionTree: (snapshot: LocalSnapshot, limit?: number) => SessionTreeResponse;
+    toLocalLiveActivity: (snapshot: LocalSnapshot, limit?: number) => Promise<{
+        activities: LiveActivityItem[];
+        total: number;
+    }>;
+    toLocalLiveAgents: (snapshot: LocalSnapshot) => {
+        agents: Array<{
+            initiativeId: string | null;
+            status: string;
+        } & Record<string, unknown>>;
+    };
+    getLiveSessions: (input: {
+        initiative: string | null;
+        limit: number;
+    }) => Promise<SessionTreeResponse>;
+    getLiveActivity: (input: {
+        run: string | null;
+        since: string | null;
+        limit: number;
+    }) => Promise<{
+        activities: LiveActivityItem[];
+    }>;
+    getHandoffs: () => Promise<{
+        handoffs: HandoffSummary[];
+    }>;
+    getLiveDecisions: (input: {
+        status: string;
+        limit: number;
+    }) => Promise<{
+        decisions: unknown[];
+    }>;
+    getLiveAgents: (input: {
+        initiative: string | null;
+        includeIdle: boolean | undefined;
+    }) => Promise<{
+        agents?: unknown[];
+    }>;
+    mapDecisionEntity: (entry: unknown) => Record<string, unknown> & {
+        waitingMinutes: number;
+    };
+    applyAgentContextsToSessionTree: (input: SessionTreeResponse, contexts: {
+        agents: Record<string, AgentLaunchContext>;
+        runs: Record<string, RunLaunchContext>;
+    }) => SessionTreeResponse;
+    applyAgentContextsToActivity: (input: LiveActivityItem[], contexts: {
+        agents: Record<string, AgentLaunchContext>;
+        runs: Record<string, RunLaunchContext>;
+    }) => LiveActivityItem[];
+    mergeSessionTrees: (base: SessionTreeResponse, extra: SessionTreeResponse) => SessionTreeResponse;
+    mergeActivities: (base: LiveActivityItem[], extra: LiveActivityItem[], limit: number) => LiveActivityItem[];
+    listRuntimeInstances: (input: {
+        limit: number;
+    }) => RuntimeInstanceRecord[];
+    injectRuntimeInstancesAsSessions: (input: SessionTreeResponse, instances: RuntimeInstanceRecord[]) => SessionTreeResponse;
+    enrichSessionsWithRuntime: (input: SessionTreeResponse, instances: RuntimeInstanceRecord[]) => SessionTreeResponse;
+    enrichActivityWithRuntime: (input: LiveActivityItem[], instances: RuntimeInstanceRecord[]) => LiveActivityItem[];
+    snapshotActivityFingerprint: (items: LiveActivityItem[]) => string;
+    appendActivityItems: (items: LiveActivityItem[]) => void;
+    snapshotActivityPersistMinIntervalMs: number;
+    readSnapshotPersistState: () => SnapshotPersistState;
+    writeSnapshotPersistState: (state: SnapshotPersistState) => void;
+    sendJson: (res: TRes, status: number, payload: unknown) => void;
+};
+export declare function registerLiveSnapshotRoutes<TReq, TRes>(router: Router<Record<string, never>, TReq, TRes>, deps: LiveSnapshotRoutesDeps<TRes>): void;
+export {};

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

@@ -0,0 +1,297 @@
+function outboxStatusFromSummary(summary) {
+    return {
+        pendingTotal: summary.pendingTotal,
+        pendingByQueue: summary.pendingByQueue,
+        oldestEventAt: summary.oldestEventAt,
+        newestEventAt: summary.newestEventAt,
+        replayStatus: "idle",
+        lastReplayAttemptAt: null,
+        lastReplaySuccessAt: null,
+        lastReplayFailureAt: null,
+        lastReplayError: null,
+    };
+}
+function emptyOutboxStatus() {
+    return {
+        pendingTotal: 0,
+        pendingByQueue: {},
+        oldestEventAt: null,
+        newestEventAt: null,
+        replayStatus: "idle",
+        lastReplayAttemptAt: null,
+        lastReplaySuccessAt: null,
+        lastReplayFailureAt: null,
+        lastReplayError: null,
+    };
+}
+function filterSessionsByInitiative(sessions, initiative) {
+    if (!initiative || initiative.trim().length === 0)
+        return sessions;
+    const filteredNodes = sessions.nodes.filter((node) => node.initiativeId === initiative || node.groupId === initiative);
+    const filteredIds = new Set(filteredNodes.map((node) => node.id));
+    const filteredGroupIds = new Set(filteredNodes.map((node) => node.groupId));
+    return {
+        nodes: filteredNodes,
+        edges: sessions.edges.filter((edge) => filteredIds.has(edge.parentId) && filteredIds.has(edge.childId)),
+        groups: sessions.groups.filter((group) => filteredGroupIds.has(group.id)),
+    };
+}
+function maybeFilterActivity(items, input) {
+    let filtered = items;
+    if (input.run && input.run.trim().length > 0) {
+        filtered = filtered.filter((item) => item.runId === input.run);
+    }
+    if (input.since && input.since.trim().length > 0) {
+        const sinceEpoch = Date.parse(input.since);
+        if (Number.isFinite(sinceEpoch)) {
+            filtered = filtered.filter((item) => Date.parse(item.timestamp) >= sinceEpoch);
+        }
+    }
+    return filtered;
+}
+export function registerLiveSnapshotRoutes(router, deps) {
+    async function renderSnapshot(path, query, res) {
+        const sessionsLimit = deps.parsePositiveInt(query.get("sessionsLimit") ?? query.get("sessions_limit"), 320);
+        const activityLimit = deps.parsePositiveInt(query.get("activityLimit") ?? query.get("activity_limit"), 600);
+        const decisionsLimit = deps.parsePositiveInt(query.get("decisionsLimit") ?? query.get("decisions_limit"), 120);
+        const initiative = query.get("initiative");
+        const run = query.get("run");
+        const since = query.get("since");
+        const decisionStatus = query.get("status") ?? "pending";
+        const includeIdleRaw = query.get("include_idle");
+        const includeIdle = includeIdleRaw === null ? undefined : includeIdleRaw !== "false";
+        const snapshotCacheKey = `${path}?${query.toString()}`;
+        const cachedSnapshot = deps.readSnapshotResponseCache(snapshotCacheKey);
+        if (cachedSnapshot) {
+            deps.sendJson(res, 200, cachedSnapshot);
+            return;
+        }
+        const degraded = [];
+        const contextStore = deps.readAgentContexts();
+        const agentContexts = contextStore.agents;
+        const runContexts = contextStore.runs ?? {};
+        const scopedAgentIds = deps.getScopedAgentIds(agentContexts);
+        let outboxStatus;
+        try {
+            const diagnosticsOutbox = await deps.readDiagnosticsOutboxStatus();
+            if (diagnosticsOutbox) {
+                outboxStatus = diagnosticsOutbox;
+            }
+            else {
+                outboxStatus = outboxStatusFromSummary(await deps.readOutboxSummary());
+            }
+        }
+        catch (err) {
+            degraded.push(`outbox status unavailable (${deps.safeErrorMessage(err)})`);
+            outboxStatus = emptyOutboxStatus();
+        }
+        let localSnapshot = null;
+        const ensureLocalSnapshot = async (minimumLimit) => {
+            if (!localSnapshot || localSnapshot.sessions.length < minimumLimit) {
+                localSnapshot = await deps.loadLocalOpenClawSnapshot(minimumLimit);
+            }
+            return localSnapshot;
+        };
+        const settled = await Promise.allSettled([
+            deps.getLiveSessions({
+                initiative,
+                limit: sessionsLimit,
+            }),
+            deps.getLiveActivity({
+                run,
+                since,
+                limit: activityLimit,
+            }),
+            deps.getHandoffs(),
+            deps.getLiveDecisions({
+                status: decisionStatus,
+                limit: decisionsLimit,
+            }),
+            deps.getLiveAgents({
+                initiative,
+                includeIdle,
+            }),
+        ]);
+        let sessions = {
+            nodes: [],
+            edges: [],
+            groups: [],
+        };
+        const sessionsResult = settled[0];
+        if (sessionsResult.status === "fulfilled") {
+            sessions = sessionsResult.value;
+        }
+        else {
+            degraded.push(`sessions unavailable (${deps.safeErrorMessage(sessionsResult.reason)})`);
+            try {
+                let local = deps.toLocalSessionTree(await ensureLocalSnapshot(Math.max(sessionsLimit, 200)), sessionsLimit);
+                local = deps.applyAgentContextsToSessionTree(local, {
+                    agents: agentContexts,
+                    runs: runContexts,
+                });
+                sessions = filterSessionsByInitiative(local, initiative);
+            }
+            catch (localErr) {
+                degraded.push(`sessions local fallback failed (${deps.safeErrorMessage(localErr)})`);
+            }
+        }
+        let activity = [];
+        const activityResult = settled[1];
+        if (activityResult.status === "fulfilled") {
+            activity = Array.isArray(activityResult.value.activities)
+                ? activityResult.value.activities
+                : [];
+        }
+        else {
+            degraded.push(`activity unavailable (${deps.safeErrorMessage(activityResult.reason)})`);
+            try {
+                const local = await deps.toLocalLiveActivity(await ensureLocalSnapshot(Math.max(activityLimit, 240)), Math.max(activityLimit, 240));
+                const filtered = maybeFilterActivity(local.activities, { run, since });
+                const withContexts = deps.applyAgentContextsToActivity(filtered, {
+                    agents: agentContexts,
+                    runs: runContexts,
+                });
+                activity = withContexts.slice(0, activityLimit);
+            }
+            catch (localErr) {
+                degraded.push(`activity local fallback failed (${deps.safeErrorMessage(localErr)})`);
+            }
+        }
+        let handoffs = [];
+        const handoffsResult = settled[2];
+        if (handoffsResult.status === "fulfilled") {
+            handoffs = Array.isArray(handoffsResult.value.handoffs)
+                ? handoffsResult.value.handoffs
+                : [];
+        }
+        else {
+            degraded.push(`handoffs unavailable (${deps.safeErrorMessage(handoffsResult.reason)})`);
+        }
+        let decisions = [];
+        const decisionsResult = settled[3];
+        if (decisionsResult.status === "fulfilled") {
+            decisions = decisionsResult.value.decisions
+                .map(deps.mapDecisionEntity)
+                .sort((a, b) => b.waitingMinutes - a.waitingMinutes);
+        }
+        else {
+            degraded.push(`decisions unavailable (${deps.safeErrorMessage(decisionsResult.reason)})`);
+        }
+        let agents = [];
+        const agentsResult = settled[4];
+        if (agentsResult.status === "fulfilled") {
+            agents = Array.isArray(agentsResult.value.agents)
+                ? agentsResult.value.agents
+                : [];
+        }
+        else {
+            degraded.push(`agents unavailable (${deps.safeErrorMessage(agentsResult.reason)})`);
+            try {
+                const local = deps.toLocalLiveAgents(await ensureLocalSnapshot(Math.max(sessionsLimit, 240)));
+                let localAgents = local.agents;
+                if (initiative && initiative.trim().length > 0) {
+                    localAgents = localAgents.filter((agent) => agent.initiativeId === initiative);
+                }
+                if (includeIdle === false) {
+                    localAgents = localAgents.filter((agent) => agent.status !== "idle");
+                }
+                agents = localAgents;
+            }
+            catch (localErr) {
+                degraded.push(`agents local fallback failed (${deps.safeErrorMessage(localErr)})`);
+            }
+        }
+        if (scopedAgentIds.size > 0) {
+            try {
+                const minimum = Math.max(Math.max(sessionsLimit, activityLimit), 240);
+                const snapshot = await ensureLocalSnapshot(minimum);
+                const scopedSnapshot = {
+                    ...snapshot,
+                    sessions: snapshot.sessions.filter((session) => Boolean(session.agentId && scopedAgentIds.has(session.agentId))),
+                    agents: snapshot.agents.filter((agent) => scopedAgentIds.has(agent.id)),
+                };
+                let localSessions = deps.applyAgentContextsToSessionTree(deps.toLocalSessionTree(scopedSnapshot, sessionsLimit), { agents: agentContexts, runs: runContexts });
+                localSessions = filterSessionsByInitiative(localSessions, initiative);
+                sessions = deps.mergeSessionTrees(sessions, localSessions);
+                const localActivity = await deps.toLocalLiveActivity(scopedSnapshot, Math.max(activityLimit, 240));
+                let localItems = deps.applyAgentContextsToActivity(localActivity.activities, {
+                    agents: agentContexts,
+                    runs: runContexts,
+                });
+                localItems = maybeFilterActivity(localItems, { run, since });
+                activity = deps.mergeActivities(activity, localItems, activityLimit);
+            }
+            catch (err) {
+                degraded.push(`local agent merge failed (${deps.safeErrorMessage(err)})`);
+            }
+        }
+        try {
+            const buffered = await deps.readOutboxItems();
+            if (buffered.length > 0) {
+                const merged = [...activity, ...buffered]
+                    .sort((a, b) => Date.parse(b.timestamp) - Date.parse(a.timestamp))
+                    .slice(0, activityLimit);
+                const deduped = [];
+                const seen = new Set();
+                for (const item of merged) {
+                    if (seen.has(item.id))
+                        continue;
+                    seen.add(item.id);
+                    deduped.push(item);
+                }
+                activity = deduped;
+            }
+        }
+        catch (err) {
+            degraded.push(`outbox unavailable (${deps.safeErrorMessage(err)})`);
+        }
+        let runtimeInstances = deps.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 = deps.injectRuntimeInstancesAsSessions(sessions, runtimeInstances);
+        sessions = deps.enrichSessionsWithRuntime(sessions, runtimeInstances);
+        activity = deps.enrichActivityWithRuntime(activity, runtimeInstances);
+        activity = deps.applyAgentContextsToActivity(activity, {
+            agents: agentContexts,
+            runs: runContexts,
+        });
+        try {
+            const fingerprint = deps.snapshotActivityFingerprint(activity);
+            const now = Date.now();
+            const persistState = deps.readSnapshotPersistState();
+            const shouldPersist = fingerprint !== persistState.lastFingerprint ||
+                now - persistState.lastPersistAt >= deps.snapshotActivityPersistMinIntervalMs;
+            if (shouldPersist) {
+                deps.appendActivityItems(activity);
+                deps.writeSnapshotPersistState({
+                    lastFingerprint: fingerprint,
+                    lastPersistAt: now,
+                });
+            }
+        }
+        catch {
+            // best effort
+        }
+        const payload = {
+            sessions,
+            activity,
+            handoffs,
+            decisions,
+            agents,
+            runtimeInstances,
+            outbox: outboxStatus,
+            generatedAt: new Date().toISOString(),
+            degraded: degraded.length > 0 ? degraded : undefined,
+        };
+        deps.writeSnapshotResponseCache(snapshotCacheKey, payload);
+        deps.sendJson(res, 200, payload);
+    }
+    router.add("GET", "dashboard-bundle", async ({ path, query, res }) => renderSnapshot(path, query, res), "Live dashboard bundle");
+    router.add("HEAD", "dashboard-bundle", async ({ path, query, res }) => renderSnapshot(path, query, res), "Live dashboard bundle (HEAD)");
+    router.add("GET", "live/snapshot", async ({ path, query, res }) => renderSnapshot(path, query, res), "Live snapshot");
+    router.add("HEAD", "live/snapshot", async ({ path, query, res }) => renderSnapshot(path, query, res), "Live snapshot (HEAD)");
+}

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

@@ -0,0 +1,83 @@
+import type { Router } from "../router.js";
+type JsonRecord = Record<string, unknown>;
+type AutoContinueRunRecord = Record<string, any> & {
+    activeRunId?: string | null;
+    stopReason?: string | null;
+    status?: string;
+    stopRequested?: boolean;
+    updatedAt?: string;
+};
+type NextUpQueue = {
+    items: Array<{
+        workstreamId: string;
+        runnerAgentId?: string | null;
+        runnerAgentName?: string | null;
+        runnerSource?: string | null;
+        initiativeTitle?: string | null;
+        workstreamTitle?: string | null;
+        nextTaskId?: string | null;
+        nextTaskTitle?: string | null;
+    }>;
+    degraded: string[];
+};
+type RegisterMissionControlActionsRoutesDeps<TReq, TRes> = {
+    parseJsonRequest: (req: TReq) => Promise<JsonRecord>;
+    pickString: (input: Record<string, unknown>, keys: string[]) => string | null;
+    pickNumber: (input: Record<string, unknown>, keys: string[]) => number | null;
+    parseBooleanQuery: (value: string | null) => boolean | null;
+    pickStringArray: (input: Record<string, unknown>, keys: string[]) => string[];
+    dedupeStrings: (values: string[]) => string[];
+    resolveAgentDisplayName: (agentId: string, fallbackName: string | null) => Promise<string | null>;
+    buildNextUpQueue: (input: {
+        initiativeId: string;
+    }) => Promise<NextUpQueue>;
+    startAutoContinueRun: (input: any) => Promise<AutoContinueRunRecord>;
+    autoContinueRuns: Map<string, any>;
+    autoContinueSliceRuns: Map<string, any>;
+    dispatchFallbackWorkstreamTurn: (input: any) => Promise<{
+        sessionId: string | null;
+        pid: number | null;
+        blockedReason: string | null;
+        retryable: boolean;
+        executionPolicy: {
+            domain: string;
+            requiredSkills: string[];
+        };
+        spawnGuardResult: unknown | null;
+    }>;
+    tickAutoContinueRun: (run: any) => Promise<void>;
+    stopAutoContinueRun: (input: any) => Promise<void>;
+    updateInitiativeAutoContinueState: (input: any) => Promise<void>;
+    tickAllAutoContinue: () => Promise<void>;
+    upsertNextUpQueuePin: (input: {
+        initiativeId: string;
+        workstreamId: string;
+        preferredTaskId: string | null;
+        preferredMilestoneId: string | null;
+    }) => {
+        pins: unknown[];
+        updatedAt: string;
+    };
+    removeNextUpQueuePin: (input: {
+        initiativeId: string;
+        workstreamId: string;
+    }) => {
+        pins: unknown[];
+        updatedAt: string;
+    };
+    setNextUpQueuePinOrder: (input: {
+        order: Array<{
+            initiativeId: string;
+            workstreamId: string;
+        }>;
+    }) => {
+        pins: unknown[];
+        updatedAt: string;
+    };
+    resolveAutoAssignments: (input: any) => Promise<unknown>;
+    client: any;
+    sendJson: (res: TRes, status: number, payload: unknown) => void;
+    safeErrorMessage: (err: unknown) => string;
+};
+export declare function registerMissionControlActionsRoutes<TReq, TRes>(router: Router<Record<string, never>, TReq, TRes>, deps: RegisterMissionControlActionsRoutesDeps<TReq, TRes>): void;
+export {};