@useorgx/openclaw-plugin 0.4.6 → 0.4.8

package/dist/http-handler.js

@@ -17,7 +17,7 @@
  *   /orgx/api/runs/:id/checkpoints/:checkpointId/restore → restore checkpoint
  *   /orgx/api/runs/:id/actions/:action → run control action
  */
-import { readFileSync, existsSync, mkdirSync, chmodSync, createWriteStream, readdirSync, statSync, writeFileSync, } from "node:fs";
+import { readFileSync, existsSync, mkdirSync, chmodSync, createWriteStream, readdirSync, statSync, writeFileSync, openSync, readSync, closeSync, } from "node:fs";
 import { homedir } from "node:os";
 import { join, extname, normalize, resolve, relative, sep, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
@@ -25,6 +25,7 @@ import { spawn, spawnSync } from "node:child_process";
 import { createHash, randomUUID } from "node:crypto";
 import { backupCorruptFileSync, writeFileAtomicSync } from "./fs-utils.js";
 import { getOrgxPluginConfigDir } from "./paths.js";
+import { registerArtifact } from "./artifacts/register-artifact.js";
 import { readNextUpQueuePins, removeNextUpQueuePin, setNextUpQueuePinOrder, 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";
@@ -35,6 +36,7 @@ import { readAgentContexts, upsertAgentContext, upsertRunContext } from "./agent
 import { getAgentRun, markAgentRunStopped, readAgentRuns, upsertAgentRun, } from "./agent-run-store.js";
 import { appendEntityComment, listEntityComments, mergeEntityComments, } from "./entity-comment-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 { computeMilestoneRollup, computeWorkstreamRollup, } from "./reporting/rollups.js";
@@ -53,11 +55,17 @@ async function resolveSkillPackOverrides(input) {
     const getSkillPack = input.client.getSkillPack;
     if (typeof getSkillPack !== "function")
         return state.overrides;
-    const refreshed = await refreshSkillPackState({
-        getSkillPack: (args) => getSkillPack(args),
-        force,
-    });
-    return refreshed.state.overrides;
+    try {
+        const refreshed = await refreshSkillPackState({
+            getSkillPack: (args) => getSkillPack(args),
+            force,
+        });
+        return refreshed.state.overrides;
+    }
+    catch {
+        // If refresh fails (network, disk, etc.), fall back to cached overrides.
+        return state.overrides;
+    }
 }
 function safeErrorMessage(err) {
     if (err instanceof Error)
@@ -96,6 +104,167 @@ function isUnauthorizedOrgxError(err) {
 }
 const ACTIVITY_WARM_THROTTLE_MS = 30_000;
 const activityWarmByKey = new Map();
+const SNAPSHOT_RESPONSE_CACHE_TTL_MS = 1_500;
+const SNAPSHOT_RESPONSE_CACHE_MAX_ENTRIES = 16;
+const SNAPSHOT_ACTIVITY_PERSIST_MIN_INTERVAL_MS = 15_000;
+const SNAPSHOT_ACTIVITY_FINGERPRINT_DEPTH = 8;
+let lastSnapshotActivityPersistAt = 0;
+let lastSnapshotActivityFingerprint = "";
+const snapshotResponseCache = new Map();
+const ACTIVITY_DECISION_EVENT_HINTS = new Set([
+    "decision_buffered",
+    "auto_continue_spawn_guard_blocked",
+    "autopilot_slice_mcp_handshake_failed",
+    "autopilot_slice_timeout",
+    "autopilot_slice_log_stall",
+]);
+const ACTIVITY_ARTIFACT_EVENT_HINTS = new Set([
+    "autopilot_slice_artifact_buffered",
+]);
+function normalizeActivityBucket(value) {
+    if (typeof value !== "string")
+        return null;
+    const normalized = value.trim().toLowerCase();
+    if (normalized === "artifact")
+        return "artifact";
+    if (normalized === "decision")
+        return "decision";
+    if (normalized === "message")
+        return "message";
+    return null;
+}
+function activityMetadataBoolean(metadata, keys) {
+    if (!metadata)
+        return null;
+    for (const key of keys) {
+        const value = metadata[key];
+        if (typeof value === "boolean")
+            return value;
+        if (typeof value === "string") {
+            const normalized = value.trim().toLowerCase();
+            if (normalized === "true")
+                return true;
+            if (normalized === "false")
+                return false;
+        }
+    }
+    return null;
+}
+function activityMetadataNumber(metadata, keys) {
+    if (!metadata)
+        return null;
+    for (const key of keys) {
+        const value = metadata[key];
+        if (typeof value === "number" && Number.isFinite(value)) {
+            return Math.max(0, value);
+        }
+        if (typeof value === "string") {
+            const parsed = Number(value);
+            if (Number.isFinite(parsed)) {
+                return Math.max(0, parsed);
+            }
+        }
+    }
+    return null;
+}
+function activityMetadataEventName(metadata) {
+    if (!metadata)
+        return null;
+    const raw = metadata.event;
+    if (typeof raw !== "string")
+        return null;
+    const normalized = raw.trim().toLowerCase();
+    return normalized.length > 0 ? normalized : null;
+}
+function deriveStructuredActivityBucket(input) {
+    const metadata = input.metadata;
+    const explicit = normalizeActivityBucket(input.explicitBucket) ??
+        normalizeActivityBucket(metadata?.activity_bucket) ??
+        normalizeActivityBucket(metadata?.activityBucket) ??
+        normalizeActivityBucket(metadata?.bucket) ??
+        null;
+    if (explicit)
+        return explicit;
+    const event = activityMetadataEventName(metadata);
+    const decisionRequired = activityMetadataBoolean(metadata, ["decision_required", "decisionRequired"]) === true;
+    const artifacts = activityMetadataNumber(metadata, ["artifacts", "artifact_count", "artifactCount"]) ?? 0;
+    const decisions = activityMetadataNumber(metadata, ["decisions", "decision_count", "decisionCount"]) ?? 0;
+    const blockingDecisions = activityMetadataNumber(metadata, [
+        "blocking_decisions",
+        "blockingDecisions",
+        "blocking_decision_count",
+        "blockingDecisionCount",
+    ]) ?? 0;
+    const nonBlockingDecisions = activityMetadataNumber(metadata, [
+        "non_blocking_decisions",
+        "nonBlockingDecisions",
+        "non_blocking_decision_count",
+        "nonBlockingDecisionCount",
+    ]) ?? 0;
+    if (event === "autopilot_slice_result") {
+        if (decisionRequired || blockingDecisions > 0)
+            return "decision";
+        if (artifacts > 0)
+            return "artifact";
+        if (decisions > 0 || nonBlockingDecisions > 0)
+            return "decision";
+        return "message";
+    }
+    if (event && ACTIVITY_ARTIFACT_EVENT_HINTS.has(event))
+        return "artifact";
+    if (event && ACTIVITY_DECISION_EVENT_HINTS.has(event))
+        return "decision";
+    const hasArtifactReference = typeof metadata?.artifact_id === "string" ||
+        typeof metadata?.artifactId === "string" ||
+        typeof metadata?.work_artifact_id === "string";
+    if (hasArtifactReference || artifacts > 0)
+        return "artifact";
+    if (decisionRequired || blockingDecisions > 0 || decisions > 0 || nonBlockingDecisions > 0) {
+        return "decision";
+    }
+    return "message";
+}
+function snapshotActivityFingerprint(items) {
+    if (!Array.isArray(items) || items.length === 0)
+        return "0";
+    const sample = items
+        .slice(0, SNAPSHOT_ACTIVITY_FINGERPRINT_DEPTH)
+        .map((item) => `${item.id}|${item.timestamp}`)
+        .join(";");
+    return `${items.length}:${sample}`;
+}
+function readSnapshotResponseCache(key) {
+    const entry = snapshotResponseCache.get(key);
+    if (!entry)
+        return null;
+    if (entry.expiresAt <= Date.now()) {
+        snapshotResponseCache.delete(key);
+        return null;
+    }
+    return entry.payload;
+}
+function writeSnapshotResponseCache(key, payload) {
+    const now = Date.now();
+    snapshotResponseCache.set(key, {
+        expiresAt: now + SNAPSHOT_RESPONSE_CACHE_TTL_MS,
+        payload,
+    });
+    if (snapshotResponseCache.size <= SNAPSHOT_RESPONSE_CACHE_MAX_ENTRIES)
+        return;
+    for (const [cachedKey, entry] of snapshotResponseCache.entries()) {
+        if (entry.expiresAt <= now)
+            snapshotResponseCache.delete(cachedKey);
+    }
+    while (snapshotResponseCache.size > SNAPSHOT_RESPONSE_CACHE_MAX_ENTRIES) {
+        const oldestKey = snapshotResponseCache.keys().next().value;
+        if (!oldestKey)
+            break;
+        snapshotResponseCache.delete(oldestKey);
+    }
+}
+function clearSnapshotResponseCache() {
+    snapshotResponseCache.clear();
+}
 function isUserScopedApiKey(apiKey) {
     return apiKey.trim().toLowerCase().startsWith("oxk_");
 }
@@ -107,6 +276,150 @@ function parseJsonSafe(value) {
         return null;
     }
 }
+function asRecord(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return null;
+    return value;
+}
+function flattenActivityMetadata(value) {
+    const record = asRecord(value);
+    if (!record)
+        return null;
+    const nested = asRecord(record.metadata);
+    if (!nested)
+        return record;
+    return { ...record, ...nested };
+}
+function metadataString(metadata, keys) {
+    if (!metadata)
+        return null;
+    for (const key of keys) {
+        const value = metadata[key];
+        if (typeof value === "string" && value.trim().length > 0) {
+            return value.trim();
+        }
+    }
+    return null;
+}
+function metadataNumber(metadata, keys) {
+    if (!metadata)
+        return null;
+    for (const key of keys) {
+        const value = metadata[key];
+        if (typeof value === "number" && Number.isFinite(value))
+            return value;
+        if (typeof value === "string" && value.trim().length > 0) {
+            const parsed = Number(value.trim());
+            if (Number.isFinite(parsed))
+                return parsed;
+        }
+    }
+    return null;
+}
+function resolveArtifactIdFromActivityItem(item) {
+    const metadata = flattenActivityMetadata(item.metadata);
+    if (!metadata)
+        return null;
+    const rawId = metadataString(metadata, ["artifact_id", "artifactId", "work_artifact_id"]);
+    return rawId && rawId.length > 0 ? rawId : null;
+}
+function resolveArtifactHref(value) {
+    if (!value)
+        return null;
+    const trimmed = value.trim();
+    if (!trimmed)
+        return null;
+    if (/^https?:\/\//i.test(trimmed))
+        return trimmed;
+    return `/orgx/api/live/filesystem/open?path=${encodeURIComponent(trimmed)}`;
+}
+function buildLocalArtifactDetailFallback(artifactId, warning) {
+    let cursor = null;
+    const maxPages = 8;
+    for (let pageIndex = 0; pageIndex < maxPages; pageIndex += 1) {
+        const page = listActivityPage({ limit: 500, cursor });
+        const activities = Array.isArray(page.activities) ? page.activities : [];
+        for (const item of activities) {
+            const matchId = resolveArtifactIdFromActivityItem(item);
+            if (!matchId || matchId !== artifactId)
+                continue;
+            const metadata = flattenActivityMetadata(item.metadata) ?? {};
+            const rawPath = metadataString(metadata, [
+                "url",
+                "path",
+                "file_path",
+                "filepath",
+                "artifact_path",
+                "output_path",
+                "external_url",
+                "artifact_url",
+            ]) ?? null;
+            const artifactHref = resolveArtifactHref(rawPath);
+            const artifactType = metadataString(metadata, ["artifact_type", "artifactType", "type"]) ?? "report";
+            const artifactName = metadataString(metadata, ["artifact_name", "artifactName", "name", "title"]) ??
+                item.title?.trim() ??
+                `Artifact ${artifactId.slice(0, 8)}`;
+            const status = metadataString(metadata, ["artifact_status", "status", "state"]) ??
+                (typeof metadata.event === "string" && metadata.event.includes("buffered")
+                    ? "buffered"
+                    : "draft");
+            const entityType = metadataString(metadata, ["entity_type", "entityType"]) ??
+                (metadataString(metadata, ["initiative_id", "initiativeId"]) ? "initiative" : "task");
+            const entityId = metadataString(metadata, [
+                "entity_id",
+                "entityId",
+                "task_id",
+                "taskId",
+                "workstream_id",
+                "workstreamId",
+                "initiative_id",
+                "initiativeId",
+                "run_id",
+                "runId",
+            ]) ?? "local";
+            const description = metadataString(metadata, ["description", "summary", "message"]) ??
+                item.summary ??
+                item.description ??
+                null;
+            const version = Math.max(1, Math.round(metadataNumber(metadata, ["version", "artifact_version"]) ?? 1));
+            const createdAt = item.timestamp ?? new Date().toISOString();
+            const updatedAt = item.timestamp ?? createdAt;
+            return {
+                artifact: {
+                    id: artifactId,
+                    name: artifactName,
+                    description,
+                    artifact_url: artifactHref ?? "",
+                    artifact_type: artifactType,
+                    status,
+                    version,
+                    entity_type: entityType,
+                    entity_id: entityId,
+                    metadata: {
+                        ...metadata,
+                        local_fallback: true,
+                        local_warning: warning,
+                        local_activity_event_id: item.id,
+                        local_activity_type: item.type,
+                        local_activity_timestamp: item.timestamp,
+                        local_source_path: rawPath,
+                    },
+                    created_at: createdAt,
+                    updated_at: updatedAt,
+                    catalog: null,
+                    cached_metadata: null,
+                },
+                relationships: [],
+                localFallback: true,
+                warning,
+            };
+        }
+        if (!page.nextCursor)
+            break;
+        cursor = page.nextCursor;
+    }
+    return null;
+}
 function maskSecret(value) {
     if (!value)
         return null;
@@ -756,48 +1069,52 @@ function applyAgentContextsToActivity(input, contexts) {
     if (!Array.isArray(input))
         return [];
     return input.map((item) => {
+        let nextItem = item;
         const existingInitiativeId = (item.initiativeId ?? "").trim();
-        if (isUuidLike(existingInitiativeId))
-            return item;
-        const runCtx = item.runId ? contexts.runs[item.runId] : null;
-        if (runCtx && runCtx.initiativeId && runCtx.initiativeId.trim().length > 0) {
-            const initiativeId = runCtx.initiativeId.trim();
-            const metadata = item.metadata && typeof item.metadata === "object"
-                ? { ...item.metadata }
-                : {};
-            metadata.orgx_context = {
-                initiativeId,
-                workstreamId: runCtx.workstreamId ?? null,
-                taskId: runCtx.taskId ?? null,
-                updatedAt: runCtx.updatedAt,
-            };
-            return {
-                ...item,
-                initiativeId,
-                metadata,
-            };
+        if (!isUuidLike(existingInitiativeId)) {
+            const runCtx = item.runId ? contexts.runs[item.runId] : null;
+            if (runCtx && runCtx.initiativeId && runCtx.initiativeId.trim().length > 0) {
+                const initiativeId = runCtx.initiativeId.trim();
+                const metadata = item.metadata && typeof item.metadata === "object"
+                    ? { ...item.metadata }
+                    : {};
+                metadata.orgx_context = {
+                    initiativeId,
+                    workstreamId: runCtx.workstreamId ?? null,
+                    taskId: runCtx.taskId ?? null,
+                    updatedAt: runCtx.updatedAt,
+                };
+                nextItem = {
+                    ...item,
+                    initiativeId,
+                    metadata,
+                };
+            }
+            else {
+                const agentId = item.agentId?.trim() ?? "";
+                if (agentId) {
+                    const ctx = contexts.agents[agentId];
+                    const initiativeId = ctx?.initiativeId?.trim() ?? "";
+                    if (initiativeId) {
+                        const metadata = item.metadata && typeof item.metadata === "object"
+                            ? { ...item.metadata }
+                            : {};
+                        metadata.orgx_context = {
+                            initiativeId,
+                            workstreamId: ctx.workstreamId ?? null,
+                            taskId: ctx.taskId ?? null,
+                            updatedAt: ctx.updatedAt,
+                        };
+                        nextItem = {
+                            ...item,
+                            initiativeId,
+                            metadata,
+                        };
+                    }
+                }
+            }
         }
-        const agentId = item.agentId?.trim() ?? "";
-        if (!agentId)
-            return item;
-        const ctx = contexts.agents[agentId];
-        const initiativeId = ctx?.initiativeId?.trim() ?? "";
-        if (!initiativeId)
-            return item;
-        const metadata = item.metadata && typeof item.metadata === "object"
-            ? { ...item.metadata }
-            : {};
-        metadata.orgx_context = {
-            initiativeId,
-            workstreamId: ctx.workstreamId ?? null,
-            taskId: ctx.taskId ?? null,
-            updatedAt: ctx.updatedAt,
-        };
-        return {
-            ...item,
-            initiativeId,
-            metadata,
-        };
+        return enrichActivityActorFields(nextItem);
     });
 }
 function mergeSessionTrees(base, extra) {
@@ -849,7 +1166,12 @@ function mergeSessionTrees(base, extra) {
     };
 }
 function mergeActivities(base, extra, limit) {
-    const merged = [...(base ?? []), ...(extra ?? [])].sort((a, b) => Date.parse(b.timestamp) - Date.parse(a.timestamp));
+    const merged = [...(base ?? []), ...(extra ?? [])].sort((a, b) => {
+        const timestampDelta = Date.parse(b.timestamp) - Date.parse(a.timestamp);
+        if (timestampDelta !== 0)
+            return timestampDelta;
+        return b.id.localeCompare(a.id);
+    });
     const deduped = [];
     const seen = new Set();
     for (const item of merged) {
@@ -899,6 +1221,56 @@ function normalizeRuntimeSource(value) {
         return "api";
     return "unknown";
 }
+function runtimeSourceDefaultAgentLabel(sourceClient) {
+    if (sourceClient === "codex")
+        return "Codex";
+    if (sourceClient === "claude-code")
+        return "Claude Code";
+    if (sourceClient === "openclaw")
+        return "OpenClaw";
+    if (sourceClient === "api")
+        return "OrgX API";
+    return null;
+}
+function runtimeSourceDefaultAgentId(sourceClient) {
+    if (sourceClient === "codex")
+        return "runtime:codex";
+    if (sourceClient === "claude-code")
+        return "runtime:claude-code";
+    if (sourceClient === "openclaw")
+        return "runtime:openclaw";
+    if (sourceClient === "api")
+        return "runtime:api";
+    return null;
+}
+function deriveRuntimeFallbackAgent(instance) {
+    const sourceClient = normalizeRuntimeSource(instance.sourceClient);
+    const agentId = (instance.agentId ?? "").trim() || runtimeSourceDefaultAgentId(sourceClient);
+    const agentName = (instance.agentName ?? "").trim() ||
+        (instance.displayName ?? "").trim() ||
+        runtimeSourceDefaultAgentLabel(sourceClient);
+    return {
+        agentId: agentId || null,
+        agentName: agentName || null,
+    };
+}
+function deriveRuntimeSessionStatus(instance) {
+    const state = (instance.state ?? "").trim().toLowerCase();
+    const phase = (instance.phase ?? "").trim().toLowerCase();
+    if (phase === "blocked" || state === "error")
+        return "blocked";
+    if (phase === "completed")
+        return "completed";
+    if (phase === "handoff")
+        return "handoff";
+    if (phase === "review")
+        return "review";
+    if (state === "stopped")
+        return "paused";
+    if (state === "stale")
+        return "queued";
+    return "running";
+}
 function runtimeMatchMaps(instances) {
     const byRunId = new Map();
     const byAgentInitiative = new Map();
@@ -931,8 +1303,32 @@ function enrichSessionsWithRuntime(input, instances) {
         const match = byRun ?? byAgent;
         if (!match)
             return node;
+        const runtimeStatus = deriveRuntimeSessionStatus(match);
+        const fallbackAgent = deriveRuntimeFallbackAgent(match);
+        const agentId = (node.agentId ?? "").trim() || fallbackAgent.agentId;
+        const agentName = (node.agentName ?? "").trim() || fallbackAgent.agentName;
+        const nodeStatus = (node.status ?? "").trim().toLowerCase();
+        const isLiveLikeNodeStatus = nodeStatus === "running" ||
+            nodeStatus === "active" ||
+            nodeStatus === "in_progress" ||
+            nodeStatus === "working" ||
+            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()
+                : "");
         return {
             ...node,
+            agentId: agentId || null,
+            agentName: agentName || null,
+            status: shouldDowngradeStatusFromRuntime ? runtimeStatus : node.status,
+            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,
             runtimeClient: normalizeRuntimeSource(match.sourceClient),
             runtimeLabel: match.displayName,
             runtimeProvider: match.providerLogo,
@@ -966,13 +1362,15 @@ function injectRuntimeInstancesAsSessions(input, instances) {
             continue;
         if (existingRunIds.has(runId))
             continue;
-        // Only surface active/stale runtime instances as "sessions" so the Activity UI can show
-        // a seamless "in progress" lane even when this isn't an OpenClaw session tree node.
-        if (instance.state !== "active" && instance.state !== "stale")
+        // 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 groupId = initiativeId ?? "runtime";
+        const runtimeClient = normalizeRuntimeSource(instance.sourceClient);
+        const fallbackAgent = deriveRuntimeFallbackAgent(instance);
+        const groupId = initiativeId ?? fallbackAgent.agentId ?? `runtime:${runtimeClient}`;
         const meta = instance.metadata && typeof instance.metadata === "object"
             ? instance.metadata
             : {};
@@ -980,7 +1378,7 @@ function injectRuntimeInstancesAsSessions(input, instances) {
             (workstreamId ? `Workstream ${workstreamId.slice(0, 8)}` : null);
         const initiativeHint = pickString(meta, ["initiative_title", "initiativeTitle"]) ??
             (initiativeId ? `Initiative ${initiativeId.slice(0, 8)}` : null);
-        const groupLabel = (initiativeHint ?? groupId).trim();
+        const groupLabel = (initiativeHint ?? fallbackAgent.agentName ?? groupId).trim();
         if (!groupsById.has(groupId)) {
             const group = { id: groupId, label: groupLabel, status: null };
             groupsById.set(groupId, group);
@@ -991,14 +1389,19 @@ function injectRuntimeInstancesAsSessions(input, instances) {
             continue;
         existingNodeIds.add(nodeId);
         existingRunIds.add(runId);
+        const status = deriveRuntimeSessionStatus(instance);
+        const blockerReason = status === "blocked" ? (instance.lastMessage ?? null) : null;
+        const blockers = status === "blocked" && typeof blockerReason === "string" && blockerReason.trim().length > 0
+            ? [blockerReason.trim()]
+            : [];
         const node = {
             id: nodeId,
             parentId: null,
             runId,
             title: titleHint ?? instance.lastMessage ?? `Runtime ${runId.slice(0, 8)}`,
-            agentId: instance.agentId ?? null,
-            agentName: instance.agentName ?? null,
-            status: "running",
+            agentId: fallbackAgent.agentId,
+            agentName: fallbackAgent.agentName,
+            status,
             progress: instance.progressPct ?? null,
             initiativeId,
             workstreamId,
@@ -1008,10 +1411,11 @@ function injectRuntimeInstancesAsSessions(input, instances) {
             updatedAt: instance.updatedAt ?? null,
             lastEventAt: instance.lastEventAt ?? null,
             lastEventSummary: instance.lastMessage ?? null,
-            blockers: [],
+            blockers,
+            blockerReason,
             phase: instance.phase ?? null,
             state: instance.state ?? null,
-            runtimeClient: normalizeRuntimeSource(instance.sourceClient),
+            runtimeClient,
             runtimeLabel: instance.displayName,
             runtimeProvider: instance.providerLogo,
             instanceId: instance.id,
@@ -1362,6 +1766,8 @@ function resolveSafeDistPath(subPath) {
 // =============================================================================
 const IMMUTABLE_FILE_CACHE = new Map();
 const IMMUTABLE_FILE_CACHE_MAX = 128;
+const FILE_PREVIEW_MAX_BYTES = 1_000_000;
+const FILE_PREVIEW_MAX_DIR_ENTRIES = 300;
 function sendJson(res, status, data) {
     const body = JSON.stringify(data);
     res.writeHead(status, {
@@ -1373,6 +1779,70 @@ function sendJson(res, status, data) {
     });
     res.end(body);
 }
+function sendHtml(res, status, html) {
+    res.writeHead(status, {
+        "Content-Type": "text/html; charset=utf-8",
+        "Cache-Control": "no-store",
+        ...SECURITY_HEADERS,
+        ...CORS_HEADERS,
+    });
+    res.end(html);
+}
+function escapeHtml(value) {
+    return value
+        .replaceAll("&", "&amp;")
+        .replaceAll("<", "&lt;")
+        .replaceAll(">", "&gt;")
+        .replaceAll('"', "&quot;")
+        .replaceAll("'", "&#39;");
+}
+function resolveFilesystemOpenPath(rawPath) {
+    let value = rawPath.trim();
+    if (value.toLowerCase().startsWith("file://")) {
+        value = value.replace(/^file:\/\//i, "");
+        try {
+            value = decodeURIComponent(value);
+        }
+        catch {
+            // best effort
+        }
+        if (process.platform === "win32" && value.startsWith("/")) {
+            value = value.slice(1);
+        }
+    }
+    if (value.startsWith("~/")) {
+        return resolve(homedir(), value.slice(2));
+    }
+    const looksWindowsAbsolute = /^[A-Za-z]:[\\/]/.test(value);
+    if (value.startsWith("/") || looksWindowsAbsolute) {
+        return resolve(value);
+    }
+    return resolve(process.cwd(), value);
+}
+function readFilePreview(pathname, totalBytes) {
+    if (totalBytes <= 0) {
+        return { previewBuffer: Buffer.alloc(0), truncated: false };
+    }
+    const previewBytes = Math.min(totalBytes, FILE_PREVIEW_MAX_BYTES);
+    const previewBuffer = Buffer.alloc(previewBytes);
+    const fd = openSync(pathname, "r");
+    try {
+        const bytesRead = readSync(fd, previewBuffer, 0, previewBytes, 0);
+        if (bytesRead < previewBytes) {
+            return {
+                previewBuffer: previewBuffer.subarray(0, bytesRead),
+                truncated: totalBytes > bytesRead,
+            };
+        }
+        return {
+            previewBuffer,
+            truncated: totalBytes > previewBytes,
+        };
+    }
+    finally {
+        closeSync(fd);
+    }
+}
 function sendFile(res, filePath, cacheControl) {
     try {
         const shouldCacheImmutable = cacheControl.includes("immutable");
@@ -2647,7 +3117,16 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
         const message = input.message.trim();
         if (!message)
             return;
-        const enrichedMetadata = withProvenanceMetadata(input.metadata);
+        const metadataWithProvenance = withProvenanceMetadata(input.metadata);
+        const activityBucket = deriveStructuredActivityBucket({
+            phase: input.phase,
+            metadata: metadataWithProvenance,
+            explicitBucket: input.activityBucket ?? null,
+        });
+        const enrichedMetadata = {
+            ...(metadataWithProvenance ?? {}),
+            activity_bucket: activityBucket,
+        };
         try {
             await client.emitActivity({
                 initiative_id: initiativeId,
@@ -2712,17 +3191,26 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
                             : "run_started",
                     title: message,
                     description: input.nextStep ?? null,
-                    agentId: (typeof enrichedMetadata?.agent_id === "string"
-                        ? enrichedMetadata.agent_id
+                    agentId: (typeof metadataWithProvenance?.agent_id === "string"
+                        ? metadataWithProvenance.agent_id
                         : null) ?? null,
-                    agentName: (typeof enrichedMetadata?.agent_name === "string"
-                        ? enrichedMetadata.agent_name
+                    agentName: (typeof metadataWithProvenance?.agent_name === "string"
+                        ? metadataWithProvenance.agent_name
+                        : null) ?? null,
+                    requesterAgentId: null,
+                    requesterAgentName: null,
+                    executorAgentId: (typeof metadataWithProvenance?.agent_id === "string"
+                        ? metadataWithProvenance.agent_id
+                        : null) ?? null,
+                    executorAgentName: (typeof metadataWithProvenance?.agent_name === "string"
+                        ? metadataWithProvenance.agent_name
                         : null) ?? null,
                     runId,
                     initiativeId,
                     timestamp,
                     phase: input.phase,
                     summary: message,
+                    kind: activityBucket,
                     metadata: {
                         ...(enrichedMetadata ?? {}),
                         source: "openclaw_local_fallback",
@@ -2807,6 +3295,10 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
                 description: input.summary ?? null,
                 agentId: null,
                 agentName: null,
+                requesterAgentId: null,
+                requesterAgentName: null,
+                executorAgentId: null,
+                executorAgentName: null,
                 runId: correlationId ?? null,
                 initiativeId,
                 timestamp,
@@ -3157,10 +3649,22 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
     }
     const autoContinueRuns = new Map();
     const localInitiativeStatusOverrides = new Map();
-    let autoContinueTickInFlight = false;
-    const AUTO_CONTINUE_TICK_MS = 2_500;
+    let autoContinueTickInFlight = null;
+    const AUTO_CONTINUE_TICK_MS = readBudgetEnvNumber("ORGX_AUTO_CONTINUE_TICK_MS", 2_500, {
+        min: 250,
+        max: 60_000,
+    });
     const autoContinueSliceRuns = new Map();
+    // Keep child handles alive so stdout/stderr capture remains reliable even when the process is detached.
+    const autoContinueSliceChildren = new Map();
     const autoContinueSliceLastHeartbeatMs = new Map();
+    const clearAutoContinueSliceTransientState = (sliceRunId) => {
+        const id = (sliceRunId ?? "").trim();
+        if (!id)
+            return;
+        autoContinueSliceChildren.delete(id);
+        autoContinueSliceLastHeartbeatMs.delete(id);
+    };
     const AUTO_CONTINUE_SLICE_MAX_TASKS = 6;
     const AUTO_CONTINUE_SLICE_TIMEOUT_MS = readBudgetEnvNumber("ORGX_AUTOPILOT_SLICE_TIMEOUT_MS", 55 * 60_000, 
     // Keep test runs fast; real-world defaults are still ~1h unless overridden.
@@ -3287,7 +3791,7 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
     async function updateInitiativeAutoContinueState(input) {
         const now = new Date().toISOString();
         const patch = {
-            auto_continue_enabled: true,
+            auto_continue_enabled: input.run.status === "running" || input.run.status === "stopping",
             auto_continue_status: input.run.status,
             auto_continue_stop_reason: input.run.stopReason,
             auto_continue_started_at: input.run.startedAt,
@@ -3308,6 +3812,7 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
     }
     async function stopAutoContinueRun(input) {
         const now = new Date().toISOString();
+        const activeRunId = input.run.activeRunId;
         input.run.status = "stopped";
         input.run.stopReason = input.reason;
         input.run.stoppedAt = now;
@@ -3315,16 +3820,21 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
         input.run.stopRequested = false;
         input.run.activeRunId = null;
         input.run.activeTaskId = null;
+        input.run.activeTaskTokenEstimate = null;
         if (input.error)
             input.run.lastError = input.error;
-        // Autopilot should not auto-complete initiatives; keep status changes conservative.
-        try {
-            await client.updateEntity("initiative", input.run.initiativeId, {
-                status: "paused",
-            });
-        }
-        catch {
-            // best effort
+        clearAutoContinueSliceTransientState(activeRunId);
+        // Only pause the initiative on non-terminal stops (error, blocked, user-requested).
+        // Completed / budget-exhausted runs should not override the initiative status.
+        if (input.reason !== "completed" && input.reason !== "budget_exhausted") {
+            try {
+                await client.updateEntity("initiative", input.run.initiativeId, {
+                    status: "paused",
+                });
+            }
+            catch {
+                // best effort
+            }
         }
         try {
             await updateInitiativeAutoContinueState({
@@ -3335,6 +3845,48 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
         catch {
             // best effort
         }
+        const scopeSuffix = Array.isArray(input.run.allowedWorkstreamIds) && input.run.allowedWorkstreamIds.length === 1
+            ? ` (${input.run.allowedWorkstreamIds[0]})`
+            : "";
+        const message = input.reason === "completed"
+            ? `Autopilot stopped: current dispatch scope completed${scopeSuffix}.`
+            : input.reason === "budget_exhausted"
+                ? `Autopilot stopped: token budget exhausted (${input.run.tokensUsed}/${input.run.tokenBudget}).`
+                : input.reason === "stopped"
+                    ? `Autopilot stopped by user request${scopeSuffix}.`
+                    : input.reason === "blocked"
+                        ? `Autopilot stopped: blocked pending decision${scopeSuffix}.`
+                        : `Autopilot stopped due to error${scopeSuffix}.`;
+        const phase = input.reason === "completed"
+            ? "completed"
+            : input.reason === "blocked" || input.reason === "error"
+                ? "blocked"
+                : "review";
+        const level = input.reason === "completed"
+            ? "info"
+            : input.reason === "budget_exhausted" || input.reason === "stopped"
+                ? "warn"
+                : "error";
+        await emitActivitySafe({
+            initiativeId: input.run.initiativeId,
+            runId: activeRunId ?? input.run.lastRunId ?? undefined,
+            correlationId: activeRunId ?? input.run.lastRunId ?? undefined,
+            phase,
+            level,
+            message,
+            metadata: {
+                event: "auto_continue_stopped",
+                stop_reason: input.reason,
+                requested_by_agent_id: input.run.agentId,
+                requested_by_agent_name: input.run.agentName,
+                active_run_id: activeRunId,
+                last_run_id: input.run.lastRunId,
+                token_budget: input.run.tokenBudget,
+                tokens_used: input.run.tokensUsed,
+                allowed_workstream_ids: input.run.allowedWorkstreamIds,
+                last_error: input.run.lastError,
+            },
+        });
     }
     function ensurePrivateDirForFile(pathname) {
         const dir = dirname(pathname);
@@ -3460,11 +4012,54 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
         const direct = parseJsonSafe(trimmed);
         if (direct && typeof direct === "object")
             return direct;
-        // Tolerant parse: grab the last JSON object-looking blob.
-        const first = trimmed.lastIndexOf("{");
-        const last = trimmed.lastIndexOf("}");
-        if (first >= 0 && last > first) {
-            const candidate = trimmed.slice(first, last + 1);
+        // Tolerant parse: extract the last complete top-level JSON object from mixed logs.
+        // (Workers sometimes append multiple JSON payloads, or wrap output with extra text.)
+        const extractLastTopLevelObject = (text) => {
+            let inString = false;
+            let escaped = false;
+            let depth = 0;
+            let start = -1;
+            let lastObject = null;
+            for (let i = 0; i < text.length; i += 1) {
+                const ch = text[i];
+                if (inString) {
+                    if (escaped) {
+                        escaped = false;
+                        continue;
+                    }
+                    if (ch === "\\") {
+                        escaped = true;
+                        continue;
+                    }
+                    if (ch === "\"") {
+                        inString = false;
+                    }
+                    continue;
+                }
+                if (ch === "\"") {
+                    inString = true;
+                    continue;
+                }
+                if (ch === "{") {
+                    if (depth === 0)
+                        start = i;
+                    depth += 1;
+                    continue;
+                }
+                if (ch === "}") {
+                    if (depth <= 0)
+                        continue;
+                    depth -= 1;
+                    if (depth === 0 && start >= 0) {
+                        lastObject = text.slice(start, i + 1);
+                        start = -1;
+                    }
+                }
+            }
+            return lastObject;
+        };
+        const candidate = extractLastTopLevelObject(trimmed);
+        if (candidate) {
             const parsed = parseJsonSafe(candidate);
             if (parsed && typeof parsed === "object")
                 return parsed;
@@ -3717,8 +4312,16 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
                     ...input.env,
                 },
                 stdio: ["ignore", "pipe", "pipe"],
-                detached: true,
+                // Keep the mock worker as a normal child so stdout/stderr capture is deterministic.
+                detached: false,
             });
+            autoContinueSliceChildren.set(input.runId, child);
+            try {
+                logStream.write(`spawned pid=${String(child.pid ?? "")} stdout=${String(Boolean(child.stdout))} stderr=${String(Boolean(child.stderr))}\n`);
+            }
+            catch {
+                // ignore
+            }
             child.stdout?.on("data", (chunk) => {
                 try {
                     logStream.write(chunk);
@@ -3742,6 +4345,7 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
                 }
             });
             child.on("close", (code, signal) => {
+                autoContinueSliceChildren.delete(input.runId);
                 const stamp = new Date().toISOString();
                 try {
                     logStream.write(`\n==== ${stamp} :: exit code=${String(code)} signal=${String(signal)} ====\n`);
@@ -3763,6 +4367,7 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
                 }
             });
             child.on("error", (error) => {
+                autoContinueSliceChildren.delete(input.runId);
                 const msg = safeErrorMessage(error);
                 try {
                     logStream.write(`\nworker error: ${msg}\n`);
@@ -3783,7 +4388,6 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
                     // ignore
                 }
             });
-            child.unref();
             return { pid: child.pid ?? null };
         }
         if (workerKind === "claude-code" || workerKind === "claude_code") {
@@ -3805,6 +4409,7 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
                 stdio: ["ignore", "pipe", "pipe"],
                 detached: true,
             });
+            autoContinueSliceChildren.set(input.runId, child);
             child.stdout?.on("data", (chunk) => {
                 try {
                     logStream.write(chunk);
@@ -3828,6 +4433,7 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
                 }
             });
             child.on("close", (code, signal) => {
+                autoContinueSliceChildren.delete(input.runId);
                 const stamp = new Date().toISOString();
                 try {
                     logStream.write(`\n==== ${stamp} :: exit code=${String(code)} signal=${String(signal)} ====\n`);
@@ -3849,6 +4455,7 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
                 }
             });
             child.on("error", (error) => {
+                autoContinueSliceChildren.delete(input.runId);
                 const msg = safeErrorMessage(error);
                 try {
                     logStream.write(`\nworker error: ${msg}\n`);
@@ -3908,6 +4515,7 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
             stdio: ["ignore", "pipe", "pipe"],
             detached: true,
         });
+        autoContinueSliceChildren.set(input.runId, child);
         child.stdout?.on("data", (chunk) => {
             try {
                 logStream.write(chunk);
@@ -3925,6 +4533,7 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
             }
         });
         child.on("close", (code, signal) => {
+            autoContinueSliceChildren.delete(input.runId);
             const stamp = new Date().toISOString();
             try {
                 logStream.write(`\n==== ${stamp} :: exit code=${String(code)} signal=${String(signal)} ====\n`);
@@ -3940,6 +4549,7 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
             }
         });
         child.on("error", (error) => {
+            autoContinueSliceChildren.delete(input.runId);
             const msg = safeErrorMessage(error);
             try {
                 logStream.write(`\nworker error: ${msg}\n`);
@@ -3982,6 +4592,7 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
         });
         // Make runtime updates feel instantaneous (don't wait for the 15s staleness timer).
         broadcastRuntimeSse("runtime.updated", instance);
+        clearSnapshotResponseCache();
         return instance;
     }
     function buildWorkstreamSlicePrompt(input) {
@@ -4026,6 +4637,10 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
             `- Your JSON MUST conform to this schema file: ${input.schemaPath}`,
             `- Artifacts must be verifiable: include URLs or local paths, plus verification steps.`,
             `- If you need a human decision, include it in decisions_needed.`,
+            `- For every decisions_needed entry, ALWAYS set blocking explicitly (true or false).`,
+            `- Status/decision consistency is strict:`,
+            `  - If any decision is blocking=true, status MUST be needs_decision or blocked (never completed).`,
+            `  - Only use status=completed when all listed decisions are non-blocking follow-ups.`,
             `- If you are confident OrgX statuses should change, include task_updates and/or milestone_updates (with a short reason).`,
             `  - task_updates.status must be one of: todo, in_progress, done, blocked`,
             `  - milestone_updates.status must be one of: planned, in_progress, completed, at_risk, cancelled`,
@@ -4037,6 +4652,7 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
         if (!name)
             return { ok: false, id: null };
         const artifactType = (input.artifact.artifact_type ?? "other").trim() || "other";
+        const artifactId = randomUUID();
         const verificationSteps = Array.isArray(input.artifact.verification_steps)
             ? input.artifact.verification_steps
                 .filter((step) => typeof step === "string")
@@ -4051,23 +4667,38 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
             descriptionParts.push(`Verification:\n${verificationSteps.map((step) => `- ${step}`).join("\n")}`);
         }
         const description = descriptionParts.length > 0 ? descriptionParts.join("\n\n") : undefined;
+        const hasUuidAgent = typeof input.agentId === "string" &&
+            /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(input.agentId);
+        const createdByType = hasUuidAgent ? "agent" : "human";
+        const createdById = hasUuidAgent ? input.agentId : null;
         try {
-            const entity = await client.createEntity("artifact", {
-                initiative_id: input.initiativeId,
-                workstream_id: input.workstreamId,
-                title: name,
+            const entityType = input.artifact.milestone_id ? "milestone" : "initiative";
+            const entityId = input.artifact.milestone_id ? input.artifact.milestone_id : input.initiativeId;
+            const result = await registerArtifact(client, client.getBaseUrl(), {
+                artifact_id: artifactId,
+                entity_type: entityType,
+                entity_id: entityId,
+                name,
                 artifact_type: artifactType,
+                created_by_type: createdByType,
+                created_by_id: createdById,
                 description,
-                artifact_url: input.artifact.url ?? undefined,
-                status: "active",
+                external_url: input.artifact.url ?? null,
+                preview_markdown: null,
+                status: "draft",
                 metadata: {
                     source: "autopilot_slice",
+                    artifact_id: artifactId,
                     run_id: input.runId,
+                    initiative_id: input.initiativeId,
+                    workstream_id: input.workstreamId,
                     milestone_id: input.artifact.milestone_id ?? null,
                     task_ids: input.artifact.task_ids ?? null,
                 },
+                // Make persistence validation opt-in to avoid adding latency to every slice by default.
+                validate_persistence: process.env.ORGX_VALIDATE_ARTIFACT_PERSISTENCE === "1",
             });
-            return { ok: true, id: pickString(entity, ["id"]) ?? null };
+            return { ok: result.ok, id: result.artifact_id };
         }
         catch (err) {
             try {
@@ -4076,10 +4707,13 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
                     type: "artifact",
                     timestamp: now,
                     payload: {
-                        initiative_id: input.initiativeId,
-                        workstream_id: input.workstreamId,
+                        artifact_id: artifactId,
+                        entity_type: input.artifact.milestone_id ? "milestone" : "initiative",
+                        entity_id: input.artifact.milestone_id ?? input.initiativeId,
                         name,
                         artifact_type: artifactType,
+                        created_by_type: createdByType,
+                        created_by_id: createdById,
                         description,
                         url: input.artifact.url ?? undefined,
                         run_id: input.runId,
@@ -4091,6 +4725,10 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
                         description: description ?? null,
                         agentId: input.agentId,
                         agentName: input.agentName ?? null,
+                        requesterAgentId: input.agentId,
+                        requesterAgentName: input.agentName ?? null,
+                        executorAgentId: input.agentId,
+                        executorAgentName: input.agentName ?? null,
                         runId: input.runId,
                         initiativeId: input.initiativeId,
                         timestamp: now,
@@ -4100,6 +4738,7 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
                             source: "openclaw_local_fallback",
                             event: "autopilot_slice_artifact_buffered",
                             artifact_type: artifactType,
+                            artifact_id: artifactId,
                             url: input.artifact.url ?? null,
                             error: safeErrorMessage(err),
                         },
@@ -4228,6 +4867,10 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
                         description: null,
                         agentId: null,
                         agentName: null,
+                        requesterAgentId: null,
+                        requesterAgentName: null,
+                        executorAgentId: null,
+                        executorAgentName: null,
                         runId: input.runId,
                         initiativeId: input.initiativeId,
                         timestamp,
@@ -4330,6 +4973,9 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
             metadata: {
                 event: "next_up_manual_dispatch_started",
                 agent_id: input.agentId,
+                agent_name: input.agentName ?? input.agentId,
+                requested_by_agent_id: input.agentId,
+                requested_by_agent_name: input.agentName ?? input.agentId,
                 session_id: sessionId,
                 workstream_id: input.workstreamId,
                 workstream_title: resolvedWorkstreamTitle,
@@ -4384,6 +5030,32 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
             spawnGuardResult: guard.spawnGuardResult,
         };
     }
+    async function resolveAgentDisplayName(agentId, fallbackName) {
+        const normalizedAgentId = agentId.trim();
+        if (!normalizedAgentId)
+            return null;
+        const normalizedFallback = typeof fallbackName === "string" && fallbackName.trim().length > 0
+            ? fallbackName.trim()
+            : null;
+        try {
+            const agents = await listAgents();
+            for (const entry of agents) {
+                const record = entry;
+                const candidateId = pickString(record, ["id", "agent_id", "agentId"]);
+                if (!candidateId || candidateId.trim() !== normalizedAgentId)
+                    continue;
+                const candidateName = pickString(record, ["name", "agent_name", "agentName"]);
+                if (candidateName && candidateName.trim().length > 0) {
+                    return candidateName.trim();
+                }
+                break;
+            }
+        }
+        catch {
+            // best effort
+        }
+        return normalizedFallback ?? normalizedAgentId;
+    }
     async function tickAutoContinueRun(run) {
         if (run.status !== "running" && run.status !== "stopping")
             return;
@@ -4408,13 +5080,15 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
                         typeof outputParsed.summary === "string");
                     if (outputComplete) {
                         // Some platforms can report a just-finished detached process as still "alive" (zombie).
-                        // Best-effort stop so we can proceed to parse the output contract below.
+                        // Best-effort stop, then clear pid so we can proceed to parse the output contract below.
                         try {
                             await stopProcess(pid);
                         }
                         catch {
                             // best effort
                         }
+                        slice.pid = null;
+                        autoContinueSliceRuns.set(slice.runId, slice);
                     }
                     else {
                         const lastHeartbeat = autoContinueSliceLastHeartbeatMs.get(slice.runId) ?? 0;
@@ -4433,6 +5107,8 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
                                     message: `Autopilot slice running: ${slice.workstreamTitle ?? slice.workstreamId}`,
                                     metadata: {
                                         event: "autopilot_slice_heartbeat",
+                                        requested_by_agent_id: run.agentId,
+                                        requested_by_agent_name: run.agentName,
                                         domain: slice.domain,
                                         required_skills: slice.requiredSkills,
                                         workstream_id: slice.workstreamId,
@@ -4470,6 +5146,7 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
                             autoContinueSliceRuns.set(slice.runId, slice);
                             run.lastError = slice.lastError;
                             run.updatedAt = now;
+                            clearAutoContinueSliceTransientState(slice.runId);
                             await emitActivitySafe({
                                 initiativeId: run.initiativeId,
                                 runId: slice.runId,
@@ -4479,6 +5156,8 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
                                 message: `Autopilot slice MCP failed: ${slice.workstreamTitle ?? slice.workstreamId}.`,
                                 metadata: {
                                     event: "autopilot_slice_mcp_handshake_failed",
+                                    requested_by_agent_id: run.agentId,
+                                    requested_by_agent_name: run.agentName,
                                     mcp_server: mcpHandshake.server,
                                     mcp_line: mcpHandshake.line,
                                     workstream_id: slice.workstreamId,
@@ -4530,6 +5209,7 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
                             autoContinueSliceRuns.set(slice.runId, slice);
                             run.lastError = slice.lastError;
                             run.updatedAt = now;
+                            clearAutoContinueSliceTransientState(slice.runId);
                             const event = killDecision.kind === "timeout" ? "autopilot_slice_timeout" : "autopilot_slice_log_stall";
                             const humanLabel = killDecision.kind === "timeout" ? "timed out" : "stalled";
                             await emitActivitySafe({
@@ -4541,6 +5221,8 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
                                 message: `Autopilot slice ${humanLabel}: ${slice.workstreamTitle ?? slice.workstreamId}.`,
                                 metadata: {
                                     event,
+                                    requested_by_agent_id: run.agentId,
+                                    requested_by_agent_name: run.agentName,
                                     workstream_id: slice.workstreamId,
                                     task_ids: slice.taskIds,
                                     milestone_ids: slice.milestoneIds,
@@ -4579,17 +5261,28 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
                                 // best effort
                             }
                         }
-                        return;
+                        if (!outputComplete)
+                            return;
                     }
                 }
                 // Slice finished.
                 const raw = readSliceOutputFile(slice.outputPath);
                 const parsed = raw ? parseSliceResult(raw) : null;
                 const parsedStatus = parsed?.status ?? "error";
+                const defaultDecisionBlocking = parsedStatus === "completed" ? false : true;
+                const decisions = Array.isArray(parsed?.decisions_needed)
+                    ? (parsed?.decisions_needed ?? [])
+                        .filter((item) => Boolean(item && typeof item.question === "string" && item.question.trim()))
+                    : [];
+                const blockingDecisionCount = decisions.filter((item) => typeof item.blocking === "boolean" ? item.blocking : defaultDecisionBlocking).length;
+                const nonBlockingDecisionCount = Math.max(0, decisions.length - blockingDecisionCount);
+                const effectiveParsedStatus = parsedStatus === "completed" && blockingDecisionCount > 0
+                    ? "needs_decision"
+                    : parsedStatus;
                 slice.status =
-                    parsedStatus === "completed"
+                    effectiveParsedStatus === "completed"
                         ? "completed"
-                        : parsedStatus === "blocked" || parsedStatus === "needs_decision"
+                        : effectiveParsedStatus === "blocked" || effectiveParsedStatus === "needs_decision"
                             ? "blocked"
                             : "error";
                 slice.finishedAt = now;
@@ -4599,14 +5292,11 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
                         ? slice.lastError ?? "Autopilot slice failed or returned invalid output."
                         : null;
                 autoContinueSliceRuns.set(slice.runId, slice);
+                clearAutoContinueSliceTransientState(slice.runId);
                 // Token accounting: codex CLI doesn't provide tokens here; use the modeled estimate.
                 const modeledTokens = slice.tokenEstimate ?? run.activeTaskTokenEstimate ?? 0;
                 run.tokensUsed += Math.max(0, modeledTokens);
                 run.activeTaskTokenEstimate = null;
-                const decisions = Array.isArray(parsed?.decisions_needed)
-                    ? (parsed?.decisions_needed ?? [])
-                        .filter((item) => Boolean(item && typeof item.question === "string" && item.question.trim()))
-                    : [];
                 const artifacts = Array.isArray(parsed?.artifacts)
                     ? (parsed?.artifacts ?? [])
                         .filter((item) => Boolean(item && typeof item.name === "string" && item.name.trim()))
@@ -4627,7 +5317,7 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
                         options: Array.isArray(decision.options)
                             ? decision.options.filter((opt) => typeof opt === "string" && opt.trim())
                             : [],
-                        blocking: typeof decision.blocking === "boolean" ? decision.blocking : true,
+                        blocking: typeof decision.blocking === "boolean" ? decision.blocking : defaultDecisionBlocking,
                     });
                 }
                 for (const artifact of artifacts) {
@@ -4661,9 +5351,13 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
                         message: parsed?.summary ?? slice.lastError ?? "Autopilot slice finished.",
                         metadata: {
                             event: "autopilot_slice_finished",
-                            status: parsedStatus,
+                            requested_by_agent_id: run.agentId,
+                            requested_by_agent_name: run.agentName,
+                            status: effectiveParsedStatus,
                             artifacts: artifacts.length,
                             decisions: decisions.length,
+                            blocking_decisions: blockingDecisionCount,
+                            non_blocking_decisions: nonBlockingDecisionCount,
                             status_updates: statusUpdateResult.applied,
                             status_updates_buffered: statusUpdateResult.buffered,
                         },
@@ -4679,10 +5373,12 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
                     phase: slice.status === "completed" ? "completed" : "blocked",
                     level: slice.status === "completed" ? "info" : "warn",
                     message: slice.status === "completed"
-                        ? `Autopilot slice completed: ${slice.workstreamTitle ?? slice.workstreamId}.`
+                        ? `Autopilot slice completed for ${slice.workstreamTitle ?? slice.workstreamId} (${slice.taskIds.length} task${slice.taskIds.length === 1 ? "" : "s"}).`
                         : `Autopilot slice blocked: ${slice.workstreamTitle ?? slice.workstreamId}.`,
                     metadata: {
                         event: "autopilot_slice_result",
+                        requested_by_agent_id: run.agentId,
+                        requested_by_agent_name: run.agentName,
                         agent_id: slice.agentId,
                         agent_name: slice.agentName,
                         domain: slice.domain,
@@ -4690,10 +5386,13 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
                         workstream_id: slice.workstreamId,
                         task_ids: slice.taskIds,
                         milestone_ids: slice.milestoneIds,
-                        parsed_status: parsedStatus,
+                        parsed_status: effectiveParsedStatus,
                         has_output: Boolean(parsed),
                         artifacts: artifacts.length,
                         decisions: decisions.length,
+                        blocking_decisions: blockingDecisionCount,
+                        non_blocking_decisions: nonBlockingDecisionCount,
+                        decision_required: blockingDecisionCount > 0,
                         status_updates_applied: statusUpdateResult.applied,
                         status_updates_buffered: statusUpdateResult.buffered,
                         output_path: slice.outputPath,
@@ -4724,7 +5423,7 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
                         reason: slice.status === "error" ? "error" : "blocked",
                         error: parsed?.summary ??
                             slice.lastError ??
-                            `Slice returned status: ${parsedStatus}`,
+                            `Slice returned status: ${effectiveParsedStatus}`,
                     });
                     return;
                 }
@@ -4839,7 +5538,7 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
                 continue;
             if (!run.includeVerification &&
                 typeof node.title === "string" &&
-                /^verification\\s+scenario/i.test(node.title)) {
+                /^verification[ \t]+scenario/i.test(node.title)) {
                 continue;
             }
             if (run.allowedWorkstreamIds && node.workstreamId) {
@@ -4875,7 +5574,7 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
             taskIsReady(node) &&
             !taskHasBlockedParent(node) &&
             (run.includeVerification ||
-                !/^verification\\s+scenario/i.test(String(node.title ?? "")))))
+                !/^verification[ \t]+scenario/i.test(String(node.title ?? "")))))
             .slice(0, AUTO_CONTINUE_SLICE_MAX_TASKS);
         const primaryTask = sliceTaskNodes[0] ?? null;
         if (!primaryTask) {
@@ -5055,6 +5754,7 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
                 ORGX_TASK_ID: primaryTask.id,
                 ORGX_AGENT_ID: sliceAgent.id,
                 ORGX_AGENT_NAME: sliceAgent.name,
+                ORGX_OUTPUT_PATH: outputPath,
                 ORGX_RUNTIME_HOOK_URL: runtimeHookUrl ?? undefined,
                 ORGX_HOOK_TOKEN: runtimeHookToken ?? undefined,
             },
@@ -5097,6 +5797,8 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
                 message: `Autopilot slice started: ${workstreamTitle ?? selectedWorkstreamId}`,
                 metadata: {
                     event: "autopilot_slice_started",
+                    requested_by_agent_id: run.agentId,
+                    requested_by_agent_name: run.agentName,
                     domain: executionPolicy.domain,
                     required_skills: executionPolicy.requiredSkills,
                     task_ids: slice.taskIds,
@@ -5120,6 +5822,8 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
             message: `Autopilot dispatched slice for ${workstreamTitle ?? selectedWorkstreamId}.`,
             metadata: {
                 event: "autopilot_slice_dispatched",
+                requested_by_agent_id: run.agentId,
+                requested_by_agent_name: run.agentName,
                 agent_id: slice.agentId,
                 agent_name: sliceAgent.name,
                 domain: executionPolicy.domain,
@@ -5163,10 +5867,12 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
         }
     }
     async function tickAllAutoContinue() {
-        if (autoContinueTickInFlight)
+        if (autoContinueTickInFlight) {
+            // Wait for the in-flight tick to finish instead of silently dropping.
+            await autoContinueTickInFlight.catch(() => { });
             return;
-        autoContinueTickInFlight = true;
-        try {
+        }
+        const work = (async () => {
             for (const run of autoContinueRuns.values()) {
                 try {
                     await tickAutoContinueRun(run);
@@ -5178,9 +5884,13 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
                     await stopAutoContinueRun({ run, reason: "error", error: run.lastError });
                 }
             }
+        })();
+        autoContinueTickInFlight = work;
+        try {
+            await work;
         }
         finally {
-            autoContinueTickInFlight = false;
+            autoContinueTickInFlight = null;
         }
     }
     function isInitiativeActiveStatus(status) {
@@ -5207,10 +5917,12 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
     async function startAutoContinueRun(input) {
         const now = new Date().toISOString();
         const existing = autoContinueRuns.get(input.initiativeId) ?? null;
+        const existingIsLive = existing?.status === "running" || existing?.status === "stopping";
         const run = existing ??
             {
                 initiativeId: input.initiativeId,
                 agentId: input.agentId,
+                agentName: input.agentName ?? null,
                 includeVerification: false,
                 allowedWorkstreamIds: null,
                 stopAfterSlice: false,
@@ -5230,6 +5942,10 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
                 activeTaskTokenEstimate: null,
             };
         run.agentId = input.agentId;
+        run.agentName =
+            typeof input.agentName === "string" && input.agentName.trim().length > 0
+                ? input.agentName.trim()
+                : null;
         run.includeVerification = input.includeVerification;
         run.allowedWorkstreamIds = input.allowedWorkstreamIds;
         run.stopAfterSlice = Boolean(input.stopAfterSlice);
@@ -5237,10 +5953,19 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
         run.status = "running";
         run.stopReason = null;
         run.stopRequested = false;
-        run.startedAt = now;
         run.stoppedAt = null;
         run.updatedAt = now;
         run.lastError = null;
+        const forceFreshRun = Boolean(input.stopAfterSlice);
+        if (!existingIsLive || forceFreshRun) {
+            run.tokensUsed = 0;
+            run.startedAt = now;
+            run.lastTaskId = null;
+            run.lastRunId = null;
+            run.activeTaskId = null;
+            run.activeRunId = null;
+            run.activeTaskTokenEstimate = null;
+        }
         autoContinueRuns.set(input.initiativeId, run);
         try {
             await client.updateEntity("initiative", input.initiativeId, { status: "active" });
@@ -5784,6 +6509,8 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
             const isEntitiesRoute = route === "entities";
             const entityCommentsMatch = route.match(/^entities\/([^/]+)\/([^/]+)\/comments$/);
             const entityActionMatch = route.match(/^entities\/([^/]+)\/([^/]+)\/([^/]+)$/);
+            const isArtifactsByEntityRoute = route === "work-artifacts/by-entity";
+            const artifactDetailMatch = route.match(/^artifacts\/([^/]+)$/);
             const isOnboardingStartRoute = route === "onboarding/start";
             const isOnboardingStatusRoute = route === "onboarding/status";
             const isOnboardingManualKeyRoute = route === "onboarding/manual-key";
@@ -6306,6 +7033,23 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
                     }
                     const result = await stopProcess(record.pid);
                     const updated = markAgentRunStopped(runId);
+                    try {
+                        writeRuntimeEvent({
+                            sourceClient: "codex",
+                            event: "session_stop",
+                            runId,
+                            initiativeId: record.initiativeId ?? "",
+                            workstreamId: record.workstreamId ?? null,
+                            taskId: record.taskId ?? null,
+                            agentId: record.agentId ?? null,
+                            agentName: null,
+                            phase: "stopped",
+                            message: `Agent ${record.agentId ?? "unknown"} stopped.`,
+                        });
+                    }
+                    catch {
+                        // best effort
+                    }
                     void posthogCapture({
                         event: "openclaw_agent_stop",
                         distinctId: telemetryDistinctId,
@@ -6363,6 +7107,17 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
                         sendJson(res, 404, { ok: false, error: "Run not found" });
                         return true;
                     }
+                    // Stop the previous process before spawning a replacement to avoid
+                    // orphaned workers consuming resources or writing conflicting output.
+                    if (record.pid) {
+                        try {
+                            await stopProcess(record.pid);
+                        }
+                        catch {
+                            // best effort — process may have already exited
+                        }
+                        markAgentRunStopped(previousRunId);
+                    }
                     const messageOverride = (pickString(payload, ["message", "prompt", "text"]) ??
                         searchParams.get("message") ??
                         searchParams.get("prompt") ??
@@ -6578,6 +7333,9 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
                         });
                         return true;
                     }
+                    const requestedAgentName = await resolveAgentDisplayName(agentId, matchedQueueItem?.runnerAgentId === agentId
+                        ? matchedQueueItem.runnerAgentName
+                        : null);
                     // Autopilot v2 runs slices via local codex dispatch, so BYOK plan gating does not apply here.
                     const tokenBudget = pickNumber(payload, [
                         "tokenBudget",
@@ -6612,9 +7370,29 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
                     const fastAck = typeof fastAckRaw === "boolean"
                         ? fastAckRaw
                         : parseBooleanQuery(typeof fastAckRaw === "string" ? fastAckRaw : null);
+                    const existingRun = autoContinueRuns.get(initiativeId) ?? null;
+                    if (existingRun &&
+                        (existingRun.status === "running" || existingRun.status === "stopping") &&
+                        existingRun.activeRunId) {
+                        const activeSlice = autoContinueSliceRuns.get(existingRun.activeRunId) ?? null;
+                        const activeWorkstreamId = activeSlice?.workstreamId ?? null;
+                        const activeWorkstreamTitle = activeSlice?.workstreamTitle ?? null;
+                        sendJson(res, 409, {
+                            ok: false,
+                            code: "auto_continue_already_running",
+                            error: activeWorkstreamId || activeWorkstreamTitle
+                                ? `Auto-continue is already running for ${activeWorkstreamTitle ?? activeWorkstreamId}. Stop it before launching another Play run.`
+                                : "Auto-continue is already running for this initiative. Stop it before launching another Play run.",
+                            run: existingRun,
+                            activeWorkstreamId,
+                            activeWorkstreamTitle,
+                        });
+                        return true;
+                    }
                     const run = await startAutoContinueRun({
                         initiativeId,
                         agentId,
+                        agentName: requestedAgentName,
                         tokenBudget,
                         includeVerification,
                         allowedWorkstreamIds: [workstreamId],
@@ -6631,6 +7409,7 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
                                 workstreamId,
                                 workstreamTitle: matchedQueueItem.workstreamTitle,
                                 agentId,
+                                agentName: requestedAgentName,
                                 taskId: matchedQueueItem.nextTaskId ?? null,
                                 taskTitle: matchedQueueItem.nextTaskTitle ?? null,
                             });
@@ -6880,6 +7659,7 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
                     const run = await startAutoContinueRun({
                         initiativeId,
                         agentId,
+                        agentName: await resolveAgentDisplayName(agentId, null),
                         tokenBudget,
                         includeVerification,
                         allowedWorkstreamIds,
@@ -7120,6 +7900,40 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
                 }
                 return true;
             }
+            // Work artifacts by entity: GET /orgx/api/work-artifacts/by-entity?entity_type=...&entity_id=...&limit=...&status=...
+            if (isArtifactsByEntityRoute && method === "GET") {
+                try {
+                    const qs = rawUrl.includes("?") ? rawUrl.split("?")[1] : "";
+                    const path = `/api/work-artifacts/by-entity${qs ? `?${qs}` : ""}`;
+                    const data = await client.rawRequest("GET", path);
+                    sendJson(res, 200, data);
+                }
+                catch (err) {
+                    sendJson(res, 502, { error: safeErrorMessage(err) });
+                }
+                return true;
+            }
+            // Artifact detail: GET /orgx/api/artifacts/:artifactId
+            if (artifactDetailMatch && method === "GET") {
+                try {
+                    const artifactId = decodeURIComponent(artifactDetailMatch[1]);
+                    const path = `/api/artifacts/${encodeURIComponent(artifactId)}`;
+                    const data = await client.rawRequest("GET", path);
+                    sendJson(res, 200, data);
+                }
+                catch (err) {
+                    const warning = safeErrorMessage(err);
+                    const artifactId = decodeURIComponent(artifactDetailMatch[1]);
+                    const fallback = buildLocalArtifactDetailFallback(artifactId, warning);
+                    if (fallback) {
+                        sendJson(res, 200, fallback);
+                    }
+                    else {
+                        sendJson(res, 502, { error: warning });
+                    }
+                }
+                return true;
+            }
             // Entity comments route: GET/POST /orgx/api/entities/{type}/{id}/comments
             if (entityCommentsMatch && (method === "GET" || method === "POST")) {
                 try {
@@ -7339,7 +8153,15 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
             switch (route) {
                 case "agent-suite/status": {
                     try {
-                        const skillPack = await resolveSkillPackOverrides({ client });
+                        // Resolve skill pack overrides — tolerate failures so the plan
+                        // is still returned even when the remote API is unreachable.
+                        let skillPack = null;
+                        try {
+                            skillPack = await resolveSkillPackOverrides({ client });
+                        }
+                        catch {
+                            // Fall through with null — plan will use builtin defaults.
+                        }
                         const state = readSkillPackState();
                         const updateAvailable = Boolean(state.remote?.checksum &&
                             state.pack?.checksum &&
@@ -8050,6 +8872,7 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
                         };
                         const instance = upsertRuntimeInstanceFromHook(payload);
                         broadcastRuntimeSse("runtime.updated", instance);
+                        clearSnapshotResponseCache();
                         const fallbackPhaseByEvent = {
                             session_start: "intent",
                             heartbeat: "execution",
@@ -8547,6 +9370,12 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
                     const decisionStatus = searchParams.get("status") ?? "pending";
                     const includeIdleRaw = searchParams.get("include_idle");
                     const includeIdle = includeIdleRaw === null ? undefined : includeIdleRaw !== "false";
+                    const snapshotCacheKey = `${route}?${searchParams.toString()}`;
+                    const cachedSnapshot = readSnapshotResponseCache(snapshotCacheKey);
+                    if (cachedSnapshot) {
+                        sendJson(res, 200, cachedSnapshot);
+                        return true;
+                    }
                     const degraded = [];
                     const contextStore = readAgentContexts();
                     const agentContexts = contextStore.agents;
@@ -8808,13 +9637,27 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
                     sessions = injectRuntimeInstancesAsSessions(sessions, runtimeInstances);
                     sessions = enrichSessionsWithRuntime(sessions, runtimeInstances);
                     activity = enrichActivityWithRuntime(activity, runtimeInstances);
+                    activity = applyAgentContextsToActivity(activity, {
+                        agents: agentContexts,
+                        runs: runContexts,
+                    });
                     try {
-                        appendActivityItems(activity);
+                        // Avoid reprocessing/storing large activity snapshots when the leading window
+                        // is unchanged and we persisted recently.
+                        const fingerprint = snapshotActivityFingerprint(activity);
+                        const now = Date.now();
+                        const shouldPersist = fingerprint !== lastSnapshotActivityFingerprint ||
+                            now - lastSnapshotActivityPersistAt >= SNAPSHOT_ACTIVITY_PERSIST_MIN_INTERVAL_MS;
+                        if (shouldPersist) {
+                            appendActivityItems(activity);
+                            lastSnapshotActivityFingerprint = fingerprint;
+                            lastSnapshotActivityPersistAt = now;
+                        }
                     }
                     catch {
                         // best effort
                     }
-                    sendJson(res, 200, {
+                    const payload = {
                         sessions,
                         activity,
                         handoffs,
@@ -8824,7 +9667,9 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
                         outbox: outboxStatus,
                         generatedAt: new Date().toISOString(),
                         degraded: degraded.length > 0 ? degraded : undefined,
-                    });
+                    };
+                    writeSnapshotResponseCache(snapshotCacheKey, payload);
+                    sendJson(res, 200, payload);
                     return true;
                 }
                 // Legacy endpoints retained for backwards compatibility.
@@ -8897,6 +9742,16 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
                         until,
                         cursor,
                     });
+                    {
+                        const ctx = readAgentContexts();
+                        page = {
+                            ...page,
+                            activities: applyAgentContextsToActivity(page.activities, {
+                                agents: ctx.agents,
+                                runs: ctx.runs ?? {},
+                            }),
+                        };
+                    }
                     // If the local store is empty or we haven't warmed enough history yet, opportunistically
                     // warm from the remote API (which only supports since+limit) and re-page.
                     const warmKey = `${run ?? ""}::${since ?? ""}::${until ?? ""}`;
@@ -8929,6 +9784,16 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
                                 until,
                                 cursor,
                             });
+                            {
+                                const ctx = readAgentContexts();
+                                page = {
+                                    ...page,
+                                    activities: applyAgentContextsToActivity(page.activities, {
+                                        agents: ctx.agents,
+                                        runs: ctx.runs ?? {},
+                                    }),
+                                };
+                            }
                         }
                         catch {
                             // best effort
@@ -9098,6 +9963,75 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
                     }
                     return true;
                 }
+                case "live/filesystem/open": {
+                    if (method !== "GET") {
+                        sendJson(res, 405, { error: "Use GET /orgx/api/live/filesystem/open?path=..." });
+                        return true;
+                    }
+                    const rawPath = searchParams.get("path") ?? "";
+                    if (!rawPath.trim()) {
+                        sendJson(res, 400, { error: "path is required" });
+                        return true;
+                    }
+                    const pathInput = rawPath.trim();
+                    if (/^https?:\/\//i.test(pathInput)) {
+                        res.writeHead(302, {
+                            Location: pathInput,
+                            ...SECURITY_HEADERS,
+                            ...CORS_HEADERS,
+                        });
+                        res.end();
+                        return true;
+                    }
+                    const resolvedPath = resolveFilesystemOpenPath(pathInput);
+                    const escapedInput = escapeHtml(pathInput);
+                    const escapedResolved = escapeHtml(resolvedPath);
+                    const shellPath = resolvedPath.replaceAll("'", "'\\''");
+                    if (!existsSync(resolvedPath)) {
+                        sendHtml(res, 404, `<!doctype html><html><head><meta charset="utf-8"/><title>Path Not Found</title><style>body{margin:0;padding:24px;background:#080808;color:#e5e7eb;font:14px/1.5 ui-sans-serif,system-ui,-apple-system,Segoe UI,sans-serif}pre{background:#0f0f0f;border:1px solid rgba(255,255,255,.08);padding:12px;border-radius:10px;white-space:pre-wrap;word-break:break-word}a{color:#BFFF00}</style></head><body><h1 style="margin:0 0 8px;font-size:18px;">Path not found</h1><p style="margin:0 0 12px;color:#9ca3af;">The evidence path no longer exists.</p><pre>${escapedInput}</pre><p style="margin:12px 0 0;color:#9ca3af;">Resolved as:</p><pre>${escapedResolved}</pre></body></html>`);
+                        return true;
+                    }
+                    try {
+                        const stats = statSync(resolvedPath);
+                        if (stats.isDirectory()) {
+                            const entries = readdirSync(resolvedPath);
+                            const visibleEntries = entries.slice(0, FILE_PREVIEW_MAX_DIR_ENTRIES);
+                            const items = visibleEntries
+                                .map((name) => {
+                                const nextPath = resolve(resolvedPath, name);
+                                const href = `/orgx/api/live/filesystem/open?path=${encodeURIComponent(nextPath)}`;
+                                return `<li style="margin:0 0 6px;"><a href="${href}" target="_blank" rel="noreferrer" style="color:#BFFF00;text-decoration:none;">${escapeHtml(name)}</a></li>`;
+                            })
+                                .join("");
+                            const overflowNote = entries.length > visibleEntries.length
+                                ? `<p style="margin:12px 0 0;color:#9ca3af;">Showing ${visibleEntries.length} of ${entries.length} entries.</p>`
+                                : "";
+                            sendHtml(res, 200, `<!doctype html><html><head><meta charset="utf-8"/><title>Directory Preview</title><style>body{margin:0;padding:24px;background:#080808;color:#e5e7eb;font:14px/1.5 ui-sans-serif,system-ui,-apple-system,Segoe UI,sans-serif}pre,ul{background:#0f0f0f;border:1px solid rgba(255,255,255,.08);padding:12px;border-radius:10px}ul{list-style:none;margin:0;max-height:70vh;overflow:auto}pre{white-space:pre-wrap;word-break:break-word}code{color:#7dd3c0}</style></head><body><h1 style="margin:0 0 8px;font-size:18px;">Directory</h1><p style="margin:0 0 12px;color:#9ca3af;">${escapedResolved}</p><ul>${items || "<li style=\"color:#9ca3af;\">(empty)</li>"}</ul>${overflowNote}<p style="margin:12px 0 0;color:#9ca3af;">Tip: open in terminal with <code>ls -la '${escapeHtml(shellPath)}'</code></p></body></html>`);
+                            return true;
+                        }
+                        if (!stats.isFile()) {
+                            sendHtml(res, 200, `<!doctype html><html><head><meta charset="utf-8"/><title>Unsupported Path</title><style>body{margin:0;padding:24px;background:#080808;color:#e5e7eb;font:14px/1.5 ui-sans-serif,system-ui,-apple-system,Segoe UI,sans-serif}pre{background:#0f0f0f;border:1px solid rgba(255,255,255,.08);padding:12px;border-radius:10px;white-space:pre-wrap;word-break:break-word}</style></head><body><h1 style="margin:0 0 8px;font-size:18px;">Unsupported path type</h1><p style="margin:0 0 12px;color:#9ca3af;">Only files and directories are previewable.</p><pre>${escapedResolved}</pre></body></html>`);
+                            return true;
+                        }
+                        const totalBytes = Number.isFinite(stats.size) ? Math.max(0, stats.size) : 0;
+                        const { previewBuffer, truncated } = readFilePreview(resolvedPath, totalBytes);
+                        const isBinary = previewBuffer.includes(0);
+                        const sizeLabel = `${totalBytes.toLocaleString()} bytes`;
+                        if (isBinary) {
+                            sendHtml(res, 200, `<!doctype html><html><head><meta charset="utf-8"/><title>Binary File</title><style>body{margin:0;padding:24px;background:#080808;color:#e5e7eb;font:14px/1.5 ui-sans-serif,system-ui,-apple-system,Segoe UI,sans-serif}pre{background:#0f0f0f;border:1px solid rgba(255,255,255,.08);padding:12px;border-radius:10px;white-space:pre-wrap;word-break:break-word}code{color:#7dd3c0}</style></head><body><h1 style="margin:0 0 8px;font-size:18px;">Binary file</h1><p style="margin:0 0 12px;color:#9ca3af;">Cannot render binary content in browser preview.</p><pre>${escapedResolved}\n${escapeHtml(sizeLabel)}</pre><p style="margin:12px 0 0;color:#9ca3af;">Inspect in terminal with <code>file '${escapeHtml(shellPath)}'</code></p></body></html>`);
+                            return true;
+                        }
+                        const previewText = previewBuffer.toString("utf8");
+                        const truncationNote = truncated
+                            ? `<p style="margin:12px 0 0;color:#9ca3af;">Preview truncated to first ${FILE_PREVIEW_MAX_BYTES.toLocaleString()} bytes.</p>`
+                            : "";
+                        sendHtml(res, 200, `<!doctype html><html><head><meta charset="utf-8"/><title>File Preview</title><style>body{margin:0;padding:24px;background:#080808;color:#e5e7eb;font:14px/1.5 ui-sans-serif,system-ui,-apple-system,Segoe UI,sans-serif}pre{background:#0f0f0f;border:1px solid rgba(255,255,255,.08);padding:12px;border-radius:10px;white-space:pre;overflow:auto;max-height:75vh}code{color:#7dd3c0}</style></head><body><h1 style="margin:0 0 8px;font-size:18px;">File preview</h1><p style="margin:0 0 12px;color:#9ca3af;">${escapedResolved}</p><p style="margin:0 0 12px;color:#9ca3af;">${escapeHtml(sizeLabel)}</p><pre>${escapeHtml(previewText)}</pre>${truncationNote}<p style="margin:12px 0 0;color:#9ca3af;">Open in terminal with <code>cat '${escapeHtml(shellPath)}'</code></p></body></html>`);
+                    }
+                    catch (err) {
+                        sendHtml(res, 500, `<!doctype html><html><head><meta charset="utf-8"/><title>Preview Error</title><style>body{margin:0;padding:24px;background:#080808;color:#e5e7eb;font:14px/1.5 ui-sans-serif,system-ui,-apple-system,Segoe UI,sans-serif}pre{background:#0f0f0f;border:1px solid rgba(255,255,255,.08);padding:12px;border-radius:10px;white-space:pre-wrap;word-break:break-word}</style></head><body><h1 style="margin:0 0 8px;font-size:18px;">Unable to preview path</h1><p style="margin:0 0 12px;color:#9ca3af;">${escapeHtml(safeErrorMessage(err))}</p><pre>${escapedResolved}</pre></body></html>`);
+                    }
+                    return true;
+                }
                 case "live/activity/headline": {
                     if (method !== "POST") {
                         sendJson(res, 405, { error: "Use POST /orgx/api/live/activity/headline" });
@@ -9628,7 +10562,14 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
                             assetPath.startsWith(`${RESOLVED_DIST_ASSETS_DIR}${sep}`);
                 }
                 if (assetPath && isWithinAssetsDir && existsSync(assetPath)) {
-                    sendFile(res, assetPath, "public, max-age=31536000, immutable");
+                    const assetExt = extname(assetPath).toLowerCase();
+                    // JS/CSS chunks can be invalidated by dashboard rebuilds while browsers retain
+                    // immutable cached entry chunks in local plugin environments.
+                    // Revalidate executable assets to avoid stale chunk graph 404s.
+                    const cacheControl = assetExt === ".js" || assetExt === ".css"
+                        ? "no-cache"
+                        : "public, max-age=31536000, immutable";
+                    sendFile(res, assetPath, cacheControl);
                 }
                 else {
                     send404(res);