@pasko70/pibo 3.2.7 → 3.4.0

package/dist/agent-runtime/capabilities.js

@@ -6,6 +6,7 @@ const BOOLEAN_CAPABILITY_PATHS = [
     "lifecycle.attach",
     "lifecycle.listNativeSessions",
     "lifecycle.fork",
+    "lifecycle.forkWhileRunning",
     "lifecycle.clone",
     "lifecycle.tree",
     "input.text",
@@ -107,6 +108,9 @@ export function validateAgentRuntimeCapabilities(value) {
     for (const path of DELIVERY_CAPABILITY_PATHS)
         validateDelivery(path, readPath(value, path), errors);
     const persistent = readPath(value, "lifecycle.persistent");
+    if (readPath(value, "lifecycle.forkWhileRunning") === true && readPath(value, "lifecycle.fork") !== true) {
+        errors.push("lifecycle.forkWhileRunning requires lifecycle.fork");
+    }
     for (const path of ["lifecycle.resume", "lifecycle.attach"]) {
         if (readPath(value, path) === true && persistent !== true)
             errors.push(`${path} requires lifecycle.persistent`);
@@ -223,6 +227,7 @@ export function createMinimalAgentRuntimeCapabilities() {
             attach: false,
             listNativeSessions: false,
             fork: false,
+            forkWhileRunning: false,
             clone: false,
             tree: false,
         },

package/dist/agent-runtime/contract.js

@@ -43,6 +43,8 @@ export function validateAgentRuntimeSessionContract(session) {
     if (capabilities) {
         requireMethod(capabilities.lifecycle.listNativeSessions, "lifecycle.listNativeSessions", "listSessions");
         requireMethod(capabilities.lifecycle.fork, "lifecycle.fork", "forkSession");
+        requireMethod(capabilities.lifecycle.forkWhileRunning, "lifecycle.forkWhileRunning", "getForkCandidatesWhileRunning");
+        requireMethod(capabilities.lifecycle.forkWhileRunning, "lifecycle.forkWhileRunning", "forkSessionWhileRunning");
         requireMethod(capabilities.lifecycle.clone, "lifecycle.clone", "cloneSession");
         requireMethod(capabilities.lifecycle.tree, "lifecycle.tree", "getSessionTree");
         requireMethod(capabilities.lifecycle.tree, "lifecycle.tree", "navigateSessionTree");

package/dist/agent-runtime/routed-session.js

@@ -87,6 +87,7 @@ function nativeOperationToPiCompatibility(session, piboSessionId, result) {
         selectedText: result.selectedText,
         editorText: result.editorText,
         summaryEntryId: result.summaryEntryId,
+        sourceSessionUnchanged: result.sourceSessionUnchanged,
     };
 }
 function nativeSessionInfoToPiCompatibility(session, info) {
@@ -137,6 +138,7 @@ export class RuntimeRoutedSession {
     activeThinkingIndex;
     nextThinkingIndex = 0;
     sessionIdentityOperationInFlight = false;
+    forkWhileRunningOperationInFlight = false;
     forkCandidatesRequest;
     primaryModel;
     modelFallbacks;
@@ -215,10 +217,23 @@ export class RuntimeRoutedSession {
                 : event.action === "session.switch"
                     ? "switch"
                     : undefined;
+        const status = this.getStatus();
+        const sourceHasWork = status.processing || status.streaming || status.queuedMessages > 0;
+        const forkWhileRunning = event.action === "session.fork"
+            && sourceHasWork
+            && Boolean(this.runtimeSession.controls?.forkSessionWhileRunning);
         if (sessionIdentityOperation) {
-            this.assertSessionIdentityOperationIdle(sessionIdentityOperation);
-            this.sessionIdentityOperationInFlight = true;
-            this.notifyState();
+            if (forkWhileRunning) {
+                if (this.forkWhileRunningOperationInFlight) {
+                    throw new Error("Pibo session already has a running-safe fork in progress.");
+                }
+                this.forkWhileRunningOperationInFlight = true;
+            }
+            else {
+                this.assertSessionIdentityOperationIdle(sessionIdentityOperation);
+                this.sessionIdentityOperationInFlight = true;
+                this.notifyState();
+            }
         }
         try {
             if (sessionIdentityOperation)
@@ -237,7 +252,10 @@ export class RuntimeRoutedSession {
             return output;
         }
         finally {
-            if (sessionIdentityOperation) {
+            if (forkWhileRunning) {
+                this.forkWhileRunningOperationInFlight = false;
+            }
+            else if (sessionIdentityOperation) {
                 this.sessionIdentityOperationInFlight = false;
                 this.notifyState();
                 this.startDrain();
@@ -368,7 +386,25 @@ export class RuntimeRoutedSession {
     async getForkCandidates() {
         if (this.forkCandidatesRequest)
             return await this.forkCandidatesRequest;
-        this.assertSessionIdentityOperationIdle("inspect fork candidates");
+        if (this.sessionIdentityOperationInFlight) {
+            throw new Error("Pibo session already has a session identity operation in progress; cannot inspect fork candidates.");
+        }
+        const status = this.getStatus();
+        const sourceHasWork = status.processing || status.streaming || status.queuedMessages > 0;
+        if (sourceHasWork) {
+            const getForkCandidatesWhileRunning = this.runtimeSession.controls?.getForkCandidatesWhileRunning;
+            if (!getForkCandidatesWhileRunning)
+                this.assertSessionWorkIdle("inspect fork candidates");
+            const request = Promise.resolve().then(async () => await getForkCandidatesWhileRunning());
+            this.forkCandidatesRequest = request;
+            try {
+                return await request;
+            }
+            finally {
+                if (this.forkCandidatesRequest === request)
+                    this.forkCandidatesRequest = undefined;
+            }
+        }
         const getForkCandidates = this.runtimeSession.controls?.getForkCandidates;
         if (!getForkCandidates)
             throw runtimeCapabilityError(this.runtimeSession, "native session fork candidates");
@@ -388,6 +424,12 @@ export class RuntimeRoutedSession {
         }
     }
     async forkSession(entryId) {
+        if (this.forkWhileRunningOperationInFlight) {
+            const forkSessionWhileRunning = this.runtimeSession.controls?.forkSessionWhileRunning;
+            if (!forkSessionWhileRunning)
+                throw runtimeCapabilityError(this.runtimeSession, "forking completed history while running");
+            return nativeOperationToPiCompatibility(this.runtimeSession, this.piboSessionId, await forkSessionWhileRunning(entryId));
+        }
         this.assertSessionWorkIdle("fork");
         const forkSession = this.runtimeSession.controls?.forkSession;
         if (!forkSession)
@@ -436,11 +478,26 @@ export class RuntimeRoutedSession {
         return nativeOperationToPiCompatibility(this.runtimeSession, this.piboSessionId, await switchSession(params));
     }
     async setModel(model) {
-        const setModel = this.runtimeSession.controls?.setModel;
+        const selected = await this.setRuntimeModelPreservingReasoning(model);
+        this.primaryModel = { ...selected };
+        return selected;
+    }
+    async setRuntimeModelPreservingReasoning(model) {
+        const controls = this.runtimeSession.controls;
+        const setModel = controls?.setModel;
         if (!setModel)
             throw runtimeCapabilityError(this.runtimeSession, "in-session model switching");
+        const priorReasoning = controls.getReasoning?.() ?? this.runtimeSession.getStatus().reasoning;
         const selected = await setModel(model);
-        this.primaryModel = { ...selected };
+        if (!priorReasoning?.supported || !priorReasoning.value || !controls.setReasoning)
+            return selected;
+        const currentReasoning = controls.getReasoning?.() ?? this.runtimeSession.getStatus().reasoning;
+        if (!currentReasoning?.supported || currentReasoning.value === priorReasoning.value)
+            return selected;
+        if (currentReasoning.availableValues?.length && !currentReasoning.availableValues.includes(priorReasoning.value)) {
+            return selected;
+        }
+        controls.setReasoning(priorReasoning.value);
         return selected;
     }
     setThinkingLevel(level) {
@@ -751,9 +808,9 @@ export class RuntimeRoutedSession {
         }
     }
     async promptWithModelFallbacks(event, inFlight) {
-        const setModel = this.runtimeSession.controls?.setModel;
+        const canSetModel = Boolean(this.runtimeSession.controls?.setModel);
         const fallbackModels = this.modelFallbacks.filter((model) => !sameModel(model, this.primaryModel));
-        if (!setModel || fallbackModels.length === 0) {
+        if (!canSetModel || fallbackModels.length === 0) {
             await this.runtimeSession.prompt({
                 text: event.text,
                 source: promptSource(event.source),
@@ -770,7 +827,7 @@ export class RuntimeRoutedSession {
                     return;
                 if (attempt > 0) {
                     try {
-                        await setModel(fallbackModels[attempt - 1]);
+                        await this.setRuntimeModelPreservingReasoning(fallbackModels[attempt - 1]);
                         switchedModel = true;
                     }
                     catch {
@@ -807,7 +864,7 @@ export class RuntimeRoutedSession {
             this.pendingProviderFailure = undefined;
             if (switchedModel && this.primaryModel && !this.disposed) {
                 try {
-                    await setModel(this.primaryModel);
+                    await this.setRuntimeModelPreservingReasoning(this.primaryModel);
                 }
                 catch (error) {
                     console.warn(`Failed to restore primary model for Pibo session "${this.piboSessionId}": ${errorMessage(error)}`);

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

@@ -88,6 +88,7 @@ function codexNativeCapabilities(structuredUserInput) {
             attach: true,
             listNativeSessions: true,
             fork: true,
+            forkWhileRunning: true,
             clone: true,
             tree: false,
         },
@@ -112,7 +113,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: {
@@ -313,6 +314,7 @@ export class CodexNativeThreadSession {
             getCurrentSession: () => this.threads.getSnapshot(this.runtimeInstanceId),
             listSessions: () => this.threads.list(this.runtimeInstanceId, this.cwd),
             getForkCandidates: () => this.threads.getForkCandidates(),
+            getForkCandidatesWhileRunning: () => this.threads.getForkCandidatesWhileRunning(),
             forkSession: async (entryId) => await this.runIdleOperation(async () => {
                 const result = await this.threads.fork(this.runtimeInstanceId, this.cwd, entryId, async (threadId) => await this.resourceDelivery.verifyThread(this.process.client, threadId));
                 if (result.current.nativeSessionId) {
@@ -321,6 +323,7 @@ export class CodexNativeThreadSession {
                 }
                 return result;
             }),
+            forkSessionWhileRunning: async (entryId) => await this.threads.forkWhileRunning(this.runtimeInstanceId, this.cwd, entryId, async (threadId) => await this.resourceDelivery.verifyThread(this.process.client, threadId)),
             cloneSession: async () => await this.runIdleOperation(async () => {
                 const result = await this.threads.clone(this.runtimeInstanceId, this.cwd, async (threadId) => await this.resourceDelivery.verifyThread(this.process.client, threadId));
                 this.settings.attachThread(this.threads.thread.id, this.threads.configuration);

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/codex-native/thread.js

@@ -303,6 +303,12 @@ export class CodexNativeThreadController {
     getForkCandidates() {
         return codexThreadForkCandidates(this.currentThread);
     }
+    getForkCandidatesWhileRunning() {
+        return codexThreadForkCandidates({
+            ...this.currentThread,
+            turns: this.currentThread.turns.filter((turn) => turn.status !== "inProgress"),
+        });
+    }
     setStatus(status) {
         this.currentThread = { ...this.currentThread, status: structuredClone(status) };
         this.knownThreads.set(this.currentThread.id, structuredClone(this.currentThread));
@@ -372,10 +378,24 @@ export class CodexNativeThreadController {
             text: legacyText ?? `Codex turn ${entryId}`,
         });
     }
+    async forkWhileRunning(runtimeInstanceId, workspace, entryId, validateThread) {
+        if (!entryId.trim())
+            throw new Error("Codex thread fork requires a native user-message id.");
+        const target = codexThreadForkTargets({
+            ...this.currentThread,
+            turns: this.currentThread.turns.filter((turn) => turn.status !== "inProgress"),
+        }).find((candidate) => candidate.entryId === entryId);
+        if (!target)
+            throw new Error("Fork target is not a completed user message.");
+        const result = !target.previousTurnId
+            ? this.branchBeforeFirstTurn(runtimeInstanceId, workspace, target)
+            : await this.forkAt(runtimeInstanceId, workspace, target.previousTurnId, validateThread, target, false);
+        return { ...result, sourceSessionUnchanged: true };
+    }
     async clone(runtimeInstanceId, workspace, validateThread) {
         return await this.forkAt(runtimeInstanceId, workspace, undefined, validateThread);
     }
-    async forkAt(runtimeInstanceId, workspace, lastTurnId, validateThread, selectedTarget) {
+    async forkAt(runtimeInstanceId, workspace, lastTurnId, validateThread, selectedTarget, adoptFork = true) {
         const previousThread = this.currentThread;
         const previous = codexThreadSnapshot(runtimeInstanceId, previousThread);
         const params = {
@@ -398,10 +418,12 @@ export class CodexNativeThreadController {
                 throw new CodexNativeThreadProtocolError("Codex thread/fork returned the source thread id.");
             }
             await validateThread?.(forked.id);
-            this.knownThreads.set(previousThread.id, structuredClone(previousThread));
+            if (adoptFork) {
+                this.knownThreads.set(previousThread.id, structuredClone(previousThread));
+                this.currentThread = forked;
+                this.currentConfiguration = selected.configuration;
+            }
             this.knownThreads.set(forked.id, structuredClone(forked));
-            this.currentThread = forked;
-            this.currentConfiguration = selected.configuration;
             return {
                 previous,
                 current: codexThreadSnapshot(runtimeInstanceId, forked),

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

@@ -50,6 +50,7 @@ function ompCapabilities() {
             attach: true,
             listNativeSessions: true,
             fork: true,
+            forkWhileRunning: false,
             clone: false,
             tree: false,
         },

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;
@@ -46,6 +46,7 @@ export const PI_AGENT_RUNTIME_CAPABILITIES = {
         attach: true,
         listNativeSessions: true,
         fork: true,
+        forkWhileRunning: true,
         clone: true,
         tree: true,
     },
@@ -176,6 +177,7 @@ function nativeOperationFromPi(runtimeInstanceId, result) {
         previous: nativeSnapshotFromPi(runtimeInstanceId, result.previous),
         current: nativeSnapshotFromPi(runtimeInstanceId, result.current),
         cancelled: result.cancelled,
+        sourceSessionUnchanged: result.sourceSessionUnchanged,
         selectedText: result.selectedText,
         editorText: result.editorText,
         summaryEntryId: result.summaryEntryId,
@@ -439,7 +441,9 @@ class PiAgentRuntimeSession {
             getCurrentSession: () => nativeSnapshotFromPi(this.runtimeInstanceId, this.routed.getCurrentSession()),
             listSessions: async () => (await this.routed.listSessions()).map((info) => nativeSessionInfoFromPi(this.runtimeInstanceId, info)),
             getForkCandidates: () => this.routed.getForkCandidates(),
+            getForkCandidatesWhileRunning: () => this.routed.getForkCandidatesWhileRunning(),
             forkSession: async (entryId) => nativeOperationFromPi(this.runtimeInstanceId, await this.routed.forkSession(entryId)),
+            forkSessionWhileRunning: async (entryId) => nativeOperationFromPi(this.runtimeInstanceId, await this.routed.forkSessionWhileRunning(entryId)),
             cloneSession: async () => nativeOperationFromPi(this.runtimeInstanceId, await this.routed.cloneSession()),
             getSessionTree: () => {
                 const result = this.routed.getSessionTree();

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/routed-session.js

@@ -1239,6 +1239,52 @@ export class RoutedSession {
         this.assertSessionIdentityOperationIdle("inspect fork candidates");
         return this.runtime.session.getUserMessagesForForking();
     }
+    getForkCandidatesWhileRunning() {
+        const candidates = this.runtime.session.getUserMessagesForForking();
+        return this.getStatus().processing || this.getStatus().streaming
+            ? candidates.slice(0, -1)
+            : candidates;
+    }
+    async forkSessionWhileRunning(entryId) {
+        this.assertActive();
+        const sourceManager = this.runtime.session.sessionManager;
+        const sourceFile = sourceManager.getSessionFile();
+        if (!sourceManager.isPersisted() || !sourceFile || !existsSync(sourceFile)) {
+            throw new Error("A running Pi session can only fork from persisted history.");
+        }
+        const selected = this.getForkCandidatesWhileRunning().find((candidate) => candidate.entryId === entryId);
+        if (!selected)
+            throw new Error("Fork target is not a completed user message.");
+        const selectedEntry = sourceManager.getEntry(entryId);
+        if (!selectedEntry || selectedEntry.type !== "message" || selectedEntry.message.role !== "user") {
+            throw new Error("Invalid entry ID for forking");
+        }
+        const previous = this.createSessionSnapshot();
+        const targetLeafId = selectedEntry.parentId;
+        let forkedManager;
+        if (!targetLeafId) {
+            forkedManager = SessionManager.create(this.runtime.cwd, sourceManager.getSessionDir());
+            forkedManager.newSession({ parentSession: sourceFile });
+        }
+        else {
+            forkedManager = SessionManager.open(sourceFile, sourceManager.getSessionDir(), this.runtime.cwd);
+            if (!forkedManager.getEntry(targetLeafId)) {
+                throw new Error("Fork target is not available in persisted history.");
+            }
+            const forkedSessionPath = forkedManager.createBranchedSession(targetLeafId);
+            if (!forkedSessionPath)
+                throw new Error("Failed to create forked session");
+        }
+        materializeForkedSession(forkedManager);
+        return {
+            piboSessionId: this.piboSessionId,
+            previous,
+            current: this.createSessionManagerSnapshot(forkedManager),
+            cancelled: false,
+            sourceSessionUnchanged: true,
+            selectedText: selected.text,
+        };
+    }
     async forkSession(entryId) {
         this.assertActive();
         this.assertSessionWorkIdle("fork");
@@ -1809,13 +1855,15 @@ export class RoutedSession {
     }
     createSessionSnapshot() {
         const session = this.runtime.session;
-        const manager = session.sessionManager;
+        return this.createSessionManagerSnapshot(session.sessionManager, session.sessionName);
+    }
+    createSessionManagerSnapshot(manager, sessionName = manager.getSessionName()) {
         return {
-            piSessionId: session.sessionId,
-            sessionFile: session.sessionFile,
+            piSessionId: manager.getSessionId(),
+            sessionFile: manager.getSessionFile(),
             leafId: manager.getLeafId(),
-            cwd: this.runtime.cwd,
-            sessionName: session.sessionName,
+            cwd: manager.getCwd(),
+            sessionName,
             parentSessionFile: manager.getHeader()?.parentSession,
         };
     }

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

@@ -13,7 +13,7 @@ export function roomResourcePath(pathname) {
     try {
         const roomId = decodeURIComponent(parts[0]);
         const child = parts[1] ? decodeURIComponent(parts[1]) : undefined;
-        if (child && child !== "events" && child !== "messages" && child !== "read")
+        if (child && child !== "events" && child !== "messages" && child !== "read" && child !== "order")
             return undefined;
         return { roomId, child };
     }
@@ -246,52 +246,26 @@ export function userSkillResourceId(pathname) {
         throw new PiboWebHttpError("Invalid user skill id", 400);
     }
 }
-export function projectResourcePath(pathname) {
-    const prefix = `${CHAT_WEB_API_PREFIX}/projects/`;
-    if (!pathname.startsWith(prefix))
-        return undefined;
-    const parts = pathname.slice(prefix.length).split("/").filter(Boolean).map((part) => decodeURIComponent(part));
-    if (!parts[0])
-        return undefined;
-    return { projectId: parts[0], ...(parts[1] ? { child: parts[1] } : {}) };
-}
-export function projectWorkflowSessionStartResource(pathname) {
-    const prefix = `${CHAT_WEB_API_PREFIX}/projects/`;
+export function sessionWorkflowResource(pathname) {
+    const prefix = `${CHAT_WEB_API_PREFIX}/sessions/`;
     if (!pathname.startsWith(prefix))
         return undefined;
     const parts = pathname.slice(prefix.length).split("/");
-    if (parts.length !== 4 || !parts[0] || parts[1] !== "workflow-sessions" || !parts[2] || parts[3] !== "start")
+    if (parts.length < 2 || parts.length > 3 || !parts[0] || parts[1] !== "workflow")
         return undefined;
-    try {
-        return { projectId: decodeURIComponent(parts[0]), piboSessionId: decodeURIComponent(parts[2]) };
-    }
-    catch {
-        throw new PiboWebHttpError("Invalid Project workflow session start path", 400);
-    }
-}
-export function projectWorkflowHumanActionsResource(pathname) {
-    const prefix = `${CHAT_WEB_API_PREFIX}/projects/`;
-    if (!pathname.startsWith(prefix))
-        return undefined;
-    const parts = pathname.slice(prefix.length).split("/");
-    if (parts.length !== 4 || !parts[0] || parts[1] !== "workflow-sessions" || !parts[2] || parts[3] !== "human-actions")
+    const action = parts[2];
+    if (action !== undefined && action !== "start" && action !== "human-actions")
         return undefined;
     try {
-        return { projectId: decodeURIComponent(parts[0]), piboSessionId: decodeURIComponent(parts[2]) };
+        return {
+            piboSessionId: decodeURIComponent(parts[0]),
+            ...(action ? { action } : {}),
+        };
     }
     catch {
-        throw new PiboWebHttpError("Invalid Project workflow human-action path", 400);
+        throw new PiboWebHttpError("Invalid Workflow session path", 400);
     }
 }
-export function projectSessionResourceId(pathname) {
-    const prefix = `${CHAT_WEB_API_PREFIX}/project-sessions/`;
-    if (!pathname.startsWith(prefix))
-        return undefined;
-    const encodedId = pathname.slice(prefix.length);
-    if (!encodedId || encodedId.includes("/"))
-        return undefined;
-    return decodeURIComponent(encodedId);
-}
 export function sessionResourceId(pathname) {
     const prefix = `${CHAT_WEB_API_PREFIX}/sessions/`;
     if (!pathname.startsWith(prefix))
@@ -314,7 +288,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 };