@pasko70/pibo 3.3.0 → 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,
         },
@@ -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/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/pi/adapter.js

@@ -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/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/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))

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

@@ -1,12 +1,12 @@
 import { existsSync, statSync } from "node:fs";
-import { isAbsolute, resolve } from "node:path";
+import { isAbsolute } from "node:path";
 import { savePiboModelDefaults } from "../../core/model-defaults.js";
 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, withChatWebSessionPinned } from "./session-metadata.js";
-import { isDefaultPiboRoom, withPiboRoomArchived, withPiboRoomWorkspace } from "./types/rooms.js";
+import { isDefaultPiboRoom, withPiboRoomArchived, withPiboRoomPinned, withPiboRoomWorkspace } from "./types/rooms.js";
 import { isValidCustomAgentName } from "./agent-store.js";
 export function normalizeRoomName(value, fallback = "New Chat") {
     if (value === undefined)
@@ -595,52 +595,6 @@ export function updateChatModelDefaults(body, cwd = process.cwd()) {
         subagentFast: normalizeOptionalBoolean(body.subagentFast, "subagentFast"),
     }, cwd);
 }
-const PROJECT_SESSION_PATCH_FIELDS = new Set([
-    "title",
-    "archived",
-]);
-export function assertProjectSessionPatchFields(body) {
-    if (!body || typeof body !== "object" || Array.isArray(body))
-        throw new PiboWebHttpError("Invalid JSON body", 400);
-    for (const key of Object.keys(body)) {
-        if (!PROJECT_SESSION_PATCH_FIELDS.has(key)) {
-            throw new PiboWebHttpError(`Unsupported project session update field: ${key}. Project workflow selection and configuration are immutable; create a new configured session to change workflow, input, prompt, model, thinking, or fast-mode values.`, 400);
-        }
-    }
-}
-export function normalizeProjectPath(value) {
-    if (typeof value !== "string" || !value.trim())
-        throw new PiboWebHttpError("Project folder is required", 400);
-    let projectPath = value.trim();
-    if (projectPath === "~")
-        projectPath = process.env.HOME ?? projectPath;
-    else if (projectPath.startsWith("~/"))
-        projectPath = `${process.env.HOME ?? ""}${projectPath.slice(1)}`;
-    if (!isAbsolute(projectPath))
-        throw new PiboWebHttpError("Project folder must be an absolute path, e.g. ~/code/my-project or /home/me/code/my-project", 400);
-    return resolve(projectPath);
-}
-export function normalizeProjectDescription(value) {
-    if (value === undefined || value === null)
-        return undefined;
-    if (typeof value !== "string")
-        throw new PiboWebHttpError("Project description must be a string", 400);
-    return value.trim() || undefined;
-}
-export function normalizeProjectArchived(value) {
-    if (value === undefined)
-        return undefined;
-    if (typeof value !== "boolean")
-        throw new PiboWebHttpError("Project archived flag must be boolean", 400);
-    return value;
-}
-export function normalizeProjectSessionArchived(value) {
-    if (value === undefined)
-        return undefined;
-    if (typeof value !== "boolean")
-        throw new PiboWebHttpError("Project session archived flag must be boolean", 400);
-    return value;
-}
 export function normalizeSessionTitle(value) {
     if (value === undefined)
         return undefined;
@@ -712,6 +666,12 @@ export function createRoomUpdate(room, body) {
         metadata = withPiboRoomWorkspace(metadata, workspace ?? undefined);
         metadataChanged = true;
     }
+    if (body.pinned !== undefined) {
+        if (typeof body.pinned !== "boolean")
+            throw new PiboWebHttpError("Room pinned flag must be boolean", 400);
+        metadata = withPiboRoomPinned(metadata, body.pinned);
+        metadataChanged = true;
+    }
     if (metadataChanged)
         update.metadata = metadata;
     if (Object.keys(update).length === 0) {