@pasko70/pibo 1.7.3 → 1.7.5

package/dist/apps/chat/chat-api-routes.js

@@ -94,6 +94,20 @@ export function workflowDraftActionResource(pathname) {
         throw new PiboWebHttpError("Invalid workflow draft action", 400);
     }
 }
+export function workflowDraftManualTriggerRunResource(pathname) {
+    const prefix = `${CHAT_WEB_API_PREFIX}/workflows/drafts/`;
+    if (!pathname.startsWith(prefix))
+        return undefined;
+    const parts = pathname.slice(prefix.length).split("/");
+    if (parts.length !== 2 || !parts[0] || parts[1] !== "manual-trigger-runs")
+        return undefined;
+    try {
+        return { draftId: decodeURIComponent(parts[0]) };
+    }
+    catch {
+        throw new PiboWebHttpError("Invalid workflow draft manual trigger route", 400);
+    }
+}
 export function workflowDuplicateResourceId(pathname) {
     const prefix = `${CHAT_WEB_API_PREFIX}/workflows/`;
     const suffix = "/duplicate";

package/dist/apps/chat/data/session-query-service.js

@@ -1,5 +1,6 @@
 import { chatRoomIdFromMetadata } from "../types/rooms.js";
 import { sessionFromRow, statusFromOutputEvent } from "./chat-data-mappers.js";
+import { rootSessionId } from "../../../data/session-store.js";
 export class ChatSessionQueryService {
     store;
     constructor(store) {
@@ -11,9 +12,17 @@ export class ChatSessionQueryService {
         this.upsertNavigation(session, roomId, status, session.updatedAt);
     }
     upsertSessionsIfChanged(sessions) {
-        for (const session of sessions)
+        let written = 0;
+        let skipped = 0;
+        for (const session of sessions) {
+            if (this.sessionIndexMatches(session)) {
+                skipped++;
+                continue;
+            }
             this.upsertSession(session);
-        return { checked: sessions.length, written: sessions.length, skipped: 0 };
+            written++;
+        }
+        return { checked: sessions.length, written, skipped };
     }
     recordEvent(event, session) {
         if (session)
@@ -44,11 +53,65 @@ export class ChatSessionQueryService {
         return Number(result.changes ?? 0);
     }
     close() { }
+    sessionIndexMatches(session, status = "idle") {
+        const roomId = chatRoomIdFromMetadata(session.metadata) ?? "room_default";
+        const title = session.title || "Untitled Session";
+        const metadataJson = JSON.stringify(session.metadata ?? {});
+        const activeModelJson = session.activeModel ? JSON.stringify(session.activeModel) : null;
+        const row = this.store.db.prepare(`
+			SELECT
+				s.pi_session_id,
+				s.room_id,
+				s.root_session_id,
+				s.parent_id,
+				s.origin_id,
+				s.channel,
+				s.kind,
+				s.profile,
+				s.active_model_json,
+				s.workspace,
+				s.title,
+				s.status,
+				s.metadata_json,
+				s.created_at,
+				s.updated_at,
+				s.last_activity_at,
+				n.status AS navigation_status,
+				n.title AS navigation_title,
+				n.sort_key AS navigation_sort_key,
+				n.updated_at AS navigation_updated_at
+			FROM sessions s
+			LEFT JOIN session_navigation n ON n.session_id = s.id
+			WHERE s.id = ? AND s.deleted_at IS NULL
+		`).get(session.id);
+        if (!row)
+            return false;
+        return row.pi_session_id === session.piSessionId
+            && row.room_id === roomId
+            && row.root_session_id === rootSessionId(session)
+            && row.parent_id === (session.parentId ?? null)
+            && row.origin_id === (session.originId ?? null)
+            && row.channel === session.channel
+            && row.kind === session.kind
+            && row.profile === session.profile
+            && row.active_model_json === activeModelJson
+            && row.workspace === (session.workspace ?? null)
+            && row.title === title
+            && row.status === status
+            && row.metadata_json === metadataJson
+            && row.created_at === session.createdAt
+            && row.updated_at === session.updatedAt
+            && row.last_activity_at === session.updatedAt
+            && row.navigation_status === status
+            && row.navigation_title === title
+            && row.navigation_sort_key === session.updatedAt
+            && row.navigation_updated_at === session.updatedAt;
+    }
     upsertNavigation(session, roomId, status, now) {
         this.store.navigation.upsertSession({
             roomId,
             sessionId: session.id,
-            rootSessionId: session.parentId ? (typeof session.metadata?.rootSessionId === "string" ? session.metadata.rootSessionId : session.parentId) : session.id,
+            rootSessionId: rootSessionId(session),
             parentId: session.parentId,
             originId: session.originId,
             title: session.title || "Untitled Session",

package/dist/apps/chat/data/timeline-query-service.js

@@ -75,8 +75,14 @@ export class ChatTimelineQueryService {
         return rows.map((row) => ({ eventType: row.type, count: Number(row.count) }));
     }
     getLatestEventSequence(piboSessionId) {
-        const row = this.store.db.prepare("SELECT COALESCE(MAX(session_sequence), 0) AS latest_sequence FROM event_log WHERE session_id = ?").get(piboSessionId);
-        return row.latest_sequence;
+        const row = this.store.db.prepare(`
+			SELECT session_sequence AS latest_sequence
+			FROM event_log
+			WHERE session_id = ?
+			ORDER BY session_sequence DESC, stream_id DESC
+			LIMIT 1
+		`).get(piboSessionId);
+        return row?.latest_sequence ?? 0;
     }
     getLatestStreamId(input = {}) {
         const clauses = [];

package/dist/apps/chat/trace.js

@@ -14,6 +14,11 @@ export async function loadPiSessionMetadata(session, cwd = process.cwd()) {
     const piSession = await findPiSession(session, cwd);
     return metadataFromPiSession(piSession);
 }
+export async function loadPiSessionFastMetadata(session, cwd = process.cwd()) {
+    const piSession = findPiSessionDirectFast(session.piSessionId, cwd)
+        ?? findPiSessionDirect(session.piSessionId, cwd, { fast: true });
+    return metadataFromPiSession(piSession);
+}
 function metadataFromPiSession(piSession) {
     if (!piSession)
         return {};
@@ -196,7 +201,10 @@ export function createTraceViewVersion(input) {
         .digest("hex");
 }
 const PI_SESSION_LIST_CACHE_TTL_MS = 5_000;
+const PI_SESSION_DIRECT_CACHE_TTL_MS = 5_000;
+const PI_SESSION_FAST_HEAD_BYTES = 64 * 1024;
 const piSessionListCache = new Map();
+const piSessionDirectCache = new Map();
 export async function listPiSessions(cwd = process.cwd()) {
     const now = Date.now();
     const cached = piSessionListCache.get(cwd);
@@ -234,7 +242,31 @@ async function findPiSession(piboSession, cwd) {
     return (findPiSessionDirect(piboSession.piSessionId, cwd) ??
         (await listPiSessions(cwd)).find((session) => session.id === piboSession.piSessionId));
 }
-function findPiSessionDirect(piSessionId, cwd) {
+function findPiSessionDirectFast(piSessionId, cwd) {
+    const cacheKey = `${cwd}\0${piSessionId}`;
+    const cached = piSessionDirectCache.get(cacheKey);
+    if (!cached || cached.expiresAt <= Date.now())
+        return undefined;
+    try {
+        const stats = statSync(cached.path);
+        if (stats.size === cached.size && stats.mtimeMs === cached.mtimeMs)
+            return cached.item;
+    }
+    catch {
+        piSessionDirectCache.delete(cacheKey);
+    }
+    return undefined;
+}
+function setPiSessionDirectFastCache(piSessionId, cwd, item, stats) {
+    piSessionDirectCache.set(`${cwd}\0${piSessionId}`, {
+        expiresAt: Date.now() + PI_SESSION_DIRECT_CACHE_TTL_MS,
+        path: item.path,
+        size: stats.size,
+        mtimeMs: stats.mtimeMs,
+        item,
+    });
+}
+function findPiSessionDirect(piSessionId, cwd, options = {}) {
     const sessionDir = defaultPiSessionDir(cwd);
     if (!existsSync(sessionDir))
         return undefined;
@@ -244,7 +276,9 @@ function findPiSessionDirect(piSessionId, cwd) {
             return undefined;
         const sessionPath = join(sessionDir, file);
         const stats = statSync(sessionPath);
-        const entries = parseSessionEntries(readFileSync(sessionPath, "utf8"));
+        const entries = options.fast
+            ? readHeadEntries(sessionPath, stats.size, PI_SESSION_FAST_HEAD_BYTES)
+            : parseSessionEntries(readFileSync(sessionPath, "utf8"));
         const header = entries.find((entry) => entry.type === "session");
         if (header?.id !== piSessionId)
             return undefined;
@@ -261,17 +295,22 @@ function findPiSessionDirect(piSessionId, cwd) {
                 continue;
             firstMessage = extractMessageText(messageContent(entry));
         }
-        return {
+        const item = {
             path: sessionPath,
             id: piSessionId,
             cwd: stringValue(header.cwd) ?? cwd,
             name,
             parentSessionPath: stringValue(header.parentSession),
             created: stringValue(header.timestamp) ?? stats.birthtime.toISOString(),
-            modified: sessionModifiedIso(entries.filter((entry) => entry.type !== "session"), stringValue(header.timestamp), stats.mtime),
+            modified: options.fast
+                ? stats.mtime.toISOString()
+                : sessionModifiedIso(entries.filter((entry) => entry.type !== "session"), stringValue(header.timestamp), stats.mtime),
             messageCount,
             firstMessage: firstMessage || "(no messages)",
         };
+        if (options.fast)
+            setPiSessionDirectFastCache(piSessionId, cwd, item, stats);
+        return item;
     }
     catch {
         return undefined;
@@ -307,6 +346,26 @@ function readEntries(path) {
     const content = readFileSync(path, "utf8");
     return parseSessionEntries(content).filter((entry) => entry.type !== "session");
 }
+function readHeadEntries(path, fileSize, maxBytes) {
+    const length = Math.max(1, Math.min(maxBytes, fileSize));
+    const buffer = Buffer.alloc(length);
+    const fd = openSync(path, "r");
+    try {
+        const bytesRead = readSync(fd, buffer, 0, length, 0);
+        let content = buffer.subarray(0, bytesRead).toString("utf8");
+        if (bytesRead < fileSize && !content.endsWith("\n")) {
+            const lastNewline = content.lastIndexOf("\n");
+            if (lastNewline >= 0)
+                content = content.slice(0, lastNewline + 1);
+        }
+        if (!content.trim())
+            return [];
+        return parseSessionEntries(content.endsWith("\n") ? content : `${content}\n`);
+    }
+    finally {
+        closeSync(fd);
+    }
+}
 export function readTailEntries(path, maxBytes = TRACE_TRANSCRIPT_TAIL_MAX_BYTES) {
     if (!existsSync(path))
         return [];

package/dist/apps/chat/web-app.js

@@ -6,7 +6,7 @@ import { OutputCompactor } from "./output-compactor.js";
 import { isLiveOnlyOutputEvent, isPersistableOutputEvent } from "./output-event-policy.js";
 import { chatRoomIdFromMetadata, isDefaultPiboRoom, isPiboRoomArchived, roomWorkspaceFromMetadata, withChatRoomId, withPiboRoomWorkspace, } from "./types/rooms.js";
 import { chatStreamFramesFromOutputEvent, createChatStreamState, nextTransientChatStreamFrameId } from "./stream.js";
-import { buildSessionNodes, buildTraceView, createTraceViewVersion, loadPiSessionMetadata, readTailEntries, readTranscriptHistoryPage } from "./trace.js";
+import { buildSessionNodes, buildTraceView, createTraceViewVersion, loadPiSessionFastMetadata, loadPiSessionMetadata, readTailEntries, readTranscriptHistoryPage } from "./trace.js";
 import { DEFAULT_TRACE_EVENTS_PAGE_SIZE, annotateTracePage, etagForVersion, estimateTraceViewBytes, traceCacheEstimatedBytes, liveSnapshotVersion, requestMatchesVersion, setTraceCache, traceCacheKey, withLiveSnapshots, withRawTraceTail, } from "./chat-trace-helpers.js";
 import { TRACE_V2_DEFAULT_TIMELINE_LIMIT, TRACE_V2_MAX_TIMELINE_LIMIT, TRACE_V2_PAYLOAD_DEFAULT_LIMIT_BYTES, TRACE_V2_PAYLOAD_MAX_LIMIT_BYTES, TRACE_V2_RAW_EVENTS_DEFAULT_LIMIT, TRACE_V2_RAW_EVENTS_MAX_LIMIT, TRACE_V2_TIMELINE_HARD_BYTES, parseTracePayloadRef, readTracePayloadChunk, traceRawEventsPageFromEvents, traceTimelinePageFromView, } from "./trace-v2.js";
 import { isChatWebSessionArchived } from "./session-metadata.js";
@@ -43,7 +43,7 @@ import { prepareChatFileAttachments, resolveDownloadPath, responseChatFileDownlo
 import { chatSettingsRoute, chatSettingsRouteInvalidatesBootstrapCatalog, chatSettingsRouteRequiresSameOrigin, handleChatSettingsRoute, } from "./chat-settings-routes.js";
 import { chatCapabilityRoute, chatCapabilityRouteRequiresSameOrigin, handleChatCapabilityRoute, } from "./chat-capability-routes.js";
 import { chatUserSkillRoute, chatUserSkillRouteRequiresSameOrigin, handleChatUserSkillRoute, syncChatUserSkills, } from "./chat-user-skill-routes.js";
-import { CHAT_WEB_API_PREFIX, agentResourceId, projectResourcePath, projectSessionResourceId, projectWorkflowHumanActionsResource, projectWorkflowSessionStartResource, roomResourcePath, sessionActionResource, sessionResourceId, signalResource, workflowArchiveResourceId, workflowCatalogResourceId, workflowDraftActionResource, workflowDraftResourceId, workflowDuplicateResourceId, workflowNextDraftResourceId, workflowPickerKind, workflowPromptAssetResourceId, workflowVersionResource, } from "./chat-api-routes.js";
+import { CHAT_WEB_API_PREFIX, agentResourceId, projectResourcePath, projectSessionResourceId, projectWorkflowHumanActionsResource, projectWorkflowSessionStartResource, roomResourcePath, sessionActionResource, sessionResourceId, signalResource, workflowArchiveResourceId, workflowCatalogResourceId, workflowDraftActionResource, workflowDraftManualTriggerRunResource, workflowDraftResourceId, workflowDuplicateResourceId, workflowNextDraftResourceId, workflowPickerKind, workflowPromptAssetResourceId, workflowVersionResource, } from "./chat-api-routes.js";
 import { assertProjectSessionPatchFields, buildStreamingFixtureSchedule, createAgentInput, createAgentUpdate, createRoomUpdate, createSessionUpdate, normalizeAgentArchived, normalizeClientTxnId, normalizeMessageText, normalizeParentRoomId, normalizeProjectArchived, normalizeProjectDescription, normalizeProjectPath, normalizeProjectSessionArchived, normalizeRoomDeleteConfirmation, normalizeRoomName, normalizeRoomTopic, normalizeRoomType, normalizeRoomWorkspace, normalizeSessionDeleteConfirmation, normalizeSessionTitle, normalizeStreamingFixtureCadenceMs, normalizeStreamingFixtureDeltas, normalizeStreamingFixtureMix, normalizeStreamingFixturePreludeMessages, normalizeStreamingFixturePreludeOnly, normalizeStreamingFixtureProfile, normalizeStreamingFixtureSuppressLiveDeltas, normalizeStreamingFixtureTraceSnapshots, resolveCreateSessionProfile, } from "./chat-request-normalizers.js";
 import { ChatWorkflowArchiveStore, ChatWorkflowDraftStore, ChatWorkflowLifecycleEventStore, ChatWorkflowPromptAssetStore, ChatWorkflowPublishedVersionStore, ChatWorkflowTombstoneStore, hashWorkflowDefinitionJson, normalizeWorkflowPromptAssetLabel, sanitizeWorkflowDiagnostics, } from "./workflow-persistence.js";
 import { normalizeProjectWorkflowHumanActionBody, projectWorkflowHumanActionDiagnosticResponse, projectWorkflowHumanActionLifecyclePayload, projectWorkflowHumanActionRuntimeDiagnostic, projectWorkflowHumanActionSubmittedLifecyclePayload, projectWorkflowPendingHumanActionFromToken, validateProjectWorkflowHumanActionRequest, } from "./project-workflow-human-actions.js";
@@ -51,6 +51,7 @@ import { createProjectWorkflowRunCurrent, createProjectWorkflowSessionSnapshot,
 import { STATIC_WORKFLOW_VERSION_CATALOG, buildProjectWorkflowVersionCatalog, buildProjectWorkflowVersionOptions, buildWorkflowCatalogInspect as buildWorkflowCatalogInspectWithServices, buildWorkflowCatalogList as buildWorkflowCatalogListWithServices, buildWorkflowVersionHistory, buildWorkflowVersionInspect as buildWorkflowVersionInspectWithServices, buildWorkflowVersionList as buildWorkflowVersionListWithServices, buildWorkflowVersionPicker, createPublishedWorkflowDefinition, selectWorkflowCatalogDisplayVersion, workflowDefinitionTags, workflowVersionPickerOptionFromCatalogRecord, } from "./workflow-catalog.js";
 import { cloneJsonObject, isWorkflowValidationPipelineDiagnostic, normalizeWorkflowValidationTrigger, normalizeWorkflowVersionIntent, parseWorkflowDraftDefinitionFromPatch, summarizeWorkflowDiagnostics, withoutRawWorkflowIrParseDiagnostic, } from "./workflow-validation-helpers.js";
 import { validateWorkflowEdgeAdapterOutputCompatibilityLike, validateWorkflowEdgeDirectCompatibilityLike, } from "./workflow-edge-compatibility.js";
+import { runWorkflowManualTextTrigger, } from "./workflow-manual-trigger-runtime.js";
 import { validateJsonSchemaObjectLike } from "./workflow-json-schema-validation.js";
 import { WORKFLOW_ADAPTER_REF_OPTIONS, WORKFLOW_GUARD_REF_OPTIONS, WORKFLOW_HUMAN_ACTION_REF_OPTIONS, buildWorkflowPromptAssetPicker, buildWorkflowRegisteredRefPicker, getWorkflowPromptAssetDocument, isWorkflowPromptAssetRegistered, } from "./workflow-registered-ref-pickers.js";
 import { validateRegisteredAdapterRefLike, validateWorkflowGuardRefLike, validateWorkflowHumanActionRefsLike, validateWorkflowPromptAssetRefLike, } from "./workflow-registered-ref-validation.js";
@@ -1536,6 +1537,31 @@ function runWorkflowDraftValidation(state, context, webSession, record, trigger)
     });
     return { validation, diagnostics };
 }
+function normalizeWorkflowDraftManualTriggerRunBody(body) {
+    const triggerNodeId = typeof body.triggerNodeId === "string" ? body.triggerNodeId.trim() : "";
+    if (!triggerNodeId)
+        throw new PiboWebHttpError("Manual trigger node id is required", 400);
+    if (typeof body.input !== "string")
+        throw new PiboWebHttpError("Manual trigger input must be text", 400);
+    return { triggerNodeId, input: body.input };
+}
+function resolveWorkflowRuntimeProfile(input) {
+    const profile = input.context.channelContext.getProfiles?.().find((candidate) => candidate.name === input.requestedId || candidate.aliases.includes(input.requestedId));
+    return profile?.name;
+}
+function workflowManualTriggerRunResponse(result, validation, draft) {
+    return {
+        ok: result.ok,
+        draft: serializeWorkflowDraft(draft),
+        validation: validation.validation,
+        diagnostics: sanitizeWorkflowDiagnostics([...validation.diagnostics, ...result.diagnostics]),
+        ...(result.run ? { run: result.run } : {}),
+        nodeAttempts: result.nodeAttempts,
+        edgeTransfers: result.edgeTransfers,
+        ...(result.output !== undefined ? { output: result.output } : {}),
+        ...(result.error ? { error: result.error } : {}),
+    };
+}
 function validatePublishedWorkflowBoundary(input) {
     const diagnostics = sanitizeWorkflowDiagnostics(validateWorkflowDefinitionForV2(input.definition, input));
     return {
@@ -1656,15 +1682,62 @@ function validateWorkflowNodeLike(nodeId, value, input, diagnostics) {
         validateWorkflowHumanNodeLike(nodeId, value, diagnostics);
         return;
     }
+    if (kind === "trigger") {
+        validateWorkflowTriggerNodeLike(nodeId, value, diagnostics);
+        return;
+    }
     diagnostics.push({
         code: "WorkflowValidationError.unknownNodeKind",
-        message: `Workflow node '${nodeId}' must use kind agent, code, workflow, adapter, or human.`,
+        message: `Workflow node '${nodeId}' must use kind trigger, agent, code, workflow, adapter, or human.`,
         severity: "error",
         path: `${path}.kind`,
         nodeId,
         hint: "Use one of the registered V2 editable node kinds.",
     });
 }
+function validateWorkflowTriggerNodeLike(nodeId, node, diagnostics) {
+    const path = `$.nodes.${nodeId}`;
+    const trigger = isJsonObject(node.trigger) ? node.trigger : undefined;
+    if (!trigger) {
+        diagnostics.push({
+            code: "WorkflowValidationError.missingTriggerConfig",
+            message: `Trigger node '${nodeId}' must include a trigger configuration object.`,
+            severity: "error",
+            path: `${path}.trigger`,
+            nodeId,
+        });
+        return;
+    }
+    if (trigger.kind !== "manual") {
+        diagnostics.push({
+            code: "WorkflowValidationError.unsupportedTriggerKind",
+            message: `Trigger node '${nodeId}' must use manual trigger kind in this Workflow V1 slice.`,
+            severity: "error",
+            path: `${path}.trigger.kind`,
+            nodeId,
+            hint: "Webhook, cron, and other trigger providers are planned but not implemented yet.",
+        });
+    }
+    if (trigger.mode !== undefined && trigger.mode !== "editor" && trigger.mode !== "api") {
+        diagnostics.push({
+            code: "WorkflowValidationError.unsupportedTriggerMode",
+            message: `Trigger node '${nodeId}' has unsupported manual trigger mode.`,
+            severity: "error",
+            path: `${path}.trigger.mode`,
+            nodeId,
+        });
+    }
+    if (!node.output) {
+        diagnostics.push({
+            code: "WorkflowValidationError.missingTriggerOutput",
+            message: `Trigger node '${nodeId}' must declare an output port.`,
+            severity: "error",
+            path: `${path}.output`,
+            nodeId,
+            hint: "Use a text output port for the first manual trigger implementation.",
+        });
+    }
+}
 function validateWorkflowAgentNodeLike(nodeId, node, input, diagnostics) {
     const path = `$.nodes.${nodeId}`;
     if (node.runtime !== "pibo") {
@@ -3522,6 +3595,56 @@ export function createChatWebApp(options = {}) {
                 const body = await readJsonBody(request);
                 return responseJson({ asset: saveWorkflowPromptAssetRevision(state, webSession, body) }, { status: 201 });
             }
+            const workflowDraftManualTriggerRun = workflowDraftManualTriggerRunResource(url.pathname);
+            if (workflowDraftManualTriggerRun && request.method === "POST") {
+                requireSameOriginJsonRequest(request);
+                const webSession = await requireSession(request, context);
+                const body = normalizeWorkflowDraftManualTriggerRunBody(await readJsonBody(request));
+                const record = requireMutableWorkflowDraft(state, webSession, workflowDraftManualTriggerRun.draftId);
+                const validation = runWorkflowDraftValidation(state, context, webSession, record, "before_workflow_start");
+                if (!validation.validation.ok) {
+                    recordWorkflowLifecycleEvent(state, webSession, {
+                        type: "workflow.editor_test_run.blocked",
+                        workflowId: record.workflowId,
+                        workflowVersion: typeof record.definition.version === "string" ? record.definition.version : undefined,
+                        draftId: record.draftId,
+                        status: "blocked",
+                        validation: validation.validation,
+                        diagnostics: validation.diagnostics,
+                        payload: { triggerNodeId: body.triggerNodeId },
+                    });
+                    return workflowValidationBlockedResponse("Workflow draft has validation errors and cannot be test-run", validation, { draft: serializeWorkflowDraft(record) });
+                }
+                const result = await runWorkflowManualTextTrigger({
+                    definition: record.definition,
+                    triggerNodeId: body.triggerNodeId,
+                    input: body.input,
+                    actorId: auditActorIdFor(webSession),
+                    draftId: record.draftId,
+                    channelContext: context.channelContext,
+                    channel: CHAT_WEB_CHANNEL,
+                    defaultWorkspace: getDefaultPiboWorkspace(),
+                    onSessionCreated: (session) => state.sessionQuery.upsertSession(session),
+                    resolveProfile: (profileId) => resolveWorkflowRuntimeProfile({ context, requestedId: profileId }),
+                });
+                const diagnostics = result.ok ? validation.diagnostics : sanitizeWorkflowDiagnostics([...validation.diagnostics, ...result.diagnostics]);
+                recordWorkflowLifecycleEvent(state, webSession, {
+                    type: result.ok ? "workflow.editor_test_run.completed" : "workflow.editor_test_run.failed",
+                    workflowId: record.workflowId,
+                    workflowVersion: typeof record.definition.version === "string" ? record.definition.version : undefined,
+                    draftId: record.draftId,
+                    workflowRunId: result.run?.id,
+                    status: result.ok ? "accepted" : "blocked",
+                    validation: validation.validation,
+                    diagnostics,
+                    payload: {
+                        triggerNodeId: body.triggerNodeId,
+                        ...(result.run?.status ? { status: result.run.status } : {}),
+                        ...(result.ok && result.output !== undefined ? { output: result.output } : {}),
+                    },
+                });
+                return responseJson(workflowManualTriggerRunResponse(result, { validation: validation.validation, diagnostics }, record), { status: result.ok ? 202 : 400 });
+            }
             const workflowDraftAction = workflowDraftActionResource(url.pathname);
             if (workflowDraftAction && request.method === "POST") {
                 requireSameOriginJsonRequest(request);
@@ -4024,7 +4147,7 @@ export function createChatWebApp(options = {}) {
                 state.sessionQuery.upsertSession(selectedSession);
                 const indexedSession = state.sessionQuery.getSession(selectedSession.id);
                 const metadataStartedAt = performance.now();
-                const metadata = await loadPiSessionMetadata(selectedSession, selectedSession.workspace ?? process.cwd());
+                const metadata = await loadPiSessionFastMetadata(selectedSession, selectedSession.workspace ?? process.cwd());
                 const metadataMs = performance.now() - metadataStartedAt;
                 const lastEventSequence = state.timelineQuery.getLatestEventSequence(selectedSession.id);
                 const latestStreamId = state.timelineQuery.getLatestStreamId({ piboSessionId: selectedSession.id });
@@ -4075,9 +4198,11 @@ export function createChatWebApp(options = {}) {
                 const lastEventSequence = state.timelineQuery.getLatestEventSequence(selectedSession.id);
                 const latestStreamId = state.timelineQuery.getLatestStreamId({ piboSessionId: selectedSession.id });
                 const liveSnapshots = timelineCursor.kind === "tail" ? state.outputCompactor.snapshotsForSession(selectedSession.id) : [];
+                const metadataStartedAt = performance.now();
                 const transcriptMetadata = timelineCursor.kind === "tail" || timelineCursor.kind === "transcript"
-                    ? await loadPiSessionMetadata(selectedSession, selectedSession.workspace ?? process.cwd())
+                    ? await loadPiSessionFastMetadata(selectedSession, selectedSession.workspace ?? process.cwd())
                     : undefined;
+                metadataMs += performance.now() - metadataStartedAt;
                 const baseVersion = createFastTraceV2Version({
                     session: selectedSession,
                     sessions: ownedSessions,