@llblab/pi-kit 0.36.1 → 0.36.3

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

@@ -6359,12 +6359,13 @@ export function createTelegramUpdateAdmissionWorkerRuntime(deps) {
             const typedUpdate = update;
             const prepared = deps.prepareUpdateForExecution?.(typedUpdate) ?? typedUpdate;
             // Journal/source evidence remains the original; only the warm released handler projection changes destination.
-            const routed = target ? { ...prepared,
-                ...(prepared.message ? { message: prepared.message.message_thread_id === target.threadId ? { ...prepared.message }
-                        : withoutTelegramTurnReplyAnchor({ ...prepared.message, message_thread_id: target.threadId, reply_to_message: undefined }) } : {}),
-                ...(prepared.edited_message ? { edited_message: prepared.edited_message.message_thread_id === target.threadId ? { ...prepared.edited_message }
-                        : withoutTelegramTurnReplyAnchor({ ...prepared.edited_message, message_thread_id: target.threadId, reply_to_message: undefined }) } : {}),
-            } : prepared;
+            const projectTo = (destination) => ({ ...prepared,
+                ...(prepared.message ? { message: prepared.message.message_thread_id === destination.threadId ? { ...prepared.message }
+                        : withoutTelegramTurnReplyAnchor({ ...prepared.message, message_thread_id: destination.threadId, reply_to_message: undefined }) } : {}),
+                ...(prepared.edited_message ? { edited_message: prepared.edited_message.message_thread_id === destination.threadId ? { ...prepared.edited_message }
+                        : withoutTelegramTurnReplyAnchor({ ...prepared.edited_message, message_thread_id: destination.threadId, reply_to_message: undefined }) } : {}),
+            });
+            const routed = target ? projectTo(target) : prepared;
             try {
                 return await executeUpdate(routed, ctx, signal);
             }
@@ -6372,6 +6373,8 @@ export function createTelegramUpdateAdmissionWorkerRuntime(deps) {
                 if (await deps.settleTerminalExecutionFailure?.(error)) {
                     return { kind: "complete" };
                 }
+                // A refused reply proves only that send was not issued, not that the handler made no prior effects.
+                // Leave failure settlement to the worker's retry policy; never re-enter the handler to recover delivery here.
                 throw error;
             }
         },

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

@@ -61,7 +61,8 @@ interface TelegramWorkspaceRetirementFenceBase {
     retirementIntentId: string;
     profileKey: string;
     bindingKey: string;
-    slot: string;
+    /** Null is admitted only for explicit manual cleanup of a slotless binding. */
+    slot: string | null;
     target: TelegramTarget & {
         threadId: number;
     };
@@ -93,7 +94,7 @@ export interface TelegramWorkspaceDeletionPermit {
     readonly retirementIntentId: string;
     readonly profileKey: string;
     readonly bindingKey: string;
-    readonly slot: string;
+    readonly slot: string | null;
     readonly target: TelegramTarget & {
         threadId: number;
     };
@@ -205,7 +206,7 @@ export interface TelegramWorkspaceAdmissionLedger {
         operationId: string;
         cleanupWorkSetId: string;
         bindingKey: string;
-        slot: string;
+        slot: string | null;
         target: TelegramTarget & {
             threadId: number;
         };

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

@@ -194,8 +194,8 @@ function normalizeFence(value, profileKey) {
         !isBoundedText(value.retirementIntentId) ||
         value.profileKey !== profileKey ||
         !isBoundedText(value.bindingKey) ||
-        typeof value.slot !== "string" ||
-        !/^[A-Z]$/u.test(value.slot) ||
+        !((typeof value.slot === "string" && /^[A-Z]$/u.test(value.slot)) ||
+            (value.destructiveKind === "manual-thread-cleanup" && value.slot === null)) ||
         !target ||
         !isLeaderEpoch(value.leaderEpoch) ||
         !isSafeTimestamp(value.retirementRequestedAtMs) ||
@@ -1442,7 +1442,7 @@ export function createTelegramWorkspaceAdmissionLedger(options) {
         }),
         listReservedSlots: () => {
             const fence = read().fence;
-            return fence && isTelegramWorkspaceRetirementFence(fence)
+            return fence && isTelegramWorkspaceRetirementFence(fence) && fence.slot !== null
                 ? [fence.slot]
                 : [];
         },

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

@@ -325,5 +325,6 @@ export declare function createTelegramWorkspaceSlotRotation(input: TelegramWorks
     getLeaderEpoch: () => number | string | undefined;
     getExternalProtection: (binding: TelegramWorkspaceThreadBinding) => TelegramWorkspaceExternalProtectionEvidence;
     recordEvent: (message: string, details: Record<string, unknown>) => void;
+    onSlotReused?: (bindingKey: string, isCurrent: () => boolean) => Promise<void>;
 }): TelegramWorkspaceCapacityRunner;
 export {};

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

@@ -1053,6 +1053,8 @@ export async function runTelegramWorkspaceRetirementLifecycle(input) {
                     owner,
                     leaderEpoch: epoch,
                 });
+            if (fence.slot === null)
+                return { kind: "retained", reason: "stale-intent" };
             input.admission.completeRetirementFence(fence);
             return {
                 kind: "retired",
@@ -1162,7 +1164,7 @@ export function createTelegramWorkspaceSlotRotation(input) {
         return requests.runExclusive(async () => {
             if (!isCurrent())
                 throw new Error("Telegram Workspace allocation lost leader authority.");
-            const rotate = async () => {
+            const rotate = async (options) => {
                 const result = await input.runExclusive(async () => {
                     if (!isCurrent())
                         throw new Error("Telegram Workspace rotation lost leader authority.");
@@ -1207,6 +1209,54 @@ export function createTelegramWorkspaceSlotRotation(input) {
                         },
                     });
                 });
+                if (options?.reuseWhenProtected &&
+                    result.kind === "blocked" &&
+                    result.stage === "preparation" &&
+                    result.reason === "protected-capacity") {
+                    // Every letter is protected, so deleting a Thread is off the table: reassign the
+                    // least recently used letter as metadata and keep its Thread, journals and work.
+                    const reused = await input.runExclusive(async () => {
+                        if (!isCurrent())
+                            throw new Error("Telegram Workspace slot reuse lost leader authority.");
+                        await input.store.load();
+                        if (!isCurrent())
+                            throw new Error("Telegram Workspace slot reuse lost leader authority.");
+                        return input.store.reuseLeastRecentlyUsedWorkspaceSlot(isCurrent);
+                    });
+                    if (!isCurrent())
+                        throw new Error("Telegram Workspace rotation lost leader authority.");
+                    if (reused) {
+                        if (reused.kind === "reused") {
+                            // The store commit is final. Await display repair before the next allocation,
+                            // but never roll back or repeat a published reuse after a transport failure.
+                            try {
+                                await input.onSlotReused?.(reused.bindingKey, isCurrent);
+                            }
+                            catch (error) {
+                                try {
+                                    input.recordEvent("Telegram Workspace slot display update failed.", {
+                                        slot: reused.slot,
+                                        error: error instanceof Error ? error.message : String(error),
+                                    });
+                                }
+                                catch {
+                                    /* A diagnostic failure grants no rollback or another display attempt. */
+                                }
+                            }
+                            if (!isCurrent())
+                                throw new Error("Telegram Workspace rotation lost leader authority.");
+                            try {
+                                input.recordEvent("Telegram Workspace slot reused.", {
+                                    slot: reused.slot,
+                                });
+                            }
+                            catch {
+                                /* Diagnostics cannot turn a published reassignment into another attempt. */
+                            }
+                        }
+                        return { kind: "reused" };
+                    }
+                }
                 if (result.kind !== "retired" &&
                     result.kind !== "not-needed" &&
                     result.kind !== "cancelled") {
@@ -1320,7 +1370,7 @@ export function createTelegramWorkspaceSlotRotation(input) {
                         }
                     }
                 }
-                await rotate();
+                await rotate({ reuseWhenProtected: true });
                 return operation();
             }
         });

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

@@ -25,6 +25,23 @@ export type TelegramWorkspaceSlotAllocation = {
     kind: "blocked";
     reason: "invalid-state" | "protected-capacity";
 };
+/** A binding whose letter may be reassigned without touching its Thread, journals or accepted work. */
+export interface TelegramWorkspaceReusableSlot {
+    bindingKey: string;
+    /** Uppercase display letter currently held by the binding. */
+    slot: string;
+    /** A live owner counts as most recently used, whatever its stored clocks say. */
+    live: boolean;
+    /** Last known use: inactivity start for detached bindings, otherwise the last binding update. */
+    lastUsedMs: number;
+}
+/**
+ * Metadata-only fallback for a full A-Z pool: pick the least recently used letter,
+ * preferring detached bindings over live ones. Unlike pressure retirement this
+ * ignores accepted-work protection because reuse deletes nothing.
+ * Returns undefined for an empty or malformed candidate set.
+ */
+export declare function selectTelegramWorkspaceReusableSlot(candidates: readonly TelegramWorkspaceReusableSlot[]): TelegramWorkspaceReusableSlot | undefined;
 /** Caller must recheck exact ownership and protected work before retirement. */
 export declare function planTelegramWorkspaceSlotAllocation(input: {
     bindings: readonly TelegramWorkspaceSlotOccupancy[];

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

@@ -12,6 +12,31 @@ export class TelegramWorkspaceSlotUnavailableError extends Error {
         this.name = "TelegramWorkspaceSlotUnavailableError";
     }
 }
+/**
+ * Metadata-only fallback for a full A-Z pool: pick the least recently used letter,
+ * preferring detached bindings over live ones. Unlike pressure retirement this
+ * ignores accepted-work protection because reuse deletes nothing.
+ * Returns undefined for an empty or malformed candidate set.
+ */
+export function selectTelegramWorkspaceReusableSlot(candidates) {
+    const slots = new Set();
+    const keys = new Set();
+    for (const candidate of candidates) {
+        if (!/^[A-Z]$/u.test(candidate.slot) ||
+            !candidate.bindingKey ||
+            !Number.isSafeInteger(candidate.lastUsedMs) ||
+            candidate.lastUsedMs < 0 ||
+            slots.has(candidate.slot) ||
+            keys.has(candidate.bindingKey))
+            return undefined;
+        slots.add(candidate.slot);
+        keys.add(candidate.bindingKey);
+    }
+    const [selected] = [...candidates].sort((left, right) => Number(left.live) - Number(right.live) ||
+        left.lastUsedMs - right.lastUsedMs ||
+        left.slot.localeCompare(right.slot));
+    return selected ? { ...selected } : undefined;
+}
 function isSlot(slot) {
     return /^[a-z]$/u.test(slot);
 }

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

@@ -1,6 +1,6 @@
 {
   "name": "@llblab/pi-telegram",
-  "version": "0.57.3",
+  "version": "0.57.11",
   "private": false,
   "publishConfig": {
     "access": "public"
@@ -28,6 +28,7 @@
   },
   "scripts": {
     "test": "node --experimental-strip-types --import ./tests/fixtures/canonical-tmpdir.ts --test --test-concurrency=4 --test-reporter=dot tests/*.test.ts",
+    "test:low-concurrency": "node --experimental-strip-types --import ./tests/fixtures/canonical-tmpdir.ts --test --test-concurrency=2 --test-reporter=dot tests/*.test.ts",
     "test:verbose": "node --experimental-strip-types --import ./tests/fixtures/canonical-tmpdir.ts --test --test-reporter=spec tests/*.test.ts",
     "typecheck": "tsc --noEmit",
     "build": "node scripts/build-dist.mjs",