pi-sessions 0.9.0 → 0.10.0

package/README.md

@@ -140,6 +140,8 @@ If you want to override the shortcut, put this in your `~/.pi/agent/settings.jso
   "sessions": {
     "handoff": {
       "pickerShortcut": "alt+p",
+      "model": "openai-codex/gpt-5.6-terra",
+      "thinkingLevel": "low",
       "deferred": {
         "copyToClipboard": true
       }
@@ -148,6 +150,8 @@ If you want to override the shortcut, put this in your `~/.pi/agent/settings.jso
 }
 ```
 
+`model` and `thinkingLevel` configure the agent that builds handoff prompts. They default to the new session's values when absent.
+
 `deferred.copyToClipboard` (default `true`) controls whether deferred handoffs copy the resume command to the clipboard. When off, the resume command is only shown in the tool call.
 
 Subagents require the handoff and messaging features. Limit recursive delegation depth with `sessions.subagents.maxDepth` (default `2`):

package/dist/session-messaging/broker/process.js

@@ -0,0 +1,234 @@
+import { mkdirSync, unlinkSync, writeFileSync } from "node:fs";
+import { createServer } from "node:net";
+import { join } from "node:path";
+import { readFrames, writeFrame } from "../../shared/session-broker/framing.js";
+import { CLIENT_FRAME_SCHEMA, } from "../../shared/session-broker/protocol.js";
+import { getSessionMessagingDir, getSessionMessagingSocketPath, } from "../../shared/session-broker/socket-path.js";
+const SEND_TIMEOUT_MS = 10_000;
+const EXIT_IDLE_MS = 5_000;
+const KEEPALIVE_DELAY_MS = 5_000;
+const messagingDir = getSessionMessagingDir();
+const socketPath = getSessionMessagingSocketPath();
+const pidPath = join(messagingDir, "broker.pid");
+const sessions = new Map();
+const pendingSends = new Map();
+let idleTimer;
+let server;
+function closeWithError(socket, message) {
+    try {
+        writeFrame(socket, { type: "error", message });
+    }
+    catch { }
+    socket.destroy();
+}
+function scheduleIdleExit() {
+    if (idleTimer)
+        clearTimeout(idleTimer);
+    idleTimer = setTimeout(() => {
+        if (sessions.size === 0)
+            shutdown();
+    }, EXIT_IDLE_MS);
+}
+function clearIdleExit() {
+    if (!idleTimer)
+        return;
+    clearTimeout(idleTimer);
+    idleTimer = undefined;
+}
+function unregister(sessionId) {
+    if (!sessionId)
+        return;
+    sessions.delete(sessionId);
+    failPendingSendsTo(sessionId);
+    if (sessions.size === 0)
+        scheduleIdleExit();
+}
+function resolveTarget(target) {
+    const socket = sessions.get(target);
+    if (socket)
+        return { sessionId: target, socket };
+    return { error: `No live session found for id: ${target}` };
+}
+function handleFrame(socket, message, getSessionId, setSessionId) {
+    const currentSessionId = getSessionId();
+    if (!currentSessionId && message.type !== "register") {
+        closeWithError(socket, `Received ${message.type} before register.`);
+        return;
+    }
+    switch (message.type) {
+        case "register": {
+            const existing = sessions.get(message.sessionId);
+            if (existing && existing !== socket && !existing.destroyed) {
+                writeFrame(socket, {
+                    type: "register_failed",
+                    reason: "Session messaging unavailable: this session is already registered by another live Pi process.",
+                });
+                socket.end();
+                return;
+            }
+            clearIdleExit();
+            setSessionId(message.sessionId);
+            sessions.set(message.sessionId, socket);
+            socket.setKeepAlive(true, KEEPALIVE_DELAY_MS);
+            writeFrame(socket, { type: "registered", sessionId: message.sessionId });
+            break;
+        }
+        case "unregister":
+            unregister(currentSessionId);
+            setSessionId(undefined);
+            socket.end();
+            break;
+        case "list":
+            writeFrame(socket, {
+                type: "sessions",
+                requestId: message.requestId,
+                sessionIds: [...sessions.keys()],
+            });
+            break;
+        case "send":
+            handleSend(socket, currentSessionId, message);
+            break;
+        case "incoming_ack":
+            handleIncomingAck(socket, message);
+            break;
+    }
+}
+function handleSend(socket, currentSessionId, message) {
+    const source = currentSessionId ? sessions.get(currentSessionId) : undefined;
+    if (!currentSessionId || !source) {
+        writeFrame(socket, {
+            type: "send_result",
+            requestId: message.requestId,
+            delivered: false,
+            error: "Sender session is not registered.",
+        });
+        return;
+    }
+    const resolved = resolveTarget(message.target);
+    if ("error" in resolved) {
+        writeFrame(socket, {
+            type: "send_result",
+            requestId: message.requestId,
+            delivered: false,
+            reason: "no_session",
+            error: resolved.error,
+        });
+        return;
+    }
+    if (resolved.sessionId === currentSessionId) {
+        writeFrame(socket, {
+            type: "send_result",
+            requestId: message.requestId,
+            delivered: false,
+            error: "Cannot send a session envelope to the current session.",
+        });
+        return;
+    }
+    const timeout = setTimeout(() => {
+        pendingSends.delete(message.requestId);
+        writeFrame(socket, {
+            type: "send_result",
+            requestId: message.requestId,
+            delivered: false,
+            error: "Timed out waiting for target session to accept the envelope.",
+        });
+    }, SEND_TIMEOUT_MS);
+    pendingSends.set(message.requestId, {
+        source: socket,
+        target: resolved.socket,
+        timeout,
+        targetSessionId: resolved.sessionId,
+    });
+    writeFrame(resolved.socket, {
+        type: "incoming",
+        requestId: message.requestId,
+        envelope: stampEnvelope(message.envelope, currentSessionId, resolved.sessionId),
+    });
+}
+function failPendingSendsTo(targetSessionId) {
+    for (const [requestId, pending] of pendingSends) {
+        if (pending.targetSessionId !== targetSessionId) {
+            continue;
+        }
+        clearTimeout(pending.timeout);
+        pendingSends.delete(requestId);
+        writeFrame(pending.source, {
+            type: "send_result",
+            requestId,
+            delivered: false,
+            reason: "disconnected",
+            error: "Target disconnected before accepting the envelope.",
+        });
+    }
+}
+function handleIncomingAck(socket, message) {
+    const pending = pendingSends.get(message.requestId);
+    if (!pending || pending.target !== socket)
+        return;
+    clearTimeout(pending.timeout);
+    pendingSends.delete(message.requestId);
+    writeFrame(pending.source, {
+        type: "send_result",
+        requestId: message.requestId,
+        delivered: message.delivered,
+        ...(message.error === undefined ? {} : { error: message.error }),
+    });
+}
+function stampEnvelope(envelope, source, target) {
+    return { ...envelope, source, target };
+}
+function handleConnection(socket) {
+    let sessionId;
+    socket.setKeepAlive(true, KEEPALIVE_DELAY_MS);
+    void readConnection(socket, () => sessionId, (nextSessionId) => {
+        sessionId = nextSessionId;
+    });
+    socket.on("close", () => {
+        unregister(sessionId);
+    });
+    socket.on("error", () => { });
+}
+async function readConnection(socket, getSessionId, setSessionId) {
+    try {
+        for await (const frame of readFrames(socket, CLIENT_FRAME_SCHEMA, "Invalid session messaging client frame")) {
+            handleFrame(socket, frame, getSessionId, setSessionId);
+        }
+    }
+    catch (error) {
+        closeWithError(socket, error instanceof Error ? error.message : String(error));
+    }
+}
+function shutdown() {
+    for (const socket of sessions.values())
+        socket.end();
+    sessions.clear();
+    for (const pending of pendingSends.values())
+        clearTimeout(pending.timeout);
+    pendingSends.clear();
+    if (server)
+        server.close();
+    if (process.platform !== "win32") {
+        try {
+            unlinkSync(socketPath);
+        }
+        catch { }
+    }
+    try {
+        unlinkSync(pidPath);
+    }
+    catch { }
+    process.exit(0);
+}
+mkdirSync(messagingDir, { recursive: true, mode: 0o700 });
+if (process.platform !== "win32") {
+    try {
+        unlinkSync(socketPath);
+    }
+    catch { }
+}
+server = createServer(handleConnection);
+server.listen(socketPath, () => {
+    writeFileSync(pidPath, String(process.pid));
+});
+process.on("SIGTERM", shutdown);
+process.on("SIGINT", shutdown);

package/dist/shared/session-broker/framing.js

@@ -0,0 +1,58 @@
+import { createInterface } from "node:readline";
+import { parseTypeBoxValue } from "../typebox.js";
+const MAX_FRAME_BYTES = 256 * 1024;
+export function writeFrame(socket, frame) {
+    socket.write(`${JSON.stringify(frame)}\n`);
+}
+export async function* readFrames(socket, schema, context) {
+    const reader = createInterface({ input: socket, crlfDelay: Number.POSITIVE_INFINITY });
+    const lines = [];
+    const waiters = [];
+    let error;
+    let closed = false;
+    const wake = () => {
+        const waiter = waiters.shift();
+        waiter?.();
+    };
+    reader.on("line", (line) => {
+        lines.push(line);
+        wake();
+    });
+    reader.on("error", (nextError) => {
+        error = nextError instanceof Error ? nextError : new Error(String(nextError));
+        closed = true;
+        wake();
+    });
+    reader.on("close", () => {
+        closed = true;
+        wake();
+    });
+    try {
+        while (true) {
+            while (lines.length === 0 && !closed) {
+                await new Promise((resolve) => waiters.push(resolve));
+            }
+            const line = lines.shift();
+            if (line === undefined) {
+                if (error) {
+                    throw error;
+                }
+                return;
+            }
+            if (Buffer.byteLength(line, "utf8") > MAX_FRAME_BYTES) {
+                throw new Error("Session messaging frame exceeds maximum size.");
+            }
+            let parsed;
+            try {
+                parsed = JSON.parse(line);
+            }
+            catch (parseError) {
+                throw parseError instanceof Error ? parseError : new Error(String(parseError));
+            }
+            yield parseTypeBoxValue(schema, parsed, context);
+        }
+    }
+    finally {
+        reader.close();
+    }
+}

package/dist/shared/session-broker/protocol.js

@@ -0,0 +1,163 @@
+import { Type } from "typebox";
+export const TASK_REPORT_REFERENCE_SCHEMA = Type.Object({
+    reference: Type.String({
+        description: "A precise reference such as a file path and line range, symbol name, command, URL, session id, or external artifact.",
+    }),
+    description: Type.Optional(Type.String({
+        description: "Why this reference matters or what evidence the parent should take from it.",
+    })),
+});
+export const TASK_REPORT_SCHEMA = Type.Object({
+    status: Type.Union([
+        Type.Literal("done", {
+            description: "The delegated task or requested follow-up is complete.",
+        }),
+        Type.Literal("blocked", {
+            description: "The task cannot continue without a specific decision, clarification, permission, dependency, or other action outside the scope of the task.",
+        }),
+        Type.Literal("incomplete", {
+            description: "Useful work was performed, but the requested result could not be completed and it's uncertain what should be done to reach completion.",
+        }),
+    ], { description: "The subagent's assessment of the task at the end of this turn." }),
+    summary: Type.String({
+        description: "A concise, 3-4 sentence self-contained account of the outcome and its most important evidence.",
+    }),
+    details: Type.Optional(Type.String({
+        description: "Optional supporting context such as reasoning, implementation notes, validation performed, limitations, unexpected behavior or roadblocks, or failed approaches.",
+    })),
+    references: Type.Optional(Type.Array(TASK_REPORT_REFERENCE_SCHEMA, {
+        description: "Supporting material for the report.",
+    })),
+    nextSteps: Type.Optional(Type.Array(Type.String(), {
+        description: "Optional concrete actions that would extend or build on the state of the work. If blocked or incomplete, call out specifically what is causing the early return.",
+    })),
+});
+const OUTBOUND_MESSAGE_ENVELOPE_SCHEMA = Type.Object({
+    kind: Type.Literal("message"),
+    messageId: Type.String(),
+    body: Type.String(),
+    requestResponse: Type.Optional(Type.Boolean()),
+    sentAt: Type.String(),
+    sourceToolCallId: Type.Optional(Type.String()),
+});
+const OUTBOUND_CANCEL_ENVELOPE_SCHEMA = Type.Object({
+    kind: Type.Literal("cancel"),
+    cancelId: Type.String(),
+    sentAt: Type.String(),
+});
+const OUTBOUND_SUBAGENT_REPORT_ENVELOPE_SCHEMA = Type.Intersect([
+    Type.Object({
+        kind: Type.Literal("subagent_report"),
+        reportId: Type.String(),
+        sentAt: Type.String(),
+    }),
+    TASK_REPORT_SCHEMA,
+]);
+export const OUTBOUND_SESSION_ENVELOPE_SCHEMA = Type.Union([
+    OUTBOUND_MESSAGE_ENVELOPE_SCHEMA,
+    OUTBOUND_CANCEL_ENVELOPE_SCHEMA,
+    OUTBOUND_SUBAGENT_REPORT_ENVELOPE_SCHEMA,
+]);
+export const SESSION_MESSAGE_ENVELOPE_SCHEMA = Type.Object({
+    kind: Type.Literal("message"),
+    messageId: Type.String(),
+    source: Type.String(),
+    target: Type.String(),
+    body: Type.String(),
+    requestResponse: Type.Optional(Type.Boolean()),
+    sentAt: Type.String(),
+    sourceToolCallId: Type.Optional(Type.String()),
+});
+export const SESSION_CANCEL_ENVELOPE_SCHEMA = Type.Object({
+    kind: Type.Literal("cancel"),
+    cancelId: Type.String(),
+    source: Type.String(),
+    target: Type.String(),
+    sentAt: Type.String(),
+});
+export const SESSION_SUBAGENT_REPORT_ENVELOPE_SCHEMA = Type.Intersect([
+    Type.Object({
+        kind: Type.Literal("subagent_report"),
+        reportId: Type.String(),
+        source: Type.String(),
+        target: Type.String(),
+        sentAt: Type.String(),
+    }),
+    TASK_REPORT_SCHEMA,
+]);
+export const SESSION_ENVELOPE_SCHEMA = Type.Union([
+    SESSION_MESSAGE_ENVELOPE_SCHEMA,
+    SESSION_CANCEL_ENVELOPE_SCHEMA,
+    SESSION_SUBAGENT_REPORT_ENVELOPE_SCHEMA,
+]);
+const REGISTER_CLIENT_FRAME_SCHEMA = Type.Object({
+    type: Type.Literal("register"),
+    sessionId: Type.String(),
+});
+const UNREGISTER_CLIENT_FRAME_SCHEMA = Type.Object({
+    type: Type.Literal("unregister"),
+});
+const LIST_CLIENT_FRAME_SCHEMA = Type.Object({
+    type: Type.Literal("list"),
+    requestId: Type.String(),
+});
+const SEND_CLIENT_FRAME_SCHEMA = Type.Object({
+    type: Type.Literal("send"),
+    requestId: Type.String(),
+    target: Type.String(),
+    envelope: OUTBOUND_SESSION_ENVELOPE_SCHEMA,
+});
+const INCOMING_ACK_CLIENT_FRAME_SCHEMA = Type.Object({
+    type: Type.Literal("incoming_ack"),
+    requestId: Type.String(),
+    delivered: Type.Boolean(),
+    error: Type.Optional(Type.String()),
+});
+const REGISTERED_BROKER_FRAME_SCHEMA = Type.Object({
+    type: Type.Literal("registered"),
+    sessionId: Type.String(),
+});
+const REGISTER_FAILED_BROKER_FRAME_SCHEMA = Type.Object({
+    type: Type.Literal("register_failed"),
+    reason: Type.String(),
+});
+const SESSIONS_BROKER_FRAME_SCHEMA = Type.Object({
+    type: Type.Literal("sessions"),
+    requestId: Type.String(),
+    sessionIds: Type.Array(Type.String()),
+});
+const INCOMING_BROKER_FRAME_SCHEMA = Type.Object({
+    type: Type.Literal("incoming"),
+    requestId: Type.String(),
+    envelope: SESSION_ENVELOPE_SCHEMA,
+});
+export const SESSION_ENVELOPE_SEND_FAILURE_REASON_SCHEMA = Type.Union([
+    Type.Literal("no_session"),
+    Type.Literal("disconnected"),
+]);
+const SEND_RESULT_BROKER_FRAME_SCHEMA = Type.Object({
+    type: Type.Literal("send_result"),
+    requestId: Type.String(),
+    delivered: Type.Boolean(),
+    reason: Type.Optional(SESSION_ENVELOPE_SEND_FAILURE_REASON_SCHEMA),
+    error: Type.Optional(Type.String()),
+});
+const ERROR_BROKER_FRAME_SCHEMA = Type.Object({
+    type: Type.Literal("error"),
+    message: Type.String(),
+});
+export const CLIENT_FRAME_SCHEMA = Type.Union([
+    REGISTER_CLIENT_FRAME_SCHEMA,
+    UNREGISTER_CLIENT_FRAME_SCHEMA,
+    LIST_CLIENT_FRAME_SCHEMA,
+    SEND_CLIENT_FRAME_SCHEMA,
+    INCOMING_ACK_CLIENT_FRAME_SCHEMA,
+]);
+export const BROKER_FRAME_SCHEMA = Type.Union([
+    REGISTERED_BROKER_FRAME_SCHEMA,
+    REGISTER_FAILED_BROKER_FRAME_SCHEMA,
+    SESSIONS_BROKER_FRAME_SCHEMA,
+    INCOMING_BROKER_FRAME_SCHEMA,
+    SEND_RESULT_BROKER_FRAME_SCHEMA,
+    ERROR_BROKER_FRAME_SCHEMA,
+]);

package/dist/shared/session-broker/socket-path.js

@@ -0,0 +1,19 @@
+import { homedir } from "node:os";
+import { join } from "node:path";
+function sanitizePipeSegment(value) {
+    return (value
+        .replace(/[^a-zA-Z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .toLowerCase() || "default");
+}
+export function getSessionMessagingDir(homeDir = homedir()) {
+    return (process.env.PI_SESSIONS_MESSAGING_DIR ??
+        join(homeDir, ".pi", "agent", "pi-sessions", "messaging"));
+}
+export function getSessionMessagingSocketPath(platform = process.platform, homeDir = homedir()) {
+    const messagingDir = getSessionMessagingDir(homeDir);
+    if (platform === "win32") {
+        return `\\\\.\\pipe\\pi-sessions-messaging-${sanitizePipeSegment(messagingDir)}`;
+    }
+    return join(messagingDir, "broker.sock");
+}

package/dist/shared/typebox.js

@@ -0,0 +1,36 @@
+import { Value } from "typebox/value";
+export function isTypeBoxValue(schema, value) {
+    return Value.Check(schema, value);
+}
+export function parseTypeBoxValue(schema, value, context) {
+    if (Value.Check(schema, value)) {
+        return value;
+    }
+    throw new Error(formatTypeBoxError(schema, value, context));
+}
+export function safeParseTypeBoxValue(schema, value) {
+    return Value.Check(schema, value) ? value : undefined;
+}
+export function parseTypeBoxRows(schema, value, context) {
+    if (!Array.isArray(value)) {
+        throw new Error(`${context}: expected an array of rows.`);
+    }
+    return value.map((row, index) => parseTypeBoxValue(schema, row, `${context} at row ${index + 1}`));
+}
+export function safeParseTypeBoxJson(schema, raw) {
+    try {
+        const parsed = JSON.parse(raw);
+        return safeParseTypeBoxValue(schema, parsed);
+    }
+    catch {
+        return undefined;
+    }
+}
+function formatTypeBoxError(schema, value, context) {
+    const firstError = Value.Errors(schema, value)[0];
+    if (!firstError) {
+        return `${context}: invalid value.`;
+    }
+    const path = firstError.instancePath.length > 0 ? firstError.instancePath : "/";
+    return `${context}: ${path} ${firstError.message}`;
+}

package/extensions/session-handoff/board-view-model.ts

@@ -1,11 +1,9 @@
 import { tmuxSessionName } from "../shared/tmux.ts";
-import type { SubagentState } from "../subagents/classify.ts";
+import { isRunningSubagentState, type SubagentState } from "../subagents/classify.ts";
 import type { SubagentRosterEntry } from "../subagents/roster.ts";
 import { shellQuote } from "./launch/shell.ts";
 import type { HandoffLaunchReceipt } from "./receipt.ts";
 
-const RUNNING_SUBAGENT_STATES: ReadonlySet<SubagentState> = new Set(["starting", "busy", "active"]);
-
 export type HandoffBoardTab = "subagents" | "user-sessions";
 export type UserSessionStatus = "live" | "ready" | "starting" | "closed" | "unknown";
 
@@ -169,7 +167,7 @@ function buildUserSessionAction(
 function buildSubagentAction(entry: SubagentRosterEntry, insideTmux: boolean): HandoffBoardAction {
   return {
     subagent: entry,
-    canStop: RUNNING_SUBAGENT_STATES.has(entry.state),
+    canStop: isRunningSubagentState(entry.state),
     ...(entry.tmuxWindowId ? { observeCommand: buildObserveCommand(entry, insideTmux) } : {}),
     ...(!entry.managedLive ? { resumeCommand: entry.resumeCommand } : {}),
   };

package/extensions/session-handoff/bootstrap.ts

@@ -2,9 +2,9 @@ import type { ThinkingLevel } from "@earendil-works/pi-agent-core";
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { SessionManager } from "@earendil-works/pi-coding-agent";
 import type { ModelRuntimeProvider } from "../shared/model-runtime.ts";
+import type { HandoffSettings } from "../shared/settings.ts";
 import { generateHandoffDraftFromSessionManager } from "./extract.ts";
 import { buildHandoffKickoffMessage, buildHandoffKickoffSource } from "./kickoff.ts";
-import { SUBAGENT_LAUNCH } from "./launch-target.ts";
 import {
   type ChildGeneratedHandoffBootstrap,
   createHandoffSessionMetadata,
@@ -23,8 +23,8 @@ export async function consumePendingHandoffBootstrap(
   pi: ExtensionAPI,
   ctx: ExtensionContext,
   getModelRuntime: ModelRuntimeProvider,
-  thinkingLevel: ThinkingLevel | undefined,
-  persistRuns: boolean,
+  destinationThinkingLevel: ThinkingLevel | undefined,
+  handoffSettings: HandoffSettings,
 ): Promise<void> {
   const scan = findPendingHandoffBootstrap(ctx.sessionManager.getBranch());
   if (!scan) {
@@ -56,8 +56,8 @@ export async function consumePendingHandoffBootstrap(
     scan.entryId,
     consumeBootstrap,
     getModelRuntime,
-    thinkingLevel,
-    persistRuns,
+    destinationThinkingLevel,
+    handoffSettings,
   );
 }
 
@@ -68,8 +68,8 @@ async function startChildGeneratedHandoff(
   bootstrapEntryId: string,
   consumeBootstrap: (reason: HandoffBootstrapConsumedReason) => void,
   getModelRuntime: ModelRuntimeProvider,
-  thinkingLevel: ThinkingLevel | undefined,
-  persistRuns: boolean,
+  destinationThinkingLevel: ThinkingLevel | undefined,
+  handoffSettings: HandoffSettings,
 ): Promise<void> {
   const entries = ctx.sessionManager.getEntries();
   if (hasStartedConversation(entries)) {
@@ -96,17 +96,17 @@ async function startChildGeneratedHandoff(
       ctx,
       "Generating handoff draft...",
       async (signal: AbortSignal) =>
-        generateHandoffDraftFromSessionManager(
+        generateHandoffDraftFromSessionManager({
           ctx,
           modelRuntime,
           sourceSessionManager,
-          bootstrap.sourceLeafId,
-          bootstrap.goal,
-          thinkingLevel,
-          persistRuns,
+          sourceLeafId: bootstrap.sourceLeafId,
+          goal: bootstrap.goal,
+          settings: handoffSettings,
+          destinationThinkingLevel,
           signal,
-          bootstrap.requestResponse,
-        ),
+          requestResponse: bootstrap.requestResponse,
+        }),
     );
     if (!generatedDraft) {
       consumeBootstrap("cancelled");
@@ -140,13 +140,11 @@ async function startChildGeneratedHandoff(
 
     // The tool-provided bootstrap title is authoritative; extraction does not
     // replace it with a second generated title.
-    const subagent = bootstrap.launch === SUBAGENT_LAUNCH ? bootstrap.subagent : undefined;
     const metadata = createHandoffSessionMetadata(
       bootstrap.goal,
       prompt,
       bootstrap.title,
       bootstrap.launch,
-      subagent,
     );
     if (!getHandoffMetadataFromEntries(ctx.sessionManager.getEntries())) {
       pi.appendEntry(HANDOFF_METADATA_CUSTOM_TYPE, metadata);