@useorgx/openclaw-plugin 0.7.15 → 0.7.16

package/dist/http/helpers/auto-continue-engine.d.ts

@@ -485,6 +485,21 @@ export declare function createAutoContinueEngine(deps: CreateAutoContinueEngineD
         activeRunId: string | null;
         activeTaskTokenEstimate: number | null;
     }>;
+    skipCurrentWorkstream: (initiativeId: string, workstreamId: string, reason?: string) => Promise<{
+        ok: boolean;
+        skippedWorkstreamId: string;
+        nextWorkstreamId?: string;
+        nextWorkstreamTitle?: string;
+    }>;
+    getCanonicalAutopilotState: (initiativeId: string) => {
+        state: "idle" | "running" | "blocked" | "stopping";
+        reason: string | null;
+        activeRunId: string | null;
+        activeWorkstreamId: string | null;
+        activeWorkstreamTitle: string | null;
+        queueHeadTitle: string | null;
+        lastTransitionAt: string;
+    } | null;
     workstreamSessionStore: Map<string, {
         sessionId: string;
         workstreamId: string;

package/dist/http/helpers/auto-continue-engine.js

@@ -1554,6 +1554,20 @@ export function createAutoContinueEngine(deps) {
                 decision_count: decisionIds.length,
                 last_error: input.run.lastError,
                 error_location: errorLocation,
+                ...(input.reason === "blocked" || input.reason === "error"
+                    ? {
+                        blocker: {
+                            kind: decisionRequired ? "decision_required" : "error",
+                            summary: input.error ?? input.run.lastError ?? "Execution blocked",
+                            required_actor: decisionRequired ? "user" : "system",
+                            required_action: decisionRequired
+                                ? "Resolve the pending decision in Decisions panel"
+                                : "Review the error and retry",
+                            can_skip: true,
+                            skip_route: "/orgx/api/autopilot/skip",
+                        },
+                    }
+                    : {}),
             },
         });
         // Emit autopilot_transition event for state observers.
@@ -2278,12 +2292,53 @@ export function createAutoContinueEngine(deps) {
                             ...mockMeta(slice),
                             user_summary: userSummary,
                             next_actions: nextActions,
+                            outcomes: {
+                                pr_url: typeof parsed?.pr_url === "string" ? parsed.pr_url : null,
+                                pr_number: typeof parsed?.pr_number === "number" ? parsed.pr_number : null,
+                                commit_sha: typeof parsed?.commit_sha === "string" ? parsed.commit_sha : null,
+                                commit_url: typeof parsed?.commit_url === "string" ? parsed.commit_url : null,
+                                tests: null,
+                                artifact_ids: artifacts.map((a) => a.name).filter(Boolean),
+                                task_updates: taskUpdates?.length ?? 0,
+                            },
                         },
                     });
                 }
                 catch {
                     // best effort
                 }
+                // Emit explicit session completion event for canonical agent panel state
+                if (slice.status === "completed" || reportedParsedStatus === "completed") {
+                    await emitActivitySafe({
+                        initiativeId: run.initiativeId,
+                        runId: slice.runId,
+                        correlationId: slice.runId,
+                        phase: "completed",
+                        level: "info",
+                        message: userSummary ?? `Completed work on ${slice.workstreamTitle ?? "task"}`,
+                        metadata: {
+                            ...buildSliceEnrichment({
+                                run,
+                                slice,
+                                workstreamId: slice.workstreamId,
+                                workstreamTitle: slice.workstreamTitle ?? null,
+                                domain: slice.domain,
+                                requiredSkills: slice.requiredSkills,
+                                userSummary,
+                                event: "session_completed",
+                            }),
+                            session_id: slice.cliSessionId ?? null,
+                            source_client: slice.sourceClient,
+                            workstream_title: slice.workstreamTitle ?? null,
+                            task_title: slice.workstreamTitle ?? slice.workstreamId,
+                            duration_ms: slice.finishedAt
+                                ? new Date(slice.finishedAt).getTime() - new Date(slice.startedAt).getTime()
+                                : null,
+                            outcome: reportedParsedStatus ?? slice.status,
+                            artifacts_produced: artifacts.length,
+                        },
+                    });
+                }
                 if (slice.status === "completed") {
                     await emitActivitySafe({
                         initiativeId: run.initiativeId,
@@ -2754,8 +2809,11 @@ export function createAutoContinueEngine(deps) {
         };
         // Select the next eligible workstream by scanning ordered todos.
         let selectedWorkstreamId = null;
+        let selectedQueueRank = 0;
         let deferredBySpawnGuardRateLimit = 0;
+        let queueScanIndex = 0;
         for (const taskId of graph.recentTodos) {
+            queueScanIndex++;
             const node = nodeById.get(taskId);
             if (!node || node.type !== "task")
                 continue;
@@ -2797,6 +2855,7 @@ export function createAutoContinueEngine(deps) {
                 continue;
             }
             selectedWorkstreamId = node.workstreamId;
+            selectedQueueRank = queueScanIndex + 1;
             break;
         }
         if (!selectedWorkstreamId) {
@@ -3675,6 +3734,10 @@ export function createAutoContinueEngine(deps) {
                     scope_milestone_ids: slice.scopeMilestoneIds,
                     log_path: logPath,
                     output_path: outputPath,
+                    dispatch_queue_rank: selectedQueueRank > 0 ? selectedQueueRank : null,
+                    dispatch_workstream_title: workstreamTitle ?? null,
+                    dispatch_task_title: primaryTask.title ?? null,
+                    dispatch_selection_reason: "top_of_queue",
                     ...mockMeta(slice),
                 },
             });
@@ -3714,6 +3777,10 @@ export function createAutoContinueEngine(deps) {
                 scope_milestone_ids: slice.scopeMilestoneIds,
                 log_path: logPath,
                 output_path: outputPath,
+                dispatch_queue_rank: selectedQueueRank > 0 ? selectedQueueRank : null,
+                dispatch_workstream_title: workstreamTitle ?? null,
+                dispatch_task_title: primaryTask.title ?? null,
+                dispatch_selection_reason: "top_of_queue",
                 ...mockMeta(slice),
             },
         });
@@ -4286,6 +4353,102 @@ export function createAutoContinueEngine(deps) {
         }
         return run;
     }
+    async function skipCurrentWorkstream(initiativeId, workstreamId, reason) {
+        const run = autoContinueRuns.get(initiativeId) ?? null;
+        if (!run) {
+            return { ok: false, skippedWorkstreamId: workstreamId };
+        }
+        ensureRunInternals(run);
+        if (!run.blockedWorkstreamIds.includes(workstreamId)) {
+            run.blockedWorkstreamIds.push(workstreamId);
+        }
+        setLaneState(run, {
+            workstreamId,
+            state: LaneState.BLOCKED,
+            activeRunId: null,
+            activeTaskIds: [],
+            blockedReason: reason ?? "Skipped by user",
+            waitingOnWorkstreamIds: [],
+            retryAt: null,
+        });
+        run.updatedAt = new Date().toISOString();
+        try {
+            await emitActivitySafe({
+                initiativeId,
+                runId: run.lastRunId ?? undefined,
+                correlationId: run.lastRunId ?? undefined,
+                phase: "review",
+                level: "info",
+                message: `Workstream ${workstreamId} skipped${reason ? `: ${reason}` : ""}.`,
+                metadata: {
+                    ...buildSliceEnrichment({
+                        run,
+                        workstreamId,
+                        event: "autopilot_item_skipped",
+                    }),
+                    skipped_workstream_id: workstreamId,
+                    skip_reason: reason ?? null,
+                },
+            });
+        }
+        catch {
+            // best effort
+        }
+        // Re-enable the run if it was stopped due to the blocked workstream.
+        if (run.status === RunStatus.STOPPED && run.stopReason === "blocked") {
+            run.status = RunStatus.RUNNING;
+            run.stopReason = null;
+            run.stoppedAt = null;
+            run.stopRequested = false;
+            run.lastError = null;
+        }
+        // Trigger the next tick to pick up a different workstream.
+        try {
+            await tickAutoContinueRun(run);
+        }
+        catch {
+            // best effort
+        }
+        // Determine what the next workstream is, if any.
+        const nextLane = Object.values(run.laneByWorkstreamId ?? {}).find((lane) => lane.state === LaneState.RUNNING && lane.workstreamId !== workstreamId) ?? null;
+        return {
+            ok: true,
+            skippedWorkstreamId: workstreamId,
+            nextWorkstreamId: nextLane?.workstreamId ?? undefined,
+            nextWorkstreamTitle: undefined,
+        };
+    }
+    function getCanonicalAutopilotState(initiativeId) {
+        const run = autoContinueRuns.get(initiativeId) ?? null;
+        if (!run)
+            return null;
+        const canonicalState = run.status === RunStatus.RUNNING
+            ? "running"
+            : run.status === RunStatus.STOPPING
+                ? "stopping"
+                : run.stopReason === "blocked" || run.stopReason === "error"
+                    ? "blocked"
+                    : "idle";
+        const reason = canonicalState === "blocked"
+            ? run.lastError ?? run.stopReason ?? null
+            : canonicalState === "stopping"
+                ? "stop_requested"
+                : null;
+        // Find the first active slice to identify the current workstream.
+        const activeSliceRunId = (run.activeSliceRunIds ?? [])[0] ?? run.activeRunId ?? null;
+        const activeSlice = activeSliceRunId
+            ? autoContinueSliceRuns.get(activeSliceRunId) ?? null
+            : null;
+        return {
+            state: canonicalState,
+            reason,
+            activeRunId: activeSliceRunId,
+            activeWorkstreamId: activeSlice?.workstreamId ?? null,
+            activeWorkstreamTitle: activeSlice?.workstreamTitle ?? null,
+            queueHeadTitle: activeSlice?.workstreamTitle ?? null,
+            lastTransitionAt: run.updatedAt ?? run.startedAt,
+        };
+    }
     return {
         autoContinueRuns,
         autoContinueSliceRuns,
@@ -4307,6 +4470,8 @@ export function createAutoContinueEngine(deps) {
         getAutoContinueLaneForWorkstream,
         scheduleAutoFixForWorkstream,
         startAutoContinueRun,
+        skipCurrentWorkstream,
+        getCanonicalAutopilotState,
         // Session store (for resume support)
         workstreamSessionStore,
         getWorkstreamSession,

package/dist/http/helpers/mission-control.d.ts

@@ -87,7 +87,10 @@ export declare const DEFAULT_TOKEN_BUDGET_ASSUMPTIONS: {
 export declare function pickStringArray(record: Record<string, unknown>, keys: string[]): string[];
 export declare function dedupeStrings(items: string[]): string[];
 export declare function isTodoStatus(status: string): boolean;
+export declare function isPausedStatus(status: string): boolean;
+export declare function isBlockedStatus(status: string): boolean;
 export declare function isInProgressStatus(status: string): boolean;
+export declare function deriveInitiativeLifecycleStatus(currentStatus: string, childStatuses: string[]): string;
 export declare function isDispatchableWorkstreamStatus(status: string): boolean;
 export declare function isDoneStatus(status: string): boolean;
 export declare function listEntitiesSafe(client: OrgXClient, type: MissionControlNodeType, filters: Record<string, unknown>): Promise<{

package/dist/http/helpers/mission-control.js

@@ -637,6 +637,18 @@ export function isTodoStatus(status) {
         normalized === "backlog" ||
         normalized === "pending");
 }
+export function isPausedStatus(status) {
+    const normalized = status.toLowerCase();
+    return (normalized === "paused" ||
+        normalized === "idle" ||
+        normalized === "hold" ||
+        normalized === "on_hold" ||
+        normalized === "waiting");
+}
+export function isBlockedStatus(status) {
+    const normalized = status.toLowerCase();
+    return normalized === "blocked" || normalized === "at_risk" || normalized === "needs_input";
+}
 export function isInProgressStatus(status) {
     const normalized = status.toLowerCase();
     return (normalized === "in_progress" ||
@@ -644,6 +656,30 @@ export function isInProgressStatus(status) {
         normalized === "running" ||
         normalized === "queued");
 }
+export function deriveInitiativeLifecycleStatus(currentStatus, childStatuses) {
+    const normalizedCurrent = currentStatus.toLowerCase();
+    if (!childStatuses.length)
+        return currentStatus;
+    const hasInProgressChildren = childStatuses.some((status) => isInProgressStatus(status));
+    const hasRemainingChildren = childStatuses.some((status) => !isDoneStatus(status));
+    const hasBlockedChildren = childStatuses.some((status) => isBlockedStatus(status));
+    const hasPausedChildren = childStatuses.some((status) => isPausedStatus(status));
+    const hasTodoChildren = childStatuses.some((status) => isTodoStatus(status));
+    const isActiveLikeCurrent = normalizedCurrent === "active" ||
+        normalizedCurrent === "running" ||
+        normalizedCurrent === "in_progress" ||
+        normalizedCurrent === "queued";
+    if (!hasInProgressChildren && isActiveLikeCurrent && hasRemainingChildren) {
+        if (hasBlockedChildren && !hasPausedChildren && !hasTodoChildren) {
+            return "blocked";
+        }
+        return "paused";
+    }
+    if (hasInProgressChildren && (normalizedCurrent === "paused" || normalizedCurrent === "idle")) {
+        return "active";
+    }
+    return currentStatus;
+}
 export function isDispatchableWorkstreamStatus(status) {
     const normalized = status.toLowerCase();
     if (!normalized)
@@ -889,13 +925,8 @@ export async function buildMissionControlGraph(client, initiativeId, options) {
         }
     }
     const taskNodesOnly = nodes.filter((node) => node.type === "task");
-    const hasActiveTasks = taskNodesOnly.some((node) => isInProgressStatus(node.status));
-    const hasTodoTasks = taskNodesOnly.some((node) => isTodoStatus(node.status));
-    if (initiativeNode.status.toLowerCase() === "active" &&
-        !hasActiveTasks &&
-        hasTodoTasks) {
-        initiativeNode.status = "paused";
-    }
+    const lifecycleChildren = taskNodesOnly.length > 0 ? taskNodesOnly : workstreamNodes;
+    initiativeNode.status = deriveInitiativeLifecycleStatus(initiativeNode.status, lifecycleChildren.map((node) => node.status));
     const nodeById = new Map(nodes.map((node) => [node.id, node]));
     const taskIsReady = (task) => task.dependencyIds.every((depId) => {
         const dependency = nodeById.get(depId);

package/dist/http/helpers/value-utils.d.ts

@@ -2,5 +2,5 @@ export declare function pickString(record: Record<string, unknown>, keys: string
 export declare function pickNumber(record: Record<string, unknown>, keys: string[]): number | null;
 export declare function pickHeaderString(headers: Record<string, string | string[] | undefined>, keys: string[]): string | null;
 export declare function toIsoString(value: string | null): string | null;
-export declare function parsePositiveInt(raw: string | null, fallback: number): number;
+export declare function parsePositiveInt(raw: string | null, fallback: number, max?: number): number;
 export declare function parseBooleanQuery(raw: string | null): boolean;

package/dist/http/helpers/value-utils.js

@@ -48,7 +48,7 @@ export function toIsoString(value) {
         return null;
     return new Date(parsed).toISOString();
 }
-export function parsePositiveInt(raw, fallback) {
+export function parsePositiveInt(raw, fallback, max = Number.POSITIVE_INFINITY) {
     if (!raw)
         return fallback;
     const normalized = raw.trim();
@@ -59,7 +59,10 @@ export function parsePositiveInt(raw, fallback) {
         return fallback;
     // Offset-like parameters may intentionally allow zero when fallback is zero.
     const minimum = fallback <= 0 ? 0 : 1;
-    return Math.max(minimum, Math.floor(parsed));
+    const clamped = Math.max(minimum, Math.floor(parsed));
+    if (!Number.isFinite(max))
+        return clamped;
+    return Math.min(clamped, Math.max(minimum, Math.floor(max)));
 }
 export function parseBooleanQuery(raw) {
     if (!raw)

package/dist/http/index.js

@@ -1846,7 +1846,7 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
     };
     const codexBinResolver = createCodexBinResolver();
     const resolveCodexBinInfo = () => codexBinResolver.resolveCodexBinInfo();
-    const { autoContinueRuns, autoContinueSliceRuns, localInitiativeStatusOverrides, writeRuntimeEvent, autoContinueTickMs: AUTO_CONTINUE_TICK_MS, defaultAutoContinueTokenBudget, defaultAutoContinueMaxParallelSlices, setLocalInitiativeStatusOverride, clearLocalInitiativeStatusOverride, applyLocalInitiativeOverrides, applyLocalInitiativeOverrideToGraph, updateInitiativeAutoContinueState, stopAutoContinueRun, tickAutoContinueRun, tickAllAutoContinue, isInitiativeActiveStatus, runningAutoContinueForWorkstream, getAutoContinueLaneForWorkstream, scheduleAutoFixForWorkstream, startAutoContinueRun, } = createAutoContinueEngine({
+    const { autoContinueRuns, autoContinueSliceRuns, localInitiativeStatusOverrides, writeRuntimeEvent, autoContinueTickMs: AUTO_CONTINUE_TICK_MS, defaultAutoContinueTokenBudget, defaultAutoContinueMaxParallelSlices, setLocalInitiativeStatusOverride, clearLocalInitiativeStatusOverride, applyLocalInitiativeOverrides, applyLocalInitiativeOverrideToGraph, updateInitiativeAutoContinueState, stopAutoContinueRun, tickAutoContinueRun, tickAllAutoContinue, isInitiativeActiveStatus, runningAutoContinueForWorkstream, getAutoContinueLaneForWorkstream, scheduleAutoFixForWorkstream, startAutoContinueRun, skipCurrentWorkstream, getCanonicalAutopilotState, } = createAutoContinueEngine({
         client,
         filename: __filename,
         safeErrorMessage,
@@ -3417,6 +3417,7 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
         dispatchFallbackWorkstreamTurn,
         tickAutoContinueRun,
         stopAutoContinueRun,
+        skipCurrentWorkstream,
         updateInitiativeAutoContinueState,
         tickAllAutoContinue,
         scheduleAutoFixForWorkstream,
@@ -3592,6 +3593,7 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
         },
         runAction: (runId, action, input) => client.runAction(runId, action, input),
         listChatThreads: ({ commandCenterId, initiativeId, limit, offset }) => listChatThreads({ commandCenterId, initiativeId, limit, offset }),
+        getCanonicalAutopilotState,
         sendJson,
     });
     registerRuntimeHookRoutes(apiRouter, {

package/dist/http/routes/chat.d.ts

@@ -3,7 +3,7 @@ type JsonRecord = Record<string, unknown>;
 type RegisterChatRoutesDeps<TReq, TRes> = {
     parseJsonRequest: (req: TReq) => Promise<JsonRecord>;
     pickString: (input: Record<string, unknown>, keys: string[]) => string | null;
-    parsePositiveInt: (raw: string | null, fallback: number) => number;
+    parsePositiveInt: (raw: string | null, fallback: number, max?: number) => number;
     emitActivitySafe?: (input: {
         initiativeId: string | null;
         sourceClient?: string;

package/dist/http/routes/chat.js

@@ -161,8 +161,8 @@ export function registerChatRoutes(router, deps) {
             const initiativeId = query.get("initiative_id") ?? query.get("initiative");
             const searchQuery = query.get("query") ?? query.get("q");
             const status = query.get("status");
-            const limit = deps.parsePositiveInt(query.get("limit"), 60);
-            const offset = deps.parsePositiveInt(query.get("offset"), 0);
+            const limit = deps.parsePositiveInt(query.get("limit"), 60, 200);
+            const offset = deps.parsePositiveInt(query.get("offset"), 0, 10000);
             sendThreadList(deps, res, {
                 commandCenterId: commandCenterId?.trim() ?? null,
                 initiativeId: initiativeId?.trim() ?? null,

package/dist/http/routes/entities.js

@@ -1,4 +1,5 @@
 import { resolveWorkspaceScope, workspaceScopeFromHeaders, } from "../helpers/workspace-scope.js";
+import { deriveInitiativeLifecycleStatus } from "../helpers/mission-control.js";
 const WORKSTREAM_REASSIGNMENT_FIELDS = [
     "domain",
     "role",
@@ -38,6 +39,59 @@ function toObjectArray(input) {
         return [];
     return input.filter((item) => Boolean(item) && typeof item === "object");
 }
+async function reconcileInitiativeStatusesFromWorkstreams(deps, rows, input) {
+    if (rows.length === 0)
+        return rows;
+    const initiativeIds = new Set(rows
+        .map((row) => deps.pickString(row, ["id"]))
+        .filter((value) => Boolean(value)));
+    if (initiativeIds.size === 0)
+        return rows;
+    const scopedInitiativeId = input.initiativeId?.trim() ?? "";
+    const scopedWorkspaceId = input.workspaceId?.trim() ?? "";
+    if (!scopedInitiativeId && !scopedWorkspaceId) {
+        // Avoid unscoped global workstream scans.
+        return rows;
+    }
+    const filters = { limit: 2000 };
+    if (scopedInitiativeId) {
+        filters.initiative_id = scopedInitiativeId;
+    }
+    if (scopedWorkspaceId) {
+        filters.workspace_id = scopedWorkspaceId;
+        filters.command_center_id = scopedWorkspaceId;
+    }
+    const response = await deps.client.listEntities("workstream", filters);
+    const workstreamRows = toObjectArray(response && typeof response === "object"
+        ? response.data
+        : []);
+    const childStatusesByInitiative = new Map();
+    for (const workstreamRow of workstreamRows) {
+        const initiativeId = deps.pickString(workstreamRow, ["initiative_id", "initiativeId"]);
+        if (!initiativeId || !initiativeIds.has(initiativeId))
+            continue;
+        const status = deps.pickString(workstreamRow, ["status"]) ?? "todo";
+        const statuses = childStatusesByInitiative.get(initiativeId) ?? [];
+        statuses.push(status);
+        childStatusesByInitiative.set(initiativeId, statuses);
+    }
+    return rows.map((row) => {
+        const initiativeId = deps.pickString(row, ["id"]);
+        const status = deps.pickString(row, ["status"]);
+        if (!initiativeId || !status)
+            return row;
+        const childStatuses = childStatusesByInitiative.get(initiativeId) ?? [];
+        if (childStatuses.length === 0)
+            return row;
+        const normalized = deriveInitiativeLifecycleStatus(status, childStatuses);
+        if (normalized === status)
+            return row;
+        return {
+            ...row,
+            status: normalized,
+        };
+    });
+}
 export function registerEntitiesRoutes(router, deps) {
     router.add("POST", "entities", async ({ req, res }) => {
         try {
@@ -305,13 +359,17 @@ export function registerEntitiesRoutes(router, deps) {
                         return rowScope.trim() === workspaceScopeId;
                     })
                     : searchedRows;
+                const reconciledRows = await reconcileInitiativeStatusesFromWorkstreams(deps, rows, {
+                    initiativeId: id,
+                    workspaceId: workspaceScopeId,
+                }).catch(() => rows);
                 deps.sendJson(res, 200, {
                     ...payload,
-                    data: deps.applyLocalInitiativeOverrides(rows),
+                    data: deps.applyLocalInitiativeOverrides(reconciledRows),
                     pagination: payload.pagination && typeof payload.pagination === "object"
                         ? {
                             ...payload.pagination,
-                            total: rows.length,
+                            total: reconciledRows.length,
                         }
                         : payload.pagination,
                 });

package/dist/http/routes/entity-dynamic.js

@@ -1,3 +1,51 @@
+function resolveEntityActionStatus(entityType, entityAction) {
+    const normalizedType = entityType.trim().toLowerCase();
+    const normalizedAction = entityAction.trim().toLowerCase();
+    const defaultStatusMap = {
+        start: "in_progress",
+        complete: "done",
+        block: "blocked",
+        unblock: "in_progress",
+        pause: "paused",
+        resume: "active",
+    };
+    const statusMapByEntityType = {
+        initiative: {
+            start: "active",
+            complete: "completed",
+            block: "blocked",
+            unblock: "active",
+            pause: "paused",
+            resume: "active",
+        },
+        workstream: {
+            start: "active",
+            complete: "completed",
+            block: "blocked",
+            unblock: "active",
+            pause: "paused",
+            resume: "active",
+        },
+        milestone: {
+            start: "in_progress",
+            complete: "completed",
+            block: "at_risk",
+            unblock: "in_progress",
+            pause: "planned",
+            resume: "in_progress",
+        },
+        task: {
+            start: "in_progress",
+            complete: "done",
+            block: "blocked",
+            unblock: "in_progress",
+            pause: "todo",
+            resume: "in_progress",
+        },
+    };
+    const map = statusMapByEntityType[normalizedType] ?? defaultStatusMap;
+    return map[normalizedAction] ?? null;
+}
 export function registerEntityDynamicRoutes(router, deps) {
     router.add("*", "entities/*", async ({ req, res, path }) => {
         const method = (req.method ?? "GET").toUpperCase();
@@ -137,15 +185,7 @@ export function registerEntityDynamicRoutes(router, deps) {
                     }
                     return;
                 }
-                const statusMap = {
-                    start: "in_progress",
-                    complete: "done",
-                    block: "blocked",
-                    unblock: "in_progress",
-                    pause: "paused",
-                    resume: "active",
-                };
-                const newStatus = statusMap[entityAction];
+                const newStatus = resolveEntityActionStatus(entityType, entityAction);
                 if (!newStatus) {
                     deps.sendJson(res, 400, {
                         error: `Unknown entity action: ${entityAction}`,

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

@@ -14,7 +14,7 @@ type SnapshotPersistState = {
     lastPersistAt: number;
 };
 type LiveSnapshotRoutesDeps<TReq, TRes> = {
-    parsePositiveInt: (raw: string | null, fallback: number) => number;
+    parsePositiveInt: (raw: string | null, fallback: number, max?: number) => number;
     readSnapshotResponseCache: (key: string) => Record<string, unknown> | null;
     writeSnapshotResponseCache: (key: string, payload: Record<string, unknown>) => void;
     safeErrorMessage: (err: unknown) => string;
@@ -131,6 +131,15 @@ type LiveSnapshotRoutesDeps<TReq, TRes> = {
         total: number;
         updatedAt: string;
     };
+    getCanonicalAutopilotState?: (initiativeId: string) => {
+        state: "idle" | "running" | "blocked" | "stopping";
+        reason: string | null;
+        activeRunId: string | null;
+        activeWorkstreamId: string | null;
+        activeWorkstreamTitle: string | null;
+        queueHeadTitle: string | null;
+        lastTransitionAt: string;
+    } | null;
     sendJson: (res: TRes, status: number, payload: unknown) => void;
 };
 export declare function registerLiveSnapshotRoutes<TReq, TRes>(router: Router<Record<string, never>, TReq, TRes>, deps: LiveSnapshotRoutesDeps<TReq, TRes>): void;

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

@@ -231,9 +231,9 @@ export function registerLiveSnapshotRoutes(router, deps) {
     };
     const headerScopeFromRequest = (req) => workspaceScopeFromHeaders(req?.headers);
     function parseSnapshotQuery(query, headerScope) {
-        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 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);
+        const decisionsLimit = deps.parsePositiveInt(query.get("decisionsLimit") ?? query.get("decisions_limit"), 120, 500);
         const initiative = query.get("initiative");
         const scope = resolveWorkspaceScope(query, headerScope, {
             allowProjectScope: false,
@@ -523,6 +523,14 @@ export function registerLiveSnapshotRoutes(router, deps) {
             projectId,
             degraded: degraded.length > 0 ? degraded : undefined,
         };
+        if (typeof deps.getCanonicalAutopilotState === "function" && initiative) {
+            try {
+                payload.autopilot = deps.getCanonicalAutopilotState(initiative) ?? null;
+            }
+            catch {
+                // best effort
+            }
+        }
         if (typeof deps.listChatThreads === "function") {
             try {
                 const listed = deps.listChatThreads({

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

@@ -66,6 +66,12 @@ type RegisterMissionControlActionsRoutesDeps<TReq, TRes> = {
     }>;
     tickAutoContinueRun: (run: any) => Promise<void>;
     stopAutoContinueRun: (input: any) => Promise<void>;
+    skipCurrentWorkstream: (initiativeId: string, workstreamId: string, reason?: string) => Promise<{
+        ok: boolean;
+        skippedWorkstreamId: string;
+        nextWorkstreamId?: string;
+        nextWorkstreamTitle?: string;
+    }>;
     updateInitiativeAutoContinueState: (input: any) => Promise<void>;
     tickAllAutoContinue: () => Promise<void>;
     scheduleAutoFixForWorkstream: (input: {