@llblab/pi-kit 0.15.0 → 0.16.0

package/node_modules/@llblab/pi-telegram/dist/lib/menu-settings.js

@@ -25,12 +25,14 @@ function getVoiceReplyModeSetting(mode, configured) {
 export function buildTelegramSettingsMenuText() {
     return SETTINGS_MENU_TITLE;
 }
-export function buildThreadDisplaySettingsText(mode) {
+export function buildThreadDisplaySettingsText(mode, custom = false) {
     return [
-        `${THREAD_DISPLAY_SETTINGS_TITLE} <code>${threadDisplayModeLabel(mode)}</code>`,
+        `${THREAD_DISPLAY_SETTINGS_TITLE} <code>${custom ? "custom" : threadDisplayModeLabel(mode)}</code>`,
         "",
         "Choose how this bot profile labels Telegram tabs and Pi terminal status. Each slot is unique across this bot profile.",
         "",
+        "Set a manual name for the current Thread with /name <code>Name</code>.",
+        "",
         "<code>-</code> <code>letters</code> (default): show the unique slot, such as <b><i>A</i></b> or <b><i>B</i></b>.",
         "<code>-</code> <code>names</code>: show the generated dictionary name for the slot, such as <b><i>Anchor</i></b> or <b><i>Briar</i></b>.",
         "<code>-</code> <code>directory-title</code>: humanize the distinguishing directory path, such as <b><i>Api Tools</i></b> or <b><i>Frontend / Extensions A</i></b>.",
@@ -122,7 +124,7 @@ export function buildTimeInjectionModeSettingsText(mode) {
         "<code>-</code> <code>interval</code> (default): add time at most once per chat interval (1 hour unless configured).",
     ].join("\n");
 }
-export function buildTelegramSettingsMenuReplyMarkup(draftPreviewsEnabled, assistantRenderingModeOrVoiceReplyMode, voiceReplyModeOrTimeInjectionMode, timeInjectionModeOrSectionRegistry, sectionRegistryOrVoiceReplyModeConfigured, voiceReplyModeConfigured = true, automaticThreadCleanupEnabled = true, activityVerbosity = "quiet", threadDisplayMode) {
+export function buildTelegramSettingsMenuReplyMarkup(draftPreviewsEnabled, assistantRenderingModeOrVoiceReplyMode, voiceReplyModeOrTimeInjectionMode, timeInjectionModeOrSectionRegistry, sectionRegistryOrVoiceReplyModeConfigured, voiceReplyModeConfigured = true, automaticThreadCleanupEnabled = true, activityVerbosity = "quiet", threadDisplayMode, threadDisplayCustom = false) {
     const hasRenderingMode = assistantRenderingModeOrVoiceReplyMode === "rich" ||
         assistantRenderingModeOrVoiceReplyMode === "html";
     const assistantRenderingMode = hasRenderingMode ? assistantRenderingModeOrVoiceReplyMode : "rich";
@@ -164,14 +166,13 @@ export function buildTelegramSettingsMenuReplyMarkup(draftPreviewsEnabled, assis
             text: `🕒 Time injection: ${getTelegramSettingsStateValueLabel(timeInjectionMode)}`,
             callback_data: "settings:open:time-injection",
         },
-        {
-            text: `🧹 Thread cleanup: ${automaticThreadCleanupEnabled ? "on" : "off"}`,
-            callback_data: "settings:open:automatic-thread-cleanup",
-        },
     ];
     if (threadDisplayMode)
         settingsButtons.push({
-            text: `🧵 Thread display: ${threadDisplayMode}`,
+            text: `🧹 Thread cleanup: ${automaticThreadCleanupEnabled ? "on" : "off"}`,
+            callback_data: "settings:open:automatic-thread-cleanup",
+        }, {
+            text: `🧵 Thread display: ${threadDisplayCustom ? "custom" : threadDisplayMode}`,
             callback_data: "settings:open:thread-display",
         });
     if (sectionRegistry) {
@@ -186,7 +187,7 @@ export function buildTelegramSettingsMenuReplyMarkup(draftPreviewsEnabled, assis
 }
 export async function openTelegramSettingsMenu(deps, sectionRegistry) {
     const state = await deps.getModelMenuState();
-    const messageId = await deps.sendSettingsMenu(state, buildTelegramSettingsMenuText(), buildTelegramSettingsMenuReplyMarkup(deps.areDraftPreviewsEnabled(), deps.getAssistantRenderingMode(), deps.getVoiceReplyMode(), deps.getTimeInjectionMode(), sectionRegistry, deps.isVoiceReplyModeConfigured(), deps.isAutomaticThreadCleanupEnabled(), deps.getActivityVerbosity(), deps.getThreadDisplayMode?.()));
+    const messageId = await deps.sendSettingsMenu(state, buildTelegramSettingsMenuText(), buildTelegramSettingsMenuReplyMarkup(deps.areDraftPreviewsEnabled(), deps.getAssistantRenderingMode(), deps.getVoiceReplyMode(), deps.getTimeInjectionMode(), sectionRegistry, deps.isVoiceReplyModeConfigured(), deps.isAutomaticThreadCleanupEnabled(), deps.getActivityVerbosity(), deps.getThreadDisplayMode?.(), deps.isThreadDisplayCustom?.() ?? false));
     if (messageId === undefined)
         return;
     state.messageId = messageId;
@@ -202,11 +203,11 @@ function threadDisplayModeLabel(mode) {
         default: return "letters";
     }
 }
-export function buildThreadDisplaySettingsReplyMarkup(mode) {
+export function buildThreadDisplaySettingsReplyMarkup(mode, custom = false) {
     return { inline_keyboard: [
             [{ text: "⬆️ Back", callback_data: "settings:list" }],
             ...["letters", "names", "directory-title", "directory-snake"].map((value) => [{
-                    text: `${mode === value ? "🟢 " : ""}${threadDisplayModeLabel(value)}`,
+                    text: `${!custom && mode === value ? "🟢 " : ""}${threadDisplayModeLabel(value)}`,
                     callback_data: `settings:set:thread-display:${value}`,
                 }]),
         ] };
@@ -307,7 +308,7 @@ export function buildVoiceReplyModeSettingsReplyMarkup(mode, configured = true)
     };
 }
 export async function updateTelegramSettingsMenuMessage(deps, sectionRegistry) {
-    await deps.updateSettingsMessage(buildTelegramSettingsMenuText(), buildTelegramSettingsMenuReplyMarkup(deps.areDraftPreviewsEnabled(), deps.getAssistantRenderingMode(), deps.getVoiceReplyMode(), deps.getTimeInjectionMode(), sectionRegistry, deps.isVoiceReplyModeConfigured(), deps.isAutomaticThreadCleanupEnabled(), deps.getActivityVerbosity(), deps.getThreadDisplayMode?.()));
+    await deps.updateSettingsMessage(buildTelegramSettingsMenuText(), buildTelegramSettingsMenuReplyMarkup(deps.areDraftPreviewsEnabled(), deps.getAssistantRenderingMode(), deps.getVoiceReplyMode(), deps.getTimeInjectionMode(), sectionRegistry, deps.isVoiceReplyModeConfigured(), deps.isAutomaticThreadCleanupEnabled(), deps.getActivityVerbosity(), deps.getThreadDisplayMode?.(), deps.isThreadDisplayCustom?.() ?? false));
 }
 export async function updateAutomaticThreadCleanupSettingsMessage(deps) {
     const enabled = deps.isAutomaticThreadCleanupEnabled();
@@ -362,7 +363,7 @@ export async function handleTelegramSettingsMenuCallbackAction(callbackQueryId,
             await deps.answerCallbackQuery(callbackQueryId, "Threaded Mode is no longer available.");
             return true;
         }
-        await deps.updateSettingsMessage(buildThreadDisplaySettingsText(mode), buildThreadDisplaySettingsReplyMarkup(mode));
+        await deps.updateSettingsMessage(buildThreadDisplaySettingsText(mode, deps.isThreadDisplayCustom?.() ?? false), buildThreadDisplaySettingsReplyMarkup(mode, deps.isThreadDisplayCustom?.() ?? false));
         await deps.answerCallbackQuery(callbackQueryId);
         return true;
     }
@@ -533,6 +534,7 @@ export function createTelegramSettingsMenuRuntime(deps, sectionRegistry) {
                 getTimeInjectionMode: deps.getTimeInjectionMode,
                 isAutomaticThreadCleanupEnabled: deps.isAutomaticThreadCleanupEnabled,
                 getThreadDisplayMode: deps.getThreadDisplayMode,
+                isThreadDisplayCustom: deps.isThreadDisplayCustom,
                 sendSettingsMenu: (state, text, replyMarkup) => deps.sendInteractiveMessage(state.chatId, text, "html", replyMarkup),
                 storeModelMenuState: deps.storeModelMenuState,
             }, sectionRegistry);
@@ -548,6 +550,7 @@ export function createTelegramSettingsMenuRuntime(deps, sectionRegistry) {
                 getTimeInjectionMode: deps.getTimeInjectionMode,
                 isAutomaticThreadCleanupEnabled: deps.isAutomaticThreadCleanupEnabled,
                 getThreadDisplayMode: deps.getThreadDisplayMode,
+                isThreadDisplayCustom: deps.isThreadDisplayCustom,
                 updateSettingsMessage: (text, replyMarkup) => deps.editInteractiveMessage(state.chatId, state.messageId, text, "html", replyMarkup),
             }, sectionRegistry);
         },
@@ -577,6 +580,7 @@ export function createTelegramSettingsMenuRuntime(deps, sectionRegistry) {
                 getTimeInjectionMode: deps.getTimeInjectionMode,
                 isAutomaticThreadCleanupEnabled: deps.isAutomaticThreadCleanupEnabled,
                 getThreadDisplayMode: deps.getThreadDisplayMode,
+                isThreadDisplayCustom: deps.isThreadDisplayCustom,
                 setThreadDisplayMode: deps.setThreadDisplayMode,
                 setDraftPreviewsEnabled: deps.setDraftPreviewsEnabled,
                 setAssistantRenderingMode: deps.setAssistantRenderingMode,

package/node_modules/@llblab/pi-telegram/dist/lib/pi.d.ts

@@ -56,8 +56,9 @@ export interface PiExtensionApiRuntimePorts {
     getActiveTools: ExtensionAPI["getActiveTools"];
     setActiveTools: ExtensionAPI["setActiveTools"];
     setModel: ExtensionAPI["setModel"];
+    registerCommand: ExtensionAPI["registerCommand"];
 }
-export declare function createExtensionApiRuntimePorts(api: Pick<ExtensionAPI, "sendUserMessage" | "exec" | "getCommands" | "getThinkingLevel" | "setThinkingLevel" | "getActiveTools" | "setActiveTools" | "setModel">): PiExtensionApiRuntimePorts;
+export declare function createExtensionApiRuntimePorts(api: Pick<ExtensionAPI, "sendUserMessage" | "exec" | "getCommands" | "getThinkingLevel" | "setThinkingLevel" | "getActiveTools" | "setActiveTools" | "setModel" | "registerCommand">): PiExtensionApiRuntimePorts;
 export declare function normalizeSettingsManager(manager: unknown): PiSettingsManager;
 export declare function createSettingsManager(cwd: string): Promise<PiSettingsManager>;
 export declare function createScopedModelPatternPersister(deps: {

package/node_modules/@llblab/pi-telegram/dist/lib/pi.js

@@ -44,6 +44,7 @@ export function createExtensionApiRuntimePorts(api) {
         getActiveTools: () => api.getActiveTools(),
         setActiveTools: (names) => api.setActiveTools(names),
         setModel: (model) => api.setModel(model),
+        registerCommand: (name, options) => api.registerCommand(name, options),
     };
 }
 function readEnabledModels(value) {

package/node_modules/@llblab/pi-telegram/dist/lib/routing.d.ts

@@ -164,6 +164,7 @@ export interface TelegramInboundRouteRuntimeDeps<TMessage extends TelegramRouted
     sendUserMessage?: (message: string, options?: Queue.TelegramPromptDeliveryOptions) => void;
     isIdle: (ctx: TContext) => boolean;
     hasPendingMessages: (ctx: TContext) => boolean;
+    requestNewSession?: (source: unknown) => void;
     compact: (ctx: TContext, callbacks: {
         onComplete: () => void;
         onError: (error: unknown) => void;

package/node_modules/@llblab/pi-telegram/dist/lib/routing.js

@@ -322,6 +322,7 @@ const TELEGRAM_OWNED_CALLBACK_PREFIXES = [
     "compact:",
     "menu:",
     "model:",
+    "new:",
     "queue:",
     "section:",
     "settings:",
@@ -1216,7 +1217,7 @@ export function createTelegramInboundRouteRuntime(deps) {
                 return;
             }
             if (selected.kind === "cancel") {
-                await deps.editInteractiveMessage?.(chatId, dialogMessageId, "<b>✖ Rename cancelled. Returning to normal agent mode.</b>", "html", { inline_keyboard: [] });
+                await deps.editInteractiveMessage?.(chatId, dialogMessageId, "<b>✖ Rename cancelled.</b>", "html", { inline_keyboard: [] });
                 await deps.answerCallbackQuery(query.id);
                 return;
             }
@@ -1241,6 +1242,36 @@ export function createTelegramInboundRouteRuntime(deps) {
             }
             return;
         }
+        const handledByNew = await Commands.handleTelegramNewConfirmationCallback(query, {
+            ctx,
+            answerCallbackQuery: deps.answerCallbackQuery,
+            editInteractiveMessage: deps.editInteractiveMessage ?? (async () => { }),
+            deleteMessage: deps.deleteMessage ?? (async () => { }),
+            runNew: async (newCtx) => {
+                await Commands.handleTelegramNewCommand({
+                    isIdle: () => deps.isIdle(newCtx),
+                    hasPendingMessages: () => deps.hasPendingMessages(newCtx),
+                    hasActiveTelegramTurn: deps.activeTurnRuntime.has,
+                    hasDispatchPending: deps.bridgeRuntime.lifecycle.hasDispatchPending,
+                    hasQueuedTelegramItems: deps.telegramQueueStore.hasQueuedItems,
+                    isCompactionInProgress: deps.bridgeRuntime.lifecycle.isCompactionInProgress,
+                    requestNewSession: deps.requestNewSession
+                        ? () => deps.requestNewSession(query)
+                        : undefined,
+                    sendTextReply: async (text) => {
+                        const chatId = query.message?.chat?.id;
+                        const messageId = query.message?.message_id;
+                        if (typeof chatId !== "number" || typeof messageId !== "number")
+                            return;
+                        await deps.editInteractiveMessage?.(chatId, messageId, text, "html", { inline_keyboard: [] });
+                    },
+                    recordRuntimeEvent: deps.recordRuntimeEvent,
+                });
+            },
+        });
+        assertExecutionCurrent();
+        if (handledByNew)
+            return;
         const handledByCompact = await Commands.handleTelegramCompactConfirmationCallback(query, {
             ctx,
             answerCallbackQuery: deps.answerCallbackQuery,
@@ -1392,6 +1423,7 @@ export function createTelegramInboundRouteRuntime(deps) {
         stopTypingLoop: deps.stopTypingLoop,
         enqueueContinueTurn,
         compact: deps.compact,
+        requestNewSession: deps.requestNewSession,
         allocateItemOrder: deps.bridgeRuntime.queue.allocateItemOrder,
         allocateControlOrder: deps.bridgeRuntime.queue.allocateControlOrder,
         appendControlItem: deps.queueMutationRuntime.append,
@@ -1652,9 +1684,18 @@ export function createTelegramInboundRouteRuntime(deps) {
                         dialogMessageId: candidate.dialogMessageId,
                     });
                 }
-                await deps.sendTextReply(target.chatId, message.message_id, result.ok && !result.message
+                const replyText = result.ok && !result.message
                     ? Commands.formatTelegramAutomaticThreadDisplayNameRestoredHeading(result.threadName ?? name)
-                    : Commands.formatTelegramInformationHeading(result.ok ? "✅" : "⚠️", result.message ?? "Thread display name reset failed."), { parseMode: "HTML", target });
+                    : Commands.formatTelegramInformationHeading(result.ok ? "✅" : "⚠️", result.message ?? "Thread display name reset failed.");
+                if (result.ok) {
+                    Updates.assertTelegramUpdateExecutionCurrent(message);
+                    Updates.reportTelegramUpdateCompleted(message);
+                    void deps.sendTextReply(target.chatId, message.message_id, replyText, { parseMode: "HTML", target }).catch((error) => deps.recordRuntimeEvent?.("telegram-command", error, {
+                        command: "name", phase: "reset-result",
+                    }));
+                    return true;
+                }
+                await deps.sendTextReply(target.chatId, message.message_id, replyText, { parseMode: "HTML", target });
                 return true;
             }
             const validationError = deps.validateThreadName?.(name);
@@ -1677,9 +1718,18 @@ export function createTelegramInboundRouteRuntime(deps) {
                     dialogMessageId: candidate.dialogMessageId,
                 });
             }
-            await deps.sendTextReply(target.chatId, message.message_id, result?.ok && !result.message
+            const replyText = result?.ok && !result.message
                 ? Commands.formatTelegramThreadDisplayNameSavedHeading(result.threadName ?? consumed.name)
-                : Commands.formatTelegramInformationHeading(result?.ok ? "✅" : "⚠️", result?.message ?? "Thread display name update failed."), { parseMode: "HTML", target });
+                : Commands.formatTelegramInformationHeading(result?.ok ? "✅" : "⚠️", result?.message ?? "Thread display name update failed.");
+            if (result?.ok) {
+                Updates.assertTelegramUpdateExecutionCurrent(message);
+                Updates.reportTelegramUpdateCompleted(message);
+                void deps.sendTextReply(target.chatId, message.message_id, replyText, { parseMode: "HTML", target }).catch((error) => deps.recordRuntimeEvent?.("telegram-command", error, {
+                    command: "name", phase: "rename-result",
+                }));
+                return true;
+            }
+            await deps.sendTextReply(target.chatId, message.message_id, replyText, { parseMode: "HTML", target });
             return true;
         },
         handleCommand: commandHandler,

package/node_modules/@llblab/pi-telegram/dist/lib/thread-display.d.ts

@@ -38,6 +38,29 @@ export interface TelegramThreadDisplayReconcilerDeps {
     captureLiveBindingKeys(bindings: readonly TelegramWorkspaceThreadBinding[]): ReadonlySet<string>;
     callApi<TResponse>(method: string, body: Record<string, unknown>, options?: TelegramApiCallOptions): Promise<TResponse>;
 }
+export declare function createTelegramThreadDisplaySettingsRuntime(deps: {
+    getTarget(): {
+        chatId: number;
+        threadId?: number;
+    } | undefined;
+    getBinding(target: {
+        chatId: number;
+        threadId?: number;
+    }): {
+        manualThreadName?: string;
+    } | undefined;
+    apply(mode: TelegramThreadDisplayMode): Promise<void>;
+    reset(target: {
+        chatId: number;
+        threadId?: number;
+    }): Promise<{
+        ok: boolean;
+        message?: string;
+    }>;
+}): {
+    isCustom(): boolean;
+    setMode(mode: TelegramThreadDisplayMode): Promise<void>;
+};
 /** Caller owns triggering and reporting; no timer or background retry is created. */
 export declare function createTelegramThreadDisplayReconciler(deps: TelegramThreadDisplayReconcilerDeps): {
     reconcile(): Promise<{

package/node_modules/@llblab/pi-telegram/dist/lib/thread-display.js

@@ -192,6 +192,26 @@ export async function applyTelegramThreadDisplaySetting(mode, deps) {
     if (deps.getProfileKey() !== profile)
         throw new Error("Telegram Thread display setting changed profile.");
 }
+export function createTelegramThreadDisplaySettingsRuntime(deps) {
+    return {
+        isCustom() {
+            const target = deps.getTarget();
+            return !!target && typeof deps.getBinding(target)?.manualThreadName === "string";
+        },
+        async setMode(mode) {
+            const target = deps.getTarget();
+            const hadManualName = !!target &&
+                typeof deps.getBinding(target)?.manualThreadName === "string";
+            await deps.apply(mode);
+            if (!hadManualName || !target)
+                return;
+            const reset = await deps.reset(target);
+            if (!reset.ok) {
+                throw new Error(reset.message ?? "Telegram Thread display override reset failed.");
+            }
+        },
+    };
+}
 /** Caller owns triggering and reporting; no timer or background retry is created. */
 export function createTelegramThreadDisplayReconciler(deps) {
     let tail = Promise.resolve();

package/node_modules/@llblab/pi-telegram/dist/lib/threads.d.ts

@@ -175,6 +175,19 @@ export interface TelegramBotStateSnapshot {
     lastSlot?: string;
     lastReconcileAction?: string;
 }
+export interface TelegramSessionReplacementIntent {
+    continuity: "workspace-thread" | "classic-chat";
+    cwd: string;
+    profileName: string;
+    sourceSessionId: string;
+    sourceUpdateId: number;
+    target: TelegramTarget;
+    messageId: number;
+    slot?: string;
+    threadName?: string;
+    createdAtMs: number;
+    expiresAtMs: number;
+}
 export interface TelegramTopicTargetFile {
     version: 1;
     source: "snapshot";
@@ -187,6 +200,7 @@ export interface TelegramTopicTargetFile {
     identities?: TelegramThreadIdentityRecord[];
     workspaceBindings?: TelegramWorkspaceThreadBinding[];
     workspaceRetirements?: TelegramWorkspaceRetirementIntent[];
+    sessionReplacement?: TelegramSessionReplacementIntent;
     reservations?: TelegramThreadReservation[];
     pendingProvisions?: TelegramThreadPendingProvision[];
     pendingCleanups?: TelegramThreadCleanupIntent[];
@@ -227,6 +241,10 @@ export interface TelegramTopicTargetStore {
     getIdentityByProfileKey: (profileKey: string) => TelegramThreadIdentityRecord | undefined;
     forgetIdentityByProfileKey: (profileKey: string) => boolean;
     listWorkspaceBindings: () => TelegramWorkspaceThreadBinding[];
+    getWorkspaceBindingByTarget: (target: TelegramTarget, sessionId?: string) => TelegramWorkspaceThreadBinding | undefined;
+    getSessionReplacementIntent: () => TelegramSessionReplacementIntent | undefined;
+    commitSessionReplacementIntent: (intent: TelegramSessionReplacementIntent, isCurrent: () => boolean) => Promise<boolean>;
+    removeSessionReplacementIntent: (expected: TelegramSessionReplacementIntent, isCurrent: () => boolean) => Promise<boolean>;
     listWorkspaceRetirementIntents: () => TelegramWorkspaceRetirementIntent[];
     commitWorkspaceJournalEvidence: (expected: TelegramWorkspaceThreadBinding, journalBindingKeys: readonly string[], complete: boolean) => TelegramWorkspaceThreadBinding | undefined;
     upsertWorkspaceRetirementIntent: (intent: TelegramWorkspaceRetirementIntent) => boolean;

package/node_modules/@llblab/pi-telegram/dist/lib/threads.js

@@ -645,6 +645,50 @@ function normalizeWorkspaceBindingRecord(value) {
 function cloneWorkspaceBinding(binding) {
     return { ...binding, target: { ...binding.target } };
 }
+function cloneSessionReplacementIntent(intent) {
+    return { ...intent, target: { ...intent.target } };
+}
+function normalizeSessionReplacementIntent(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return undefined;
+    const record = value;
+    const target = record.target;
+    if (typeof record.cwd !== "string" || !normalizeTelegramWorkspacePath(record.cwd) ||
+        typeof record.profileName !== "string" || !record.profileName ||
+        typeof record.sourceSessionId !== "string" || !normalizeTelegramSessionId(record.sourceSessionId) ||
+        typeof record.sourceUpdateId !== "number" || !Number.isSafeInteger(record.sourceUpdateId) ||
+        !target || typeof target.chatId !== "number" ||
+        (target.threadId !== undefined &&
+            (typeof target.threadId !== "number" || !Number.isSafeInteger(target.threadId))) ||
+        typeof record.messageId !== "number" || !Number.isSafeInteger(record.messageId) ||
+        typeof record.createdAtMs !== "number" || !Number.isSafeInteger(record.createdAtMs) ||
+        typeof record.expiresAtMs !== "number" || !Number.isSafeInteger(record.expiresAtMs) ||
+        record.expiresAtMs <= record.createdAtMs)
+        return undefined;
+    const continuity = record.continuity === "workspace-thread" ||
+        record.continuity === "classic-chat"
+        ? record.continuity
+        : target.threadId !== undefined ? "workspace-thread" : "classic-chat";
+    if ((continuity === "workspace-thread") !== (target.threadId !== undefined)) {
+        return undefined;
+    }
+    return {
+        continuity,
+        cwd: normalizeTelegramWorkspacePath(record.cwd),
+        profileName: record.profileName,
+        sourceSessionId: normalizeTelegramSessionId(record.sourceSessionId),
+        sourceUpdateId: record.sourceUpdateId,
+        target: {
+            chatId: target.chatId,
+            ...(typeof target.threadId === "number" ? { threadId: target.threadId } : {}),
+        },
+        messageId: record.messageId,
+        ...(typeof record.slot === "string" ? { slot: record.slot } : {}),
+        ...(typeof record.threadName === "string" ? { threadName: record.threadName } : {}),
+        createdAtMs: record.createdAtMs,
+        expiresAtMs: record.expiresAtMs,
+    };
+}
 function normalizeWorkspaceRetirementIntent(value) {
     if (!value || typeof value !== "object" || Array.isArray(value))
         return undefined;
@@ -905,6 +949,7 @@ function parseTopicTargetFile(value) {
                 return normalized ? [normalized] : [];
             })
             : [],
+        sessionReplacement: normalizeSessionReplacementIntent(file.sessionReplacement),
         reservations: Array.isArray(file.reservations)
             ? file.reservations.flatMap((reservation) => {
                 const normalized = normalizeReservation(reservation);
@@ -1026,6 +1071,7 @@ export function createTelegramTopicTargetStore(options) {
     let identities = new Map();
     let workspaceBindings = new Map();
     let workspaceRetirements = [];
+    let sessionReplacement;
     let workspaceRetirementCommitInFlight = false;
     const hasWorkspaceRetirementConflict = (input) => workspaceRetirements.some((intent) => (input.bindingKey !== undefined && intent.binding.bindingKey === input.bindingKey) ||
         (input.cwd !== undefined && intent.binding.cwd === input.cwd) ||
@@ -1150,6 +1196,7 @@ export function createTelegramTopicTargetStore(options) {
         identities = new Map();
         workspaceBindings = new Map();
         workspaceRetirements = [];
+        sessionReplacement = undefined;
         workspaceRetirementCommitInFlight = false;
         workspaceClaims = new Map();
         reservations = [];
@@ -1171,6 +1218,7 @@ export function createTelegramTopicTargetStore(options) {
             identities = new Map();
             workspaceBindings = new Map();
             workspaceRetirements = [];
+            sessionReplacement = undefined;
             workspaceRetirementCommitInFlight = false;
             reservations = [];
             pendingProvisions = [];
@@ -1208,6 +1256,9 @@ export function createTelegramTopicTargetStore(options) {
             cloneWorkspaceBinding(binding),
         ]));
         workspaceRetirements = (file.workspaceRetirements ?? []).map(cloneWorkspaceRetirementIntent);
+        sessionReplacement = file.sessionReplacement
+            ? cloneSessionReplacementIntent(file.sessionReplacement)
+            : undefined;
         reconcileWorkspaceSuffixExposure();
         for (const record of records.values())
             rememberIdentity(record);
@@ -1286,6 +1337,9 @@ export function createTelegramTopicTargetStore(options) {
                 identities: Array.from(identities.values()).map(cloneIdentityRecord),
                 workspaceBindings: Array.from(workspaceBindings.values()).map(cloneWorkspaceBinding),
                 workspaceRetirements: workspaceRetirements.map(cloneWorkspaceRetirementIntent),
+                ...(sessionReplacement
+                    ? { sessionReplacement: cloneSessionReplacementIntent(sessionReplacement) }
+                    : {}),
                 reservations: reservations.map((reservation) => ({ ...reservation })),
                 pendingProvisions: pendingProvisions.map((provision) => ({
                     ...provision,
@@ -1563,6 +1617,40 @@ export function createTelegramTopicTargetStore(options) {
         listWorkspaceBindings() {
             return Array.from(workspaceBindings.values()).map(cloneWorkspaceBinding);
         },
+        getWorkspaceBindingByTarget(target, sessionId) {
+            const binding = Array.from(workspaceBindings.values()).find((candidate) => targetMatches(candidate.target, target) &&
+                (sessionId === undefined || candidate.sessionId === sessionId));
+            return binding ? cloneWorkspaceBinding(binding) : undefined;
+        },
+        getSessionReplacementIntent() {
+            return sessionReplacement
+                ? cloneSessionReplacementIntent(sessionReplacement)
+                : undefined;
+        },
+        async commitSessionReplacementIntent(intent, isCurrent) {
+            const next = normalizeSessionReplacementIntent(intent);
+            if (!next || !isCurrent())
+                return false;
+            await loadFromDisk();
+            if (!isCurrent())
+                return false;
+            const existing = sessionReplacement;
+            if (existing && existing.expiresAtMs > getNowMs() &&
+                !isDeepStrictEqual(existing, next))
+                return false;
+            sessionReplacement = cloneSessionReplacementIntent(next);
+            markDirty();
+            return await persistSnapshot() && isCurrent();
+        },
+        async removeSessionReplacementIntent(expected, isCurrent) {
+            await loadFromDisk();
+            if (!isCurrent() || !sessionReplacement ||
+                !isDeepStrictEqual(sessionReplacement, expected))
+                return false;
+            sessionReplacement = undefined;
+            markDirty();
+            return await persistSnapshot() && isCurrent();
+        },
         listWorkspaceRetirementIntents() {
             return workspaceRetirements.map(cloneWorkspaceRetirementIntent);
         },
@@ -1959,6 +2047,36 @@ export function createTelegramTopicTargetStore(options) {
                 (options?.sessionId !== undefined && !normalizedSessionId) ||
                 hasWorkspaceRetirementConflict({ cwd: normalizedCwd }))
                 return undefined;
+            let replacementPreviousInstanceId;
+            const replacement = sessionReplacement;
+            if (replacement?.continuity === "workspace-thread" && normalizedSessionId &&
+                replacement.expiresAtMs > getNowMs() &&
+                replacement.profileName === (getTelegramProfile() ?? "default") &&
+                replacement.cwd === normalizedCwd &&
+                replacement.sourceSessionId !== normalizedSessionId) {
+                const sourceEntry = Array.from(workspaceBindings.entries()).find(([, binding]) => binding.cwd === normalizedCwd &&
+                    binding.sessionId === replacement.sourceSessionId &&
+                    targetMatches(binding.target, replacement.target));
+                if (sourceEntry) {
+                    const [sourceKey, sourceBinding] = sourceEntry;
+                    const replacementIdentity = Array.from({ length: TELEGRAM_WORKSPACE_SLOTS.length })
+                        .map((_, ordinal) => createTelegramWorkspaceBindingIdentityWithKey(sourceBinding.cwd, sourceBinding.workspaceKey, ordinal, normalizedSessionId))
+                        .find((identity) => identity?.instanceSlot === sourceBinding.instanceSlot);
+                    if (replacementIdentity &&
+                        replacementIdentity.instanceSlot === sourceBinding.instanceSlot) {
+                        const existingTargetRecord = Array.from(records.values()).find((record) => targetMatches(record.target, replacement.target));
+                        replacementPreviousInstanceId = existingTargetRecord?.instanceId;
+                        workspaceBindings.delete(sourceKey);
+                        workspaceBindings.set(getWorkspaceBindingMapKey(replacementIdentity), {
+                            ...sourceBinding,
+                            ...replacementIdentity,
+                            updatedAtMs: getNowMs(),
+                        });
+                        markDirty();
+                    }
+                }
+            }
+            const effectivePreviousInstanceId = previousInstanceId ?? replacementPreviousInstanceId;
             const externalReservedSlots = captureExternalReservedSlots();
             if (!externalReservedSlots) {
                 options?.onCapacityUnavailable?.();
@@ -1995,9 +2113,16 @@ export function createTelegramTopicTargetStore(options) {
                 const mapKey = getWorkspaceBindingMapKey(identity);
                 const existingClaim = workspaceClaims.get(mapKey);
                 if (existingClaim) {
-                    return existingClaim.instanceId === instanceId
-                        ? { ...existingClaim.identity }
-                        : undefined;
+                    if (existingClaim.instanceId === instanceId) {
+                        return { ...existingClaim.identity };
+                    }
+                    if (existingClaim.instanceId !== effectivePreviousInstanceId)
+                        return undefined;
+                    workspaceClaims.set(mapKey, {
+                        identity: existingClaim.identity,
+                        instanceId,
+                    });
+                    return { ...existingClaim.identity };
                 }
                 const binding = workspaceBindings.get(mapKey);
                 const liveRecord = binding
@@ -2005,7 +2130,7 @@ export function createTelegramTopicTargetStore(options) {
                     : undefined;
                 if (liveRecord &&
                     liveRecord.instanceId !== instanceId &&
-                    liveRecord.instanceId !== previousInstanceId) {
+                    liveRecord.instanceId !== effectivePreviousInstanceId) {
                     return undefined;
                 }
                 const retainedTarget = binding?.target ?? legacyRecord?.target;
@@ -2147,8 +2272,29 @@ export function createTelegramTopicTargetStore(options) {
             if (!next)
                 return undefined;
             const nextMapKey = getWorkspaceBindingMapKey(next);
-            const claim = workspaceClaims.get(nextMapKey);
-            if (next.slot && Array.from(workspaceBindings.values()).some((existing) => existing.bindingKey !== next.bindingKey && existing.slot === next.slot))
+            let claim = workspaceClaims.get(nextMapKey);
+            const replacedTargetBinding = Array.from(workspaceBindings.values()).find((existing) => existing.bindingKey !== next.bindingKey &&
+                targetMatches(existing.target, next.target));
+            if (claimInstanceId && claim?.instanceId === claimInstanceId &&
+                replacedTargetBinding?.slot) {
+                claim = {
+                    ...claim,
+                    identity: { ...claim.identity, slot: replacedTargetBinding.slot },
+                };
+                workspaceClaims.set(nextMapKey, claim);
+                next.slot = replacedTargetBinding.slot;
+                if (replacedTargetBinding.threadName && !next.threadName) {
+                    next.threadName = replacedTargetBinding.threadName;
+                }
+                if (replacedTargetBinding.manualThreadName && !next.manualThreadName) {
+                    next.manualThreadName = replacedTargetBinding.manualThreadName;
+                }
+                if (replacedTargetBinding.displayTitle && !next.displayTitle) {
+                    next.displayTitle = replacedTargetBinding.displayTitle;
+                }
+            }
+            if (next.slot && Array.from(workspaceBindings.values()).some((existing) => existing.bindingKey !== next.bindingKey && existing.slot === next.slot &&
+                !targetMatches(existing.target, next.target)))
                 return undefined;
             for (const existing of workspaceBindings.values()) {
                 if (existing.workspaceKey === next.workspaceKey &&

package/node_modules/@llblab/pi-telegram/dist/lib/updates.d.ts

@@ -1216,6 +1216,7 @@ export interface TelegramUpdateWorkerOwnerRuntimeDeps<TContext> {
     isContextCurrent: (ctx: TContext) => boolean;
     dispatchNext: (ctx: TContext) => void;
     requestQueueHandoffReconciliation: (ctx: TContext) => void;
+    afterUpdateCompleted?: (updateId: number) => void;
 }
 export declare function createTelegramUpdateWorkerOwnerRuntime<TContext>(deps: TelegramUpdateWorkerOwnerRuntimeDeps<TContext>): TelegramUpdateWorkerOwnerRuntime<TContext>;
 export interface TelegramUpdateAdmissionRuntimeBinding<TContext> {

package/node_modules/@llblab/pi-telegram/dist/lib/updates.js

@@ -3177,9 +3177,11 @@ export function createTelegramUpdateWorkerOwnerRuntime(deps) {
             deps.dispatchNext(ctx);
             deps.requestQueueHandoffReconciliation(ctx);
         },
-        onUpdateCompleted(_updateId, ctx) {
-            if (deps.isContextCurrent(ctx))
-                deps.dispatchNext(ctx);
+        onUpdateCompleted(updateId, ctx) {
+            if (!deps.isContextCurrent(ctx))
+                return;
+            deps.dispatchNext(ctx);
+            deps.afterUpdateCompleted?.(updateId);
         },
     };
 }

package/node_modules/@llblab/pi-telegram/dist/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@llblab/pi-telegram",
-  "version": "0.48.3",
+  "version": "0.49.0",
   "private": false,
   "publishConfig": {
     "access": "public"