@useorgx/openclaw-plugin 0.7.20 → 0.7.23

package/dist/http/helpers/triage-mapper.js

@@ -5,6 +5,136 @@
  * `LiveTriageItem` objects with proof bundles and recommended actions.
  */
 import { callLlmJson } from "./llm-client.js";
+function asRecord(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return null;
+    return value;
+}
+function pickString(record, keys) {
+    if (!record)
+        return null;
+    for (const key of keys) {
+        const value = record[key];
+        if (typeof value !== "string")
+            continue;
+        const normalized = value.trim();
+        if (normalized.length > 0)
+            return normalized;
+    }
+    return null;
+}
+function pickStringArray(record, keys) {
+    if (!record)
+        return [];
+    const values = [];
+    for (const key of keys) {
+        const candidate = record[key];
+        if (!Array.isArray(candidate))
+            continue;
+        for (const entry of candidate) {
+            if (typeof entry !== "string")
+                continue;
+            const normalized = entry.trim();
+            if (normalized.length > 0)
+                values.push(normalized);
+        }
+        if (values.length > 0)
+            break;
+    }
+    return values;
+}
+function countArray(record, keys) {
+    if (!record)
+        return 0;
+    for (const key of keys) {
+        const candidate = record[key];
+        if (Array.isArray(candidate))
+            return candidate.length;
+    }
+    return 0;
+}
+function deriveInterventionContext(input) {
+    const metadata = asRecord(input.metadata);
+    const result = asRecord(metadata?.result);
+    const blocker = asRecord(metadata?.blocker) ?? asRecord(result?.blocker);
+    const blockerReason = pickString(blocker, ["description", "summary"]) ??
+        pickString(result, ["blocked_reason", "blockedReason", "error"]) ??
+        pickString(metadata, ["blocked_reason", "blockedReason", "error", "reason"]) ??
+        (typeof input.reason === "string" && input.reason.trim().length > 0 ? input.reason.trim() : null);
+    const waitingOn = pickString(blocker, ["waiting_on", "required_actor", "requiredActor"]) ??
+        pickString(result, ["waiting_on", "required_actor", "requiredActor"]) ??
+        pickString(metadata, ["waiting_on", "required_actor", "requiredActor"]);
+    const nextActions = [
+        ...pickStringArray(result, ["next_actions", "nextActions"]),
+        ...pickStringArray(metadata, ["next_actions", "nextActions"]),
+    ];
+    const requiredAction = pickString(blocker, ["required_action", "requiredAction"]) ??
+        pickString(result, ["required_action", "requiredAction"]) ??
+        pickString(metadata, ["required_action", "requiredAction"]) ??
+        (nextActions[0] ?? null);
+    const requiredActor = pickString(blocker, ["required_actor", "requiredActor"]) ??
+        pickString(result, ["required_actor", "requiredActor"]) ??
+        pickString(metadata, ["required_actor", "requiredActor"]);
+    const suggestedActions = [
+        ...pickStringArray(blocker, ["suggested_actions", "suggestedActions"]),
+        ...pickStringArray(result, ["suggested_actions", "suggestedActions"]),
+        ...pickStringArray(metadata, ["suggested_actions", "suggestedActions"]),
+    ];
+    const decisionIds = [
+        ...pickStringArray(result, ["decision_ids", "decisionIds"]),
+        ...pickStringArray(metadata, ["decision_ids", "decisionIds"]),
+    ];
+    const retryable = typeof blocker?.retryable === "boolean"
+        ? blocker.retryable
+        : typeof result?.retryable === "boolean"
+            ? result.retryable
+            : typeof metadata?.retryable === "boolean"
+                ? metadata.retryable
+                : null;
+    const errorCode = pickString(blocker, ["error_code", "errorCode"]) ??
+        pickString(result, ["error_code", "errorCode"]) ??
+        pickString(metadata, ["error_code", "errorCode"]);
+    const errorCategory = pickString(blocker, ["error_category", "errorCategory"]) ??
+        pickString(result, ["error_category", "errorCategory"]) ??
+        pickString(metadata, ["error_category", "errorCategory"]);
+    const taskUpdateCount = countArray(result, ["task_updates", "taskUpdates"]) ||
+        countArray(metadata, ["task_updates", "taskUpdates"]);
+    const milestoneUpdateCount = countArray(result, ["milestone_updates", "milestoneUpdates"]) ||
+        countArray(metadata, ["milestone_updates", "milestoneUpdates"]);
+    const context = {
+        blockerReason,
+        waitingOn,
+        requiredAction,
+        requiredActor,
+        retryable,
+        errorCode,
+        errorCategory,
+        suggestedActions: suggestedActions.length > 0 ? Array.from(new Set(suggestedActions)) : [],
+        nextActions: nextActions.length > 0 ? Array.from(new Set(nextActions)) : [],
+        decisionIds: decisionIds.length > 0 ? Array.from(new Set(decisionIds)) : [],
+        taskUpdateCount: taskUpdateCount > 0 ? taskUpdateCount : undefined,
+        milestoneUpdateCount: milestoneUpdateCount > 0 ? milestoneUpdateCount : undefined,
+    };
+    const hasValue = [
+        context.blockerReason,
+        context.waitingOn,
+        context.requiredAction,
+        context.requiredActor,
+        context.errorCode,
+        context.errorCategory,
+        context.retryable,
+        context.taskUpdateCount,
+        context.milestoneUpdateCount,
+        context.suggestedActions?.length,
+        context.nextActions?.length,
+        context.decisionIds?.length,
+    ].some((entry) => {
+        if (typeof entry === "number")
+            return entry > 0;
+        return entry != null && String(entry).trim().length > 0;
+    });
+    return hasValue ? context : null;
+}
 const FAILURE_MAPPINGS = {
     credential_missing: {
         kind: "blocked_intervention",
@@ -288,12 +418,16 @@ export async function mapFailureToTriageItem(input) {
         metadata: input.metadata,
     };
     const now = input.timestamp ?? new Date().toISOString();
+    const intervention = deriveInterventionContext({
+        reason: input.reason ?? null,
+        metadata: input.metadata,
+    });
     const proofBundle = {
         artifactRefs: [],
         fileChanges: [],
         prRefs: [],
         logRefs: input.logPath ? [input.logPath] : [],
-        decisionRefs: [],
+        decisionRefs: intervention?.decisionIds ?? [],
     };
     if (input.outputPath) {
         proofBundle.artifactRefs.push(input.outputPath);
@@ -380,6 +514,25 @@ export async function mapFailureToTriageItem(input) {
             },
         ];
     }
+    const summaryDetails = [];
+    if (intervention?.waitingOn)
+        summaryDetails.push(`Waiting on ${intervention.waitingOn}.`);
+    if (intervention?.requiredAction)
+        summaryDetails.push(`Required action: ${intervention.requiredAction}.`);
+    if (intervention?.errorCode)
+        summaryDetails.push(`Error code: ${intervention.errorCode}.`);
+    if (intervention?.taskUpdateCount && intervention.taskUpdateCount > 0) {
+        summaryDetails.push(`${intervention.taskUpdateCount} task update${intervention.taskUpdateCount === 1 ? "" : "s"} pending apply.`);
+    }
+    if (intervention?.milestoneUpdateCount && intervention.milestoneUpdateCount > 0) {
+        summaryDetails.push(`${intervention.milestoneUpdateCount} milestone update${intervention.milestoneUpdateCount === 1 ? "" : "s"} pending apply.`);
+    }
+    if (summaryDetails.length > 0) {
+        summary = `${summary} ${summaryDetails.join(" ")}`.trim();
+    }
+    if (intervention?.requiredAction) {
+        recommendedAction = intervention.requiredAction;
+    }
     return {
         id: input.id,
         kind,
@@ -407,6 +560,7 @@ export async function mapFailureToTriageItem(input) {
         blocking: kind === "blocked_intervention" || kind === "decision_required",
         recommendedAction,
         agentId: input.agentId ?? null,
+        intervention,
         impact,
         proofBundle,
         actionContract,
@@ -426,7 +580,38 @@ export function mapDecisionToTriageItem(decision) {
     const now = new Date().toISOString();
     const decisionType = decision.decisionType ?? "decision_required";
     const mapping = FAILURE_MAPPINGS[decisionType];
-    const actions = [
+    const metadata = decision.metadata && typeof decision.metadata === "object" && !Array.isArray(decision.metadata)
+        ? decision.metadata
+        : null;
+    const intervention = deriveInterventionContext({
+        reason: decision.context ?? null,
+        metadata: metadata ?? undefined,
+    });
+    const blocking = metadata?.blocking !== false;
+    const options = Array.isArray(decision.options) ? decision.options : [];
+    const optionActions = options
+        .map((option) => {
+        const implied = (option.impliedStatus ?? "").toLowerCase();
+        const action = implied === "declined" || implied === "cancelled" ? "reject" : "approve";
+        const optionConsequences = typeof option.consequences === "string" && option.consequences.trim().length > 0
+            ? option.consequences.trim()
+            : null;
+        const consequences = optionConsequences ??
+            (action === "approve"
+                ? "Will continue execution using this option."
+                : "Will decline this direction and keep the run blocked.");
+        return {
+            action,
+            label: option.label,
+            description: option.description ?? (action === "approve" ? "Approve this option" : "Reject with this rationale"),
+            consequences,
+            requiresNote: option.requiresNote === true,
+            available: true,
+            optionId: option.id,
+        };
+    })
+        .slice(0, 4);
+    const fallbackActions = [
         {
             action: "approve",
             label: "Approve",
@@ -434,6 +619,7 @@ export function mapDecisionToTriageItem(decision) {
             consequences: "Will proceed with the recommended action.",
             requiresNote: false,
             available: true,
+            optionId: null,
         },
         {
             action: "reject",
@@ -442,7 +628,20 @@ export function mapDecisionToTriageItem(decision) {
             consequences: "Agent will pause and await new instructions.",
             requiresNote: true,
             available: true,
+            optionId: null,
         },
+    ];
+    const optionActionsWithCoverage = [...optionActions];
+    if (optionActionsWithCoverage.length > 0) {
+        if (!optionActionsWithCoverage.some((action) => action.action === "approve")) {
+            optionActionsWithCoverage.unshift(fallbackActions[0]);
+        }
+        if (!optionActionsWithCoverage.some((action) => action.action === "reject")) {
+            optionActionsWithCoverage.push(fallbackActions[1]);
+        }
+    }
+    const actions = [
+        ...(optionActionsWithCoverage.length > 0 ? optionActionsWithCoverage.slice(0, 4) : fallbackActions),
         {
             action: "snooze",
             label: "Snooze",
@@ -450,6 +649,7 @@ export function mapDecisionToTriageItem(decision) {
             consequences: "Item reappears after snooze period.",
             requiresNote: false,
             available: true,
+            optionId: null,
         },
     ];
     const proofBundle = {
@@ -457,20 +657,33 @@ export function mapDecisionToTriageItem(decision) {
         fileChanges: [],
         prRefs: [],
         logRefs: [],
-        decisionRefs: [decision.id],
+        decisionRefs: Array.from(new Set([decision.id, ...(intervention?.decisionIds ?? [])].filter(Boolean))),
     };
     if (decision.evidenceRefs) {
         for (const ref of decision.evidenceRefs) {
             if (ref.sourceUrl)
                 proofBundle.artifactRefs.push(ref.sourceUrl);
+            if (ref.sourcePointer)
+                proofBundle.logRefs.push(ref.sourcePointer);
         }
     }
+    const summaryBase = (typeof decision.context === "string" && decision.context.trim()) ||
+        intervention?.blockerReason ||
+        decision.title;
+    const summarySuffix = [
+        intervention?.waitingOn ? `Waiting on ${intervention.waitingOn}.` : null,
+        intervention?.requiredAction ? `Required action: ${intervention.requiredAction}.` : null,
+    ]
+        .filter((entry) => Boolean(entry))
+        .join(" ");
+    const summary = summarySuffix.length > 0 ? `${summaryBase} ${summarySuffix}` : summaryBase;
+    const recommendedAction = decision.recommendedAction ?? intervention?.requiredAction ?? null;
     return {
         id: `triage-decision-${decision.id}`,
         kind: mapping?.kind ?? "decision_required",
         status: decision.status === "pending" ? "open" : decision.status === "resolved" ? "resolved" : "open",
         title: decision.title,
-        summary: decision.context ?? decision.title,
+        summary,
         initiativeId: decision.initiativeId ?? null,
         initiativeTitle: null,
         workstreamId: decision.workstreamId ?? null,
@@ -482,9 +695,10 @@ export function mapDecisionToTriageItem(decision) {
         dedupeKey: decision.dedupeKey ?? null,
         occurrenceCount: decision.occurrenceCount ?? 1,
         severity: decision.priority === "urgent" ? "critical" : decision.priority === "high" ? "high" : "medium",
-        blocking: true,
-        recommendedAction: decision.recommendedAction ?? null,
+        blocking,
+        recommendedAction,
         agentId: decision.agentId ?? null,
+        intervention,
         impact: {
             initiativeCount: decision.initiativeId ? 1 : 0,
             workstreamCount: decision.workstreamId ? 1 : 0,

package/dist/http/index.d.ts

@@ -70,6 +70,7 @@ interface OnboardingController {
         apiKey: string;
         userId?: string;
     }) => Promise<OnboardingState>;
+    cancelPairing?: () => Promise<OnboardingState>;
     disconnect: () => Promise<OnboardingState>;
 }
 interface DiagnosticsProvider {

package/dist/http/index.js

@@ -41,6 +41,7 @@ import { listRuntimeInstances, resolveRuntimeHookToken, upsertRuntimeInstanceFro
 import { parseJsonSafe } from "../json-utils.js";
 import { readSkillPackState, refreshSkillPackState, rollbackSkillPackPolicy, updateSkillPackPolicy, } from "../skill-pack-state.js";
 import { posthogCapture } from "../telemetry/posthog.js";
+import { clearMaterializedSnapshotMemory, readMaterializedSnapshot, writeMaterializedSnapshot, } from "../stores/materialized-snapshot-store.js";
 import { createRouter } from "./router.js";
 import { summarizeActivityHeadline } from "./helpers/activity-headline.js";
 import { createAutoContinueEngine, } from "./helpers/auto-continue-engine.js";
@@ -271,7 +272,6 @@ async function mapWithConcurrency(items, concurrency, mapper) {
 const ACTIVITY_WARM_THROTTLE_MS = 30_000;
 const activityWarmByKey = new Map();
 const SNAPSHOT_RESPONSE_CACHE_TTL_MS = 800;
-const SNAPSHOT_RESPONSE_CACHE_MAX_ENTRIES = 16;
 const SNAPSHOT_ACTIVITY_PERSIST_MIN_INTERVAL_MS = 15_000;
 const SNAPSHOT_ACTIVITY_FINGERPRINT_DEPTH = 8;
 const NEXT_UP_QUEUE_CACHE_TTL_MS = readPositiveIntEnv("ORGX_NEXT_UP_QUEUE_CACHE_TTL_MS", 30_000, { min: 250, max: 120_000 });
@@ -292,7 +292,6 @@ const LIVE_WORKSPACE_INITIATIVE_STATUSES = [
 let lastSnapshotActivityPersistAt = 0;
 let lastSnapshotActivityFingerprint = "";
 let snapshotCacheGeneration = 0;
-const snapshotResponseCache = new Map();
 const ACTIVITY_DECISION_EVENT_HINTS = new Set([
     "decision_buffered",
     "auto_continue_spawn_guard_blocked",
@@ -435,39 +434,24 @@ function snapshotActivityFingerprint(items) {
         .join(";");
     return `${items.length}:${sample}`;
 }
-function readSnapshotResponseCache(key) {
-    const entry = snapshotResponseCache.get(key);
-    if (!entry)
-        return null;
-    if (entry.generation !== snapshotCacheGeneration || entry.expiresAt <= Date.now()) {
-        snapshotResponseCache.delete(key);
-        return null;
-    }
-    return entry.payload;
+function getSnapshotCacheGeneration() {
+    return snapshotCacheGeneration;
+}
+function readSnapshotResponseCache(key, options) {
+    return readMaterializedSnapshot(key, {
+        allowStale: options?.allowStale,
+        generation: snapshotCacheGeneration,
+    });
 }
 function writeSnapshotResponseCache(key, payload) {
-    const now = Date.now();
-    snapshotResponseCache.set(key, {
-        expiresAt: now + SNAPSHOT_RESPONSE_CACHE_TTL_MS,
+    writeMaterializedSnapshot(key, payload, {
         generation: snapshotCacheGeneration,
-        payload,
+        ttlMs: SNAPSHOT_RESPONSE_CACHE_TTL_MS,
     });
-    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() {
     snapshotCacheGeneration += 1;
-    snapshotResponseCache.clear();
+    clearMaterializedSnapshotMemory();
 }
 function isUserScopedApiKey(apiKey) {
     return apiKey.trim().toLowerCase().startsWith("oxk_");
@@ -1751,9 +1735,36 @@ async function parseJsonRequest(req) {
     }
     return parseJsonBody(streamed);
 }
-// =============================================================================
-// Factory
-// =============================================================================
+let activeHttpRuntimeLifecycle = null;
+function createHttpRuntimeLifecycle(input) {
+    let nextUpPrewarmTimer = null;
+    let autoContinueTimer = null;
+    const stop = () => {
+        if (nextUpPrewarmTimer) {
+            clearTimeout(nextUpPrewarmTimer);
+            nextUpPrewarmTimer = null;
+        }
+        if (autoContinueTimer) {
+            clearInterval(autoContinueTimer);
+            autoContinueTimer = null;
+        }
+    };
+    return {
+        start() {
+            stop();
+            nextUpPrewarmTimer = setTimeout(() => {
+                nextUpPrewarmTimer = null;
+                input.prewarmNextUpQueue();
+            }, 75);
+            nextUpPrewarmTimer.unref?.();
+            autoContinueTimer = setInterval(() => {
+                void input.tickAllAutoContinue();
+            }, input.autoContinueTickMs);
+            autoContinueTimer.unref?.();
+        },
+        stop,
+    };
+}
 export function createHttpHandler(config, client, getSnapshot, onboarding, diagnostics, adapters) {
     const dashboardEnabled = config.dashboardEnabled ??
         true;
@@ -2962,12 +2973,14 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
             // best effort prewarm only
         });
     };
-    const nextUpPrewarmTimer = setTimeout(prewarmNextUpQueue, 75);
-    nextUpPrewarmTimer.unref?.();
-    const autoContinueTimer = setInterval(() => {
-        void tickAllAutoContinue();
-    }, AUTO_CONTINUE_TICK_MS);
-    autoContinueTimer.unref?.();
+    activeHttpRuntimeLifecycle?.stop();
+    const runtimeLifecycle = createHttpRuntimeLifecycle({
+        prewarmNextUpQueue,
+        tickAllAutoContinue,
+        autoContinueTickMs: AUTO_CONTINUE_TICK_MS,
+    });
+    runtimeLifecycle.start();
+    activeHttpRuntimeLifecycle = runtimeLifecycle;
     const apiRouter = createRouter();
     registerOnboardingRoutes(apiRouter, {
         onboarding,
@@ -3511,6 +3524,7 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
         outboxReadAllItems: () => outboxAdapter.readAllItems(),
         toLocalLiveActivity,
         loadLocalTurnDetail,
+        summarizeActivityHeadline,
         sendJson,
         safeErrorMessage,
         sendHtml,
@@ -3539,6 +3553,7 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
         parsePositiveInt,
         readSnapshotResponseCache,
         writeSnapshotResponseCache,
+        getSnapshotCacheGeneration,
         safeErrorMessage,
         readAgentContexts,
         getScopedAgentIds,
@@ -3596,6 +3611,8 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
         listChatThreads: ({ commandCenterId, initiativeId, limit, offset }) => listChatThreads({ commandCenterId, initiativeId, limit, offset }),
         getCanonicalAutopilotState,
         sendJson,
+        securityHeaders: SECURITY_HEADERS,
+        corsHeaders: CORS_HEADERS,
     });
     registerRuntimeHookRoutes(apiRouter, {
         parseJsonRequest,
@@ -3679,10 +3696,11 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
             const keys = [...scopedKeys, ...fallbackKeys];
             const seen = new Set();
             const mapped = [];
-            const deriveFailureType = (eventNameRaw, actionTypeRaw) => {
+            const deriveFailureType = (eventNameRaw, actionTypeRaw, reasonRaw) => {
                 const eventName = (eventNameRaw ?? "").trim().toLowerCase();
                 const actionType = (actionTypeRaw ?? "").trim().toLowerCase();
-                const signature = `${eventName} ${actionType}`;
+                const reason = (reasonRaw ?? "").trim().toLowerCase();
+                const signature = `${eventName} ${actionType} ${reason}`;
                 if (!signature.trim())
                     return null;
                 if (signature.includes("status_updates_buffered"))
@@ -3707,6 +3725,18 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
                     return "budget_exhausted";
                 if (signature.includes("stale_blocked_workstream"))
                     return "stale_blocked_workstream";
+                if (signature.includes("credit") ||
+                    signature.includes("insufficient_quota") ||
+                    signature.includes("insufficient credit") ||
+                    signature.includes("payment required")) {
+                    return "budget_exhausted";
+                }
+                if (signature.includes("run_failed") ||
+                    signature.includes("autopilot_slice_result") ||
+                    signature.includes("autopilot_slice_finished") ||
+                    signature.includes("failed")) {
+                    return "worker_exit_no_output";
+                }
                 return null;
             };
             try {
@@ -3724,7 +3754,20 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
                         const metadataRecord = activityRecord.metadata && typeof activityRecord.metadata === "object"
                             ? activityRecord.metadata
                             : {};
-                        const failureType = deriveFailureType(pickString(metadataRecord, ["event", "event_name"]), pickString(metadataRecord, ["action_type", "actionType"]));
+                        const resultRecord = metadataRecord.result && typeof metadataRecord.result === "object"
+                            ? metadataRecord.result
+                            : null;
+                        const blockerRecord = metadataRecord.blocker && typeof metadataRecord.blocker === "object"
+                            ? metadataRecord.blocker
+                            : resultRecord && resultRecord.blocker && typeof resultRecord.blocker === "object"
+                                ? resultRecord.blocker
+                                : null;
+                        const reasonText = pickString(blockerRecord ?? {}, ["description", "summary"]) ??
+                            pickString(resultRecord ?? {}, ["error", "reason", "blocked_reason", "blockedReason", "summary"]) ??
+                            pickString(metadataRecord, ["error", "reason", "message", "blocked_reason", "blockedReason"]) ??
+                            pickString(activityRecord, ["description", "summary", "title"]);
+                        const failureType = deriveFailureType(pickString(metadataRecord, ["event", "event_name"]), pickString(metadataRecord, ["action_type", "actionType"]) ??
+                            pickString(activityRecord, ["type"]), reasonText);
                         if (!failureType)
                             continue;
                         const runId = pickString(metadataRecord, ["run_id", "source_run_id"]) ?? pickString(activityRecord, ["runId"]);
@@ -3743,9 +3786,9 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
                         mapped.push({
                             id: dedupeId,
                             failureType,
-                            reason: pickString(metadataRecord, ["error", "reason", "message"]) ??
-                                pickString(activityRecord, ["description", "summary", "title"]),
-                            provider: pickString(metadataRecord, ["provider"]),
+                            reason: reasonText,
+                            provider: pickString(metadataRecord, ["provider"]) ??
+                                pickString(blockerRecord ?? {}, ["provider"]),
                             initiativeId,
                             initiativeTitle: pickString(metadataRecord, ["initiative_title"]) ??
                                 pickString(activityRecord, ["initiativeTitle"]),
@@ -3759,8 +3802,12 @@ export function createHttpHandler(config, client, getSnapshot, onboarding, diagn
                             domain: pickString(metadataRecord, ["domain", "executor_domain"]),
                             sourceSystem: pickString(metadataRecord, ["source_system", "source"]) ?? "openclaw",
                             runId,
-                            logPath: pickString(metadataRecord, ["log_path"]),
-                            outputPath: pickString(metadataRecord, ["output_path"]),
+                            logPath: pickString(metadataRecord, ["log_path"]) ??
+                                pickString(resultRecord ?? {}, ["log_path"]) ??
+                                pickString(blockerRecord ?? {}, ["log_path"]),
+                            outputPath: pickString(metadataRecord, ["output_path"]) ??
+                                pickString(resultRecord ?? {}, ["output_path"]) ??
+                                pickString(blockerRecord ?? {}, ["output_path"]),
                             metadata: metadataRecord,
                             timestamp: timestamp ?? undefined,
                         });

package/dist/http/router.js

@@ -1,20 +1,75 @@
-function isPatternMatch(pattern, path) {
-    if (pattern.endsWith("/*")) {
-        return path.startsWith(pattern.slice(0, -1));
+function normalizePrefixBase(pattern) {
+    return pattern.endsWith("/*") ? pattern.slice(0, -1) : null;
+}
+function getOrCreateBucket(map, key) {
+    const existing = map.get(key);
+    if (existing)
+        return existing;
+    const created = [];
+    map.set(key, created);
+    return created;
+}
+function getOrCreateMethodBuckets(map, method) {
+    const existing = map.get(method);
+    if (existing)
+        return existing;
+    const created = new Map();
+    map.set(method, created);
+    return created;
+}
+function collectPathPrefixBases(path) {
+    const bases = new Set();
+    let slashIndex = path.indexOf("/");
+    while (slashIndex !== -1) {
+        bases.add(path.slice(0, slashIndex + 1));
+        slashIndex = path.indexOf("/", slashIndex + 1);
     }
-    return pattern === path;
+    bases.add(`${path}/`);
+    return Array.from(bases);
 }
 export function createRouter() {
     const entries = [];
+    const exactRoutes = new Map();
+    const prefixRoutes = new Map();
     function add(method, pattern, handler, description) {
-        entries.push({ method, pattern, handler, description });
+        const route = {
+            method,
+            pattern,
+            handler,
+            description,
+            order: entries.length,
+            prefixBase: normalizePrefixBase(pattern),
+        };
+        entries.push(route);
+        if (route.prefixBase) {
+            getOrCreateBucket(getOrCreateMethodBuckets(prefixRoutes, method), route.prefixBase).push(route);
+            return;
+        }
+        getOrCreateBucket(getOrCreateMethodBuckets(exactRoutes, method), pattern).push(route);
+    }
+    function pickEarlierRoute(current, candidate) {
+        if (!current)
+            return candidate;
+        return candidate.order < current.order ? candidate : current;
+    }
+    function matchFromBuckets(routeBuckets, method, key, current) {
+        const methodBuckets = routeBuckets.get(method);
+        const wildcardBuckets = routeBuckets.get("*");
+        for (const candidate of methodBuckets?.get(key) ?? []) {
+            current = pickEarlierRoute(current, candidate);
+        }
+        for (const candidate of wildcardBuckets?.get(key) ?? []) {
+            current = pickEarlierRoute(current, candidate);
+        }
+        return current;
     }
     function match(method, path) {
         const normalizedMethod = method.toUpperCase();
-        return entries.find((route) => {
-            const methodMatches = route.method === "*" || route.method === normalizedMethod;
-            return methodMatches && isPatternMatch(route.pattern, path);
-        });
+        let matched = matchFromBuckets(exactRoutes, normalizedMethod, path, undefined);
+        for (const base of collectPathPrefixBases(path)) {
+            matched = matchFromBuckets(prefixRoutes, normalizedMethod, base, matched);
+        }
+        return matched;
     }
     function routes() {
         return entries;