@pasko70/pibo 3.2.6 → 3.3.0

package/dist/agent-runtime/history.js

@@ -1,3 +1,4 @@
+import { createHash } from "node:crypto";
 /**
  * Build a structural complete-history claim for compatibility callers.
  *
@@ -17,24 +18,12 @@ export function createCompleteHistoryReconciliationProof(entries, scopeId) {
     };
 }
 export function historyReconciliationDigest(entries) {
-    const mask = 0xffffffffffffffffn;
-    const prime = 0x100000001b3n;
-    const hashes = [
-        0xcbf29ce484222325n,
-        0x84222325cbf29ce4n,
-        0x9e3779b97f4a7c15n,
-        0x517cc1b727220a95n,
-    ];
+    const hash = createHash("sha256");
     for (const entry of entries) {
-        const signature = `${historyReconciliationEntrySignature(entry)}\n`;
-        for (let index = 0; index < signature.length; index += 1) {
-            const codeUnit = BigInt(signature.charCodeAt(index));
-            for (let hashIndex = 0; hashIndex < hashes.length; hashIndex += 1) {
-                hashes[hashIndex] = ((hashes[hashIndex] ^ codeUnit) * prime) & mask;
-            }
-        }
+        hash.update(historyReconciliationEntrySignature(entry));
+        hash.update("\n");
     }
-    return hashes.map((hash) => hash.toString(16).padStart(16, "0")).join("");
+    return hash.digest("hex");
 }
 export function historyReconciliationEntrySignature(entry) {
     const { sequence: _pageLocalSequence, ...proofContent } = entry;

package/dist/agent-runtimes/codex-native/adapter.js

@@ -112,7 +112,7 @@ function codexNativeCapabilities(structuredUserInput) {
             nativeToolInspection: {
                 support: "degraded",
                 mode: "observed-runtime-items",
-                reason: "Stable Codex App Server 0.147.0 does not expose a complete pre-turn native-tool inventory; Pibo reports selected MCP tools immediately and harness-native tools after stable item notifications prove they are active.",
+                reason: "Stable Codex App Server 0.153.2 does not expose a complete pre-turn native-tool inventory; Pibo reports selected MCP tools immediately and harness-native tools after stable item notifications prove they are active.",
             },
             nativeToolYielding: unsupportedAgentRuntimeCapability("Codex native tools remain harness-owned and are not wrapped as Pibo yielded tools."),
             intentTracing: {
@@ -776,6 +776,7 @@ export class CodexNativeThreadSession {
 }
 const codexNativeCompleteHistoryProofs = new WeakMap();
 const codexNativeHistoryReaders = new WeakMap();
+const CODEX_NATIVE_HISTORY_INSPECTION_CACHE_TTL_MS = 5_000;
 const startCodexNativeHistoryProcess = startCodexNativeAppServer;
 const readCodexNativeHistoryThread = CodexNativeThreadController.read;
 function bindCodexNativeCompleteHistoryProof(page) {
@@ -807,6 +808,7 @@ class CodexNativeAgentRuntimeAdapter {
     displayName;
     enabled;
     modelCatalogCache;
+    historyInspectionCache = new Map();
     authController;
     constructor(instanceId, config, displayName, enabled) {
         this.instanceId = instanceId;
@@ -871,6 +873,29 @@ class CodexNativeAgentRuntimeAdapter {
     async disposeAuth() {
         await this.authController.dispose();
     }
+    historyInspectionCacheKey(input, threadId) {
+        return `${input.binding.piboSessionId}\0${input.workspace}\0${threadId}`;
+    }
+    cacheHistoryInspection(cacheKey, inspection) {
+        this.historyInspectionCache.set(cacheKey, {
+            expiresAt: Date.now() + CODEX_NATIVE_HISTORY_INSPECTION_CACHE_TTL_MS,
+            value: Promise.resolve(inspection),
+        });
+    }
+    async readHistoryInspection(input, threadId) {
+        try {
+            const readHistory = codexNativeHistoryReaders.get(this);
+            if (!readHistory)
+                throw new Error("Codex built-in history reader is unavailable.");
+            const thread = await readHistory(input.binding.piboSessionId, input.workspace, threadId, false);
+            return inspectCodexThreadHistory(this.instanceId, input.binding, thread);
+        }
+        catch (error) {
+            return unavailableCodexThreadHistoryInspection(this.instanceId, input.binding, error instanceof CodexNativeThreadMissingError ? "codex_native_history_not_found" : "codex_native_history_unavailable", error instanceof CodexNativeThreadMissingError
+                ? "The bound Codex thread is unavailable for native history inspection."
+                : "Codex native history inspection failed safely.");
+        }
+    }
     validateProfile(input) {
         const diagnostics = [];
         if (input.profile.runtimeInstanceId !== this.instanceId) {
@@ -1123,18 +1148,18 @@ class CodexNativeAgentRuntimeAdapter {
         if (!threadId) {
             return unavailableCodexThreadHistoryInspection(this.instanceId, input.binding, "codex_native_history_thread_id_missing", "The Codex runtime binding has no native thread id for history lookup.");
         }
-        try {
-            const readHistory = codexNativeHistoryReaders.get(this);
-            if (!readHistory)
-                throw new Error("Codex built-in history reader is unavailable.");
-            const thread = await readHistory(input.binding.piboSessionId, input.workspace, threadId, false);
-            return inspectCodexThreadHistory(this.instanceId, input.binding, thread);
-        }
-        catch (error) {
-            return unavailableCodexThreadHistoryInspection(this.instanceId, input.binding, error instanceof CodexNativeThreadMissingError ? "codex_native_history_not_found" : "codex_native_history_unavailable", error instanceof CodexNativeThreadMissingError
-                ? "The bound Codex thread is unavailable for native history inspection."
-                : "Codex native history inspection failed safely.");
+        const cacheKey = this.historyInspectionCacheKey(input, threadId);
+        const cached = this.historyInspectionCache.get(cacheKey);
+        if (cached && cached.expiresAt > Date.now())
+            return await cached.value;
+        const value = this.readHistoryInspection(input, threadId);
+        const entry = { expiresAt: Date.now() + CODEX_NATIVE_HISTORY_INSPECTION_CACHE_TTL_MS, value };
+        this.historyInspectionCache.set(cacheKey, entry);
+        const inspection = await value;
+        if (!inspection.available && this.historyInspectionCache.get(cacheKey) === entry) {
+            this.historyInspectionCache.delete(cacheKey);
         }
+        return inspection;
     }
     async readHistory(input) {
         const threadId = input.binding.nativeSessionId;
@@ -1149,21 +1174,26 @@ class CodexNativeAgentRuntimeAdapter {
                 inspection,
             };
         }
+        const cacheKey = this.historyInspectionCacheKey(input, threadId);
         try {
             const readHistory = codexNativeHistoryReaders.get(this);
             if (!readHistory)
                 throw new Error("Codex built-in history reader is unavailable.");
             const thread = await readHistory(input.binding.piboSessionId, input.workspace, threadId, true);
-            return bindCodexNativeCompleteHistoryProof(pageCodexThreadHistory({
+            const page = pageCodexThreadHistory({
                 runtimeInstanceId: this.instanceId,
                 binding: input.binding,
                 thread,
                 cursor: input.cursor,
                 beforeTimestamp: input.beforeTimestamp,
                 limit: input.limit,
-            }));
+            });
+            if (page.inspection)
+                this.cacheHistoryInspection(cacheKey, page.inspection);
+            return bindCodexNativeCompleteHistoryProof(page);
         }
         catch (error) {
+            this.historyInspectionCache.delete(cacheKey);
             if (error instanceof CodexNativeThreadMissingError) {
                 const inspection = unavailableCodexThreadHistoryInspection(this.instanceId, input.binding, "codex_native_history_not_found", "The bound Codex thread is unavailable for native history reads.");
                 return {

package/dist/agent-runtimes/codex-native/process.js

@@ -277,7 +277,7 @@ function parseCodexVersion(output) {
     };
 }
 function versionSupported(version) {
-    return !version.prerelease && version.major === 0 && version.minor === 147 && version.patch >= 0;
+    return !version.prerelease && version.major === 0 && version.minor === 153 && version.patch >= 2;
 }
 export async function diagnoseCodexNativeRuntime(config, runtimeInstanceId, options = {}) {
     const diagnostics = [];

package/dist/agent-runtimes/codex-native/protocol-version.js

@@ -1,7 +1,7 @@
-export const CODEX_APP_SERVER_VERSION = "0.147.0";
-export const CODEX_APP_SERVER_SUPPORTED_RANGE = ">=0.147.0 <0.148.0";
+export const CODEX_APP_SERVER_VERSION = "0.153.2";
+export const CODEX_APP_SERVER_SUPPORTED_RANGE = ">=0.153.2 <0.154.0";
 export const CODEX_APP_SERVER_PROTOCOL_NAME = "codex-app-server-v2";
-export const CODEX_APP_SERVER_SCHEMA_SHA256 = "f72b2caa3cbfa4298de9e85c62dda6dfbaf2266ffeb916fed30615ca69ff8c74";
-export const CODEX_APP_SERVER_V2_SCHEMA_SHA256 = "f3dec1e031d99a420b137b903f02196d4325eece57620c925bb7130b25f168d2";
-export const CODEX_APP_SERVER_GENERATED_TYPES_INDEX_SHA256 = "1cca50b4003a6661cd211dff7c655ecf03ecfe4c7bba8e72a5bbc9af33ee5086";
-export const CODEX_APP_SERVER_GENERATED_BUNDLE_SHA256 = "ab890a36f19a6b48284c34dd46bb5154ccc34185c4c4d0f05c16e0bf113956a1";
+export const CODEX_APP_SERVER_SCHEMA_SHA256 = "e8284c5cb8157554a3dd1e035aadbd4325aea501af56887e9c2e12eb1b9b9448";
+export const CODEX_APP_SERVER_V2_SCHEMA_SHA256 = "d3eace08be5dca386bfd1f1e8df650058b4113f1e10870a284d775d75517576a";
+export const CODEX_APP_SERVER_GENERATED_TYPES_INDEX_SHA256 = "cad2c5b82900b6bc58cdc36fdb756e2ab8a49274147af96a7ca7ac2aecd0db08";
+export const CODEX_APP_SERVER_GENERATED_BUNDLE_SHA256 = "7dc2b38ce79ce8e08014ae129363a4ae9626d1f0d8af47b960da11221eab5676";

package/dist/agent-runtimes/omp/process.js

@@ -4,6 +4,7 @@ import { mkdir, rm, stat, writeFile } from "node:fs/promises";
 import { dirname, join, resolve } from "node:path";
 import { protectPrivateFileSync, protectPrivatePathsSync } from "../../core/private-path.js";
 import { OmpRpcClient } from "./client.js";
+import { OMP_CLI_SUPPORTED_RANGE, OMP_CLI_VERSION } from "./protocol-version.js";
 const MAX_VERSION_OUTPUT_BYTES = 256 * 1024;
 const PRIVATE_DIRECTORY_MODE = 0o700;
 const PRIVATE_FILE_MODE = 0o600;
@@ -258,12 +259,31 @@ export async function diagnoseOmpRuntime(config, runtimeInstanceId, options = {}
         });
         return diagnostics;
     }
-    const version = probe.output.trim().split("\n").slice(-1)[0] ?? "";
+    const versionOutput = probe.output.trim().split("\n").slice(-1)[0] ?? "";
+    const versionMatch = versionOutput.match(/\bomp(?:\/|\s+)v?(\d+\.\d+\.\d+)\b/i);
+    const version = versionMatch?.[1];
+    if (!version) {
+        diagnostics.push({
+            severity: "error",
+            code: "omp_version_unreadable",
+            message: `OMP CLI returned an unrecognized version for runtime instance "${runtimeInstanceId}".`,
+        });
+        return diagnostics;
+    }
+    if (version !== OMP_CLI_VERSION) {
+        diagnostics.push({
+            severity: "error",
+            code: "omp_version_unsupported",
+            message: `OMP CLI ${version} is outside the supported range for runtime instance "${runtimeInstanceId}".`,
+            details: { version, supportedRange: OMP_CLI_SUPPORTED_RANGE },
+        });
+        return diagnostics;
+    }
     diagnostics.push({
         severity: "info",
         code: "omp_version_ok",
-        message: `OMP CLI is available for runtime instance "${runtimeInstanceId}".`,
-        details: { version: version || "unknown", private: true },
+        message: `OMP CLI ${version} is available for runtime instance "${runtimeInstanceId}".`,
+        details: { version, supportedRange: OMP_CLI_SUPPORTED_RANGE, private: true },
     });
     return diagnostics;
 }

package/dist/agent-runtimes/omp/protocol-version.js

@@ -0,0 +1,2 @@
+export const OMP_CLI_VERSION = "18.1.10";
+export const OMP_CLI_SUPPORTED_RANGE = "=18.1.10";

package/dist/agent-runtimes/pi/adapter.js

@@ -14,7 +14,7 @@ import { importPortableHistoryIntoPi } from "./portable-history.js";
 import { piIntentTracingEnabled } from "./intent-tracing.js";
 import { isWebSearchProviderTool } from "../../tools/web-search.js";
 const PI_ADAPTER_ID = "pi";
-export const PI_PROTOCOL_VERSION = "0.84.2";
+export const PI_PROTOCOL_VERSION = "0.85.0";
 const piCompleteHistoryProofs = new WeakMap();
 function bindPiCompleteHistoryProof(page) {
     const claim = page.reconciliationProof;

package/dist/agent-runtimes/pi/model-catalog.js

@@ -2,7 +2,7 @@ import { ModelRegistry, createAgentSessionServices, } from "@earendil-works/pi-c
 import { registerMiniMaxProvider } from "../../providers/minimax.js";
 import { registerGlmProvider } from "../../providers/glm.js";
 import { registerQwenTokenPlanProvider } from "../../providers/qwen-token-plan.js";
-import { registerOpenAiGpt56Models } from "../../providers/openai-gpt56.js";
+import { registerOpenAiSupplementalModels } from "../../providers/openai-gpt56.js";
 import { piAuthMethodsForProvider } from "./auth.js";
 export function buildModelCatalogFromRegistry(registry) {
     const providers = new Map();
@@ -52,7 +52,7 @@ export async function loadModelCatalogWithServices(createServices, cwd = process
 }
 export async function loadModelCatalog(cwd = process.cwd()) {
     return loadModelCatalogWithServices(createAgentSessionServices, cwd, (registry) => {
-        registerOpenAiGpt56Models(registry);
+        registerOpenAiSupplementalModels(registry);
         registerMiniMaxProvider(registry);
         registerGlmProvider(registry);
         registerQwenTokenPlanProvider(registry);

package/dist/agent-runtimes/pi/runtime.js

@@ -21,7 +21,7 @@ import { DEFAULT_USER_TIMEZONE } from "../../core/user-settings.js";
 import { registerMiniMaxProvider } from "../../providers/minimax.js";
 import { registerGlmProvider } from "../../providers/glm.js";
 import { registerQwenTokenPlanProvider } from "../../providers/qwen-token-plan.js";
-import { registerOpenAiGpt56Models } from "../../providers/openai-gpt56.js";
+import { registerOpenAiSupplementalModels } from "../../providers/openai-gpt56.js";
 import { PIBO_APP_CONTEXT } from "../../app-context.js";
 import { RuntimeSessionRegistry } from "../../tools/runtime/registry.js";
 import { CodexBrowserSessionController } from "../../tools/codex-browser.js";
@@ -123,7 +123,10 @@ function getBuiltinToolAllowlist(profile, customTools) {
     if (profile.builtinTools === "disabled")
         return undefined;
     const defaultBuiltinTools = new Set(DEFAULT_BUILTIN_TOOL_NAMES);
-    const selectedBuiltinTools = profile.builtinToolNames.filter((name) => defaultBuiltinTools.has(name));
+    const replacedBuiltinTools = new Set(profile.tools
+        .filter((tool) => tool.enabled !== false)
+        .flatMap((tool) => tool.replacesBuiltinTools ?? []));
+    const selectedBuiltinTools = profile.builtinToolNames.filter((name) => defaultBuiltinTools.has(name) && !replacedBuiltinTools.has(name));
     if (selectedBuiltinTools.length === DEFAULT_BUILTIN_TOOL_NAMES.length)
         return undefined;
     return [...selectedBuiltinTools, ...customTools.map((tool) => tool.name)];
@@ -253,7 +256,7 @@ export async function createPiboRuntime(options = {}) {
         runtimeSettingsManager = services.settingsManager;
         applyPiboRuntimeRetryDefaults(services.settingsManager, options.retryDefaults);
         const modelRegistry = new ModelRegistry(services.modelRuntime);
-        registerOpenAiGpt56Models(modelRegistry);
+        registerOpenAiSupplementalModels(modelRegistry);
         registerMiniMaxProvider(modelRegistry);
         registerGlmProvider(modelRegistry);
         registerQwenTokenPlanProvider(modelRegistry);

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

@@ -314,7 +314,7 @@ export function sessionActionResource(pathname) {
     if (parts.length !== 2 || !parts[0])
         return undefined;
     const action = parts[1];
-    if (action !== "read" && action !== "kill" && action !== "kill-all" && action !== "runtime-binding" && action !== "fork-candidates")
+    if (action !== "read" && action !== "kill" && action !== "kill-all" && action !== "runtime-binding" && action !== "fork-candidates" && action !== "order")
         return undefined;
     try {
         return { piboSessionId: decodeURIComponent(parts[0]), action };

package/dist/apps/chat/chat-request-normalizers.js

@@ -5,7 +5,7 @@ import { DEFAULT_AGENT_RUNTIME_INSTANCE_ID } from "../../core/profiles.js";
 import { isPiboThinkingLevel } from "../../core/thinking.js";
 import { PiboWebHttpError } from "../../web/http.js";
 import { listPiPackages } from "../../pi-packages/store.js";
-import { withChatWebArchived } from "./session-metadata.js";
+import { withChatWebArchived, withChatWebSessionPinned } from "./session-metadata.js";
 import { isDefaultPiboRoom, withPiboRoomArchived, withPiboRoomWorkspace } from "./types/rooms.js";
 import { isValidCustomAgentName } from "./agent-store.js";
 export function normalizeRoomName(value, fallback = "New Chat") {
@@ -670,7 +670,12 @@ export function createSessionUpdate(context, session, body) {
     const title = normalizeSessionTitle(body.title);
     if (title !== undefined)
         update.title = title;
-    const metadata = metadataWithArchiveState(session, body.archived);
+    let metadata = metadataWithArchiveState(session, body.archived);
+    if (body.pinned !== undefined) {
+        if (typeof body.pinned !== "boolean")
+            throw new PiboWebHttpError("Session pinned flag must be boolean", 400);
+        metadata = withChatWebSessionPinned(metadata ?? session.metadata, body.pinned);
+    }
     if (metadata)
         update.metadata = metadata;
     if (body.profile !== undefined) {

package/dist/apps/chat/data/read-state-service.js

@@ -16,21 +16,23 @@ export class ChatReadStateService {
     }
     countUnreadMessagesBySession(input) {
         const counts = new Map();
-        if (!input.piboSessionIds.length)
+        const uniqueIds = [...new Set(input.piboSessionIds)];
+        if (!uniqueIds.length)
             return counts;
-        for (let offset = 0; offset < input.piboSessionIds.length; offset += 400) {
-            const ids = [...new Set(input.piboSessionIds)].slice(offset, offset + 400);
-            const placeholders = ids.map(() => "?").join(", ");
+        for (let offset = 0; offset < uniqueIds.length; offset += 400) {
+            const ids = uniqueIds.slice(offset, offset + 400);
+            const requested = ids.map(() => "(?)").join(", ");
             const rows = this.store.db.prepare(`
+				WITH requested(session_id) AS (VALUES ${requested})
 				SELECT e.session_id, COUNT(*) AS count
-				FROM event_log e
-				LEFT JOIN app_session_read_state reads ON reads.session_id = e.session_id
-				WHERE e.session_id IN (${placeholders})
+				FROM requested r
+				LEFT JOIN app_session_read_state reads ON reads.session_id = r.session_id
+				JOIN event_log e
+					ON e.session_id = r.session_id
 					AND e.stream_id > COALESCE(reads.last_read_stream_id, 0)
-					AND (
-						(e.retention_class = 'chat_message' AND e.type IN ('user.message.accepted', 'assistant_message'))
-						OR e.type = 'session_error'
-					)
+				WHERE
+					(e.retention_class = 'chat_message' AND e.type IN ('user.message.accepted', 'assistant_message'))
+					OR e.type = 'session_error'
 				GROUP BY e.session_id
 			`).all(...ids);
             for (const row of rows)

package/dist/apps/chat/session-metadata.js

@@ -1,7 +1,26 @@
 const CHAT_WEB_ARCHIVED_AT_KEY = "chatWebArchivedAt";
+const CHAT_WEB_PINNED_AT_KEY = "chatWebPinnedAt";
+const CHAT_WEB_SIDEBAR_ORDER_KEY = "chatWebSidebarOrder";
 export function isChatWebSessionArchived(session) {
     return typeof session.metadata?.[CHAT_WEB_ARCHIVED_AT_KEY] === "string";
 }
+export function isChatWebSessionPinned(session) {
+    return typeof session.metadata?.[CHAT_WEB_PINNED_AT_KEY] === "string";
+}
+export function chatWebSessionSidebarOrder(session) {
+    const value = session.metadata?.[CHAT_WEB_SIDEBAR_ORDER_KEY];
+    return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+export function compareChatWebSessionsBySidebarOrder(left, right) {
+    const pinnedDifference = Number(isChatWebSessionPinned(right)) - Number(isChatWebSessionPinned(left));
+    if (pinnedDifference !== 0)
+        return pinnedDifference;
+    const leftOrder = chatWebSessionSidebarOrder(left) ?? (Date.parse(left.createdAt) || 0);
+    const rightOrder = chatWebSessionSidebarOrder(right) ?? (Date.parse(right.createdAt) || 0);
+    if (leftOrder !== rightOrder)
+        return rightOrder - leftOrder;
+    return right.id.localeCompare(left.id);
+}
 export function withChatWebArchived(metadata, archived) {
     const next = { ...(metadata ?? {}) };
     if (archived) {
@@ -12,3 +31,14 @@ export function withChatWebArchived(metadata, archived) {
     }
     return next;
 }
+export function withChatWebSessionPinned(metadata, pinned, order = Date.now()) {
+    const next = { ...(metadata ?? {}), [CHAT_WEB_SIDEBAR_ORDER_KEY]: order };
+    if (pinned)
+        next[CHAT_WEB_PINNED_AT_KEY] = new Date().toISOString();
+    else
+        delete next[CHAT_WEB_PINNED_AT_KEY];
+    return next;
+}
+export function withChatWebSessionSidebarOrder(metadata, order) {
+    return { ...(metadata ?? {}), [CHAT_WEB_SIDEBAR_ORDER_KEY]: order };
+}

package/dist/apps/chat/trace.js

@@ -3,7 +3,7 @@ import { PI_HISTORY_PAGE_MAX_BYTES, PI_HISTORY_SCAN_MAX_BYTES, PI_HISTORY_TAIL_M
 import { isPiboThinkingLevel } from "../../core/thinking.js";
 import { isBuiltInHistoryReconciliationProof } from "../../agent-runtimes/history-proof.js";
 import { buildTraceViewFromEvents, traceNodesFromHistoryEntries } from "../../shared/trace-engine.js";
-import { isChatWebSessionArchived } from "./session-metadata.js";
+import { chatWebSessionSidebarOrder, isChatWebSessionArchived, isChatWebSessionPinned } from "./session-metadata.js";
 import { workflowSessionKindFromMetadata } from "../../sessions/workflow-session-kind.js";
 export const TRACE_PROJECTION_VERSION = "runtime-history-v2-incomplete-status";
 export { compareTraceNodes, sortTraceNodes, nestTraceNodes, flattenTraceNodes, mapTraceNodesById, buildTraceViewFromEvents, traceNodesFromHistoryEntries, } from "../../shared/trace-engine.js";
@@ -34,7 +34,10 @@ export async function buildSessionNodes(sessions, indexItems, _cwd = process.cwd
             workflowSessionKind: workflowSessionKindFromMetadata(session.metadata),
             title: createSessionTitle(session, historyMetadataFromInspection(inspection)),
             subtitle: session.id,
+            createdAt: session.createdAt,
             archived: isChatWebSessionArchived(session),
+            pinned: isChatWebSessionPinned(session),
+            sidebarOrder: chatWebSessionSidebarOrder(session),
             status: sessionNodeStatus(indexed?.status),
             lastActivityAt: indexed?.lastActivityAt ?? indexed?.createdAt ?? session.createdAt,
             unreadCount: unreadCounts.get(session.id) || undefined,
@@ -70,7 +73,7 @@ export async function buildSessionNodes(sessions, indexItems, _cwd = process.cwd
         });
     }
     const sortNodes = (items) => {
-        items.sort((left, right) => (right.lastActivityAt ?? "").localeCompare(left.lastActivityAt ?? ""));
+        items.sort(compareSessionNodesBySidebarOrder);
         for (const item of items) {
             item.derivedSessions.sort((left, right) => (right.lastActivityAt ?? "").localeCompare(left.lastActivityAt ?? ""));
             sortNodes(item.children);
@@ -79,6 +82,16 @@ export async function buildSessionNodes(sessions, indexItems, _cwd = process.cwd
     sortNodes(roots);
     return roots;
 }
+function compareSessionNodesBySidebarOrder(left, right) {
+    const pinnedDifference = Number(Boolean(right.pinned)) - Number(Boolean(left.pinned));
+    if (pinnedDifference !== 0)
+        return pinnedDifference;
+    const leftOrder = left.sidebarOrder ?? (Date.parse(left.createdAt ?? "") || 0);
+    const rightOrder = right.sidebarOrder ?? (Date.parse(right.createdAt ?? "") || 0);
+    if (leftOrder !== rightOrder)
+        return rightOrder - leftOrder;
+    return right.piboSessionId.localeCompare(left.piboSessionId);
+}
 function sessionNodeStatus(indexedStatus) {
     return indexedStatus ?? "idle";
 }