@useorgx/openclaw-plugin 0.4.9 → 0.7.2

package/dist/http/index.js

@@ -22,20 +22,22 @@ import { homedir } from "node:os";
 import { join, dirname, extname, normalize, resolve, relative, sep } from "node:path";
 import { fileURLToPath } from "node:url";
 import { randomUUID } from "node:crypto";
-import { readNextUpQueuePins, removeNextUpQueuePin, setNextUpQueuePinOrder, upsertNextUpQueuePin, } from "../next-up-queue-store.js";
+import { readNextUpQueuePins, removeNextUpQueuePin, setNextUpQueuePinOrder, suppressNextUpQueueItem, upsertNextUpQueuePin, } from "../next-up-queue-store.js";
 import { formatStatus, formatAgents, formatActivity, formatInitiatives, getOnboardingState, } from "../dashboard-api.js";
 import { loadLocalOpenClawSnapshot, loadLocalTurnDetail, toLocalLiveActivity, toLocalLiveAgents, toLocalLiveInitiatives, toLocalSessionTree, } from "../local-openclaw.js";
 import { defaultOutboxAdapter } from "../adapters/outbox.js";
+import { appendToOutbox } from "../outbox.js";
 import { readAgentContexts, upsertAgentContext, upsertRunContext } from "../agent-context-store.js";
 import { getAgentRun, markAgentRunStopped, readAgentRuns, upsertAgentRun, } from "../agent-run-store.js";
 import { appendEntityComment, listEntityComments, mergeEntityComments, } from "../entity-comment-store.js";
+import { listChatThreads } from "../chat-store.js";
 import { appendActivityItems, listActivityPage, } from "../activity-store.js";
 import { enrichActivityActorFields } from "../activity-actor-fields.js";
 import { readByokKeys, writeByokKeys } from "../byok-store.js";
 import { applyOrgxAgentSuitePlan, computeOrgxAgentSuitePlan, generateAgentSuiteOperationId, } from "../agent-suite.js";
 import { listRuntimeInstances, resolveRuntimeHookToken, upsertRuntimeInstanceFromHook, } from "../runtime-instance-store.js";
 import { parseJsonSafe } from "../json-utils.js";
-import { readSkillPackState, refreshSkillPackState, updateSkillPackPolicy } from "../skill-pack-state.js";
+import { readSkillPackState, refreshSkillPackState, rollbackSkillPackPolicy, updateSkillPackPolicy, } from "../skill-pack-state.js";
 import { posthogCapture } from "../telemetry/posthog.js";
 import { createRouter } from "./router.js";
 import { summarizeActivityHeadline } from "./helpers/activity-headline.js";
@@ -45,7 +47,7 @@ import { mapDecisionEntity } from "./helpers/decision-mapper.js";
 import { idempotencyKey, stableHash } from "./helpers/hash-utils.js";
 import { createCodexBinResolver, } from "./helpers/autopilot-slice-utils.js";
 import { createLocalArtifactDetailFallbackBuilder } from "./helpers/artifact-fallback.js";
-import { buildMissionControlGraph, dedupeStrings, isDoneStatus, isInProgressStatus, isTodoStatus, listEntitiesSafe, normalizeEntityMutationPayload, pickStringArray, resolveAutoAssignments, } from "./helpers/mission-control.js";
+import { buildMissionControlGraph, deriveExecutionPolicy, dedupeStrings, isDispatchableWorkstreamStatus, isDoneStatus, isInProgressStatus, isTodoStatus, listEntitiesSafe, normalizeEntityMutationPayload, pickStringArray, resolveAutoAssignments, selectSliceTasksByScope, } from "./helpers/mission-control.js";
 import { configureOpenClawProviderRouting, fetchBillingStatusSafe, isPidAlive, listOpenClawAgents, listOpenClawProviderModels, modelImpliesByok, normalizeOpenClawProvider, resolveAutoOpenClawProvider, resolveByokEnvOverrides, spawnOpenClawAgentTurn, stopDetachedProcess, } from "./helpers/openclaw-cli.js";
 import { fetchKickoffContextSafe, renderKickoffMessage } from "./helpers/kickoff-context.js";
 import { createDispatchLifecycle } from "./helpers/dispatch-lifecycle.js";
@@ -61,17 +63,23 @@ import { registerDebugRoutes } from "./routes/debug.js";
 import { registerEntityDynamicRoutes } from "./routes/entity-dynamic.js";
 import { registerEntitiesRoutes } from "./routes/entities.js";
 import { registerHealthRoutes } from "./routes/health.js";
+import { registerChatRoutes } from "./routes/chat.js";
 import { registerLiveLegacyRoutes } from "./routes/live-legacy.js";
 import { registerLiveMiscRoutes } from "./routes/live-misc.js";
+import { registerLiveTerminalRoutes } from "./routes/live-terminal.js";
 import { registerLiveSnapshotRoutes } from "./routes/live-snapshot.js";
 import { registerMissionControlActionsRoutes } from "./routes/mission-control-actions.js";
 import { registerMissionControlReadRoutes } from "./routes/mission-control-read.js";
 import { registerOnboardingRoutes } from "./routes/onboarding.js";
 import { registerRunControlRoutes } from "./routes/run-control.js";
 import { registerRuntimeHookRoutes } from "./routes/runtime-hooks.js";
+import { registerSentinelsCatalogRoutes } from "./routes/sentinels-catalog.js";
 import { registerSettingsByokRoutes } from "./routes/settings-byok.js";
 import { registerSummaryRoutes } from "./routes/summary.js";
+import { registerUsageRoutes } from "./routes/usage.js";
 import { registerWorkArtifactsRoutes } from "./routes/work-artifacts.js";
+import { registerLiveTriageRoutes } from "./routes/live-triage.js";
+import { registerRealtimeOrchestratorRoutes } from "./routes/realtime-orchestrator.js";
 // =============================================================================
 // Helpers
 // =============================================================================
@@ -96,10 +104,23 @@ async function resolveSkillPackOverrides(input) {
     }
 }
 function safeErrorMessage(err) {
-    if (err instanceof Error)
-        return err.message;
-    if (typeof err === "string")
-        return err;
+    const raw = err instanceof Error ? err.message : typeof err === "string" ? err : "";
+    const normalized = raw.trim().toLowerCase();
+    if (normalized.length > 0) {
+        if (normalized.includes("signal is aborted") ||
+            normalized.includes("aborterror") ||
+            normalized.includes("request cancelled") ||
+            normalized.includes("request canceled")) {
+            return "request timed out before upstream completed";
+        }
+        if (normalized.includes("timed out") || normalized.includes("timeout")) {
+            return "request timed out before upstream completed";
+        }
+        if (normalized.includes("failed to fetch") || normalized.includes("network")) {
+            return "network request failed";
+        }
+        return raw;
+    }
     return "Unexpected error";
 }
 function titleCaseFromSlug(value) {
@@ -181,17 +202,28 @@ async function mapWithConcurrency(items, concurrency, mapper) {
 }
 const ACTIVITY_WARM_THROTTLE_MS = 30_000;
 const activityWarmByKey = new Map();
-const SNAPSHOT_RESPONSE_CACHE_TTL_MS = 1_500;
+const SNAPSHOT_RESPONSE_CACHE_TTL_MS = 800;
 const SNAPSHOT_RESPONSE_CACHE_MAX_ENTRIES = 16;
 const SNAPSHOT_ACTIVITY_PERSIST_MIN_INTERVAL_MS = 15_000;
 const SNAPSHOT_ACTIVITY_FINGERPRINT_DEPTH = 8;
-const NEXT_UP_QUEUE_CACHE_TTL_MS = readPositiveIntEnv("ORGX_NEXT_UP_QUEUE_CACHE_TTL_MS", 4_000, { min: 250, max: 120_000 });
+const NEXT_UP_QUEUE_CACHE_TTL_MS = readPositiveIntEnv("ORGX_NEXT_UP_QUEUE_CACHE_TTL_MS", 30_000, { min: 250, max: 120_000 });
 const NEXT_UP_QUEUE_STALE_TTL_MS = readPositiveIntEnv("ORGX_NEXT_UP_QUEUE_STALE_TTL_MS", 45_000, { min: 1_000, max: 600_000 });
 const NEXT_UP_GRAPH_CONCURRENCY = readPositiveIntEnv("ORGX_NEXT_UP_GRAPH_CONCURRENCY", 20, { min: 1, max: 32 });
 const NEXT_UP_LIVE_AGENTS_TIMEOUT_MS = readPositiveIntEnv("ORGX_NEXT_UP_LIVE_AGENTS_TIMEOUT_MS", 1_500, { min: 200, max: 20_000 });
 const NEXT_UP_AGENT_CATALOG_TIMEOUT_MS = readPositiveIntEnv("ORGX_NEXT_UP_AGENT_CATALOG_TIMEOUT_MS", 900, { min: 100, max: 20_000 });
+const NEXT_UP_LIVE_SESSIONS_TIMEOUT_MS = readPositiveIntEnv("ORGX_NEXT_UP_LIVE_SESSIONS_TIMEOUT_MS", 2_500, { min: 250, max: 30_000 });
+const PROJECT_SCOPE_LOOKUP_TIMEOUT_MS = readPositiveIntEnv("ORGX_PROJECT_SCOPE_LOOKUP_TIMEOUT_MS", 2_500, { min: 250, max: 20_000 });
+const PROJECT_SCOPE_MAX_INITIATIVE_PAGES = readPositiveIntEnv("ORGX_PROJECT_SCOPE_MAX_INITIATIVE_PAGES", 12, { min: 1, max: 100 });
+const LIVE_WORKSPACE_INITIATIVE_STATUSES = [
+    "active",
+    "planning",
+    "paused",
+    "draft",
+    "in_progress",
+];
 let lastSnapshotActivityPersistAt = 0;
 let lastSnapshotActivityFingerprint = "";
+let snapshotCacheGeneration = 0;
 const snapshotResponseCache = new Map();
 const ACTIVITY_DECISION_EVENT_HINTS = new Set([
     "decision_buffered",
@@ -284,6 +316,9 @@ function deriveStructuredActivityBucket(input) {
         "nonBlockingDecisionCount",
     ]) ?? 0;
     if (event === "autopilot_slice_result") {
+        // Any blocked slice result needs decision-first surfacing in the Activity UX.
+        if (input.phase === "blocked")
+            return "decision";
         if (decisionRequired || blockingDecisions > 0)
             return "decision";
         if (artifacts > 0)
@@ -292,6 +327,13 @@ function deriveStructuredActivityBucket(input) {
             return "decision";
         return "message";
     }
+    if (event === "auto_continue_stopped") {
+        const stopReason = typeof metadata?.stop_reason === "string"
+            ? metadata.stop_reason.trim().toLowerCase()
+            : "";
+        if (stopReason === "blocked" || stopReason === "error")
+            return "decision";
+    }
     if (event && ACTIVITY_ARTIFACT_EVENT_HINTS.has(event))
         return "artifact";
     if (event && ACTIVITY_DECISION_EVENT_HINTS.has(event))
@@ -319,7 +361,7 @@ function readSnapshotResponseCache(key) {
     const entry = snapshotResponseCache.get(key);
     if (!entry)
         return null;
-    if (entry.expiresAt <= Date.now()) {
+    if (entry.generation !== snapshotCacheGeneration || entry.expiresAt <= Date.now()) {
         snapshotResponseCache.delete(key);
         return null;
     }
@@ -329,6 +371,7 @@ function writeSnapshotResponseCache(key, payload) {
     const now = Date.now();
     snapshotResponseCache.set(key, {
         expiresAt: now + SNAPSHOT_RESPONSE_CACHE_TTL_MS,
+        generation: snapshotCacheGeneration,
         payload,
     });
     if (snapshotResponseCache.size <= SNAPSHOT_RESPONSE_CACHE_MAX_ENTRIES)
@@ -345,6 +388,7 @@ function writeSnapshotResponseCache(key, payload) {
     }
 }
 function clearSnapshotResponseCache() {
+    snapshotCacheGeneration += 1;
     snapshotResponseCache.clear();
 }
 function isUserScopedApiKey(apiKey) {
@@ -528,19 +572,29 @@ function applyAgentContextsToActivity(input, contexts) {
         return enrichActivityActorFields(nextItem);
     });
 }
+function sessionNodeEpoch(node) {
+    const raw = node.updatedAt ?? node.lastEventAt ?? node.startedAt;
+    if (!raw)
+        return 0;
+    const epoch = Date.parse(raw);
+    return Number.isFinite(epoch) ? epoch : 0;
+}
 function mergeSessionTrees(base, extra) {
-    const seenNodes = new Set();
-    const nodes = [];
-    for (const node of base.nodes ?? []) {
-        seenNodes.add(node.id);
-        nodes.push(node);
-    }
+    const nodeById = new Map();
+    for (const node of base.nodes ?? [])
+        nodeById.set(node.id, node);
     for (const node of extra.nodes ?? []) {
-        if (seenNodes.has(node.id))
+        const existing = nodeById.get(node.id);
+        if (!existing) {
+            nodeById.set(node.id, node);
             continue;
-        seenNodes.add(node.id);
-        nodes.push(node);
+        }
+        const existingEpoch = sessionNodeEpoch(existing);
+        const extraEpoch = sessionNodeEpoch(node);
+        if (extraEpoch > existingEpoch)
+            nodeById.set(node.id, node);
     }
+    const nodes = Array.from(nodeById.values());
     const seenEdges = new Set();
     const edges = [];
     for (const edge of base.edges ?? []) {
@@ -576,6 +630,81 @@ function mergeSessionTrees(base, extra) {
         groups: Array.from(groupsById.values()),
     };
 }
+function asActivityMetadataRecord(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return null;
+    return value;
+}
+function activityMetadataStr(metadata, keys) {
+    if (!metadata)
+        return null;
+    for (const key of keys) {
+        const value = metadata[key];
+        if (typeof value !== "string")
+            continue;
+        const normalized = value.trim();
+        if (normalized.length > 0)
+            return normalized;
+    }
+    return null;
+}
+const SEMANTIC_ACTIVITY_EVENTS = new Set([
+    "autopilot_slice_result",
+    "auto_continue_started",
+    "auto_continue_stopped",
+    "next_up_manual_dispatch_started",
+    "autopilot_slice_mcp_handshake_failed",
+    "autopilot_slice_timeout",
+    "autopilot_slice_log_stall",
+    "auto_continue_spawn_guard_blocked",
+    "auto_continue_spawn_guard_rate_limited",
+    "autopilot_autofix_scheduled",
+    "autopilot_autofix_executed",
+    "autopilot_autofix_skipped",
+]);
+function semanticActivityKey(item) {
+    const metadata = asActivityMetadataRecord(item.metadata);
+    const eventRaw = metadata?.event;
+    const event = typeof eventRaw === "string" ? eventRaw.trim().toLowerCase() : "";
+    if (!event || !SEMANTIC_ACTIVITY_EVENTS.has(event))
+        return null;
+    const runLike = (typeof item.runId === "string" && item.runId.trim().length > 0
+        ? item.runId.trim()
+        : null) ??
+        activityMetadataStr(metadata, [
+            "run_id",
+            "runId",
+            "slice_run_id",
+            "sliceRunId",
+            "active_run_id",
+            "activeRunId",
+            "last_run_id",
+            "lastRunId",
+        ]);
+    const correlationId = activityMetadataStr(metadata, ["correlation_id", "correlationId"]);
+    const initiativeId = (typeof item.initiativeId === "string" && item.initiativeId.trim().length > 0
+        ? item.initiativeId.trim()
+        : null) ??
+        activityMetadataStr(metadata, ["initiative_id", "initiativeId"]);
+    const workstreamId = activityMetadataStr(metadata, ["workstream_id", "workstreamId"]);
+    const taskId = activityMetadataStr(metadata, ["task_id", "taskId"]);
+    const stopReason = activityMetadataStr(metadata, ["stop_reason", "stopReason"]);
+    const parsedStatus = activityMetadataStr(metadata, ["parsed_status", "parsedStatus"]);
+    const title = (item.title ?? "").trim().toLowerCase();
+    if (!runLike && !correlationId && !workstreamId && !taskId)
+        return null;
+    return [
+        event,
+        initiativeId ?? "",
+        workstreamId ?? "",
+        taskId ?? "",
+        runLike ?? "",
+        correlationId ?? "",
+        stopReason ?? "",
+        parsedStatus ?? "",
+        title,
+    ].join("|");
+}
 function mergeActivities(base, extra, limit) {
     const merged = [...(base ?? []), ...(extra ?? [])].sort((a, b) => {
         const timestampDelta = Date.parse(b.timestamp) - Date.parse(a.timestamp);
@@ -584,11 +713,17 @@ function mergeActivities(base, extra, limit) {
         return b.id.localeCompare(a.id);
     });
     const deduped = [];
-    const seen = new Set();
+    const seenIds = new Set();
+    const seenSemantic = new Set();
     for (const item of merged) {
-        if (seen.has(item.id))
+        if (seenIds.has(item.id))
+            continue;
+        seenIds.add(item.id);
+        const sk = semanticActivityKey(item);
+        if (sk && seenSemantic.has(sk))
             continue;
-        seen.add(item.id);
+        if (sk)
+            seenSemantic.add(sk);
         deduped.push(item);
         if (deduped.length >= limit)
             break;
@@ -719,6 +854,9 @@ function enrichSessionsWithRuntime(input, instances) {
         const agentId = (node.agentId ?? "").trim() || fallbackAgent.agentId;
         const agentName = (node.agentName ?? "").trim() || fallbackAgent.agentName;
         const nodeStatus = (node.status ?? "").trim().toLowerCase();
+        const isTerminalNodeStatus = nodeStatus === "completed" ||
+            nodeStatus === "cancelled" ||
+            nodeStatus === "archived";
         const isLiveLikeNodeStatus = nodeStatus === "running" ||
             nodeStatus === "active" ||
             nodeStatus === "in_progress" ||
@@ -726,20 +864,49 @@ function enrichSessionsWithRuntime(input, instances) {
             nodeStatus === "planning" ||
             nodeStatus === "dispatching";
         const shouldDowngradeStatusFromRuntime = isLiveLikeNodeStatus && (runtimeStatus === "queued" || runtimeStatus === "paused");
-        const blockerReason = (node.blockerReason ?? "").trim() ||
-            (node.status?.toLowerCase() === "blocked" || match.phase?.toLowerCase() === "blocked"
-                ? (match.lastMessage ?? "").trim()
-                : "");
+        const shouldPromoteStatusFromRuntime = runtimeStatus === "completed" ||
+            runtimeStatus === "blocked" ||
+            runtimeStatus === "review" ||
+            runtimeStatus === "handoff" ||
+            (runtimeStatus === "running" &&
+                (nodeStatus === "blocked" ||
+                    nodeStatus === "failed" ||
+                    nodeStatus === "queued" ||
+                    nodeStatus === "paused"));
+        const nextStatus = shouldDowngradeStatusFromRuntime ||
+            (!isTerminalNodeStatus && shouldPromoteStatusFromRuntime)
+            ? runtimeStatus
+            : node.status;
+        const runtimeExplicitlyBlocked = runtimeStatus === "blocked" || match.phase?.toLowerCase() === "blocked";
+        const runtimeExplicitlyUnblocked = !runtimeExplicitlyBlocked && typeof match.phase === "string" && match.phase.trim().length > 0;
+        const runtimeBlockedReason = (match.lastMessage ?? "").trim();
+        const nextBlockerReason = runtimeExplicitlyBlocked
+            ? runtimeBlockedReason || (node.blockerReason ?? "").trim() || null
+            : runtimeExplicitlyUnblocked
+                ? null
+                : node.blockerReason ?? null;
+        const nextBlockers = runtimeExplicitlyBlocked
+            ? runtimeBlockedReason
+                ? [runtimeBlockedReason]
+                : Array.isArray(node.blockers)
+                    ? node.blockers
+                    : []
+            : runtimeExplicitlyUnblocked
+                ? []
+                : Array.isArray(node.blockers)
+                    ? node.blockers
+                    : [];
         return {
             ...node,
             agentId: agentId || null,
             agentName: agentName || null,
-            status: shouldDowngradeStatusFromRuntime ? runtimeStatus : node.status,
+            status: nextStatus,
             state: node.state ?? match.state ?? null,
             lastEventSummary: shouldDowngradeStatusFromRuntime && runtimeStatus === "queued"
                 ? node.lastEventSummary ?? "Recovered stale runtime; awaiting next dispatch."
                 : node.lastEventSummary,
-            blockerReason: blockerReason || node.blockerReason || null,
+            blockers: nextBlockers,
+            blockerReason: nextBlockerReason,
             runtimeClient: normalizeRuntimeSource(match.sourceClient),
             runtimeLabel: match.displayName,
             runtimeProvider: match.providerLogo,
@@ -749,6 +916,64 @@ function enrichSessionsWithRuntime(input, instances) {
     });
     return { ...input, nodes };
 }
+function metadataHasStructuredScope(meta) {
+    const scalarScope = pickString(meta, [
+        "initiative_id",
+        "initiativeId",
+        "workstream_id",
+        "workstreamId",
+        "workstream_title",
+        "workstreamTitle",
+        "task_id",
+        "taskId",
+        "task_title",
+        "taskTitle",
+        "slice_run_id",
+        "sliceRunId",
+        "iwmt_id",
+        "iwmtId",
+        "milestone_id",
+        "milestoneId",
+        "milestone_title",
+        "milestoneTitle",
+    ]) ?? null;
+    if (scalarScope)
+        return true;
+    const listScopeKeys = [
+        "initiative_ids",
+        "initiativeIds",
+        "workstream_ids",
+        "workstreamIds",
+        "task_ids",
+        "taskIds",
+        "milestone_ids",
+        "milestoneIds",
+        "iwmt_ids",
+        "iwmtIds",
+    ];
+    for (const key of listScopeKeys) {
+        const value = meta[key];
+        if (!Array.isArray(value))
+            continue;
+        if (value.some((entry) => typeof entry === "string" && entry.trim().length > 0)) {
+            return true;
+        }
+    }
+    return false;
+}
+function shouldInjectRuntimeInstanceAsSession(instance, runId, meta) {
+    if (instance.state !== "active")
+        return false;
+    // Synthetic hook correlation ids are telemetry-only and should never render as user-facing sessions.
+    if (runId.toLowerCase().startsWith("hook-"))
+        return false;
+    const workstreamId = instance.workstreamId?.trim() ?? "";
+    const taskId = instance.taskId?.trim() ?? "";
+    if (workstreamId.length > 0 || taskId.length > 0)
+        return true;
+    // Keep only runtime records that include structured execution scope.
+    return metadataHasStructuredScope(meta);
+}
 function injectRuntimeInstancesAsSessions(input, instances) {
     if (!Array.isArray(input.nodes))
         return input;
@@ -773,10 +998,6 @@ function injectRuntimeInstancesAsSessions(input, instances) {
             continue;
         if (existingRunIds.has(runId))
             continue;
-        // Only surface active runtime instances as synthetic sessions.
-        // Stale instances are reconciled onto existing sessions but shouldn't appear as fresh work.
-        if (instance.state !== "active")
-            continue;
         const initiativeId = instance.initiativeId?.trim() || null;
         const workstreamId = instance.workstreamId?.trim() || null;
         const runtimeClient = normalizeRuntimeSource(instance.sourceClient);
@@ -785,6 +1006,8 @@ function injectRuntimeInstancesAsSessions(input, instances) {
         const meta = instance.metadata && typeof instance.metadata === "object"
             ? instance.metadata
             : {};
+        if (!shouldInjectRuntimeInstanceAsSession(instance, runId, meta))
+            continue;
         const titleHint = pickString(meta, ["workstream_title", "workstreamTitle"]) ??
             (workstreamId ? `Workstream ${workstreamId.slice(0, 8)}` : null);
         const initiativeHint = pickString(meta, ["initiative_title", "initiativeTitle"]) ??
@@ -898,18 +1121,18 @@ const CONTENT_SECURITY_POLICY = [
     "form-action 'self'",
     "object-src 'none'",
     "script-src 'self'",
-    "style-src 'self' 'unsafe-inline'",
+    "style-src 'self' 'unsafe-inline' https://fonts.googleapis.com",
     "img-src 'self' data: blob:",
-    "font-src 'self' data:",
+    "font-src 'self' data: https://fonts.gstatic.com",
     "media-src 'self'",
-    "connect-src 'self' https://*.useorgx.com https://*.openclaw.ai http://127.0.0.1:* http://localhost:*",
+    "connect-src 'self' https://*.useorgx.com https://*.openclaw.ai https://api.openai.com https://*.openai.com http://127.0.0.1:* http://localhost:*",
 ].join("; ");
 const SECURITY_HEADERS = {
     "X-Content-Type-Options": "nosniff",
     "X-Frame-Options": "DENY",
     "Referrer-Policy": "same-origin",
     "X-Robots-Tag": "noindex, nofollow, noarchive, nosnippet, noimageindex",
-    "Permissions-Policy": "camera=(), microphone=(), geolocation=(), payment=(), usb=(), midi=(), magnetometer=(), gyroscope=()",
+    "Permissions-Policy": "camera=(), microphone=(self), geolocation=(), payment=(), usb=(), midi=(), magnetometer=(), gyroscope=()",
     "Cross-Origin-Opener-Policy": "same-origin",
     "Cross-Origin-Resource-Policy": "same-origin",
     "Origin-Agent-Cluster": "?1",
@@ -982,9 +1205,16 @@ function resolveSafeDistPath(subPath) {
     }
     return candidate;
 }
-// =============================================================================
-// Helpers
-// =============================================================================
+const PRECOMPRESSED_FILE_EXTENSIONS = new Set([
+    ".css",
+    ".html",
+    ".js",
+    ".json",
+    ".map",
+    ".svg",
+    ".txt",
+    ".xml",
+]);
 const IMMUTABLE_FILE_CACHE = new Map();
 const IMMUTABLE_FILE_CACHE_MAX = 128;
 const FILE_PREVIEW_MAX_BYTES = 1_000_000;
@@ -1064,23 +1294,109 @@ function readFilePreview(pathname, totalBytes) {
         closeSync(fd);
     }
 }
-function sendFile(res, filePath, cacheControl) {
+function parseAcceptedEncodings(rawHeader) {
+    const parsed = new Map();
+    if (!rawHeader || rawHeader.trim().length === 0)
+        return parsed;
+    const parts = rawHeader.split(",");
+    for (const part of parts) {
+        const [nameRaw, ...params] = part.split(";");
+        const name = nameRaw?.trim().toLowerCase();
+        if (!name)
+            continue;
+        let q = 1;
+        for (const param of params) {
+            const [keyRaw, valueRaw] = param.split("=");
+            const key = keyRaw?.trim().toLowerCase();
+            if (key !== "q")
+                continue;
+            const candidate = Number.parseFloat((valueRaw ?? "").trim());
+            if (Number.isFinite(candidate)) {
+                q = candidate;
+            }
+        }
+        if (q <= 0)
+            continue;
+        const existing = parsed.get(name);
+        if (existing == null || q > existing) {
+            parsed.set(name, q);
+        }
+    }
+    return parsed;
+}
+function resolveEncodingQuality(accepted, encoding) {
+    if (accepted.has(encoding))
+        return accepted.get(encoding) ?? 0;
+    if (accepted.has("*"))
+        return accepted.get("*") ?? 0;
+    return 0;
+}
+function resolvePrecompressedVariant(req, filePath) {
+    const ext = extname(filePath).toLowerCase();
+    if (!PRECOMPRESSED_FILE_EXTENSIONS.has(ext))
+        return null;
+    const accepted = parseAcceptedEncodings(pickHeaderString(req.headers, ["accept-encoding"]));
+    if (accepted.size === 0)
+        return null;
+    const candidates = [
+        {
+            encoding: "br",
+            path: `${filePath}.br`,
+            quality: resolveEncodingQuality(accepted, "br"),
+            priority: 2,
+        },
+        {
+            encoding: "gzip",
+            path: `${filePath}.gz`,
+            quality: resolveEncodingQuality(accepted, "gzip"),
+            priority: 1,
+        },
+    ];
+    candidates.sort((left, right) => {
+        if (right.quality !== left.quality)
+            return right.quality - left.quality;
+        return right.priority - left.priority;
+    });
+    for (const candidate of candidates) {
+        if (candidate.quality <= 0)
+            continue;
+        if (existsSync(candidate.path)) {
+            return { path: candidate.path, encoding: candidate.encoding };
+        }
+    }
+    return null;
+}
+function sendFile(req, res, filePath, cacheControl) {
     try {
         const shouldCacheImmutable = cacheControl.includes("immutable");
+        const shouldVaryByEncoding = PRECOMPRESSED_FILE_EXTENSIONS.has(extname(filePath).toLowerCase());
+        const precompressed = resolvePrecompressedVariant(req, filePath);
+        const responsePath = precompressed?.path ?? filePath;
+        const responseEncoding = precompressed?.encoding ?? null;
+        const cacheKey = `${responsePath}|${cacheControl}`;
         if (shouldCacheImmutable) {
-            const cached = IMMUTABLE_FILE_CACHE.get(filePath);
+            const cached = IMMUTABLE_FILE_CACHE.get(cacheKey);
             if (cached) {
-                res.writeHead(200, {
+                const headers = {
                     "Content-Type": cached.contentType,
                     "Cache-Control": cacheControl,
                     ...SECURITY_HEADERS,
                     ...CORS_HEADERS,
+                };
+                if (cached.contentEncoding === "br")
+                    headers["Content-Encoding"] = "br";
+                if (cached.contentEncoding === "gzip")
+                    headers["Content-Encoding"] = "gzip";
+                if (cached.varyAcceptEncoding)
+                    headers["Vary"] = "Accept-Encoding";
+                res.writeHead(200, {
+                    ...headers,
                 });
                 res.end(cached.content);
                 return;
             }
         }
-        const content = readFileSync(filePath);
+        const content = readFileSync(responsePath);
         const type = contentType(filePath);
         if (shouldCacheImmutable) {
             if (IMMUTABLE_FILE_CACHE.size >= IMMUTABLE_FILE_CACHE_MAX) {
@@ -1088,14 +1404,26 @@ function sendFile(res, filePath, cacheControl) {
                 if (firstKey)
                     IMMUTABLE_FILE_CACHE.delete(firstKey);
             }
-            IMMUTABLE_FILE_CACHE.set(filePath, { content, contentType: type });
+            IMMUTABLE_FILE_CACHE.set(cacheKey, {
+                content,
+                contentType: type,
+                contentEncoding: responseEncoding,
+                varyAcceptEncoding: shouldVaryByEncoding,
+            });
         }
-        res.writeHead(200, {
+        const headers = {
             "Content-Type": type,
             "Cache-Control": cacheControl,
             ...SECURITY_HEADERS,
             ...CORS_HEADERS,
-        });
+        };
+        if (responseEncoding === "br")
+            headers["Content-Encoding"] = "br";
+        if (responseEncoding === "gzip")
+            headers["Content-Encoding"] = "gzip";
+        if (shouldVaryByEncoding)
+            headers["Vary"] = "Accept-Encoding";
+        res.writeHead(200, headers);
         res.end(content);
     }
     catch {
@@ -1110,10 +1438,24 @@ function send404(res) {
     });
     res.end("Not Found");
 }
-function sendIndexHtml(res) {
+function sendStaleChunkRecovery(res) {
+    const body = [
+        "// Recover from stale chunk references after dashboard/plugin upgrades.",
+        "window.location.replace('/orgx/live' + window.location.search);",
+        "export {};"
+    ].join("\n");
+    res.writeHead(200, {
+        "Content-Type": "application/javascript; charset=utf-8",
+        "Cache-Control": "no-cache, no-store, must-revalidate",
+        ...SECURITY_HEADERS,
+        ...CORS_HEADERS,
+    });
+    res.end(body);
+}
+function sendIndexHtml(req, res) {
     const indexPath = join(DIST_DIR, "index.html");
     if (existsSync(indexPath)) {
-        sendFile(res, indexPath, "no-cache, no-store, must-revalidate");
+        sendFile(req, res, indexPath, "no-cache, no-store, must-revalidate");
     }
     else {
         res.writeHead(503, {
@@ -1307,9 +1649,60 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
         spawnAgentTurn,
         upsertAgentRun,
     });
+    const normalizeRunnerAgentToken = (value) => {
+        if (typeof value !== "string")
+            return null;
+        const trimmed = value.trim();
+        if (!trimmed)
+            return null;
+        const normalized = trimmed.toLowerCase();
+        if (normalized === "main" ||
+            normalized === "undefined" ||
+            normalized === "null" ||
+            normalized === "n/a" ||
+            normalized === "na") {
+            return null;
+        }
+        return trimmed;
+    };
+    const pushRunnerAgent = (target, seen, input) => {
+        const agentId = normalizeRunnerAgentToken(input.id ?? null);
+        const agentName = normalizeRunnerAgentToken(input.name ?? null);
+        if (!agentId && !agentName)
+            return;
+        const resolvedId = agentId ?? agentName;
+        const dedupeKey = resolvedId.toLowerCase();
+        if (seen.has(dedupeKey))
+            return;
+        seen.add(dedupeKey);
+        target.push({
+            id: resolvedId,
+            name: agentName ?? resolvedId,
+        });
+    };
+    const dedupeWithPrimary = (primary, extras) => {
+        const merged = [];
+        const seen = new Set();
+        for (const candidate of [...primary, ...extras]) {
+            const id = normalizeRunnerAgentToken(candidate.id);
+            const name = normalizeRunnerAgentToken(candidate.name);
+            if (!id && !name)
+                continue;
+            const resolvedId = id ?? name;
+            const key = resolvedId.toLowerCase();
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            merged.push({
+                id: resolvedId,
+                name: name ?? resolvedId,
+            });
+        }
+        return merged;
+    };
     const codexBinResolver = createCodexBinResolver();
     const resolveCodexBinInfo = () => codexBinResolver.resolveCodexBinInfo();
-    const { autoContinueRuns, autoContinueSliceRuns, localInitiativeStatusOverrides, writeRuntimeEvent, autoContinueTickMs: AUTO_CONTINUE_TICK_MS, defaultAutoContinueTokenBudget, setLocalInitiativeStatusOverride, clearLocalInitiativeStatusOverride, applyLocalInitiativeOverrides, applyLocalInitiativeOverrideToGraph, updateInitiativeAutoContinueState, stopAutoContinueRun, tickAutoContinueRun, tickAllAutoContinue, isInitiativeActiveStatus, runningAutoContinueForWorkstream, 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, } = createAutoContinueEngine({
         client,
         filename: __filename,
         safeErrorMessage,
@@ -1327,10 +1720,194 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
         clearSnapshotResponseCache,
         resolveByokEnvOverrides,
         randomUUID,
+        fetchKickoffContextSafe,
+        renderKickoffMessage,
     });
     const nextUpQueueCache = new Map();
     const nextUpQueueInFlight = new Map();
-    const nextUpQueueCacheKeyFor = (initiativeId) => initiativeId?.trim() || "__all__";
+    const PROJECT_INITIATIVE_IDS_CACHE_TTL_MS = 20_000;
+    const projectInitiativeIdsCache = new Map();
+    const commandCenterScopeCache = new Map();
+    const nextUpQueueCacheKeyFor = (initiativeId, projectId) => {
+        const normalizedInitiative = initiativeId?.trim() || "__all__";
+        const normalizedProject = projectId?.trim() || "__all__";
+        return `${normalizedProject}::${normalizedInitiative}`;
+    };
+    async function listInitiativeIdsForProject(input) {
+        const projectId = input.projectId.trim();
+        if (!projectId)
+            return [];
+        const cached = projectInitiativeIdsCache.get(projectId);
+        if (cached && cached.expiresAt > Date.now()) {
+            return [...cached.ids];
+        }
+        const mapInitiativeIds = (rows, opts) => {
+            const projectScopeId = opts?.projectId?.trim() ?? "";
+            const commandCenterId = opts?.commandCenterId?.trim() ?? "";
+            return rows
+                .map((entry) => {
+                const record = entry;
+                if (projectScopeId) {
+                    const rowProjectId = pickString(record, ["project_id", "projectId"]) ?? "";
+                    if (rowProjectId !== projectScopeId)
+                        return null;
+                }
+                if (commandCenterId) {
+                    const rowCommandCenterId = pickString(record, [
+                        "workspace_id",
+                        "workspaceId",
+                        "command_center_id",
+                        "commandCenterId",
+                    ]) ?? "";
+                    if (rowCommandCenterId !== commandCenterId)
+                        return null;
+                }
+                return pickString(record, ["id"]);
+            })
+                .filter((id) => Boolean(id && id.trim().length > 0));
+        };
+        const cacheAndReturn = (ids) => {
+            const normalized = dedupeStrings(ids
+                .map((id) => id.trim())
+                .filter((id) => id.length > 0));
+            projectInitiativeIdsCache.set(projectId, {
+                expiresAt: Date.now() + PROJECT_INITIATIVE_IDS_CACHE_TTL_MS,
+                ids: normalized,
+            });
+            return normalized;
+        };
+        const isKnownCommandCenterScope = async () => {
+            const cachedScope = commandCenterScopeCache.get(projectId);
+            if (cachedScope && cachedScope.expiresAt > Date.now()) {
+                return cachedScope.exists;
+            }
+            const cacheScope = (exists) => {
+                commandCenterScopeCache.set(projectId, {
+                    expiresAt: Date.now() + PROJECT_INITIATIVE_IDS_CACHE_TTL_MS,
+                    exists,
+                });
+                return exists;
+            };
+            const hasId = (rows) => rows.some((entry) => {
+                const record = entry;
+                const id = pickString(record, ["id"]) ?? "";
+                return id === projectId;
+            });
+            try {
+                const byId = await withSoftTimeout("command center scope lookup", PROJECT_SCOPE_LOOKUP_TIMEOUT_MS, client.listEntities("command_center", {
+                    id: projectId,
+                    limit: 1,
+                }));
+                const byIdRows = Array.isArray(byId.data) ? byId.data : [];
+                if (hasId(byIdRows))
+                    return cacheScope(true);
+            }
+            catch {
+                // continue to all-command-center fallback
+            }
+            try {
+                const all = await withSoftTimeout("command center catalog lookup", PROJECT_SCOPE_LOOKUP_TIMEOUT_MS, client.listEntities("command_center", {
+                    limit: 100,
+                }));
+                const allRows = Array.isArray(all.data) ? all.data : [];
+                return cacheScope(hasId(allRows));
+            }
+            catch {
+                return cacheScope(false);
+            }
+        };
+        const listInitiativesWithFilters = async (filters) => {
+            const rows = [];
+            const pageSize = 100;
+            const seenIds = new Set();
+            let offset = 0;
+            let page = 0;
+            while (page < PROJECT_SCOPE_MAX_INITIATIVE_PAGES) {
+                const result = await withSoftTimeout("initiative scope lookup", PROJECT_SCOPE_LOOKUP_TIMEOUT_MS, client.listEntities("initiative", {
+                    ...filters,
+                    limit: pageSize,
+                    offset,
+                }));
+                const pageRows = Array.isArray(result.data) ? result.data : [];
+                let addedCount = 0;
+                for (const entry of pageRows) {
+                    const record = entry;
+                    const id = pickString(record, ["id"]);
+                    if (id && seenIds.has(id))
+                        continue;
+                    if (id)
+                        seenIds.add(id);
+                    rows.push(entry);
+                    addedCount += 1;
+                }
+                const hasMoreFlag = Boolean(result.pagination?.has_more);
+                const likelyMore = hasMoreFlag || pageRows.length >= pageSize;
+                if (!likelyMore)
+                    break;
+                if (addedCount === 0)
+                    break;
+                offset += pageRows.length;
+                page += 1;
+            }
+            return rows;
+        };
+        const listLiveInitiativesWithFilters = async (filters) => {
+            // Fast path: request once without status fan-out. Upstream often returns
+            // all relevant rows and this avoids 5x paginated round-trips.
+            const broadRows = await listInitiativesWithFilters(filters);
+            if (broadRows.length > 0)
+                return broadRows;
+            // Backward-compat fallback for upstreams that require explicit status.
+            const rows = [];
+            for (const status of LIVE_WORKSPACE_INITIATIVE_STATUSES) {
+                const statusRows = await listInitiativesWithFilters({
+                    ...filters,
+                    status,
+                });
+                rows.push(...statusRows);
+            }
+            return rows;
+        };
+        try {
+            // Workspace selection in the plugin uses command-center IDs.
+            // Resolve that scope first so broad project queries never leak cross-workspace items.
+            const byCommandCenterIds = mapInitiativeIds(await listLiveInitiativesWithFilters({
+                workspace_id: projectId,
+                command_center_id: projectId,
+            }), { commandCenterId: projectId });
+            if (byCommandCenterIds.length > 0)
+                return cacheAndReturn(byCommandCenterIds);
+        }
+        catch {
+            // continue to project-id fallback
+        }
+        try {
+            // Do not hard-return empty for known command-center scopes here.
+            // Some tenants only populate project_id links, so we continue through
+            // project-id fallbacks before concluding the scope is empty.
+            await isKnownCommandCenterScope();
+        }
+        catch {
+            // continue to project-id fallback
+        }
+        try {
+            const byWorkspaceFallback = mapInitiativeIds(await listLiveInitiativesWithFilters({
+                workspace_id: projectId,
+                command_center_id: projectId,
+            }), { projectId });
+            if (byWorkspaceFallback.length > 0)
+                return cacheAndReturn(byWorkspaceFallback);
+        }
+        catch {
+            // continue to empty fallback
+        }
+        try {
+            return cacheAndReturn([]);
+        }
+        catch {
+            return [];
+        }
+    }
     const readNextUpQueueCache = (key, opts) => {
         const entry = nextUpQueueCache.get(key);
         if (!entry)
@@ -1361,9 +1938,37 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
             },
         });
     };
+    const clearNextUpQueueCache = (initiativeId) => {
+        const normalized = initiativeId?.trim() || null;
+        if (!normalized) {
+            nextUpQueueCache.clear();
+            nextUpQueueInFlight.clear();
+            return;
+        }
+        for (const key of Array.from(nextUpQueueCache.keys())) {
+            if (key.endsWith(`::${normalized}`) || key.endsWith("::__all__")) {
+                nextUpQueueCache.delete(key);
+            }
+        }
+        for (const key of Array.from(nextUpQueueInFlight.keys())) {
+            if (key.endsWith(`::${normalized}`) || key.endsWith("::__all__")) {
+                nextUpQueueInFlight.delete(key);
+            }
+        }
+    };
     async function buildNextUpQueueUncached(input) {
         const degraded = [];
         const requestedInitiativeId = input?.initiativeId?.trim() || null;
+        const requestedProjectId = input?.projectId?.trim() || null;
+        let allowedInitiativeIds = null;
+        if (requestedProjectId && requestedProjectId.length > 0) {
+            const scopedIds = await listInitiativeIdsForProject({
+                projectId: requestedProjectId,
+            });
+            if (scopedIds.length > 0) {
+                allowedInitiativeIds = new Set(scopedIds);
+            }
+        }
         const pinnedQueue = readNextUpQueuePins();
         const pinnedRankByKey = new Map();
         const pinnedByKey = new Map();
@@ -1377,6 +1982,17 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
                 preferredMilestoneId: pin.preferredMilestoneId ?? null,
             });
         }
+        const suppressedKeySet = new Set();
+        for (const suppression of pinnedQueue.suppressions ?? []) {
+            const initiativeId = suppression.initiativeId?.trim();
+            const workstreamId = suppression.workstreamId?.trim();
+            if (!initiativeId || !workstreamId)
+                continue;
+            if (requestedInitiativeId && initiativeId !== requestedInitiativeId)
+                continue;
+            suppressedKeySet.add(`${initiativeId}:${workstreamId}`);
+        }
+        const isSuppressed = (initiativeId, workstreamId) => suppressedKeySet.has(`${initiativeId}:${workstreamId}`);
         const initiativeTitleById = new Map();
         const initiativeStatusById = new Map();
         const initiativePriorityById = new Map();
@@ -1388,7 +2004,10 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
             initiativeTitleById.set(id, initiative.title);
             initiativeStatusById.set(id, initiative.status || "active");
         }
-        const initiativeResult = await listEntitiesSafe(client, "initiative", { limit: 500 });
+        const initiativeResult = await withSoftTimeout("initiative list", PROJECT_SCOPE_LOOKUP_TIMEOUT_MS, listEntitiesSafe(client, "initiative", { limit: 500 })).catch((err) => ({
+            items: [],
+            warning: `initiative unavailable (${safeErrorMessage(err)})`,
+        }));
         if (initiativeResult.warning)
             degraded.push(initiativeResult.warning);
         const initiatives = initiativeResult.items;
@@ -1407,6 +2026,39 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
             if (priority)
                 initiativePriorityById.set(id, priority);
         }
+        const initiativeMatchesRequestedProject = (record) => {
+            if (!requestedProjectId)
+                return true;
+            const scopedValue = pickString(record, [
+                "workspace_id",
+                "workspaceId",
+                "command_center_id",
+                "commandCenterId",
+                "project_id",
+                "projectId",
+            ]) ?? null;
+            if (!scopedValue)
+                return false;
+            return scopedValue === requestedProjectId;
+        };
+        if (requestedProjectId && !allowedInitiativeIds) {
+            const metadataScopedIds = initiatives
+                .map((entity) => {
+                const record = entity;
+                const id = pickString(record, ["id"]);
+                if (!id)
+                    return null;
+                return initiativeMatchesRequestedProject(record) ? id : null;
+            })
+                .filter((value) => Boolean(value));
+            if (metadataScopedIds.length > 0) {
+                allowedInitiativeIds = new Set(metadataScopedIds);
+                degraded.push("workspace initiative scope lookup returned no rows; using metadata scoped initiatives.");
+            }
+            else {
+                degraded.push("workspace initiative scope lookup returned no rows; local queue may be incomplete.");
+            }
+        }
         for (const [initiativeId, override] of localInitiativeStatusOverrides.entries()) {
             initiativeStatusById.set(initiativeId, override.status);
         }
@@ -1466,10 +2118,11 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
         const buildSessionFallbackQueue = async () => {
             let sessionTree = null;
             try {
-                sessionTree = await client.getLiveSessions({
+                sessionTree = await withSoftTimeout("live sessions", NEXT_UP_LIVE_SESSIONS_TIMEOUT_MS, client.getLiveSessions({
                     initiative: requestedInitiativeId,
+                    projectId: requestedProjectId,
                     limit: 500,
-                });
+                }));
             }
             catch (err) {
                 degraded.push(`live sessions fallback unavailable (${safeErrorMessage(err)})`);
@@ -1501,6 +2154,8 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
                     continue;
                 if (requestedInitiativeId && initiativeId !== requestedInitiativeId)
                     continue;
+                if (allowedInitiativeIds && !allowedInitiativeIds.has(initiativeId))
+                    continue;
                 const initiativeStatus = initiativeStatusById.get(initiativeId) ?? "active";
                 if (!isInitiativeActiveStatus(initiativeStatus))
                     continue;
@@ -1508,6 +2163,12 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
                 const epoch = parseEpoch(node.updatedAt ?? node.lastEventAt ?? node.startedAt);
                 const existing = grouped.get(key);
                 if (!existing) {
+                    const runnerAgents = [];
+                    const runnerAgentSeen = new Set();
+                    pushRunnerAgent(runnerAgents, runnerAgentSeen, {
+                        id: node.agentId,
+                        name: node.agentName,
+                    });
                     grouped.set(key, {
                         initiativeId,
                         workstreamId,
@@ -1518,6 +2179,8 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
                         workstreamTitle: `Workstream ${workstreamId.slice(0, 8)}`,
                         statuses: new Set([node.status]),
                         blockers: Array.isArray(node.blockers) ? [...node.blockers] : [],
+                        runnerAgents,
+                        runnerAgentSeen,
                         latest: node,
                         latestEpoch: epoch,
                     });
@@ -1532,6 +2195,10 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
                             existing.blockers.push(blocker);
                     }
                 }
+                pushRunnerAgent(existing.runnerAgents, existing.runnerAgentSeen, {
+                    id: node.agentId,
+                    name: node.agentName,
+                });
                 if (epoch >= existing.latestEpoch) {
                     existing.latest = node;
                     existing.latestEpoch = epoch;
@@ -1551,11 +2218,22 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
                         : hasQueued
                             ? "queued"
                             : "idle";
-                const runnerAgentId = (entry.latest.agentId ?? "").trim() || "main";
-                const runnerAgentName = (entry.latest.agentName ?? "").trim() ||
-                    initiativeTitleById.get(`agent:${runnerAgentId}`) ||
-                    runnerAgentId;
+                const latestRunner = [];
+                const latestRunnerSeen = new Set();
+                pushRunnerAgent(latestRunner, latestRunnerSeen, {
+                    id: entry.latest.agentId,
+                    name: entry.latest.agentName,
+                });
+                const runnerAgents = latestRunner.length > 0
+                    ? dedupeWithPrimary(latestRunner, entry.runnerAgents)
+                    : [...entry.runnerAgents];
+                const primaryRunner = runnerAgents[0] ?? null;
+                const runnerAgentId = primaryRunner?.id ?? "unassigned";
+                const runnerAgentName = primaryRunner?.name ?? "Unassigned";
                 const pinKey = `${entry.initiativeId}:${entry.workstreamId}`;
+                if (isSuppressed(entry.initiativeId, entry.workstreamId) && queueState !== "running") {
+                    continue;
+                }
                 fallbackItems.push({
                     initiativeId: entry.initiativeId,
                     initiativeTitle: entry.initiativeTitle,
@@ -1571,10 +2249,12 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
                     nextTaskDueAt: null,
                     runnerAgentId,
                     runnerAgentName,
+                    runnerAgents,
                     runnerSource: "fallback",
                     queueState,
                     blockReason: hasBlocked
-                        ? entry.blockers[0] ?? (statusValues.includes("failed") ? "Latest run failed" : "Workstream blocked")
+                        ? entry.blockers[0] ??
+                            (statusValues.includes("failed") ? "Latest run failed" : "Workstream blocked")
                         : null,
                     isPinned: pinnedRankByKey.has(pinKey),
                     pinnedRank: pinnedRankByKey.get(pinKey) ?? null,
@@ -1591,6 +2271,10 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
                 return false;
             if (requestedInitiativeId && id !== requestedInitiativeId)
                 return false;
+            if (!initiativeMatchesRequestedProject(record))
+                return false;
+            if (allowedInitiativeIds && !allowedInitiativeIds.has(id))
+                return false;
             const status = pickString(record, ["status"]);
             return isInitiativeActiveStatus(status);
         });
@@ -1616,6 +2300,7 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
         try {
             const data = await withSoftTimeout("live agents", NEXT_UP_LIVE_AGENTS_TIMEOUT_MS, client.getLiveAgents({
                 initiative: requestedInitiativeId,
+                projectId: requestedProjectId,
                 includeIdle: true,
             }));
             for (const raw of Array.isArray(data.agents) ? data.agents : []) {
@@ -1673,13 +2358,50 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
                 return (milestone?.status?.toLowerCase() === "blocked" ||
                     workstream?.status?.toLowerCase() === "blocked");
             };
+            const normalizeSliceScope = (value) => {
+                if (value === "task" || value === "milestone" || value === "workstream") {
+                    return value;
+                }
+                return null;
+            };
+            const resolveExecutionPolicyFromActiveRuns = (activeRunIds, workstreamId) => {
+                for (const runId of activeRunIds) {
+                    const slice = autoContinueSliceRuns.get(runId);
+                    if (!slice)
+                        continue;
+                    if (typeof slice.workstreamId === "string" && slice.workstreamId.trim()) {
+                        if (slice.workstreamId.trim() !== workstreamId)
+                            continue;
+                    }
+                    const domain = (slice.domain ?? "").trim();
+                    const requiredSkills = Array.isArray(slice.requiredSkills)
+                        ? slice.requiredSkills.filter((skill) => typeof skill === "string" && skill.trim().length > 0)
+                        : [];
+                    if (!domain || requiredSkills.length === 0)
+                        continue;
+                    const executionPolicy = {
+                        domain,
+                        requiredSkills,
+                    };
+                    if (typeof slice.behaviorConfigId === "string" && slice.behaviorConfigId.trim()) {
+                        executionPolicy.profile = slice.behaviorConfigId.trim();
+                    }
+                    const scope = normalizeSliceScope(slice.scope ?? null);
+                    if (scope) {
+                        executionPolicy.sliceScopePreference = scope;
+                    }
+                    return executionPolicy;
+                }
+                return null;
+            };
             for (const workstream of workstreamNodes) {
+                const workstreamKey = `${initiativeId}:${workstream.id}`;
                 const todoTasks = graph.recentTodos
                     .map((taskId) => nodeById.get(taskId))
                     .filter((node) => node?.type === "task" &&
                     node.workstreamId === workstream.id &&
                     isTodoStatus(node.status));
-                const pinKey = `${initiativeId}:${workstream.id}`;
+                const pinKey = workstreamKey;
                 const pin = pinnedByKey.get(pinKey) ?? null;
                 const preferredTask = pin?.preferredTaskId && nodeById.get(pin.preferredTaskId)
                     ? nodeById.get(pin.preferredTaskId) ?? null
@@ -1704,12 +2426,100 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
                 const preferredReadyTask = preferredCandidates.find((task) => taskIsReady(task) && !taskHasBlockedParent(task));
                 const candidateTask = preferredReadyTask ?? readyTask ?? todoTasks[0] ?? null;
                 const autoContinueRun = runningAutoContinueForWorkstream(initiativeId, workstream.id);
-                let queueState = autoContinueRun
+                const autoContinueLane = getAutoContinueLaneForWorkstream(initiativeId, workstream.id);
+                const laneState = autoContinueLane?.state ?? null;
+                const scopedAllowedWorkstreams = Array.isArray(autoContinueRun?.allowedWorkstreamIds)
+                    ? (autoContinueRun.allowedWorkstreamIds
+                        .filter((id) => typeof id === "string" && id.trim().length > 0)
+                        .map((id) => id.trim()))
+                    : [];
+                const runScopedToCurrentWorkstream = scopedAllowedWorkstreams.length === 1 &&
+                    scopedAllowedWorkstreams[0] === workstream.id &&
+                    autoContinueRun?.status === "running";
+                const activeRunIds = Array.isArray(autoContinueRun?.activeSliceRunIds)
+                    ? autoContinueRun.activeSliceRunIds
+                        .filter((id) => typeof id === "string" && id.trim().length > 0)
+                        .map((id) => id.trim())
+                    : [];
+                const activeTaskId = (autoContinueLane?.activeTaskIds?.[0]?.trim() ||
+                    autoContinueRun?.activeTaskId?.trim() ||
+                    null) ??
+                    null;
+                const activeTaskNode = activeTaskId ? nodeById.get(activeTaskId) ?? null : null;
+                const policyTask = candidateTask ??
+                    activeTaskNode ??
+                    todoTasks.find((task) => task.workstreamId === workstream.id) ??
+                    null;
+                const derivedExecutionPolicy = policyTask
+                    ? deriveExecutionPolicy(policyTask, workstream)
+                    : null;
+                const activeExecutionPolicy = resolveExecutionPolicyFromActiveRuns(activeRunIds, workstream.id);
+                const executionPolicy = derivedExecutionPolicy ?? activeExecutionPolicy;
+                const runScope = normalizeSliceScope(autoContinueRun?.scope ?? null);
+                const preferredPolicyScope = normalizeSliceScope(executionPolicy?.sliceScopePreference ?? null);
+                const defaultScope = runScope ??
+                    (preferredPolicyScope && preferredPolicyScope !== "task"
+                        ? preferredPolicyScope
+                        : pin?.preferredMilestoneId
+                            ? "milestone"
+                            : "task");
+                const scopeSelection = selectSliceTasksByScope({
+                    scope: defaultScope,
+                    workstreamId: workstream.id,
+                    milestoneId: pin?.preferredMilestoneId ?? null,
+                    recentTodos: graph.recentTodos,
+                    nodeById,
+                    includeVerification: autoContinueRun?.includeVerification ?? false,
+                });
+                const cappedSliceTasks = typeof executionPolicy?.maxSliceTasks === "number" &&
+                    executionPolicy.maxSliceTasks > 0
+                    ? scopeSelection.tasks.slice(0, executionPolicy.maxSliceTasks)
+                    : scopeSelection.tasks;
+                const sliceTaskIds = cappedSliceTasks.length > 0
+                    ? cappedSliceTasks.map((task) => task.id)
+                    : candidateTask?.id
+                        ? [candidateTask.id]
+                        : activeTaskId
+                            ? [activeTaskId]
+                            : [];
+                const sliceMilestoneId = defaultScope === "milestone"
+                    ? scopeSelection.milestoneIds[0] ?? pin?.preferredMilestoneId ?? null
+                    : null;
+                let queueState = laneState === "running"
                     ? "running"
-                    : candidateTask
-                        ? "queued"
-                        : "idle";
+                    : runScopedToCurrentWorkstream
+                        ? "running"
+                        : candidateTask
+                            ? "queued"
+                            : "idle";
                 let blockReason = null;
+                if (laneState === "blocked") {
+                    queueState = "blocked";
+                    blockReason = autoContinueLane?.blockedReason ?? "Blocked";
+                }
+                else if (laneState === "waiting_dependency") {
+                    queueState = "blocked";
+                    if (Array.isArray(autoContinueLane?.waitingOnWorkstreamIds) &&
+                        autoContinueLane.waitingOnWorkstreamIds.length > 0) {
+                        const waitingTitles = autoContinueLane.waitingOnWorkstreamIds
+                            .map((id) => {
+                            const node = nodeById.get(id);
+                            return node?.type === "workstream" ? node.title : id;
+                        })
+                            .filter(Boolean);
+                        blockReason =
+                            waitingTitles.length > 0
+                                ? `Waiting on ${waitingTitles.slice(0, 2).join(", ")}${waitingTitles.length > 2 ? "…" : ""}`
+                                : "Waiting on dependency workstreams";
+                    }
+                    else {
+                        blockReason = "Waiting on dependency workstreams";
+                    }
+                }
+                else if (laneState === "rate_limited") {
+                    queueState = "blocked";
+                    blockReason = autoContinueLane?.blockedReason ?? "Rate-limited";
+                }
                 if (!autoContinueRun && !readyTask && candidateTask) {
                     queueState = "blocked";
                     const blockedDeps = candidateTask.dependencyIds
@@ -1729,27 +2539,48 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
                 if (!candidateTask && !autoContinueRun && !pin) {
                     continue;
                 }
+                if (isSuppressed(initiativeId, workstream.id) && queueState !== "running") {
+                    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
+                const assignedRunnerAgents = [];
+                const assignedRunnerSeen = new Set();
+                for (const agent of workstream.assignedAgents) {
+                    pushRunnerAgent(assignedRunnerAgents, assignedRunnerSeen, {
+                        id: agent.id,
+                        name: agent.name,
+                    });
+                }
+                const inferredRunnerAgents = [];
+                const inferredRunnerSeen = new Set();
+                for (const agent of graph.initiative.assignedAgents) {
+                    pushRunnerAgent(inferredRunnerAgents, inferredRunnerSeen, {
+                        id: agent.id,
+                        name: agent.name,
+                    });
+                }
+                for (const agent of liveAgentsByInitiative.get(initiativeId) ?? []) {
+                    pushRunnerAgent(inferredRunnerAgents, inferredRunnerSeen, {
+                        id: agent.id,
+                        name: agent.name,
+                    });
+                }
+                if (autoContinueRun?.agentId) {
+                    pushRunnerAgent(inferredRunnerAgents, inferredRunnerSeen, {
+                        id: autoContinueRun.agentId,
+                        name: agentCatalogById.get(autoContinueRun.agentId)?.name ??
+                            autoContinueRun.agentId,
+                    });
+                }
+                const runnerAgents = assignedRunnerAgents.length > 0 ? assignedRunnerAgents : inferredRunnerAgents;
+                const runnerSource = assignedRunnerAgents.length > 0
                     ? "assigned"
-                    : inferredAgent
+                    : runnerAgents.length > 0
                         ? "inferred"
                         : "fallback";
-                const resolvedRunner = assignedAgent ?? inferredAgent;
-                const runnerAgentId = resolvedRunner?.id ?? autoContinueRun?.agentId ?? "main";
-                const runnerAgentName = resolvedRunner?.name ??
-                    agentCatalogById.get(runnerAgentId)?.name ??
-                    runnerAgentId;
+                const primaryRunner = runnerAgents[0] ?? null;
+                const runnerAgentId = primaryRunner?.id ?? "unassigned";
+                const runnerAgentName = primaryRunner?.name ?? "Unassigned";
                 itemsForInitiative.push({
                     initiativeId,
                     initiativeTitle,
@@ -1758,25 +2589,50 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
                     workstreamTitle: workstream.title,
                     workstreamStatus: workstream.status,
                     nextTaskId: candidateTask?.id ??
-                        (autoContinueRun?.activeTaskId?.trim() || null),
+                        activeTaskId,
                     nextTaskTitle: candidateTask?.title ??
-                        (autoContinueRun?.activeTaskId
-                            ? nodeById.get(autoContinueRun.activeTaskId)?.title ?? null
+                        ((activeTaskId)
+                            ? nodeById.get(activeTaskId)?.title ?? null
                             : null),
                     nextTaskPriority: candidateTask?.priorityNum ?? null,
                     nextTaskDueAt: candidateTask?.dueDate ?? null,
                     runnerAgentId,
                     runnerAgentName,
+                    runnerAgents,
                     runnerSource,
                     queueState,
                     blockReason,
                     isPinned: Boolean(pin),
                     pinnedRank: pin ? (pinnedRankByKey.get(pinKey) ?? null) : null,
+                    sliceScope: defaultScope,
+                    sliceTaskIds,
+                    sliceTaskCount: sliceTaskIds.length,
+                    sliceMilestoneId,
+                    executionPolicy,
                     autoContinue: autoContinueRun
                         ? {
                             status: autoContinueRun.status,
                             activeTaskId: autoContinueRun.activeTaskId,
                             activeRunId: autoContinueRun.activeRunId,
+                            activeTaskIds: Array.isArray(autoContinueRun.activeTaskIds)
+                                ? autoContinueRun.activeTaskIds
+                                : [],
+                            activeRunIds: Array.isArray(autoContinueRun.activeSliceRunIds)
+                                ? autoContinueRun.activeSliceRunIds
+                                : [],
+                            laneState,
+                            laneBlockedReason: autoContinueLane?.blockedReason ?? null,
+                            laneWaitingOnWorkstreamIds: Array.isArray(autoContinueLane?.waitingOnWorkstreamIds)
+                                ? autoContinueLane.waitingOnWorkstreamIds
+                                : [],
+                            laneRetryAt: autoContinueLane?.retryAt ?? null,
+                            maxParallelSlices: typeof autoContinueRun.maxParallelSlices === "number"
+                                ? autoContinueRun.maxParallelSlices
+                                : 1,
+                            parallelMode: (typeof autoContinueRun.parallelMode === "string" &&
+                                autoContinueRun.parallelMode.toLowerCase() === "iwmt"
+                                ? "iwmt"
+                                : "iwmt"),
                             stopReason: autoContinueRun.stopReason,
                             updatedAt: autoContinueRun.updatedAt,
                         }
@@ -1794,6 +2650,44 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
                     const workstream = nodeById.get(workstreamId);
                     if (!workstream || workstream.type !== "workstream")
                         continue;
+                    const lane = getAutoContinueLaneForWorkstream(initiativeId, workstream.id);
+                    if (!lane &&
+                        !(typeof run.activeRunId === "string" && run.activeRunId.trim().length > 0)) {
+                        continue;
+                    }
+                    const laneState = lane?.state ?? null;
+                    const activeRunIds = Array.isArray(run.activeSliceRunIds)
+                        ? run.activeSliceRunIds
+                            .filter((id) => typeof id === "string" && id.trim().length > 0)
+                            .map((id) => id.trim())
+                        : [];
+                    const activeTaskId = lane?.activeTaskIds?.[0] ?? run.activeTaskId;
+                    const activeTaskNode = activeTaskId ? nodeById.get(activeTaskId) ?? null : null;
+                    const executionPolicy = (activeTaskNode ? deriveExecutionPolicy(activeTaskNode, workstream) : null) ??
+                        resolveExecutionPolicyFromActiveRuns(activeRunIds, workstream.id);
+                    const sliceScope = normalizeSliceScope(run.scope ?? null) ?? "task";
+                    const sliceTaskIds = lane?.activeTaskIds?.length
+                        ? lane.activeTaskIds
+                        : activeTaskId
+                            ? [activeTaskId]
+                            : [];
+                    const queueState = laneState === "running"
+                        ? "running"
+                        : laneState === "blocked" ||
+                            laneState === "waiting_dependency" ||
+                            laneState === "rate_limited"
+                            ? "blocked"
+                            : "queued";
+                    if (isSuppressed(initiativeId, workstream.id) && queueState !== "running") {
+                        continue;
+                    }
+                    const runRunnerAgents = [];
+                    const runRunnerSeen = new Set();
+                    pushRunnerAgent(runRunnerAgents, runRunnerSeen, {
+                        id: run.agentId,
+                        name: agentCatalogById.get(run.agentId)?.name ?? run.agentId,
+                    });
+                    const runPrimaryRunner = runRunnerAgents[0] ?? null;
                     itemsForInitiative.push({
                         initiativeId,
                         initiativeTitle,
@@ -1801,23 +2695,52 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
                         workstreamId: workstream.id,
                         workstreamTitle: workstream.title,
                         workstreamStatus: workstream.status,
-                        nextTaskId: run.activeTaskId,
-                        nextTaskTitle: run.activeTaskId
-                            ? nodeById.get(run.activeTaskId)?.title ?? null
+                        nextTaskId: activeTaskId ?? null,
+                        nextTaskTitle: activeTaskId
+                            ? nodeById.get(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,
+                        runnerAgentId: runPrimaryRunner?.id ?? "unassigned",
+                        runnerAgentName: runPrimaryRunner?.name ?? "Unassigned",
+                        runnerAgents: runRunnerAgents,
+                        runnerSource: runPrimaryRunner ? "inferred" : "fallback",
+                        queueState,
+                        blockReason: queueState === "blocked"
+                            ? lane?.blockedReason ?? "Blocked"
+                            : null,
                         isPinned: Boolean(pinnedByKey.get(`${initiativeId}:${workstream.id}`)),
                         pinnedRank: pinnedRankByKey.get(`${initiativeId}:${workstream.id}`) ?? null,
+                        sliceScope,
+                        sliceTaskIds,
+                        sliceTaskCount: sliceTaskIds.length,
+                        sliceMilestoneId: sliceScope === "milestone"
+                            ? activeTaskNode?.milestoneId ?? null
+                            : null,
+                        executionPolicy,
                         autoContinue: {
                             status: run.status,
                             activeTaskId: run.activeTaskId,
                             activeRunId: run.activeRunId,
+                            activeTaskIds: Array.isArray(run.activeTaskIds)
+                                ? run.activeTaskIds
+                                : [],
+                            activeRunIds: Array.isArray(run.activeSliceRunIds)
+                                ? run.activeSliceRunIds
+                                : [],
+                            laneState,
+                            laneBlockedReason: lane?.blockedReason ?? null,
+                            laneWaitingOnWorkstreamIds: Array.isArray(lane?.waitingOnWorkstreamIds)
+                                ? lane.waitingOnWorkstreamIds
+                                : [],
+                            laneRetryAt: lane?.retryAt ?? null,
+                            maxParallelSlices: typeof run.maxParallelSlices === "number"
+                                ? run.maxParallelSlices
+                                : 1,
+                            parallelMode: typeof run.parallelMode === "string" &&
+                                run.parallelMode.toLowerCase() === "iwmt"
+                                ? "iwmt"
+                                : "iwmt",
                             stopReason: run.stopReason,
                             updatedAt: run.updatedAt,
                         },
@@ -1839,7 +2762,7 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
         return { items, degraded };
     }
     async function buildNextUpQueue(input) {
-        const key = nextUpQueueCacheKeyFor(input?.initiativeId?.trim() || null);
+        const key = nextUpQueueCacheKeyFor(input?.initiativeId?.trim() || null, input?.projectId?.trim() || null);
         const fresh = readNextUpQueueCache(key, { allowStale: false });
         if (fresh)
             return fresh;
@@ -1883,6 +2806,14 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
             nextUpQueueInFlight.delete(key);
         }
     }
+    // Prime queue cache shortly after boot so first dashboard paint is not cold.
+    const prewarmNextUpQueue = () => {
+        void buildNextUpQueue({ initiativeId: null, projectId: null }).catch(() => {
+            // best effort prewarm only
+        });
+    };
+    const nextUpPrewarmTimer = setTimeout(prewarmNextUpQueue, 75);
+    nextUpPrewarmTimer.unref?.();
     const autoContinueTimer = setInterval(() => {
         void tickAllAutoContinue();
     }, AUTO_CONTINUE_TICK_MS);
@@ -1916,6 +2847,12 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
         formatInitiatives,
         getOnboardingState: async () => getOnboardingState(await onboarding.getStatus()),
     });
+    registerUsageRoutes(apiRouter, {
+        client,
+        listActivityPage: ({ limit, runId, since, until, cursor }) => listActivityPage({ limit, runId, since, until, cursor }),
+        sendJson,
+        safeErrorMessage,
+    });
     registerAgentSuiteRoutes(apiRouter, {
         pluginVersion: config.pluginVersion,
         telemetryDistinctId,
@@ -1926,6 +2863,11 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
         applyOrgxAgentSuitePlan,
         generateAgentSuiteOperationId,
         updateSkillPackPolicy,
+        rollbackSkillPackPolicy,
+        fetchAgentRuntimeSettings: ({ workspaceId, projectId } = {}) => client.getClientAgentRuntimeSettings({
+            workspaceId: workspaceId ?? projectId ?? null,
+        }),
+        updateAgentRuntimeSettings: (payload) => client.updateClientAgentRuntimeSettings(payload),
         posthogCapture,
         sendJson,
         safeErrorMessage,
@@ -1944,13 +2886,20 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
         sendJson,
         safeErrorMessage,
     });
+    registerSentinelsCatalogRoutes(apiRouter, {
+        sendJson,
+        safeErrorMessage,
+    });
     registerMissionControlReadRoutes(apiRouter, {
         autoContinueRuns,
         defaultAutoContinueTokenBudget,
+        defaultAutoContinueMaxParallelSlices,
         autoContinueTickMs: AUTO_CONTINUE_TICK_MS,
         buildMissionControlGraph: (initiativeId) => buildMissionControlGraph(client, initiativeId),
         applyLocalInitiativeOverrideToGraph: (graph) => applyLocalInitiativeOverrideToGraph(graph),
+        listInitiativeIdsForProject: ({ projectId }) => listInitiativeIdsForProject({ projectId }),
         buildNextUpQueue,
+        rawRequest: (requestMethod, requestPath, body) => client.rawRequest(requestMethod, requestPath, body),
         sendJson,
         safeErrorMessage,
     });
@@ -1993,12 +2942,127 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
         applyLocalInitiativeOverrides,
         formatInitiatives,
         getSnapshot,
+        scheduleWorkstreamReassignment: async (input) => {
+            const initiativeId = input.initiativeId.trim();
+            const workstreamId = input.workstreamId.trim();
+            if (!initiativeId || !workstreamId)
+                return null;
+            const normalizedStatus = (input.status ?? "").trim().toLowerCase();
+            const shouldRedispatch = normalizedStatus === "active" ||
+                normalizedStatus === "ready" ||
+                normalizedStatus === "queued" ||
+                normalizedStatus === "running" ||
+                normalizedStatus === "in_progress" ||
+                normalizedStatus === "pending";
+            if (!shouldRedispatch)
+                return null;
+            if (!isDispatchableWorkstreamStatus(normalizedStatus))
+                return null;
+            const liveRun = runningAutoContinueForWorkstream(initiativeId, workstreamId);
+            return await scheduleAutoFixForWorkstream({
+                initiativeId,
+                workstreamId,
+                runId: liveRun?.activeRunId ?? null,
+                event: input.event,
+                requestedByAgentId: "system",
+                requestedByAgentName: "System",
+                graceMs: 5_000,
+            });
+        },
         sendJson,
         safeErrorMessage,
     });
+    const readCachedDecisionRows = () => {
+        const snapshots = [
+            readSnapshotResponseCache("live-snapshot"),
+            readSnapshotResponseCache("dashboard-bundle"),
+            readSnapshotResponseCache("live-snapshot-v2"),
+        ];
+        const rows = [];
+        for (const snapshot of snapshots) {
+            if (!snapshot || typeof snapshot !== "object")
+                continue;
+            const decisionsRaw = snapshot.decisions;
+            if (!Array.isArray(decisionsRaw))
+                continue;
+            for (const entry of decisionsRaw) {
+                if (!entry || typeof entry !== "object" || Array.isArray(entry))
+                    continue;
+                rows.push(entry);
+            }
+        }
+        return rows;
+    };
+    const emitDecisionResolvedActivity = async (input) => {
+        const ids = Array.from(new Set(input.ids
+            .filter((id) => typeof id === "string")
+            .map((id) => id.trim())
+            .filter(Boolean)));
+        if (ids.length === 0)
+            return;
+        const decisionById = new Map();
+        for (const row of readCachedDecisionRows()) {
+            const rowId = pickString(row, ["id"])?.trim() ?? "";
+            if (!rowId || decisionById.has(rowId))
+                continue;
+            decisionById.set(rowId, row);
+        }
+        for (const decisionId of ids) {
+            const row = decisionById.get(decisionId) ?? null;
+            const decisionTitle = pickString(row ?? {}, ["title", "summary"]) ??
+                `Decision ${decisionId.slice(0, 8)}`;
+            const scopedInitiativeId = input.initiativeId ??
+                pickString(row ?? {}, ["initiative_id", "initiativeId"]) ??
+                null;
+            const scopedRunId = input.sliceRunId ??
+                pickString(row ?? {}, [
+                    "run_id",
+                    "runId",
+                    "source_run_id",
+                    "sourceRunId",
+                    "correlation_id",
+                    "correlationId",
+                ]) ??
+                null;
+            await emitActivitySafe({
+                initiativeId: scopedInitiativeId,
+                runId: scopedRunId ?? undefined,
+                correlationId: scopedRunId ?? undefined,
+                phase: "review",
+                level: "info",
+                message: `Decision ${input.action === "approve" ? "approved" : "rejected"}: ${decisionTitle}`,
+                progressPct: 100,
+                nextStep: input.action === "approve"
+                    ? "Execution can continue with the approved direction."
+                    : "Review the rejected decision and provide revised guidance to continue safely.",
+                metadata: {
+                    event: "decision_resolved",
+                    action: input.action,
+                    resolver: "human",
+                    decision_id: decisionId,
+                    decision_ids: ids,
+                    decision_title: decisionTitle,
+                    initiative_id: scopedInitiativeId,
+                    workstream_id: pickString(row ?? {}, ["workstream_id", "workstreamId"]) ?? null,
+                    source_run_id: scopedRunId,
+                    option_id: input.optionId ?? null,
+                    note: input.note ?? null,
+                    slice_run_id: input.sliceRunId ?? null,
+                },
+            });
+        }
+    };
     registerDecisionActionsRoutes(apiRouter, {
         parseJsonRequest,
-        bulkDecideDecisions: (ids, action, note) => client.bulkDecideDecisions(ids, action, note),
+        bulkDecideDecisions: (ids, action, input) => client.bulkDecideDecisions(ids, action, input),
+        emitDecisionResolvedActivity: async (ids, action, input) => {
+            await emitDecisionResolvedActivity({
+                ids,
+                action,
+                note: input?.note ?? null,
+                optionId: input?.optionId ?? null,
+            });
+        },
         sendJson,
         safeErrorMessage,
     });
@@ -2009,6 +3073,147 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
         createRunCheckpoint: (runId, input) => client.createRunCheckpoint(runId, input),
         restoreRunCheckpoint: (runId, input) => client.restoreRunCheckpoint(runId, input),
         runAction: (runId, action, input) => client.runAction(runId, action, input),
+        markRunCompleted: async (runId, input) => {
+            const normalizedRunId = runId.trim();
+            if (!normalizedRunId) {
+                throw new Error("runId is required");
+            }
+            const nowIso = new Date().toISOString();
+            const reason = input.reason?.trim() || null;
+            const message = reason
+                ? `Marked completed from dashboard (${reason}).`
+                : "Marked completed from dashboard.";
+            const existingRun = getAgentRun(normalizedRunId);
+            // ── Try OrgX-side completion first (for remote sessions) ────────────
+            let remoteOk = false;
+            try {
+                await client.updateEntity("run", normalizedRunId, {
+                    status: "completed",
+                    phase: "completed",
+                });
+                remoteOk = true;
+            }
+            catch {
+                // OrgX may not support updating runs directly — fall through to local
+            }
+            // ── Local operations (defensive — partial failures don't block) ─────
+            let runtimeRecord = null;
+            try {
+                runtimeRecord = upsertRuntimeInstanceFromHook({
+                    source_client: "api",
+                    event: "session_stop",
+                    run_id: normalizedRunId,
+                    correlation_id: normalizedRunId,
+                    initiative_id: existingRun?.initiativeId ?? null,
+                    workstream_id: existingRun?.workstreamId ?? null,
+                    task_id: existingRun?.taskId ?? null,
+                    agent_id: existingRun?.agentId ?? null,
+                    phase: "completed",
+                    message,
+                    timestamp: nowIso,
+                    metadata: {
+                        source: "dashboard_manual_complete",
+                        reason,
+                    },
+                });
+            }
+            catch (err) {
+                console.error(`[markRunCompleted] upsertRuntime failed for ${normalizedRunId}:`, err);
+            }
+            try {
+                markAgentRunStopped(normalizedRunId);
+            }
+            catch (err) {
+                console.error(`[markRunCompleted] markAgentRunStopped failed for ${normalizedRunId}:`, err);
+            }
+            if (runtimeRecord) {
+                broadcastRuntimeSse("runtime.updated", runtimeRecord);
+            }
+            clearSnapshotResponseCache();
+            try {
+                appendActivityItems([
+                    {
+                        id: randomUUID(),
+                        type: "run_completed",
+                        title: message,
+                        description: reason,
+                        agentId: runtimeRecord?.agentId ?? existingRun?.agentId ?? null,
+                        agentName: runtimeRecord?.agentName ?? null,
+                        requesterAgentId: runtimeRecord?.agentId ?? existingRun?.agentId ?? null,
+                        requesterAgentName: runtimeRecord?.agentName ?? null,
+                        executorAgentId: runtimeRecord?.agentId ?? existingRun?.agentId ?? null,
+                        executorAgentName: runtimeRecord?.agentName ?? null,
+                        runId: normalizedRunId,
+                        initiativeId: runtimeRecord?.initiativeId ?? existingRun?.initiativeId ?? null,
+                        timestamp: nowIso,
+                        phase: "completed",
+                        state: "done",
+                        summary: message,
+                        metadata: {
+                            source: "dashboard_manual_complete",
+                            reason,
+                            remoteOk,
+                            event: "dashboard_run_mark_completed",
+                        },
+                    },
+                ]);
+            }
+            catch (err) {
+                console.error(`[markRunCompleted] appendActivity failed for ${normalizedRunId}:`, err);
+            }
+            // ── Write to outbox so snapshot merge picks up the completion ───────
+            try {
+                const outboxSessionId = runtimeRecord?.initiativeId ?? existingRun?.initiativeId ?? normalizedRunId;
+                const outboxActivityItem = {
+                    id: randomUUID(),
+                    type: "run_completed",
+                    title: message,
+                    description: reason,
+                    agentId: runtimeRecord?.agentId ?? existingRun?.agentId ?? null,
+                    agentName: runtimeRecord?.agentName ?? null,
+                    requesterAgentId: runtimeRecord?.agentId ?? existingRun?.agentId ?? null,
+                    requesterAgentName: runtimeRecord?.agentName ?? null,
+                    executorAgentId: runtimeRecord?.agentId ?? existingRun?.agentId ?? null,
+                    executorAgentName: runtimeRecord?.agentName ?? null,
+                    runId: normalizedRunId,
+                    initiativeId: runtimeRecord?.initiativeId ?? existingRun?.initiativeId ?? null,
+                    timestamp: nowIso,
+                    phase: "completed",
+                    state: "done",
+                    summary: message,
+                    metadata: {
+                        source: "dashboard_manual_complete",
+                        reason,
+                        remoteOk,
+                        event: "dashboard_run_mark_completed",
+                    },
+                };
+                await appendToOutbox(outboxSessionId, {
+                    id: outboxActivityItem.id,
+                    type: "outcome",
+                    timestamp: nowIso,
+                    payload: {
+                        runId: normalizedRunId,
+                        status: "completed",
+                        reason,
+                        remoteOk,
+                    },
+                    activityItem: outboxActivityItem,
+                });
+            }
+            catch (err) {
+                console.error(`[markRunCompleted] outbox write failed for ${normalizedRunId}:`, err);
+            }
+            return {
+                ok: true,
+                data: {
+                    runId: normalizedRunId,
+                    action: "complete",
+                    status: "completed",
+                    remoteOk,
+                },
+            };
+        },
         sendJson,
         safeErrorMessage,
     });
@@ -2032,6 +3237,20 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
         sendJson,
         safeErrorMessage,
     });
+    registerChatRoutes(apiRouter, {
+        parseJsonRequest,
+        pickString,
+        parsePositiveInt,
+        emitActivitySafe,
+        sendJson,
+        safeErrorMessage,
+    });
+    registerRealtimeOrchestratorRoutes(apiRouter, {
+        parseJsonRequest,
+        rawRequest: (requestMethod, requestPath, body) => client.rawRequest(requestMethod, requestPath, body),
+        sendJson,
+        safeErrorMessage,
+    });
     registerMissionControlActionsRoutes(apiRouter, {
         parseJsonRequest,
         pickString,
@@ -2049,11 +3268,17 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
         stopAutoContinueRun,
         updateInitiativeAutoContinueState,
         tickAllAutoContinue,
+        scheduleAutoFixForWorkstream,
         upsertNextUpQueuePin,
         removeNextUpQueuePin,
+        suppressNextUpQueueItem,
         setNextUpQueuePinOrder,
+        clearNextUpQueueCache,
         resolveAutoAssignments,
+        buildMissionControlGraph: (initiativeId) => buildMissionControlGraph(client, initiativeId),
+        applyLocalInitiativeOverrideToGraph: (graph) => applyLocalInitiativeOverrideToGraph(graph),
         client,
+        rawRequest: (requestMethod, requestPath, body) => client.rawRequest(requestMethod, requestPath, body),
         sendJson,
         safeErrorMessage,
     });
@@ -2095,10 +3320,11 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
         parseJsonRequest,
         pickString,
         summarizeActivityHeadline,
-        getLiveAgents: ({ initiative, includeIdle }) => client.getLiveAgents({ initiative, includeIdle }),
-        getLiveInitiatives: ({ id, limit }) => client.getLiveInitiatives({ id, limit }),
-        getLiveDecisions: ({ status, limit }) => client.getLiveDecisions({ status, limit }),
+        getLiveAgents: ({ initiative, projectId, includeIdle }) => client.getLiveAgents({ initiative, projectId, includeIdle }),
+        getLiveInitiatives: ({ id, projectId, limit, offset }) => client.getLiveInitiatives({ id, projectId, limit, offset }),
+        getLiveDecisions: ({ status, projectId, limit }) => client.getLiveDecisions({ status, projectId, limit }),
         getHandoffs: () => client.getHandoffs(),
+        listInitiativeIdsForProject: ({ projectId }) => listInitiativeIdsForProject({ projectId }),
         loadLocalOpenClawSnapshot,
         toLocalLiveAgents,
         toLocalLiveInitiatives,
@@ -2107,9 +3333,15 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
         sendJson,
         safeErrorMessage,
     });
+    registerLiveTerminalRoutes(apiRouter, {
+        parseJsonRequest,
+        sendJson,
+        safeErrorMessage,
+    });
     registerLiveLegacyRoutes(apiRouter, {
-        getLiveSessions: ({ initiative, limit }) => client.getLiveSessions({ initiative, limit }),
-        getLiveActivity: ({ run, since, limit }) => client.getLiveActivity({ run, since, limit }),
+        getLiveSessions: ({ initiative, projectId, limit }) => client.getLiveSessions({ initiative, projectId, limit }),
+        getLiveActivity: ({ run, since, projectId, limit }) => client.getLiveActivity({ run, since, projectId, limit }),
+        listInitiativeIdsForProject: ({ projectId }) => listInitiativeIdsForProject({ projectId }),
         listRuntimeInstances,
         injectRuntimeInstancesAsSessions,
         enrichSessionsWithRuntime,
@@ -2171,16 +3403,18 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
         toLocalSessionTree,
         toLocalLiveActivity,
         toLocalLiveAgents,
-        getLiveSessions: ({ initiative, limit }) => client.getLiveSessions({ initiative, limit }),
-        getLiveActivity: ({ run, since, limit }) => client.getLiveActivity({ run, since, limit }),
+        getLiveSessions: ({ initiative, projectId, limit }) => client.getLiveSessions({ initiative, projectId, limit }),
+        getLiveActivity: ({ run, since, projectId, limit }) => client.getLiveActivity({ run, since, projectId, limit }),
         getHandoffs: () => client.getHandoffs(),
-        getLiveDecisions: ({ status, limit }) => client.getLiveDecisions({ status, limit }),
-        getLiveAgents: ({ initiative, includeIdle }) => client.getLiveAgents({ initiative, includeIdle }),
+        getLiveDecisions: ({ status, projectId, limit }) => client.getLiveDecisions({ status, projectId, limit }),
+        getLiveAgents: ({ initiative, projectId, includeIdle }) => client.getLiveAgents({ initiative, projectId, includeIdle }),
+        listInitiativeIdsForProject: ({ projectId }) => listInitiativeIdsForProject({ projectId }),
         mapDecisionEntity: (entry) => mapDecisionEntity(entry),
         applyAgentContextsToSessionTree,
         applyAgentContextsToActivity,
         mergeSessionTrees,
         mergeActivities,
+        semanticActivityKey,
         listRuntimeInstances,
         injectRuntimeInstancesAsSessions,
         enrichSessionsWithRuntime,
@@ -2196,6 +3430,14 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
             lastSnapshotActivityFingerprint = state.lastFingerprint;
             lastSnapshotActivityPersistAt = state.lastPersistAt;
         },
+        parseJsonRequest,
+        buildNextUpQueue: ({ initiativeId, projectId }) => buildNextUpQueue({ initiativeId, projectId }),
+        bulkDecideDecisions: (ids, action, input) => client.bulkDecideDecisions(ids, action, input),
+        emitDecisionResolvedActivity: async (input) => {
+            await emitDecisionResolvedActivity(input);
+        },
+        runAction: (runId, action, input) => client.runAction(runId, action, input),
+        listChatThreads: ({ commandCenterId, initiativeId, limit, offset }) => listChatThreads({ commandCenterId, initiativeId, limit, offset }),
         sendJson,
     });
     registerRuntimeHookRoutes(apiRouter, {
@@ -2232,12 +3474,81 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
         sendJson,
         safeErrorMessage,
     });
+    registerLiveTerminalRoutes(apiRouter, {
+        parseJsonRequest,
+        sendJson,
+        safeErrorMessage,
+    });
+    registerLiveTriageRoutes(apiRouter, {
+        parseJsonRequest,
+        sendJson,
+        getDecisions: (workspaceId) => {
+            // Return cached decisions from latest snapshot, or empty array
+            const normalizedWorkspaceId = (workspaceId ?? "").trim();
+            const scopedKeys = normalizedWorkspaceId
+                ? [
+                    `live-snapshot:${normalizedWorkspaceId}`,
+                    `live-snapshot-v2:${normalizedWorkspaceId}`,
+                    `dashboard-bundle:${normalizedWorkspaceId}`,
+                ]
+                : [];
+            const fallbackKeys = ["live-snapshot", "dashboard-bundle", "live-snapshot-v2"];
+            const keys = [...scopedKeys, ...fallbackKeys];
+            try {
+                for (const key of keys) {
+                    const cached = readSnapshotResponseCache(key);
+                    if (!cached || typeof cached !== "object" || !("decisions" in cached))
+                        continue;
+                    const decisions = cached.decisions;
+                    if (Array.isArray(decisions))
+                        return decisions;
+                }
+            }
+            catch {
+                // best effort
+            }
+            return [];
+        },
+        getBlockerEvents: () => {
+            // Extract blocker events from recent activity
+            // In future, this will read from a dedicated blocker store
+            return [];
+        },
+        resolveDecisionAction: async (decisionId, action, note, optionId) => {
+            try {
+                await client.bulkDecideDecisions([decisionId], action, { note: note ?? undefined, optionId: optionId ?? undefined });
+                return { ok: true };
+            }
+            catch (err) {
+                return {
+                    ok: false,
+                    error: err instanceof Error ? err.message : "Decision action failed",
+                };
+            }
+        },
+        emitDecisionResolvedActivity: async (input) => {
+            await emitDecisionResolvedActivity(input);
+        },
+    });
     return async function handler(req, res) {
         const method = (req.method ?? "GET").toUpperCase();
         const rawUrl = req.url ?? "/";
         const [path, queryString] = rawUrl.split("?", 2);
         const url = path;
         const searchParams = new URLSearchParams(queryString ?? "");
+        // Legacy deep-link compatibility:
+        // Older launch paths still point at /workspace-hub. Route those into
+        // the current dashboard entrypoint while preserving query params.
+        if (url === "/workspace-hub" || url === "/workspace-hub/") {
+            const suffix = queryString && queryString.trim().length > 0 ? `?${queryString}` : "";
+            res.writeHead(302, {
+                Location: `/orgx/live${suffix}`,
+                ...SECURITY_HEADERS,
+                ...CORS_HEADERS,
+            });
+            res.end();
+            return true;
+        }
         // Only handle /orgx paths — return false for everything else
         if (!url.startsWith("/orgx")) {
             return false;
@@ -2317,9 +3628,13 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
                     const cacheControl = assetExt === ".js" || assetExt === ".css"
                         ? "no-cache"
                         : "public, max-age=31536000, immutable";
-                    sendFile(res, assetPath, cacheControl);
+                    sendFile(req, res, assetPath, cacheControl);
                 }
                 else {
+                    if (/^assets\/[A-Za-z0-9_-]+\.js$/i.test(subPath)) {
+                        sendStaleChunkRecovery(res);
+                        return true;
+                    }
                     send404(res);
                 }
                 return true;
@@ -2328,12 +3643,12 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
             if (subPath) {
                 const filePath = resolveSafeDistPath(subPath);
                 if (filePath && existsSync(filePath)) {
-                    sendFile(res, filePath, "no-cache");
+                    sendFile(req, res, filePath, "no-cache");
                     return true;
                 }
             }
             // SPA fallback: serve index.html for all other routes under /orgx/live
-            sendIndexHtml(res);
+            sendIndexHtml(req, res);
             return true;
         }
         // Catch-all for /orgx but not /orgx/live or /orgx/api