antechamber 0.1.1 → 0.2.1

package/dist/session-history.js

@@ -2,6 +2,7 @@
 import { readFileSync } from "node:fs";
 import { applyProviderToolResults, finishProviderToolParts, mapTool, providerToolParts, resultMetadata, resultText, } from "./tool-map.js";
 import { TodoBridge } from "./todo-bridge.js";
+import { contextMessageID } from "./prompt-parts.js";
 import { bindMessageEntries } from "./session-tree.js";
 import { taskParts, updateTaskParts, taskCompletions } from "./subagents.js";
 import { shellTitle, shellUserMessage } from "./session-commands.js";
@@ -38,9 +39,7 @@ export function parsePiSessionFile(s, agentName) {
     }
     return parsePiSessionText(s, agentName, raw);
 }
-export function parsePiSessionText(s, agentName, raw) {
-    const sessionID = s.info.id;
-    const directory = s.info.directory;
+function parseEntries(raw) {
     const entries = [];
     for (const line of raw.split("\n")) {
         if (line.length === 0)
@@ -54,13 +53,44 @@ export function parsePiSessionText(s, agentName, raw) {
             /* torn trailing write — ignore */
         }
     }
-    const indexOf = new Map();
-    entries.forEach((e, i) => indexOf.set(e, i));
+    return entries;
+}
+function nativeTree(entries, leaf) {
+    return {
+        leafId: leaf?.id ?? null,
+        entries: entries.flatMap((entry) => {
+            if (entry.id === undefined || entry.type === undefined)
+                return [];
+            const message = entry.message;
+            return [
+                {
+                    type: entry.type,
+                    id: entry.id,
+                    parentId: entry.parentId ?? null,
+                    ...(message?.role === undefined
+                        ? {}
+                        : {
+                            message: {
+                                role: message.role,
+                                ...(message.clientMessageId === undefined ? {} : { clientMessageId: message.clientMessageId }),
+                                ...(message.role === "user" ? { content: [{ type: "text", text: textOf(message.content) }] } : {}),
+                                ...(message.command === undefined ? {} : { command: message.command }),
+                                ...(message.output === undefined ? {} : { output: message.output }),
+                                ...(message.exitCode === undefined ? {} : { exitCode: message.exitCode }),
+                                ...(message.cancelled === undefined ? {} : { cancelled: message.cancelled }),
+                            },
+                        }),
+                },
+            ];
+        }),
+    };
+}
+function activeChain(s, entries) {
     const byId = new Map();
-    for (const e of entries)
-        if (typeof e.id === "string")
-            byId.set(e.id, e);
-    let leaf = [...entries].reverse().find((entry) => entry.type !== "session" && typeof entry.id === "string");
+    for (const entry of entries)
+        if (typeof entry.id === "string")
+            byId.set(entry.id, entry);
+    let leaf = entries.findLast((entry) => entry.type !== "session" && typeof entry.id === "string");
     let selectedLeaf = s.tree.revert ? s.tree.revert.previousLeafId : s.tree.leafId;
     if (!s.tree.revert && s.tree.localShellTurns?.length) {
         // Follow a newly recorded descendant, never a sibling of the selected native branch.
@@ -77,40 +107,21 @@ export function parsePiSessionText(s, agentName, raw) {
         leaf = selectedLeaf === null ? undefined : byId.get(selectedLeaf);
     const chain = [];
     const seen = new Set();
-    for (let cur = leaf; cur !== undefined && !seen.has(cur);) {
-        seen.add(cur);
-        chain.push(cur);
-        cur = typeof cur.parentId === "string" ? byId.get(cur.parentId) : undefined;
+    for (let entry = leaf; entry !== undefined && !seen.has(entry);) {
+        seen.add(entry);
+        chain.push(entry);
+        entry = typeof entry.parentId === "string" ? byId.get(entry.parentId) : undefined;
     }
     chain.reverse();
-    const nativeTree = {
-        leafId: leaf?.id ?? null,
-        entries: entries.flatMap((entry) => {
-            if (entry.id === undefined || entry.type === undefined)
-                return [];
-            const m = entry.message;
-            return [
-                {
-                    type: entry.type,
-                    id: entry.id,
-                    parentId: entry.parentId ?? null,
-                    ...(m?.role === undefined
-                        ? {}
-                        : {
-                            message: {
-                                role: m.role,
-                                ...(m.clientMessageId === undefined ? {} : { clientMessageId: m.clientMessageId }),
-                                ...(m.role === "user" ? { content: [{ type: "text", text: textOf(m.content) }] } : {}),
-                                ...(m.command === undefined ? {} : { command: m.command }),
-                                ...(m.output === undefined ? {} : { output: m.output }),
-                                ...(m.exitCode === undefined ? {} : { exitCode: m.exitCode }),
-                                ...(m.cancelled === undefined ? {} : { cancelled: m.cancelled }),
-                            },
-                        }),
-                },
-            ];
-        }),
-    };
+    return { chain, nativeTree: nativeTree(entries, leaf) };
+}
+export function parsePiSessionText(s, agentName, raw) {
+    const sessionID = s.info.id;
+    const directory = s.info.directory;
+    const entries = parseEntries(raw);
+    const indexOf = new Map();
+    entries.forEach((e, i) => indexOf.set(e, i));
+    const { chain, nativeTree } = activeChain(s, entries);
     if (s.tree.localShellTurns?.length)
         bindMessageEntries(s, nativeTree);
     const out = [];
@@ -133,7 +144,41 @@ export function parsePiSessionText(s, agentName, raw) {
         }
         if (e.type === "compaction" && typeof e.summary === "string" && typeof e.firstKeptEntryId === "string") {
             // Not a run boundary: an automatic compaction can sit between steps of one turn.
-            out.push(...compactionMessages(s, e.firstKeptEntryId, e.summary, entryTime(e), currentModel));
+            out.push(...compactionMessages(s, e.id ?? `r${indexOf.get(e) ?? 0}`, e.summary, entryTime(e), currentModel));
+            continue;
+        }
+        const contextID = contextMessageID(e);
+        if (contextID !== undefined) {
+            endRun();
+            const content = Array.isArray(e.content)
+                ? e.content
+                : typeof e.content === "string"
+                    ? [{ type: "text", text: e.content }]
+                    : [];
+            const time = entryTime(e);
+            if (e.id)
+                s.tree.messageEntries[contextID] = e.id;
+            out.push({
+                info: {
+                    id: contextID,
+                    sessionID,
+                    role: "user",
+                    time: { created: time },
+                    agent: agentName,
+                    model: currentModel,
+                    synthetic: true,
+                },
+                parts: [
+                    {
+                        id: `prt_${contextID}_context`,
+                        sessionID,
+                        messageID: contextID,
+                        type: "text",
+                        text: textOf(content),
+                        time: { start: time, end: time },
+                    },
+                ],
+            });
             continue;
         }
         if (e.type !== "message")
@@ -366,13 +411,15 @@ export function parsePiSessionText(s, agentName, raw) {
         }
         // system / custom entries are not rendered
     }
-    const lastAssistant = [...chain].reverse().find((entry) => entry.message?.role === "assistant");
+    const lastAssistant = chain.findLast((entry) => entry.message?.role === "assistant");
     const stopReason = lastAssistant?.message?.stopReason;
     if (lastAssistant !== undefined && ["stop", "length", "error", "aborted"].includes(stopReason ?? "")) {
         finishProviderToolParts([...toolParts.values()].flat(), entryTime(lastAssistant), stopReason === "aborted" ? "Cancelled" : "No result");
     }
     s.todoBridge = new TodoBridge(sessionID);
-    s.todoBridge.restore(entries, new Map([...toolParts].flatMap(([callID, parts]) => (parts[0] ? [[callID, parts[0]]] : []))));
+    // Tree-less snapshots predate branch selection and have no competing ancestor chain.
+    const todoEntries = chain.length === 0 && s.tree.leafId === undefined && !s.tree.revert ? entries : chain;
+    s.todoBridge.restore(todoEntries, new Map([...toolParts].flatMap(([callID, parts]) => (parts[0] ? [[callID, parts[0]]] : []))));
     // Completions can be appended after the newest message, outside its ancestor chain.
     for (const entry of entries) {
         if (entry.customType !== "omo-senpi:wake")
@@ -417,5 +464,24 @@ export function parsePiSessionText(s, agentName, raw) {
         });
         (s.inputs ??= new Map()).set(messageID, { text, delivery, accepted: true, delivered: false });
     }
+    for (const message of out) {
+        const metadata = s.tree.promptMetadata?.[message.info.id];
+        if (message.info.role === "user" && metadata !== undefined)
+            message.info.metadata = metadata;
+        const inputParts = s.tree.promptParts?.[message.info.id];
+        if (message.info.role === "user" && inputParts !== undefined)
+            message.parts = inputParts.map((part, index) => ({
+                ...part,
+                id: part.id ?? `prt_${message.info.id}_${index}`,
+                sessionID,
+                messageID: message.info.id,
+            }));
+        const identities = s.tree.messageParts?.[message.info.id];
+        for (const [index, part] of message.parts.entries()) {
+            const identity = identities?.[index];
+            if (identity !== undefined)
+                part.id = identity;
+        }
+    }
     return out;
 }

package/dist/session-hosts.js

@@ -1,7 +1,7 @@
 import { spawn } from "node:child_process";
 import { createHash } from "node:crypto";
 import { once } from "node:events";
-import { closeSync, constants, openSync, readFileSync, readdirSync, readlinkSync } from "node:fs";
+import { closeSync, constants, openSync, readFileSync, readdirSync, readlinkSync, realpathSync } from "node:fs";
 import { basename } from "node:path";
 import { findPidfdPython } from "./pidfd.js";
 /** Capability and warning state are captured once, before any shutdown work. */
@@ -144,7 +144,7 @@ async function stopSupportedSessionHosts(created, python) {
             try {
                 // The original leader must still exist after the process-table scan:
                 // a recycled group number cannot confer its ownership on new members.
-                return readlinkSync(`/proc/self/fd/${info.fd}/cwd`) === directory;
+                return readlinkSync(`/proc/self/fd/${info.fd}/cwd`) === realpathSync(directory);
             }
             catch (error) {
                 if (error instanceof Error && "code" in error && ["ENOENT", "ESRCH"].includes(String(error.code)))

package/dist/session-store.d.ts

@@ -37,6 +37,9 @@ export interface SessionRegistryEntry {
     connectorOwned?: true;
     tree?: SessionTreeState;
     parentID?: string | undefined;
+    parentMessageID?: string;
+    agent?: string;
+    metadata?: Record<string, unknown>;
     task?: ChildTask;
     piSessionId: string;
     piPath: string;
@@ -53,6 +56,7 @@ export interface SessionRegistryEntry {
     model?: {
         providerID: string;
         modelID: string;
+        variant?: string;
     };
     created: number;
     updated: number;
@@ -81,18 +85,18 @@ export declare function piSessionsRootMtime(): number | undefined;
 export declare function scanAllPiSessions(): ScannedSession[];
 /** All restorable pi sessions recorded for `directory`. Corrupt files are skipped. */
 export declare function scanPiSessions(directory: string): ScannedSession[];
-/**
- * Persistent oc-session-id → metadata registry (title overrides, known pi
- * paths). Atomic writes, lazy load, corrupt file degrades to an empty map.
- */
 export declare class SessionStore {
     readonly stateDir: string;
     private readonly file;
     private entries;
     constructor(stateDir?: string);
     private load;
+    private readEntries;
+    private withRegistryLock;
     private persist;
+    private mutate;
     get(ocSessionId: string): SessionRegistryEntry | undefined;
+    idFor(piSessionId: string): string | undefined;
     childIds(): string[];
     set(ocSessionId: string, entry: SessionRegistryEntry): void;
     /** Merge a partial update (e.g. title override, updated timestamp). */

package/dist/session-store.js

@@ -14,9 +14,10 @@
  * the same OpenChamber id, even if the registry file is lost.
  */
 import { createHash } from "node:crypto";
-import { closeSync, existsSync, mkdirSync, openSync, readFileSync, readSync, readdirSync, renameSync, statSync, writeFileSync, } from "node:fs";
+import { chmodSync, closeSync, existsSync, mkdirSync, openSync, readFileSync, readSync, readdirSync, renameSync, statSync, unlinkSync, writeFileSync, } from "node:fs";
 import { join } from "node:path";
 import { piAgentDir } from "./agent-dir.js";
+import { isPromptPart } from "./prompt-parts.js";
 import { defaultStateDir, envSetting } from "./config.js";
 /** pi's session directory for a given cwd (see pi docs/session-format.md). */
 export function piSessionDir(cwd) {
@@ -38,6 +39,12 @@ export class SessionPersistenceError extends Error {
 /** Read at most this many leading bytes when sniffing headers/titles. */
 const SNIFF_BYTES = 256 * 1024;
 const TITLE_MAX_LINES = 200;
+const TITLE_MAX_CHARS = 60;
+const REGISTRY_DIRECTORY_MODE = 0o700;
+const REGISTRY_FILE_MODE = 0o600;
+const REGISTRY_LOCK_RETRY_MS = 10;
+const REGISTRY_LOCK_STALE_MS = 5_000;
+const registryLockWaiter = new Int32Array(new SharedArrayBuffer(4));
 function readHead(path, bytes = SNIFF_BYTES) {
     const fd = openSync(path, "r");
     try {
@@ -64,13 +71,16 @@ function titleFromHead(head, piSessionId) {
         }
         if (entry.type !== "message" || entry.message?.role !== "user")
             continue;
-        const text = (entry.message.content ?? [])
-            .filter((b) => b?.type === "text" && typeof b.text === "string")
-            .map((b) => b.text)
-            .join("\n")
-            .trim();
+        const content = entry.message.content ?? [];
+        // pi allows plain-string message content (extensions, append_user_message).
+        const text = (typeof content === "string"
+            ? content
+            : content
+                .filter((b) => b?.type === "text" && typeof b.text === "string")
+                .map((b) => b.text)
+                .join("\n")).trim();
         if (text !== "")
-            return text.slice(0, 60);
+            return text.slice(0, TITLE_MAX_CHARS);
     }
     return `pi session ${piSessionId.slice(0, 8)}`;
 }
@@ -261,6 +271,105 @@ export function scanPiSessions(directory) {
  * Persistent oc-session-id → metadata registry (title overrides, known pi
  * paths). Atomic writes, lazy load, corrupt file degrades to an empty map.
  */
+function record(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function stringRecord(value) {
+    return record(value) && Object.values(value).every((entry) => typeof entry === "string");
+}
+function booleanRecord(value) {
+    return record(value) && Object.values(value).every((entry) => typeof entry === "boolean");
+}
+function persistedMessage(value) {
+    return (record(value) &&
+        record(value.info) &&
+        typeof value.info.id === "string" &&
+        typeof value.info.role === "string" &&
+        Array.isArray(value.parts));
+}
+function sessionTreeState(value) {
+    if (!record(value) || !stringRecord(value.messageEntries))
+        return false;
+    if (value.promptParts !== undefined &&
+        (!record(value.promptParts) ||
+            !Object.values(value.promptParts).every((parts) => Array.isArray(parts) && parts.every(isPromptPart))))
+        return false;
+    if (value.promptMetadata !== undefined &&
+        (!record(value.promptMetadata) || !Object.values(value.promptMetadata).every((metadata) => record(metadata))))
+        return false;
+    if (value.messageParts !== undefined &&
+        (!record(value.messageParts) ||
+            !Object.values(value.messageParts).every((parts) => Array.isArray(parts) && parts.every((part) => typeof part === "string"))))
+        return false;
+    if (value.shellDispatch !== undefined && !booleanRecord(value.shellDispatch))
+        return false;
+    if (value.leafId !== undefined && value.leafId !== null && typeof value.leafId !== "string")
+        return false;
+    if (value.revert !== undefined) {
+        if (!record(value.revert) ||
+            typeof value.revert.messageID !== "string" ||
+            (value.revert.previousLeafId !== null && typeof value.revert.previousLeafId !== "string") ||
+            (value.revert.targetId !== null && typeof value.revert.targetId !== "string"))
+            return false;
+    }
+    return (value.localShellTurns === undefined ||
+        (Array.isArray(value.localShellTurns) &&
+            value.localShellTurns.every((turn) => record(turn) &&
+                (turn.afterEntryId === null || typeof turn.afterEntryId === "string") &&
+                Array.isArray(turn.messages) &&
+                turn.messages.length === 2 &&
+                persistedMessage(turn.messages[0]) &&
+                persistedMessage(turn.messages[1]))));
+}
+function childTask(value) {
+    return (record(value) &&
+        typeof value.id === "string" &&
+        typeof value.parentPiId === "string" &&
+        record(value.input) &&
+        record(value.details) &&
+        (value.terminalAt === undefined || (typeof value.terminalAt === "number" && Number.isFinite(value.terminalAt))));
+}
+function titleSource(value) {
+    return value === "user" || value === "native" || value === "fallback" || value === "generated";
+}
+function registryEntry(value) {
+    if (!record(value) ||
+        typeof value.piPath !== "string" ||
+        typeof value.piSessionId !== "string" ||
+        typeof value.directory !== "string" ||
+        typeof value.created !== "number" ||
+        !Number.isFinite(value.created) ||
+        typeof value.updated !== "number" ||
+        !Number.isFinite(value.updated))
+        return false;
+    if (value.connectorOwned !== undefined && value.connectorOwned !== true)
+        return false;
+    if (value.tree !== undefined && !sessionTreeState(value.tree))
+        return false;
+    if (value.parentID !== undefined && typeof value.parentID !== "string")
+        return false;
+    if (value.parentMessageID !== undefined && typeof value.parentMessageID !== "string")
+        return false;
+    if (value.agent !== undefined && typeof value.agent !== "string")
+        return false;
+    if (value.metadata !== undefined && !record(value.metadata))
+        return false;
+    if (value.task !== undefined && !childTask(value.task))
+        return false;
+    if (value.title !== undefined && typeof value.title !== "string")
+        return false;
+    if (value.titleSource !== undefined && !titleSource(value.titleSource))
+        return false;
+    if (value.archived !== undefined && (typeof value.archived !== "number" || !Number.isFinite(value.archived)))
+        return false;
+    if (value.model !== undefined &&
+        (!record(value.model) || typeof value.model.providerID !== "string" || typeof value.model.modelID !== "string"))
+        return false;
+    return true;
+}
+function errorCode(error) {
+    return error instanceof Error && "code" in error ? String(error.code) : undefined;
+}
 export class SessionStore {
     stateDir;
     file;
@@ -273,64 +382,108 @@ export class SessionStore {
     load() {
         if (this.entries !== undefined)
             return this.entries;
-        this.entries = new Map();
+        this.entries = this.readEntries();
+        return this.entries;
+    }
+    readEntries() {
+        const entries = new Map();
         try {
             const raw = JSON.parse(readFileSync(this.file, "utf8"));
-            for (const [k, v] of Object.entries(raw)) {
-                if (v && typeof v.piPath === "string" && typeof v.piSessionId === "string") {
-                    // A hand-edited or partially written registry must not be able to
-                    // poison the model a dormant session advertises.
-                    if (v.model !== undefined &&
-                        (typeof v.model.providerID !== "string" || typeof v.model.modelID !== "string")) {
-                        delete v.model;
-                    }
-                    this.entries.set(k, v);
-                }
-            }
+            if (!record(raw))
+                return entries;
+            for (const [id, value] of Object.entries(raw))
+                if (registryEntry(value))
+                    entries.set(id, value);
         }
         catch {
             /* missing or corrupt — start empty */
         }
-        return this.entries;
+        return entries;
     }
-    persist(entries) {
-        const obj = Object.fromEntries(entries);
+    withRegistryLock(action) {
+        const lock = `${this.file}.lock`;
+        let fd;
         try {
-            mkdirSync(join(this.file, ".."), { recursive: true });
-            const tmp = `${this.file}.${process.pid}.tmp`;
-            writeFileSync(tmp, JSON.stringify(obj, null, 2));
-            renameSync(tmp, this.file);
+            mkdirSync(this.stateDir, { recursive: true, mode: REGISTRY_DIRECTORY_MODE });
+            chmodSync(this.stateDir, REGISTRY_DIRECTORY_MODE);
+            for (;;) {
+                try {
+                    fd = openSync(lock, "wx", REGISTRY_FILE_MODE);
+                    break;
+                }
+                catch (error) {
+                    if (errorCode(error) !== "EEXIST")
+                        throw error;
+                    try {
+                        if (Date.now() - statSync(lock).mtimeMs >= REGISTRY_LOCK_STALE_MS) {
+                            unlinkSync(lock);
+                            continue;
+                        }
+                    }
+                    catch (staleLockError) {
+                        if (errorCode(staleLockError) !== "ENOENT")
+                            throw staleLockError;
+                        continue;
+                    }
+                    Atomics.wait(registryLockWaiter, 0, 0, REGISTRY_LOCK_RETRY_MS);
+                }
+            }
+            return action();
         }
         catch (error) {
             throw new SessionPersistenceError(this.file, error);
         }
-        this.entries = entries;
+        finally {
+            if (fd !== undefined) {
+                closeSync(fd);
+                unlinkSync(lock);
+            }
+        }
+    }
+    persist(entries) {
+        const obj = Object.fromEntries(entries);
+        const tmp = `${this.file}.${process.pid}.tmp`;
+        writeFileSync(tmp, JSON.stringify(obj, null, 2), { mode: REGISTRY_FILE_MODE });
+        chmodSync(tmp, REGISTRY_FILE_MODE);
+        renameSync(tmp, this.file);
+    }
+    mutate(change) {
+        this.withRegistryLock(() => {
+            const entries = this.readEntries();
+            if (change(entries))
+                this.persist(entries);
+            this.entries = entries;
+        });
     }
     get(ocSessionId) {
         return this.load().get(ocSessionId);
     }
+    idFor(piSessionId) {
+        return [...this.load()].find(([, entry]) => entry.piSessionId === piSessionId)?.[0];
+    }
     childIds() {
         return [...this.load()]
             .filter(([, entry]) => entry.task !== undefined && entry.parentID !== undefined)
             .map(([id]) => id);
     }
     set(ocSessionId, entry) {
-        const entries = new Map(this.load());
-        entries.set(ocSessionId, entry);
-        this.persist(entries);
+        this.mutate((entries) => {
+            entries.set(ocSessionId, entry);
+            return true;
+        });
     }
     /** Merge a partial update (e.g. title override, updated timestamp). */
     update(ocSessionId, patch) {
-        const map = this.load();
-        const prev = map.get(ocSessionId);
-        if (prev === undefined)
-            return;
-        this.set(ocSessionId, { ...prev, ...patch });
+        this.mutate((entries) => {
+            const previous = entries.get(ocSessionId);
+            if (previous === undefined)
+                return false;
+            entries.set(ocSessionId, { ...previous, ...patch });
+            return true;
+        });
     }
     remove(ocSessionId) {
-        const entries = new Map(this.load());
-        if (entries.delete(ocSessionId))
-            this.persist(entries);
+        this.mutate((entries) => entries.delete(ocSessionId));
     }
     /** Every directory the registry knows about — used to resolve bare session ids. */
     directories() {

package/dist/session-tree.d.ts

@@ -1,8 +1,15 @@
 import { type PiRpcClient } from "./pi-rpc.js";
 import type { ManagedSession } from "./sessions.js";
 import type { OCMessageWithParts } from "./types.js";
+import type { OCPromptPart } from "./types.js";
 export interface SessionTreeState {
     messageEntries: Record<string, string>;
+    /** Published part identities in native content order, keyed by durable message identity. */
+    messageParts?: Record<string, string[]>;
+    /** Original rich user input; native RPC stores only adapted text and images. */
+    promptParts?: Record<string, OCPromptPart[]>;
+    /** Client prompt metadata; native RPC does not store it. */
+    promptMetadata?: Record<string, Record<string, unknown>>;
     /** Actual transport dispatch, not inferred from a card's terminal state. */
     shellDispatch?: Record<string, boolean>;
     /** Identity-only dispatched admissions; never rendered without a native entry. */
@@ -21,10 +28,12 @@ export interface TreeEntry {
     type: string;
     id: string;
     parentId: string | null;
+    customType?: string;
+    details?: unknown;
     message?: {
         role: string;
         clientMessageId?: string;
-        content?: Array<{
+        content?: string | Array<{
             type: string;
             text?: string;
         }>;
@@ -48,7 +57,6 @@ export declare function recordTurn(s: ManagedSession): void;
 export declare function branchEntries(tree: Entries, leafId?: string | null): TreeEntry[];
 /** Live ids belong to the UI; restored ids belong to JSONL offsets. Save both. */
 export declare function bindMessageEntries(s: ManagedSession, tree: Entries): void;
-export declare function entryForMessage(s: ManagedSession, tree: Entries, messageID: string): TreeEntry;
 export declare function forkConversation(s: ManagedSession, pi: PiRpcClient, tree: Entries, messageID?: string): Promise<{
     sessionId: string;
     sessionFile: string;