@osolmaz/pi-workflows 0.15.2 → 0.16.0

package/dist/extension/index.js

@@ -1,25 +1,29 @@
 import { randomUUID } from "node:crypto";
 import path from "node:path";
 import { BUILTIN_WORKFLOW_METADATA } from "../builtins/metadata.js";
-import { SqliteControllerStore } from "../controllers/sqlite.js";
-import { WorkflowHostClient } from "../host/client.js";
-import { HostStateStore } from "../host/state.js";
-import { workflowStatePath } from "../state/database.js";
+import { ORIGIN_ACTIVITY_REFRESH_MS } from "../client/activity.js";
+import { WorkflowClient } from "../client/client.js";
+import { materializeSessionView } from "../client/materialize.js";
 import { canonicalJson, parseJson } from "../state/json.js";
 import { errorMessage } from "../workflows/errors.js";
 import { discoverWorkflows } from "../workflows/loader.js";
-import { createRunId, WorkflowRunStore } from "../workflows/store.js";
+import { createRunId } from "../workflows/store.js";
 import { parseControllerArgs } from "./controller-command.js";
+import { HerdrWorkflowViewer, PIW_SHORTCUT, PIW_SHORTCUT_HINT, VIEWER_PLACEMENTS, } from "./herdr-viewer.js";
 import { SessionDeliveryCoordinator } from "./session-delivery.js";
+import { SessionWorkflowView } from "./session-view.js";
 import { recoverAssistantStep, registerWorkflowAgentStepMessageRenderer, WORKFLOW_AGENT_STEP_MESSAGE_SCHEMA, WORKFLOW_AGENT_STEP_MESSAGE_TYPE, } from "./step-message.js";
 import { parseWorkflowToolInput, WorkflowToolParameters } from "./workflow-tool.js";
 export { parseControllerArgs } from "./controller-command.js";
 export { PiDecisionChannel, TelegramDecisionChannel, audienceChannels, createTelegramChannels, decisionConfigDir, loadDecisionChannelConfig, verifyTelegramTokenFile, writeDecisionChannelProfile, } from "./decision-channels.js";
 const INTERACTION_POLL_MS = 1_000;
-const SUBMISSION_POLL_MS = 50;
 const WORKFLOW_INTERACTION_MESSAGE_TYPE = "pi-workflows-interaction";
 const WORKFLOW_NOTIFICATION_MESSAGE_TYPE = "pi-workflows-notification";
 const WORKFLOW_PRESENTATION_MESSAGE_TYPE = "pi-workflows-presentation";
+const sessionSnapshots = new Map();
+export function activityStateForConnection(state, previousConnectionId, connectionId) {
+    return state === "refresh" && previousConnectionId !== connectionId ? "started" : state;
+}
 /** Parse `/workflow` arguments. Exported for tests. */
 export function parseWorkflowArgs(args) {
     const trimmed = args.trim();
@@ -89,12 +93,58 @@ export function parseWorkflowArgs(args) {
 }
 export default function piWorkflows(pi) {
     registerWorkflowAgentStepMessageRenderer(pi);
-    const client = new WorkflowHostClient({ clientId: `pi-extension-${randomUUID()}` });
+    let client = new WorkflowClient({ clientId: `pi-extension-${randomUUID()}` });
+    const herdrViewer = new HerdrWorkflowViewer(pi.exec);
     let sessionContext = null;
+    let sessionGeneration = 0;
+    let sessionUnsubscribe = null;
     let pollTimer = null;
     let presentationTail = Promise.resolve();
     let toolTail = Promise.resolve();
+    let originActivity = null;
+    let originActivityConnectionId = null;
+    let activityTimer = null;
     const sessionDelivery = new SessionDeliveryCoordinator();
+    const sessionView = new SessionWorkflowView();
+    const reportOriginActivity = async (activity, state) => {
+        const connection = await client.connect();
+        const reportState = activityStateForConnection(state, originActivityConnectionId, connection.connectionId);
+        const response = await client.request({
+            operation: "activity.report",
+            runId: activity.runId,
+            payload: { ...activity, state: reportState },
+        });
+        if (response.outcome !== "accepted" && response.outcome !== "adopted") {
+            throw new Error(response.error ?? "Workflow host rejected origin activity");
+        }
+        originActivityConnectionId =
+            reportState === "settled" ? null : (client.connectionId ?? connection.connectionId);
+    };
+    const startOriginActivity = (presented) => {
+        if (activityTimer !== null)
+            clearInterval(activityTimer);
+        originActivityConnectionId = null;
+        originActivity = { ...presented, sequence: 0 };
+        void reportOriginActivity(originActivity, "started").catch(() => undefined);
+        activityTimer = setInterval(() => {
+            if (originActivity === null)
+                return;
+            originActivity.sequence += 1;
+            void reportOriginActivity(originActivity, "refresh").catch(() => undefined);
+        }, ORIGIN_ACTIVITY_REFRESH_MS);
+        activityTimer.unref?.();
+    };
+    const settleOriginActivity = async () => {
+        if (activityTimer !== null)
+            clearInterval(activityTimer);
+        activityTimer = null;
+        const settled = originActivity;
+        originActivity = null;
+        if (settled === null)
+            return;
+        settled.sequence += 1;
+        await reportOriginActivity(settled, "settled").catch(() => undefined);
+    };
     const presentInOrder = async (ctx) => {
         const prior = presentationTail;
         let release;
@@ -103,16 +153,39 @@ export default function piWorkflows(pi) {
         });
         await prior;
         try {
+            const deliveries = sessionSnapshots.get(ctx.sessionManager.getSessionId())?.deliveries;
             await sessionDelivery.synchronize(ctx, [
-                () => claimPendingInteractionDelivery(pi, client, ctx),
-                () => claimPendingNotificationDelivery(pi, client, ctx),
-                () => claimPendingTurnDelivery(pi, client, ctx),
+                () => claimPendingInteractionDelivery(pi, client, ctx, startOriginActivity),
+                ...(deliveries?.notification === true
+                    ? [() => claimPendingNotificationDelivery(pi, client, ctx)]
+                    : []),
+                ...(deliveries?.turn === true ? [() => claimPendingTurnDelivery(pi, client, ctx)] : []),
             ]);
         }
         finally {
+            sessionView.refresh(ctx);
             release?.();
         }
     };
+    const openPiw = async (ctx, requestedPlacement) => {
+        const run = sessionSnapshots.get(ctx.sessionManager.getSessionId())?.run;
+        if (run === null || run === undefined || !isRecord(run.state)) {
+            ctx.ui.notify("No active workflow is available for piw.", "warning");
+            return;
+        }
+        const capability = await herdrViewer.probe();
+        if (!capability.available) {
+            ctx.ui.notify(capability.reason, "warning");
+            return;
+        }
+        const placement = requestedPlacement ??
+            (await ctx.ui.select("Open workflow viewer", [...VIEWER_PLACEMENTS]));
+        if (placement === undefined)
+            return;
+        const workflowName = typeof run.state.workflowName === "string" ? run.state.workflowName : run.runId;
+        const opened = await herdrViewer.open({ runId: run.runId, workflowName }, placement, ctx.cwd);
+        ctx.ui.notify(opened.reused ? "Focused the existing piw view." : "Opened piw in Herdr.", "info");
+    };
     const runToolInOrder = async (operation) => {
         const prior = toolTail;
         let release;
@@ -120,8 +193,12 @@ export default function piWorkflows(pi) {
             release = resolve;
         });
         await prior;
-        await presentationTail;
         try {
+            await presentationTail;
+            const currentContext = sessionContext;
+            if (currentContext === null)
+                throw new Error("Workflow session is unavailable");
+            await presentInOrder(currentContext);
             return await operation();
         }
         finally {
@@ -197,7 +274,7 @@ export default function piWorkflows(pi) {
                     }
                     const response = await requestAccepted(client, {
                         operation: params.action === "update" ? "interaction.update" : "interaction.submit",
-                        requestId: `${params.action}-${toolCallId}`,
+                        requestId: `${params.action}-${toolCallId}-${randomUUID()}`,
                         idempotencyKey: toolCallId,
                         runId: interaction.runId,
                         expectedRevision: interaction.revision,
@@ -208,10 +285,8 @@ export default function piWorkflows(pi) {
                             attempt: params.attempt,
                             value: params.action === "update" ? { update: params.update } : { output: params.output },
                         }),
+                        ...(signal === undefined ? {} : { signal }),
                     });
-                    if (params.action === "submit") {
-                        await waitForInteractionSubmission(interaction.requestId, toolCallId, signal);
-                    }
                     await presentInOrder(ctx);
                     return toolResult(params.action === "update"
                         ? "Workflow update accepted; the step remains active."
@@ -224,20 +299,127 @@ export default function piWorkflows(pi) {
             });
         },
     });
-    pi.on("session_start", async (_event, ctx) => {
+    pi.registerCommand("piw", {
+        description: "Open the active workflow in Herdr",
+        handler: async (args, ctx) => {
+            try {
+                const requested = args.trim();
+                if (requested.length > 0 && !VIEWER_PLACEMENTS.includes(requested)) {
+                    throw new Error(`Unknown piw placement: ${requested}`);
+                }
+                await openPiw(ctx, requested.length === 0 ? undefined : requested);
+            }
+            catch (error) {
+                ctx.ui.notify(`Could not open piw: ${errorMessage(error)}`, "warning");
+            }
+        },
+    });
+    pi.registerShortcut(PIW_SHORTCUT, {
+        description: "Open the active workflow in Herdr",
+        handler: async (ctx) => {
+            try {
+                await openPiw(ctx);
+            }
+            catch (error) {
+                ctx.ui.notify(`Could not open piw: ${errorMessage(error)}`, "warning");
+            }
+        },
+    });
+    pi.registerShortcut("shift+up", {
+        description: "Scroll the workflow widget up",
+        handler: (ctx) => sessionView.scrollUp(ctx),
+    });
+    pi.registerShortcut("shift+down", {
+        description: "Scroll the workflow widget down",
+        handler: (ctx) => sessionView.scrollDown(ctx),
+    });
+    pi.on("session_start", (_event, ctx) => {
         sessionContext = ctx;
-        try {
-            await client.ensureRunning();
-            await presentInOrder(ctx);
-        }
-        catch (error) {
-            ctx.ui.notify(`Workflow host is unavailable: ${errorMessage(error)}`, "warning");
-        }
+        const sessionId = ctx.sessionManager.getSessionId();
+        const generation = ++sessionGeneration;
+        let snapshotGeneration = 0;
+        const sessionClient = client;
         pollTimer = setInterval(() => {
             if (sessionContext !== null)
                 void presentInOrder(sessionContext).catch(() => undefined);
         }, INTERACTION_POLL_MS);
         pollTimer.unref?.();
+        void (async () => {
+            try {
+                await sessionClient.ensureAvailable();
+                const unsubscribe = await sessionClient.watchSession(sessionId, (event) => {
+                    if (generation !== sessionGeneration || sessionContext !== ctx)
+                        return;
+                    const currentSnapshotGeneration = ++snapshotGeneration;
+                    if (event.event === "unavailable") {
+                        sessionSnapshots.delete(sessionId);
+                        sessionView.clear(ctx);
+                        return;
+                    }
+                    if (!isWorkflowSessionView(event.payload))
+                        return;
+                    void materializeSessionView(sessionClient, event.payload)
+                        .then((session) => {
+                        if (generation !== sessionGeneration ||
+                            currentSnapshotGeneration !== snapshotGeneration ||
+                            sessionContext !== ctx) {
+                            return;
+                        }
+                        sessionSnapshots.set(sessionId, session);
+                        sessionView.update(session, ctx);
+                        void presentInOrder(ctx).catch(() => undefined);
+                    })
+                        .catch(() => {
+                        // A newer session revision retries from its own stable snapshot.
+                    });
+                });
+                if (generation !== sessionGeneration || sessionContext !== ctx) {
+                    await unsubscribe();
+                    return;
+                }
+                sessionUnsubscribe = unsubscribe;
+                const capability = await herdrViewer.probe();
+                if (generation !== sessionGeneration || sessionContext !== ctx)
+                    return;
+                sessionView.setActionHint(capability.available ? PIW_SHORTCUT_HINT : undefined, ctx);
+                await presentInOrder(ctx);
+            }
+            catch (error) {
+                if (generation === sessionGeneration && sessionContext === ctx) {
+                    ctx.ui.notify(`Workflow host is unavailable: ${errorMessage(error)}`, "warning");
+                }
+            }
+        })();
+    });
+    pi.on("agent_end", async (event, ctx) => {
+        const interrupted = ctx.signal?.aborted === true ||
+            event.messages.some((message) => isRecord(message) && "stopReason" in message && message.stopReason === "aborted");
+        if (!interrupted)
+            return;
+        const interaction = pendingInteractionForSession(ctx.sessionManager.getSessionId());
+        if (interaction === undefined ||
+            interaction.kind === "decision" ||
+            workflowRunPaused(interaction.runId)) {
+            return;
+        }
+        const turnHasPrompt = event.messages.some((message) => interactionRequestId(message) === interaction.requestId);
+        if (!turnHasPrompt)
+            return;
+        await settleOriginActivity();
+        try {
+            const pauseId = `escape-pause-${interaction.runId}-${randomUUID()}`;
+            await requestAccepted(client, {
+                operation: "run.pause",
+                requestId: pauseId,
+                idempotencyKey: pauseId,
+                runId: interaction.runId,
+            });
+            sessionView.refresh(ctx);
+            ctx.ui.notify(`Workflow ${interaction.runId} paused because its model turn was interrupted. Use /workflow resume to continue.`, "info");
+        }
+        catch (error) {
+            ctx.ui.notify(`Could not pause interrupted workflow: ${errorMessage(error)}`, "warning");
+        }
     });
     pi.on("agent_settled", async (_event, ctx) => {
         try {
@@ -246,14 +428,27 @@ export default function piWorkflows(pi) {
         catch (error) {
             ctx.ui.notify(`Workflow response was rejected: ${errorMessage(error)}`, "error");
         }
+        await settleOriginActivity();
         await presentInOrder(ctx).catch(() => undefined);
     });
-    pi.on("session_shutdown", async () => {
+    pi.on("session_shutdown", async (_event, ctx) => {
+        sessionGeneration += 1;
         sessionContext = null;
         sessionDelivery.clear();
+        sessionView.clear(ctx);
+        sessionSnapshots.delete(ctx.sessionManager.getSessionId());
+        if (activityTimer !== null)
+            clearInterval(activityTimer);
+        activityTimer = null;
+        originActivity = null;
         if (pollTimer !== null)
             clearInterval(pollTimer);
         pollTimer = null;
+        if (sessionUnsubscribe !== null)
+            await sessionUnsubscribe().catch(() => undefined);
+        sessionUnsubscribe = null;
+        await client.close();
+        client = new WorkflowClient({ clientId: `pi-extension-${randomUUID()}` });
     });
 }
 async function executeCommand(client, ctx, command, idempotencyKey = randomUUID(), authority = "human") {
@@ -269,7 +464,7 @@ async function executeCommand(client, ctx, command, idempotencyKey = randomUUID(
             };
         }
         case "run": {
-            await client.ensureRunning();
+            await client.ensureAvailable();
             const resolved = await client.resolveWorkflow({ cwd: ctx.cwd, workflowRef: command.ref });
             const runId = createRunId(resolved.workflowName);
             const response = await requestAccepted(client, {
@@ -456,15 +651,28 @@ async function executeControllerCommand(client, ctx, command) {
         details: { action: command.kind, resource: response.receipt ?? null },
     };
 }
-async function claimPendingInteractionDelivery(pi, client, ctx) {
-    const interaction = pendingInteractionForSession(ctx.sessionManager.getSessionId());
-    if (interaction === undefined || interaction.presentationSessionEntryId !== null)
+async function claimPendingInteractionDelivery(pi, client, ctx, onPresented) {
+    const storedInteraction = pendingInteractionForSession(ctx.sessionManager.getSessionId());
+    if (storedInteraction === undefined || storedInteraction.presentationSessionEntryId !== null)
         return undefined;
+    const interaction = {
+        ...storedInteraction,
+        contract: await client.hydrateContent(storedInteraction.runId, storedInteraction.contract),
+    };
+    rememberInteractiveRequest(ctx.sessionManager.getSessionId(), interaction);
     const findSessionEntryId = (entries) => entryIdentifier(entries.find((entry) => interactionRequestId(entry) === interaction.requestId));
     const existingEntryId = findSessionEntryId(ctx.sessionManager.getBranch());
     let presentationRevision = interaction.revision;
+    let claimExpiresAt = Number.POSITIVE_INFINITY;
     if (existingEntryId === undefined) {
-        const claim = await requestAccepted(client, {
+        if (workflowRunPaused(interaction.runId))
+            return undefined;
+        if (interaction.presentationClaimExpiresAt !== null &&
+            Date.parse(interaction.presentationClaimExpiresAt) > Date.now()) {
+            return undefined;
+        }
+        await client.ensureAvailable();
+        const claim = await client.request({
             operation: "interaction.update",
             requestId: `claim-presentation-${interaction.requestId}-${interaction.revision}-${client.clientId}`,
             idempotencyKey: `claim-presentation-${interaction.requestId}-${interaction.revision}-${client.clientId}`,
@@ -472,13 +680,30 @@ async function claimPendingInteractionDelivery(pi, client, ctx) {
             expectedRevision: interaction.revision,
             payload: { requestId: interaction.requestId, claimPresentation: true },
         });
+        if (claim.outcome === "conflict")
+            return undefined;
+        if (claim.outcome !== "accepted" && claim.outcome !== "adopted") {
+            throw new Error(claim.error ?? "Workflow host rejected interaction.update");
+        }
         if (claim.revision === undefined)
             throw new Error("Presentation claim has no revision");
+        const receipt = isRecord(claim.receipt) ? claim.receipt : undefined;
         presentationRevision = claim.revision;
+        claimExpiresAt = claimExpiry(receipt?.presentationClaimExpiresAt, "presentation claim");
+        rememberInteractiveRequest(ctx.sessionManager.getSessionId(), claim.receipt);
     }
     const contract = interactionContract(interaction);
     return {
         deliveryId: `interaction:${interaction.requestId}`,
+        claimExpiresAt,
+        isStillDeliverable: () => existingEntryId === undefined &&
+            interactionPresentationClaimIsLive(client, {
+                requestId: interaction.requestId,
+                runId: interaction.runId,
+                presenterId: client.clientId,
+                revision: presentationRevision,
+                claimExpiresAt,
+            }),
         findSessionEntryId,
         send: () => {
             if (interaction.kind === "decision") {
@@ -514,7 +739,7 @@ async function claimPendingInteractionDelivery(pi, client, ctx) {
             }, { triggerTurn: true });
         },
         settle: async (sessionEntryId) => {
-            await requestAccepted(client, {
+            const response = await requestAccepted(client, {
                 operation: "interaction.update",
                 requestId: `present-${interaction.requestId}-${sessionEntryId}`,
                 idempotencyKey: `present-${interaction.requestId}-${sessionEntryId}`,
@@ -522,13 +747,21 @@ async function claimPendingInteractionDelivery(pi, client, ctx) {
                 expectedRevision: presentationRevision,
                 payload: { requestId: interaction.requestId, sessionEntryId },
             });
+            rememberInteractiveRequest(ctx.sessionManager.getSessionId(), response.receipt);
+            if (interaction.kind !== "decision") {
+                onPresented({
+                    sessionId: ctx.sessionManager.getSessionId(),
+                    runId: interaction.runId,
+                    requestId: interaction.requestId,
+                    deliveryId: `interaction:${interaction.requestId}`,
+                    sessionEntryId,
+                });
+            }
         },
     };
 }
 async function claimPendingNotificationDelivery(pi, client, ctx) {
     const sessionId = ctx.sessionManager.getSessionId();
-    if (!hasClaimableNotification(sessionId))
-        return undefined;
     const claimRequestId = randomUUID();
     const claimed = await requestAccepted(client, {
         operation: "notification.claim",
@@ -541,9 +774,17 @@ async function claimPendingNotificationDelivery(pi, client, ctx) {
     if (notification === undefined)
         return undefined;
     const claimId = requireText(receipt?.claimId, "notification claimId");
+    const claimExpiresAt = claimExpiry(receipt?.claimExpiresAt, "notification claim");
     const notificationId = requireText(notification.notificationId, "notificationId");
     return {
         deliveryId: `notification:${notificationId}`,
+        claimExpiresAt,
+        isStillDeliverable: () => hostDeliveryClaimIsLive(client, {
+            kind: "notification",
+            resourceId: notificationId,
+            targetSessionId: sessionId,
+            claimId,
+        }),
         findSessionEntryId: (entries) => entryIdentifier(entries.find((entry) => customMessageDetail(entry, WORKFLOW_NOTIFICATION_MESSAGE_TYPE, "notificationId") ===
             notificationId)),
         send: () => {
@@ -574,9 +815,8 @@ async function claimPendingNotificationDelivery(pi, client, ctx) {
 }
 async function claimPendingTurnDelivery(pi, client, ctx) {
     const sessionId = ctx.sessionManager.getSessionId();
-    if (pendingInteractionForSession(sessionId) !== undefined || !hasClaimableTurn(sessionId)) {
+    if (pendingInteractionForSession(sessionId) !== undefined)
         return undefined;
-    }
     const claimRequestId = randomUUID();
     const claimed = await requestAccepted(client, {
         operation: "turn.claim",
@@ -589,13 +829,24 @@ async function claimPendingTurnDelivery(pi, client, ctx) {
     if (turn === undefined)
         return undefined;
     const claimId = requireText(receipt?.claimId, "turn claimId");
+    const claimExpiresAt = claimExpiry(receipt?.claimExpiresAt, "turn claim");
     const intentId = requireText(turn.intentId, "turn intentId");
     const runId = requireText(turn.runId, "turn runId");
-    const state = terminalRunState(runId);
-    if (state === undefined)
-        return undefined;
+    const claimedRun = await client.getRun(runId);
+    if (claimedRun === null)
+        throw new Error(`Claimed workflow turn run is missing: ${runId}`);
+    const state = await client.hydrateContent(runId, claimedRun.state);
+    if (!isRecord(state))
+        throw new Error("Workflow terminal state content is invalid");
     return {
         deliveryId: `turn:${intentId}`,
+        claimExpiresAt,
+        isStillDeliverable: () => hostDeliveryClaimIsLive(client, {
+            kind: "turn",
+            resourceId: intentId,
+            targetSessionId: sessionId,
+            claimId,
+        }),
         findSessionEntryId: (entries) => entryIdentifier(entries.find((entry) => customMessageDetail(entry, WORKFLOW_PRESENTATION_MESSAGE_TYPE, "intentId") === intentId)),
         send: () => {
             pi.sendMessage({
@@ -622,8 +873,11 @@ async function claimPendingTurnDelivery(pi, client, ctx) {
 }
 async function submitVisibleAssistantResponse(client, ctx) {
     const interaction = pendingInteractionForSession(ctx.sessionManager.getSessionId());
-    if (interaction === undefined || interaction.kind !== "assistant")
+    if (interaction === undefined ||
+        interaction.kind !== "assistant" ||
+        workflowRunPaused(interaction.runId)) {
         return;
+    }
     const contract = agentContract(interaction);
     if (contract === undefined)
         return;
@@ -647,126 +901,76 @@ async function submitVisibleAssistantResponse(client, ctx) {
             value: submission,
         },
     });
-    await waitForInteractionSubmission(interaction.requestId, `assistant-${responseId}`);
-}
-async function waitForInteractionSubmission(requestId, submissionId, signal) {
-    const store = new HostStateStore(workflowStatePath(), { readOnly: true });
-    try {
-        for (;;) {
-            if (signal?.aborted === true) {
-                throw signal.reason ?? new Error("Workflow submission validation was cancelled");
-            }
-            const submission = store.interactionSubmission(requestId, submissionId);
-            if (submission?.outcome === "accepted" || submission?.outcome === "adopted")
-                return;
-            if (submission?.outcome === "rejected") {
-                const receipt = isRecord(submission.receipt) ? submission.receipt : undefined;
-                throw new Error(typeof receipt?.error === "string"
-                    ? receipt.error
-                    : "Workflow step output failed validation");
-            }
-            await waitForSubmissionPoll(signal);
-        }
-    }
-    finally {
-        store.close();
-    }
 }
-async function waitForSubmissionPoll(signal) {
-    if (signal?.aborted === true) {
-        throw signal.reason ?? new Error("Workflow submission was cancelled");
-    }
-    await new Promise((resolve, reject) => {
-        const timer = setTimeout(finish, SUBMISSION_POLL_MS);
-        const onAbort = () => finish(signal?.reason ?? new Error("Workflow submission was cancelled"));
-        function finish(error) {
-            clearTimeout(timer);
-            signal?.removeEventListener("abort", onAbort);
-            if (error === undefined)
-                resolve();
-            else
-                reject(error);
-        }
-        signal?.addEventListener("abort", onAbort, { once: true });
+function rememberInteractiveRequest(sessionId, value) {
+    const current = parseInteractiveRequest(value);
+    const session = sessionSnapshots.get(sessionId);
+    if (current === undefined || session === undefined)
+        return;
+    let found = false;
+    const pendingInteractions = session.pendingInteractions.map((item) => {
+        const stored = parseInteractiveRequest(item);
+        if (stored?.requestId !== current.requestId)
+            return item;
+        found = true;
+        return current;
     });
+    if (found)
+        sessionSnapshots.set(sessionId, { ...session, pendingInteractions });
 }
 function pendingInteractionForSession(sessionId) {
-    try {
-        const store = new HostStateStore(workflowStatePath(), { readOnly: true });
-        try {
-            return store.listPendingInteractions(sessionId)[0];
-        }
-        finally {
-            store.close();
-        }
-    }
-    catch {
-        return undefined;
-    }
+    return sessionSnapshots
+        .get(sessionId)
+        ?.pendingInteractions.map(parseInteractiveRequest)
+        .find((request) => request !== undefined);
 }
 function pendingDecision(sessionId, runId) {
-    try {
-        const store = new HostStateStore(workflowStatePath(), { readOnly: true });
-        try {
-            return store
-                .listPendingInteractions(sessionId)
-                .find((request) => request.kind === "decision" && (runId === undefined || request.runId === runId));
-        }
-        finally {
-            store.close();
-        }
-    }
-    catch {
-        return undefined;
-    }
+    return sessionSnapshots
+        .get(sessionId)
+        ?.pendingInteractions.map(parseInteractiveRequest)
+        .find((request) => request !== undefined &&
+        request.kind === "decision" &&
+        (runId === undefined || request.runId === runId));
 }
-function hasClaimableNotification(sessionId) {
-    try {
-        const store = new SqliteControllerStore(workflowStatePath(), { readOnly: true, global: true });
-        try {
-            return (store.listPendingWorkflowNotifications({ targetSessionId: sessionId, limit: 1 }).length > 0);
-        }
-        finally {
-            store.close();
-        }
-    }
-    catch {
-        return false;
+function workflowRunPaused(runId) {
+    for (const session of sessionSnapshots.values()) {
+        if (session.run?.runId === runId)
+            return session.run.display.status === "paused";
     }
+    return false;
 }
-function hasClaimableTurn(sessionId) {
+async function interactionPresentationClaimIsLive(client, options) {
+    if (options.claimExpiresAt <= Date.now() || options.presenterId !== client.clientId)
+        return false;
     try {
-        const store = new SqliteControllerStore(workflowStatePath(), { readOnly: true, global: true });
-        try {
-            const now = Date.now();
-            return store
-                .listWorkflowTurnIntents({ targetSessionId: sessionId, unresolvedOnly: true, limit: 10 })
-                .some((intent) => intent.eligibleAt !== null &&
-                Date.parse(intent.eligibleAt) <= now &&
-                (intent.deliveryClaimExpiresAt === null ||
-                    Date.parse(intent.deliveryClaimExpiresAt) <= now));
-        }
-        finally {
-            store.close();
-        }
+        const response = await client.request({
+            operation: "interaction.update",
+            runId: options.runId,
+            expectedRevision: options.revision,
+            payload: { requestId: options.requestId, validatePresentation: true },
+        });
+        return ((response.outcome === "accepted" || response.outcome === "adopted") &&
+            isRecord(response.receipt) &&
+            response.receipt.live === true);
     }
     catch {
         return false;
     }
 }
-function terminalRunState(runId) {
+async function hostDeliveryClaimIsLive(client, options) {
     try {
-        const store = new WorkflowRunStore(workflowStatePath(), { readOnly: true });
-        try {
-            const loaded = store.readRun(runId);
-            return loaded === null ? undefined : loaded.state;
-        }
-        finally {
-            store.close();
-        }
+        const validationId = randomUUID();
+        const response = await client.request({
+            operation: options.kind === "notification" ? "notification.claim" : "turn.claim",
+            requestId: `delivery-validate-${options.claimId}-${validationId}`,
+            idempotencyKey: validationId,
+            payload: { ...options, validateClaim: true },
+        });
+        const receipt = isRecord(response.receipt) ? response.receipt : undefined;
+        return ((response.outcome === "accepted" || response.outcome === "adopted") && receipt?.live === true);
     }
     catch {
-        return undefined;
+        return false;
     }
 }
 function presentationMessage(turn, state) {
@@ -807,25 +1011,24 @@ function requireText(value, name) {
         throw new Error(`${name} must be text`);
     return value;
 }
+function claimExpiry(value, name) {
+    const expiry = Date.parse(requireText(value, `${name} expiry`));
+    if (!Number.isFinite(expiry))
+        throw new Error(`${name} expiry must be a timestamp`);
+    return expiry;
+}
 function activeSessionRun(ctx) {
     return sessionRun(ctx);
 }
 function sessionRun(ctx, runId) {
-    try {
-        const store = new SqliteControllerStore(workflowStatePath(), { readOnly: true, global: true });
-        try {
-            const run = runId === undefined
-                ? store.findSessionReservation(ctx.sessionManager.getSessionId())
-                : store.getWorkflowRun(runId);
-            return run?.originSessionId === ctx.sessionManager.getSessionId() ? run : undefined;
-        }
-        finally {
-            store.close();
-        }
-    }
-    catch {
+    const session = sessionSnapshots.get(ctx.sessionManager.getSessionId());
+    if (session?.run === null || session?.run === undefined || !isRecord(session.run.queue)) {
         return undefined;
     }
+    if (runId !== undefined && session.run.runId !== runId)
+        return undefined;
+    const queue = session.run.queue;
+    return queue.originSessionId === ctx.sessionManager.getSessionId() ? queue : undefined;
 }
 async function listWorkflowMetadata(cwd) {
     const files = await discoverWorkflows({ cwd });
@@ -866,8 +1069,10 @@ function toolInputToCommand(params) {
     }
 }
 async function requestAccepted(client, options) {
-    await client.ensureRunning();
-    const response = await client.request(options);
+    await client.ensureAvailable();
+    const response = options.idempotencyKey === undefined
+        ? await client.request(options)
+        : await client.requestDurable({ ...options, idempotencyKey: options.idempotencyKey });
     if (response.outcome !== "accepted" && response.outcome !== "adopted") {
         throw new Error(response.error ?? `Workflow host rejected ${options.operation}`);
     }
@@ -891,7 +1096,9 @@ function agentContract(interaction) {
     return value;
 }
 function interactionRequestId(value) {
-    if (!isRecord(value) || value.type !== "custom_message" || !isRecord(value.details)) {
+    if (!isRecord(value) ||
+        (value.type !== "custom_message" && value.role !== "custom") ||
+        !isRecord(value.details)) {
         return undefined;
     }
     return typeof value.details.requestId === "string" ? value.details.requestId : undefined;
@@ -989,6 +1196,27 @@ function toolResult(message, details) {
 function validRunId(value) {
     return /^[A-Za-z0-9][A-Za-z0-9._-]{0,199}$/u.test(value);
 }
+function isWorkflowSessionView(value) {
+    return (isRecord(value) &&
+        value.schema === "pi-workflows.session-view.v1" &&
+        typeof value.sessionId === "string" &&
+        Array.isArray(value.pendingInteractions) &&
+        isRecord(value.deliveries) &&
+        typeof value.deliveries.notification === "boolean" &&
+        typeof value.deliveries.turn === "boolean" &&
+        (value.run === null || isRecord(value.run)));
+}
+function parseInteractiveRequest(value) {
+    if (!isRecord(value) ||
+        typeof value.requestId !== "string" ||
+        typeof value.runId !== "string" ||
+        typeof value.targetSessionId !== "string" ||
+        typeof value.revision !== "number" ||
+        (value.kind !== "agent" && value.kind !== "assistant" && value.kind !== "decision")) {
+        return undefined;
+    }
+    return value;
+}
 function isRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }