pi-sessions 0.12.1 → 0.13.1

package/extensions/subagents/install.ts

@@ -5,15 +5,22 @@ import type {
   SendMessageRequest,
   SendMessageResult,
 } from "../session-messaging/install.ts";
+import {
+  createSessionCancelTool,
+  createSessionSendMessageTool,
+} from "../session-messaging/pi/tools.ts";
 import type { SessionLifecycle } from "../shared/composition.ts";
-import type { SessionSettings } from "../shared/settings.ts";
+import type { CompactionThresholdSettings, SessionSettings } from "../shared/settings.ts";
 import { isTmuxInstalled } from "../shared/tmux.ts";
+import { safeParseTypeBoxValue } from "../shared/typebox.ts";
 import { SubagentCancellationRouter, type SubagentCancelResult } from "./cancel.ts";
+import { createSubagentContextLimit } from "./context-limit.ts";
 import { createSubagentLaunchTarget, type SubagentLaunchState } from "./launch-target.ts";
 import {
   hasSubagentLaunchEntries,
   SUBAGENT_LAUNCHED_CUSTOM_TYPE,
   SUBAGENT_REPORT_MESSAGE_CUSTOM_TYPE,
+  SUBAGENT_REPORT_MESSAGE_SCHEMA,
   SUBAGENT_REPORT_RECEIVED_CUSTOM_TYPE,
 } from "./ledger.ts";
 import { openReconcileSession, SubagentReconciler } from "./reconcile.ts";
@@ -28,10 +35,15 @@ import {
   countSubagentReports,
   createSettledChildLifecycle,
   findSelfSubagentIdentity,
+  refreshSubagentChildState,
   type SubagentChildSessionState,
 } from "./settle.ts";
+import { shouldMessageSubagent } from "./should-message.ts";
 import { SubagentMessageRouter } from "./wake.ts";
 
+const SUBAGENT_PROMPT_SECTION = "pi_sessions_subagent";
+const SUBAGENT_PROMPT = `You are working as a subagent on one task delegated by a parent session. The handoff defines your task. Work independently, stay within its scope, and do not duplicate work assigned to the parent or another subagent. Use the available tools to complete the task and validate your conclusions. Messages from the parent may refine the task or request a follow-up, but they do not replace your original task with unrelated work.`;
+
 interface ParentSessionState extends SubagentParentSession {
   getSessionName(): string | undefined;
   launchState: SubagentLaunchState;
@@ -51,16 +63,27 @@ export interface SubagentsHandle extends SessionLifecycle {
   getLaunchTargets(): readonly HandoffLaunchTarget[];
   sendMessage(request: SendMessageRequest): Promise<SendMessageResult>;
   cancelSession(sessionId: string): Promise<SubagentCancelResult>;
+  shouldMessageSubagent(sessionId: string): Promise<boolean>;
+  /** Undefined unless the active branch makes this session someone's subagent. */
+  getParentSessionId(): string | undefined;
 }
 
 export function installSubagents(
   pi: ExtensionAPI,
-  deps: { settings: SessionSettings; messaging: MessagingHandle },
+  deps: {
+    settings: SessionSettings;
+    messaging: MessagingHandle;
+    readCompactionSettings: (cwd: string) => CompactionThresholdSettings;
+  },
 ): SubagentsHandle {
   pi.registerMessageRenderer(SUBAGENT_REPORT_MESSAGE_CUSTOM_TYPE, renderSubagentReportMessage);
 
   let epoch = 0;
   let current: CurrentSubagentSession | undefined;
+  const contextLimit = createSubagentContextLimit(
+    deps.settings.subagents.contextLimit,
+    deps.readCompactionSettings,
+  );
 
   const isCurrentSession = (candidateEpoch: number): boolean =>
     current?.parent.epoch === candidateEpoch;
@@ -104,6 +127,9 @@ export function installSubagents(
     if (!parent) {
       throw new Error("Target session is not ready to receive subagent reports.");
     }
+    if (reconciler.hasSentReport(envelope.reportId)) {
+      return;
+    }
     const incoming = buildIncomingSubagentReport(parent, envelope);
     if (!incoming) {
       return;
@@ -120,18 +146,24 @@ export function installSubagents(
       },
       incoming.delivery,
     );
+    reconciler.noteReportSent(envelope.reportId);
   });
 
   pi.on("before_agent_start", (event) => {
-    const child = current?.child;
-    if (!child) {
-      return;
+    if (current?.child) {
+      event.systemPromptOptions.sections[SUBAGENT_PROMPT_SECTION] = SUBAGENT_PROMPT;
     }
-    return {
-      systemPrompt: `${event.systemPrompt}
+  });
 
-You are working as a subagent on one task delegated by a parent session. The handoff defines your task. Work independently, stay within its scope, and do not duplicate work assigned to the parent or another subagent. Use the available tools to complete the task and validate your conclusions. Messages from the parent may refine the task or request a follow-up, but they do not replace your original task with unrelated work.`,
-    };
+  pi.on("message_end", (event) => {
+    const message = event.message;
+    if (message.role !== "custom" || message.customType !== SUBAGENT_REPORT_MESSAGE_CUSTOM_TYPE) {
+      return;
+    }
+    const report = safeParseTypeBoxValue(SUBAGENT_REPORT_MESSAGE_SCHEMA, message.details);
+    if (report && report.writerSessionId === current?.parent.sessionId) {
+      reconciler.noteReportDelivered(report.reportId);
+    }
   });
 
   pi.on("agent_start", (_event, ctx) => {
@@ -150,18 +182,82 @@ You are working as a subagent on one task delegated by a parent session. The han
       ? await reconciler.reconcile()
       : undefined;
     if (session.child) {
+      await contextLimit.compactIfOverLimit(ctx);
       await settledChildLifecycle.settle(session.parent, session.child, reconciliation);
     }
   });
 
+  const refreshChildSession = (): void => {
+    if (!current) {
+      return;
+    }
+    const previousChild = current.child;
+    current.child = refreshSubagentChildState(
+      current.parent.sessionId,
+      current.parent.getBranch(),
+      previousChild,
+    );
+    current.parent.launchState.depth = current.child?.identity.depth ?? 0;
+    if (current.child && current.child !== previousChild) {
+      pi.registerTool(
+        createSubmitTaskReportTool(pi, deps.messaging, () => {
+          const session = current;
+          return session?.child
+            ? { ...session.parent, identity: session.child.identity }
+            : undefined;
+        }),
+      );
+      const activeTools = pi.getActiveTools();
+      if (!activeTools.includes("submit_task_report")) {
+        pi.setActiveTools([...activeTools, "submit_task_report"]);
+      }
+    } else if (!current.child && previousChild) {
+      pi.setActiveTools(pi.getActiveTools().filter((name) => name !== "submit_task_report"));
+    }
+  };
+
+  const registerMessagingTools = (): void => {
+    const isSubagent = handle.getParentSessionId() !== undefined;
+    pi.registerTool(
+      createSessionSendMessageTool(handle, {
+        role: isSubagent ? { kind: "subagent" } : { kind: "wakeCapable" },
+        getCachedRelationTo: deps.messaging.getCachedRelationTo,
+        getParentSessionId: () => handle.getParentSessionId(),
+      }),
+    );
+    pi.registerTool(
+      createSessionCancelTool(handle, {
+        role: isSubagent ? { kind: "subagent" } : { kind: "plain" },
+        getParentSessionId: () => handle.getParentSessionId(),
+      }),
+    );
+  };
+
   pi.on("session_tree", async () => {
+    settledChildLifecycle.cancel();
+    refreshChildSession();
+    registerMessagingTools();
     await reconciler.reconcileAndRestoreSuspended();
   });
 
-  return {
+  const handle: SubagentsHandle = {
     roster,
     sendMessage: (request) => messageRouter.sendMessage(request),
     cancelSession: (sessionId) => cancellationRouter.cancelSession(sessionId),
+    shouldMessageSubagent: (sessionId) =>
+      shouldMessageSubagent(sessionId, {
+        executor: pi,
+        messaging: deps.messaging,
+        getParent: () => current?.parent,
+        openSession: openRosterSession,
+      }),
+    getParentSessionId() {
+      const parent = current?.parent;
+      if (!parent) {
+        return undefined;
+      }
+      return findSelfSubagentIdentity(parent.sessionId, parent.getBranch())?.ownerSessionId;
+    },
     getLaunchTargets() {
       const parent = current?.parent;
       if (!parent?.tmuxInstalled || parent.launchState.depth >= deps.settings.subagents.maxDepth) {
@@ -189,27 +285,10 @@ You are working as a subagent on one task delegated by a parent session. The han
         tmuxInstalled: await isTmuxInstalled(pi, ctx.cwd),
       };
       reconciler.beginSession();
-      current = {
-        parent,
-        ...(identity
-          ? {
-              child: {
-                identity,
-                requestResponse: identity.requestResponse,
-                reportsAtTurnStart: countSubagentReports(sessionStartBranch),
-              },
-            }
-          : {}),
-      };
+      current = { parent };
+      refreshChildSession();
       if (identity) {
-        pi.registerTool(
-          createSubmitTaskReportTool(pi, deps.messaging, () => {
-            const session = current;
-            return session?.child
-              ? { ...session.parent, identity: session.child.identity }
-              : undefined;
-          }),
-        );
+        registerMessagingTools();
       }
       if (_event.reason === "reload") {
         await reconciler.reconcile();
@@ -226,4 +305,5 @@ You are working as a subagent on one task delegated by a parent session. The han
       current = undefined;
     },
   };
+  return handle;
 }

package/extensions/subagents/reconcile.ts

@@ -84,6 +84,8 @@ export class SubagentReconciler {
   private shuttingDown = false;
   private registered: { epoch: number; sessionIds: Set<string> } | undefined;
   private latestResult: ReconcileResult = emptyReconcileResult();
+  private sentReportIds = new Set<string>();
+  private pendingRecoveredReportIds = new Set<string>();
 
   constructor(private readonly deps: ReconcileDependencies) {}
 
@@ -93,6 +95,25 @@ export class SubagentReconciler {
     this.restoreSuspended = false;
     this.registered = undefined;
     this.latestResult = emptyReconcileResult();
+    this.sentReportIds.clear();
+    this.pendingRecoveredReportIds.clear();
+  }
+
+  hasSentReport(reportId: string): boolean {
+    return this.sentReportIds.has(reportId);
+  }
+
+  noteReportSent(reportId: string): void {
+    // Pi may queue the message before persisting it. The ledger alone cannot deduplicate it yet.
+    this.sentReportIds.add(reportId);
+  }
+
+  hasPendingRecoveredReports(): boolean {
+    return this.pendingRecoveredReportIds.size > 0;
+  }
+
+  noteReportDelivered(reportId: string): void {
+    this.pendingRecoveredReportIds.delete(reportId);
   }
 
   reconcile(): Promise<ReconcileResult> {
@@ -199,15 +220,21 @@ export class SubagentReconciler {
         continue;
       }
 
+      let reportLedger: ParentSubagentLedger | undefined;
       for (const report of child.reports) {
-        if (!ledger.receivedReportIds.has(report.reportId)) {
+        if (this.hasSentReport(report.reportId)) {
+          continue;
+        }
+        // Presence and tmux awaits can yield to live delivery; read only when recovery needs it.
+        reportLedger ??= collectParentLedger(parent.getBranch(), parent.sessionId);
+        if (!reportLedger.receivedReportIds.has(report.reportId)) {
           this.append(parent, SUBAGENT_REPORT_RECEIVED_CUSTOM_TYPE, {
             writerSessionId: parent.sessionId,
             childSessionId: child.launch.childSessionId,
             reportId: report.reportId,
           });
         }
-        if (!ledger.deliveredReportIds.has(report.reportId)) {
+        if (!reportLedger.deliveredReportIds.has(report.reportId)) {
           this.deliverRecoveredReport(parent, child.launch, report);
         }
       }
@@ -340,12 +367,35 @@ export class SubagentReconciler {
       ...report,
       provenance: "recovered",
     };
-    this.sendMessage(parent, {
-      customType: SUBAGENT_REPORT_MESSAGE_CUSTOM_TYPE,
-      content: formatReportForModel(launch.title, message),
-      display: true,
-      details: message,
-    });
+    this.requireCurrent(parent);
+    const delivery = parent.isIdle()
+      ? { triggerTurn: true as const }
+      : { deliverAs: "steer" as const };
+    this.pendingRecoveredReportIds.add(report.reportId);
+    try {
+      this.deps.executor.sendMessage(
+        {
+          customType: SUBAGENT_REPORT_MESSAGE_CUSTOM_TYPE,
+          content: formatReportForModel(launch.title, message),
+          display: true,
+          details: message,
+        },
+        delivery,
+      );
+    } catch (error) {
+      this.pendingRecoveredReportIds.delete(report.reportId);
+      throw error;
+    }
+    this.noteReportSent(report.reportId);
+    // Non-streaming steering appends directly, without an extension message_end event.
+    if (
+      "deliverAs" in delivery &&
+      collectParentLedger(parent.getBranch(), parent.sessionId).deliveredReportIds.has(
+        report.reportId,
+      )
+    ) {
+      this.noteReportDelivered(report.reportId);
+    }
   }
 
   private sendDisownedMessage(parent: ReconcileParentSession): void {
@@ -359,17 +409,6 @@ export class SubagentReconciler {
     });
   }
 
-  private sendMessage(
-    parent: ReconcileParentSession,
-    message: { customType: string; content: string; display: boolean; details: unknown },
-  ): void {
-    this.requireCurrent(parent);
-    const delivery = parent.isIdle()
-      ? { triggerTurn: true as const }
-      : { deliverAs: "steer" as const };
-    this.deps.executor.sendMessage(message, delivery);
-  }
-
   private requireCurrent(parent: ReconcileParentSession): void {
     if (!this.deps.isCurrent(parent.epoch)) {
       throw new Error("The parent session changed during subagent reconciliation.");

package/extensions/subagents/report.ts

@@ -46,8 +46,6 @@ export function createSubmitTaskReportTool(
     promptSnippet: "Submit the current task report to the parent session and end the turn",
     promptGuidelines: [
       "Call submit_task_report exactly once as the final tool call for every delegated task or follow-up that expects a response.",
-      "Do not send task results through session_send_message; submit_task_report is the only supported means to send final results to the parent.",
-      "If you receive steering instructions from the parent via session_send_message, you may optionally reply to the parent using the session_send_message tool if the parent's message calls for something that is out of band of what would be included in the report.",
     ],
     parameters: TASK_REPORT_SCHEMA,
     async execute(_toolCallId, params) {

package/extensions/subagents/settle.ts

@@ -56,12 +56,17 @@ export function createSettledChildLifecycle(
     cancel,
     async settle(parent, child, reconciliation) {
       cancel();
+      // Pi defers report turns sent during agent_settled without changing idle or pending state.
+      if (reconciler.hasPendingRecoveredReports()) {
+        return;
+      }
       const currentGeneration = generation;
       let phase: "owned-subagents" | "settle" | "observer" =
         reconciliation && hasRunningOwnedSubagents(reconciliation) ? "owned-subagents" : "settle";
       const canAdvance = (): boolean =>
         generation === currentGeneration &&
         isCurrentSession(parent.epoch) &&
+        !reconciler.hasPendingRecoveredReports() &&
         !parent.hasPendingMessages() &&
         parent.isIdle();
       const schedule = (delayMs: number): void => {
@@ -126,6 +131,32 @@ export function countSubagentReports(branch: readonly SessionEntry[]): number {
   return getChildSubagentLifecycle(branch).reports.length;
 }
 
+export function refreshSubagentChildState(
+  sessionId: string,
+  branch: readonly SessionEntry[],
+  child: SubagentChildSessionState | undefined,
+): SubagentChildSessionState | undefined {
+  const identity = findSelfSubagentIdentity(sessionId, branch);
+  if (!identity) {
+    return undefined;
+  }
+  const reports = countSubagentReports(branch);
+  if (
+    child?.identity.childSessionId === identity.childSessionId &&
+    child.identity.ownerSessionId === identity.ownerSessionId &&
+    child.identity.depth === identity.depth &&
+    child.identity.requestResponse === identity.requestResponse &&
+    child.reportsAtTurnStart <= reports
+  ) {
+    return child;
+  }
+  return {
+    identity,
+    requestResponse: identity.requestResponse,
+    reportsAtTurnStart: reports,
+  };
+}
+
 export function findSelfSubagentIdentity(
   sessionId: string,
   branch: readonly SessionEntry[],

package/extensions/subagents/should-message.ts

@@ -0,0 +1,59 @@
+import type { SessionEntry } from "@earendil-works/pi-coding-agent";
+import { isSessionStarting } from "../session-handoff/metadata.ts";
+import { listTmuxWindows, type TmuxExecutor, tmuxSessionName } from "../shared/tmux.ts";
+import { classifySubagent } from "./classify.ts";
+import { collectParentLedger, getChildSubagentLifecycle } from "./ledger.ts";
+
+interface SubagentSession {
+  sessionId: string;
+  getBranch(): readonly SessionEntry[];
+}
+
+export interface ShouldMessageSubagentDependencies {
+  executor: TmuxExecutor;
+  messaging: { listSessions(): Promise<string[]> };
+  getParent(): SubagentSession | undefined;
+  openSession(path: string): SubagentSession;
+}
+
+export async function shouldMessageSubagent(
+  sessionId: string,
+  deps: ShouldMessageSubagentDependencies,
+): Promise<boolean> {
+  const parent = deps.getParent();
+  if (!parent) {
+    return false;
+  }
+  const ledger = collectParentLedger(parent.getBranch(), parent.sessionId);
+  const launch = ledger.launches.find((entry) => entry.childSessionId === sessionId);
+  if (!launch || ledger.cancelledChildIds.has(sessionId)) {
+    return false;
+  }
+
+  const [windows, liveSessions] = await Promise.all([
+    listTmuxWindows(deps.executor, tmuxSessionName(parent.sessionId)),
+    deps.messaging.listSessions(),
+  ]);
+  let childBranch: readonly SessionEntry[] | undefined;
+  try {
+    const child = deps.openSession(launch.childSessionFile);
+    if (child.sessionId === sessionId) {
+      childBranch = child.getBranch();
+    }
+  } catch {
+    // An unreadable transcript cannot establish that an owned child has finished.
+  }
+  const lifecycle = childBranch ? getChildSubagentLifecycle(childBranch) : undefined;
+  const brokerLive = liveSessions.includes(sessionId);
+  const state = classifySubagent({
+    hasWindow: windows.some((window) => window.piSessionId === sessionId),
+    brokerLive,
+    hasRegistered: brokerLive,
+    awaitingKickoff: childBranch ? isSessionStarting(childBranch) : false,
+    cancelled: false,
+    suspended: ledger.suspendedChildIds.has(sessionId),
+    hasReportOrClosure: Boolean(lifecycle?.reports.length || lifecycle?.closed),
+    childReadable: childBranch !== undefined,
+  });
+  return state !== "completed" && state !== "stopped";
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-sessions",
-  "version": "0.12.1",
+  "version": "0.13.1",
   "type": "module",
   "description": "Pi session search, ask, handoff, messaging, auto-titling, and indexing tools",
   "license": "MIT",
@@ -37,21 +37,21 @@
     "check": "mise run check"
   },
   "devDependencies": {
-    "@biomejs/biome": "^2.4.14",
-    "@earendil-works/pi-agent-core": "^0.84.1",
-    "@earendil-works/pi-ai": "^0.84.1",
-    "@earendil-works/pi-coding-agent": "^0.84.1",
-    "@earendil-works/pi-tui": "^0.84.1",
-    "@types/node": "^25.6.2",
+    "@biomejs/biome": "^2.5.10",
+    "@earendil-works/pi-agent-core": "^0.87.1",
+    "@earendil-works/pi-ai": "^0.87.1",
+    "@earendil-works/pi-coding-agent": "^0.87.1",
+    "@earendil-works/pi-tui": "^0.87.1",
+    "@types/node": "^24.13.3",
     "strip-ansi": "^7.2.0",
-    "typebox": "^1.1.38",
+    "typebox": "1.3.27",
     "typescript": "^7.0.0",
-    "vitest": "^4.1.5"
+    "vitest": "^4.1.11"
   },
   "peerDependencies": {
-    "@earendil-works/pi-agent-core": ">=0.83.0",
-    "@earendil-works/pi-ai": ">=0.83.0",
-    "@earendil-works/pi-coding-agent": ">=0.83.0",
-    "@earendil-works/pi-tui": ">=0.83.0"
+    "@earendil-works/pi-agent-core": ">=0.87.1",
+    "@earendil-works/pi-ai": ">=0.87.1",
+    "@earendil-works/pi-coding-agent": ">=0.87.1",
+    "@earendil-works/pi-tui": ">=0.87.1"
   }
 }

package/extensions/session-handoff/refs.ts

@@ -1,145 +0,0 @@
-import path from "node:path";
-import { parseSessionFile } from "../session-search/extract.ts";
-import {
-  getSessionById,
-  type SessionLineageRow,
-  type SessionOrigin,
-  withSessionIndex,
-} from "../shared/session-index/index.ts";
-
-const HANDOFF_REF_PREFIX = "@handoff/";
-const SESSION_REFERENCE_HELP =
-  "Expected an absolute session path, a raw session id, or @handoff/<full-session-id>.";
-
-export type SessionReferenceKind = "path" | "session_id" | "handoff_ref";
-
-export interface ResolvedSessionReference {
-  input: string;
-  kind: SessionReferenceKind;
-  canonicalRef: string;
-  sessionId: string;
-  sessionPath: string;
-  sessionName: string;
-  parentSessionPath?: string | undefined;
-  parentSessionId?: string | undefined;
-  sessionOrigin?: SessionOrigin | undefined;
-}
-
-export interface SessionReferenceResolution {
-  resolved?: ResolvedSessionReference | undefined;
-  error?: string | undefined;
-}
-
-export function formatHandoffRef(sessionId: string): string {
-  return `${HANDOFF_REF_PREFIX}${sessionId}`;
-}
-
-export function isHandoffRef(value: string): boolean {
-  return value.startsWith(HANDOFF_REF_PREFIX);
-}
-
-export function resolveSessionReference(
-  reference: string,
-  options: { indexPath: string },
-): SessionReferenceResolution {
-  const trimmed = reference.trim();
-  if (!trimmed) {
-    return { error: `Missing session reference. ${SESSION_REFERENCE_HELP}` };
-  }
-
-  if (path.isAbsolute(trimmed)) {
-    return resolveAbsoluteSessionPath(trimmed);
-  }
-
-  if (isHandoffRef(trimmed)) {
-    return resolveIndexedReference(
-      trimmed,
-      trimmed.slice(HANDOFF_REF_PREFIX.length),
-      "handoff_ref",
-      options,
-    );
-  }
-
-  return resolveIndexedReference(trimmed, trimmed, "session_id", options);
-}
-
-function resolveAbsoluteSessionPath(sessionPath: string): SessionReferenceResolution {
-  try {
-    const parsed = parseSessionFile(sessionPath);
-    if (!parsed) {
-      return { error: `Unable to parse session file: ${sessionPath}` };
-    }
-
-    return {
-      resolved: {
-        input: sessionPath,
-        kind: "path",
-        canonicalRef: formatHandoffRef(parsed.header.id),
-        sessionId: parsed.header.id,
-        sessionPath,
-        sessionName: parsed.sessionName,
-        parentSessionPath: normalizeOptionalString(parsed.header.parentSession),
-      },
-    };
-  } catch (error) {
-    if (error instanceof Error && "code" in error && error.code === "ENOENT") {
-      return { error: `Session file not found: ${sessionPath}` };
-    }
-
-    return { error: `Unable to load session file: ${sessionPath}` };
-  }
-}
-
-function resolveIndexedReference(
-  input: string,
-  rawValue: string,
-  kind: SessionReferenceKind,
-  options: { indexPath: string },
-): SessionReferenceResolution {
-  const value = rawValue.trim();
-  if (!value) {
-    return { error: `Invalid session reference: ${input}. ${SESSION_REFERENCE_HELP}` };
-  }
-
-  try {
-    return withSessionIndex(options.indexPath, { mode: "read", required: true }, ({ db }) => {
-      const exactMatch = getSessionById(db, value);
-      if (exactMatch) {
-        return { resolved: buildResolvedReference(input, kind, exactMatch) };
-      }
-
-      return { error: `No session found for reference: ${input}. ${SESSION_REFERENCE_HELP}` };
-    });
-  } catch {
-    return {
-      error: `Session reference resolution requires a current index at ${options.indexPath}. Run /session-index and press r to rebuild it.`,
-    };
-  }
-}
-
-function buildResolvedReference(
-  input: string,
-  kind: SessionReferenceKind,
-  session: SessionLineageRow,
-): ResolvedSessionReference {
-  return {
-    input,
-    kind,
-    canonicalRef: formatHandoffRef(session.sessionId),
-    sessionId: session.sessionId,
-    sessionPath: session.sessionPath,
-    sessionName: session.sessionName,
-    parentSessionPath: session.parentSessionPath,
-    parentSessionId: session.parentSessionId,
-    sessionOrigin: session.sessionOrigin,
-  };
-}
-
-function normalizeOptionalString(value: string | undefined): string | undefined {
-  if (typeof value !== "string") {
-    return undefined;
-  }
-
-  const trimmed = value.trim();
-  return trimmed.length > 0 ? trimmed : undefined;
-}