@llblab/pi-kit 0.36.1 → 0.36.2

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

@@ -74,6 +74,7 @@ import {
 } from "./workspace-identity.ts";
 import {
   planTelegramWorkspaceSlotAllocation,
+  selectTelegramWorkspaceReusableSlot,
   TELEGRAM_WORKSPACE_SLOTS,
   TelegramWorkspaceSlotUnavailableError,
   type TelegramWorkspaceSlotOccupancy,
@@ -873,7 +874,7 @@ export interface TelegramTopicTargetStore {
           sessionId?: string;
           sessionKey?: string;
           instanceSlot: string;
-          slot: string;
+          slot: string | null;
           bindingKey: string;
           target: { chatId: number; threadId: number };
           inactiveSinceMs: number;
@@ -886,6 +887,19 @@ export interface TelegramTopicTargetStore {
     getExternalProtection: TelegramWorkspaceExternalProtectionCapture,
     options?: { expectedRetirement?: TelegramWorkspaceRetirementIntent },
   ) => TelegramWorkspaceSlotOccupancySnapshot;
+  /**
+   * Fallback for a full A-Z pool: strips the display letter from the least recently used
+   * binding (and its current Thread record) and persists, so a fresh allocation can take it.
+   * Metadata only: the Thread, journals and accepted work stay untouched, and a binding or
+   * letter held by a claim, reservation, provision, cleanup or retirement is never chosen.
+   */
+  reuseLeastRecentlyUsedWorkspaceSlot: (
+    isCurrent: () => boolean,
+  ) => Promise<
+    | { kind: "free" }
+    | { kind: "reused"; bindingKey: string; slot: string }
+    | undefined
+  >;
   hasWorkspaceBinding: (cwd: string, sessionId?: string) => boolean;
   setWorkspaceDisplayTitle: (
     expected: TelegramWorkspaceThreadBinding,
@@ -3556,8 +3570,6 @@ export function createTelegramTopicTargetStore(
     >,
     nowMs: number,
     options: {
-      /** Slot equality only counts when the binding itself holds a slot. */
-      requireBindingSlot?: boolean;
       isRetirementExcluded?: (
         intent: TelegramWorkspaceRetirementIntent,
         index: number,
@@ -3565,7 +3577,7 @@ export function createTelegramTopicTargetStore(
     } = {},
   ): boolean => {
     const slotMatches = (slot: string | undefined): boolean =>
-      (!options.requireBindingSlot || !!binding.slot) && slot === binding.slot;
+      !!binding.slot && slot === binding.slot;
     const targetOrSlotMatches = (candidate: {
       target?: TelegramTarget;
       slot?: string;
@@ -7272,7 +7284,7 @@ export function createTelegramTopicTargetStore(
         (!cleanupSnapshot.cwd ||
           !cleanupSnapshot.workspaceKey ||
           !cleanupSnapshot.instanceSlot ||
-          !cleanupSnapshot.slot ||
+          !(cleanupSnapshot.slot === null || (typeof cleanupSnapshot.slot === "string" && /^[A-Z]$/u.test(cleanupSnapshot.slot))) ||
           !cleanupSnapshot.bindingKey ||
           ((cleanupSnapshot.sessionId !== undefined ||
             cleanupSnapshot.sessionKey !== undefined) &&
@@ -7287,7 +7299,7 @@ export function createTelegramTopicTargetStore(
         return false;
       if (
         !cleanupSnapshot &&
-        (!normalized?.slot || normalized.inactiveSinceMs === undefined)
+        (!normalized || normalized.inactiveSinceMs === undefined)
       )
         return false;
       const mapKey = getWorkspaceBindingMapKey(
@@ -7301,7 +7313,7 @@ export function createTelegramTopicTargetStore(
           binding.sessionId === cleanupSessionId &&
           binding.sessionKey === cleanupSessionKey &&
           binding.instanceSlot === cleanupSnapshot.instanceSlot &&
-          binding.slot === cleanupSnapshot.slot &&
+          (binding.slot ?? null) === cleanupSnapshot.slot &&
           binding.bindingKey === cleanupSnapshot.bindingKey &&
           targetMatches(binding.target, cleanupSnapshot.target) &&
           binding.inactiveSinceMs === cleanupSnapshot.inactiveSinceMs &&
@@ -7420,13 +7432,13 @@ export function createTelegramTopicTargetStore(
       const nowMs = getNowMs();
       const inSnapshot =
         getExternalProtection.withSnapshot ?? ((capture) => capture());
-      const bindings = inSnapshot(() => Array.from(workspaceBindings.values()).map((binding) => {
-        const slot = binding.slot?.toLowerCase() ?? "";
+      // A slotless binding (legacy or reassigned) holds no letter, so it can neither block planning nor be retired for capacity.
+      const bindings = inSnapshot(() => Array.from(workspaceBindings.values()).filter((binding) => binding.slot).map((binding) => {
+        const slot = binding.slot!.toLowerCase();
         const locallyProtected = isWorkspaceBindingLocallyProtected(
           binding,
           nowMs,
           {
-            requireBindingSlot: true,
             isRetirementExcluded: (intent) =>
               isDeepStrictEqual(intent, options?.expectedRetirement),
           },
@@ -7491,6 +7503,150 @@ export function createTelegramTopicTargetStore(
         : [...localReservedSlots, "invalid"];
       return { bindings, reservedSlots };
     },
+    async reuseLeastRecentlyUsedWorkspaceSlot(isCurrent) {
+      if (workspaceRetirementCommitInFlight || !isCurrent()) return undefined;
+      const external = captureExternalReservedSlots();
+      if (!external) return undefined;
+      const nowMs = getNowMs();
+      const currentRecords = Array.from(records.values()).filter(
+        ThreadReconciler.isCurrentThreadRecord,
+      );
+      const held = new Set<string>(
+        [
+          ...external,
+          ...Array.from(workspaceClaims.values()).map(
+            (claim) => claim.identity.slot,
+          ),
+          ...reservations
+            .filter(
+              (reservation) =>
+                reservation.expiresAtMs === undefined ||
+                reservation.expiresAtMs > nowMs,
+            )
+            .map((reservation) => reservation.slot),
+          ...pendingProvisions
+            .filter((provision) =>
+              isPendingProvisionLiveOrTargeted(provision, nowMs),
+            )
+            .map((provision) => provision.slot),
+        ].filter((slot): slot is string => !!slot),
+      );
+      const occupied = new Set<string>([
+        ...held,
+        ...Array.from(workspaceBindings.values()).flatMap((binding) =>
+          binding.slot ? [binding.slot] : [],
+        ),
+        ...currentRecords.flatMap((record) => (record.slot ? [record.slot] : [])),
+      ]);
+      if (
+        Array.from(TELEGRAM_WORKSPACE_SLOTS, (slot) => slot.toUpperCase()).some(
+          (slot) => !occupied.has(slot),
+        )
+      )
+        return { kind: "free" };
+      const claimedKeys = new Set(
+        Array.from(workspaceClaims.values()).map(
+          (claim) => claim.identity.bindingKey,
+        ),
+      );
+      const candidates = Array.from(workspaceBindings.values()).flatMap(
+        (binding) => {
+          const slot = binding.slot;
+          if (
+            !slot ||
+            !/^[A-Z]$/u.test(slot) ||
+            held.has(slot) ||
+            claimedKeys.has(binding.bindingKey) ||
+            hasWorkspaceRetirementConflict({
+              bindingKey: binding.bindingKey,
+              target: binding.target,
+              slot,
+            }) ||
+            pendingCleanups.some((intent) =>
+              targetMatches(intent.target, binding.target),
+            ) ||
+            // Another Thread already holding the letter is unresolved duplication, not reusable metadata.
+            currentRecords.some(
+              (record) =>
+                record.slot === slot && !targetMatches(record.target, binding.target),
+            )
+          )
+            return [];
+          const live = currentRecords.some((record) =>
+            targetMatches(record.target, binding.target),
+          );
+          return [
+            {
+              bindingKey: binding.bindingKey,
+              slot,
+              live,
+              lastUsedMs:
+                !live && binding.inactiveSinceMs !== undefined
+                  ? binding.inactiveSinceMs
+                  : binding.updatedAtMs,
+            },
+          ];
+        },
+      );
+      const selected = selectTelegramWorkspaceReusableSlot(candidates);
+      if (!selected) return undefined;
+      const mapKey = Array.from(workspaceBindings.entries()).find(
+        ([, binding]) => binding.bindingKey === selected.bindingKey,
+      )?.[0];
+      const binding = mapKey ? workspaceBindings.get(mapKey) : undefined;
+      if (!mapKey || !binding) return undefined;
+      const affected = currentRecords.filter(
+        (record) =>
+          record.slot === selected.slot && targetMatches(record.target, binding.target),
+      );
+      const previousBinding = cloneWorkspaceBinding(binding);
+      const previousRecords = affected.map((record) => ({
+        key: getRecordOwnerKey(record),
+        record: cloneRecord(record),
+        identity: identities.get(getRecordOwnerKey(record)),
+      }));
+      const { slot: _slot, ...slotless } = previousBinding;
+      workspaceRetirementCommitInFlight = true;
+      workspaceBindings.set(mapKey, slotless);
+      for (const record of affected) {
+        delete record.slot;
+        const key = getRecordOwnerKey(record);
+        const identity = identities.get(key);
+        if (identity?.slot === selected.slot) {
+          const { slot: _identitySlot, ...rest } = identity;
+          identities.set(key, rest);
+        }
+      }
+      markDirty();
+      const restoreInMemory = () => {
+        workspaceBindings.set(mapKey, cloneWorkspaceBinding(previousBinding));
+        for (const previous of previousRecords) {
+          records.set(previous.key, cloneRecord(previous.record));
+          if (previous.identity) identities.set(previous.key, previous.identity);
+        }
+        markDirty();
+      };
+      try {
+        if (!isCurrent() || !(await persistSnapshot())) {
+          restoreInMemory();
+          return undefined;
+        }
+        return {
+          kind: "reused" as const,
+          bindingKey: selected.bindingKey,
+          slot: selected.slot,
+        };
+      } catch (error) {
+        try {
+          await loadFromDisk();
+        } catch {
+          restoreInMemory();
+        }
+        throw error;
+      } finally {
+        workspaceRetirementCommitInFlight = false;
+      }
+    },
     hasWorkspaceBinding(cwd, sessionId) {
       const normalizedCwd = normalizeTelegramWorkspacePath(cwd);
       const normalizedSessionId =

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

@@ -10495,6 +10495,7 @@ export interface TelegramUpdateAdmissionLifecycleAssemblyDeps<
     | "getRecipientBindingKey"
     | "hasAuthority"
     | "prepareUpdateForExecution"
+    | "recoverRejectedRecipientTarget"
   >;
   leader: {
     resolveBinding: () =>
@@ -10507,6 +10508,9 @@ export interface TelegramUpdateAdmissionLifecycleAssemblyDeps<
     isRegistered: () => boolean;
     getGeneration: () => string | undefined;
     prepareUpdateForExecution: (update: TUpdate) => TUpdate;
+    recoverRejectedRecipientTarget?: NonNullable<
+      TelegramUpdateAdmissionWorkerRuntimeDeps<TUpdate, TContext>["recoverRejectedRecipientTarget"]
+    >;
     /** Session succession before worker creation, under the exact generation-fenced binding. */
     prepareBinding?: (
       binding: TelegramUpdateAdmissionLifecycleJournalBinding & {
@@ -10531,6 +10535,13 @@ export type TelegramUpdateAdmissionWorkerRuntimeDeps<
     execution?: TelegramUpdateExecutionFence,
   ) => Promise<void>;
   prepareUpdateForExecution?: (update: TUpdate) => TUpdate;
+  /**
+   * Recipient-only recovery for a journaled message whose own Thread changed (for example after its Thread was re-created):
+   * classifies a leader refusal of a reply to the original Thread and returns that Thread plus the owner's current one.
+   */
+  recoverRejectedRecipientTarget?: (error: unknown) =>
+    | { rejected: { chatId: number; threadId: number }; current: TelegramTarget & { threadId: number } }
+    | undefined;
   registry?: TelegramUpdateHandlerRegistry;
 };
 
@@ -10657,12 +10668,14 @@ export function createTelegramUpdateAdmissionWorkerRuntime<
       const typedUpdate = update as TUpdate;
       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 }) } : {}),
-      } as TUpdate : prepared;
+      // Journal/source evidence remains the original; only the warm released handler projection changes destination.
+      const projectTo = (destination: TelegramTarget & { threadId: number }): TUpdate => ({ ...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 }) } : {}),
+      } as TUpdate);
+      const routed = target ? projectTo(target) : prepared;
       try {
         return await executeUpdate(
           routed,
@@ -10673,6 +10686,17 @@ export function createTelegramUpdateAdmissionWorkerRuntime<
         if (await deps.settleTerminalExecutionFailure?.(error)) {
           return { kind: "complete" };
         }
+        // The leader refused a reply to a Thread this recipient no longer owns (re-created after the input was journaled).
+        // Re-run once against its current Thread; any other failure, or a second refusal, keeps the ordinary retry state.
+        const recovery = !target ? deps.recoverRejectedRecipientTarget?.(error) : undefined;
+        const message = prepared.message ?? prepared.edited_message;
+        if (recovery && message && message.message_thread_id === recovery.rejected.threadId &&
+            message.chat?.id === recovery.rejected.chatId && recovery.current.chatId === recovery.rejected.chatId &&
+            recovery.current.threadId !== recovery.rejected.threadId) {
+          deps.recordRuntimeEvent?.("inbound-worker", error, { phase: "recipient-target-recovery", updateId: update.update_id,
+            chatId: recovery.current.chatId, staleThreadId: recovery.rejected.threadId, threadId: recovery.current.threadId });
+          return await executeUpdate(projectTo(recovery.current), ctx, signal);
+        }
         throw error;
       }
     },
@@ -10753,6 +10777,9 @@ export function createTelegramUpdateAdmissionLifecycleAssembly<
         spendHistoricalInput: undefined,
         onHeldSourcesPrepared: undefined,
         prepareUpdateForExecution: deps.follower.prepareUpdateForExecution,
+        ...(deps.follower.recoverRejectedRecipientTarget
+          ? { recoverRejectedRecipientTarget: deps.follower.recoverRejectedRecipientTarget }
+          : {}),
       });
     },
     recordRuntimeEvent: deps.recordRuntimeEvent,

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

@@ -187,7 +187,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 };
   leaderEpoch: number | string;
   retirementRequestedAtMs: number;
@@ -228,7 +229,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 };
   readonly leaderEpoch: number | string;
   readonly issuedAtMs: number;
@@ -376,7 +377,7 @@ export interface TelegramWorkspaceAdmissionLedger {
     operationId: string;
     cleanupWorkSetId: string;
     bindingKey: string;
-    slot: string;
+    slot: string | null;
     target: TelegramTarget & { threadId: number };
     leaderEpoch: number | string;
     cleanupRequestedAtMs: number;
@@ -538,8 +539,8 @@ function normalizeFence(
     !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) ||
@@ -1869,7 +1870,7 @@ export function createTelegramWorkspaceAdmissionLedger(
       operationId: string;
       retirementIntentId: string;
       bindingKey: string;
-      slot: string;
+      slot: string | null;
       target: TelegramTarget & { threadId: number };
       leaderEpoch: number | string;
       retirementRequestedAtMs: number;
@@ -2307,7 +2308,7 @@ export function createTelegramWorkspaceAdmissionLedger(
     }),
     listReservedSlots: () => {
       const fence = read().fence;
-      return fence && isTelegramWorkspaceRetirementFence(fence)
+      return fence && isTelegramWorkspaceRetirementFence(fence) && fence.slot !== null
         ? [fence.slot]
         : [];
     },

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

@@ -1764,6 +1764,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",
@@ -1892,6 +1894,7 @@ export function createTelegramWorkspaceSlotRotation(
       binding: TelegramWorkspaceThreadBinding,
     ) => TelegramWorkspaceExternalProtectionEvidence;
     recordEvent: (message: string, details: Record<string, unknown>) => void;
+    onSlotReused?: (bindingKey: string, isCurrent: () => boolean) => Promise<void>;
   },
 ): TelegramWorkspaceCapacityRunner {
   const requests = createTelegramWorkspaceOperationGate();
@@ -1906,7 +1909,7 @@ export function createTelegramWorkspaceSlotRotation(
     return requests.runExclusive(async () => {
       if (!isCurrent())
         throw new Error("Telegram Workspace allocation lost leader authority.");
-      const rotate = async () => {
+      const rotate = async (options?: { reuseWhenProtected?: boolean }) => {
         const result = await input.runExclusive(async () => {
           if (!isCurrent())
             throw new Error(
@@ -1959,6 +1962,57 @@ export function createTelegramWorkspaceSlotRotation(
             },
           });
         });
+        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" as const };
+          }
+        }
         if (
           result.kind !== "retired" &&
           result.kind !== "not-needed" &&
@@ -2104,7 +2158,7 @@ export function createTelegramWorkspaceSlotRotation(
             }
           }
         }
-        await rotate();
+        await rotate({ reuseWhenProtected: true });
         return operation();
       }
     });

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

@@ -27,6 +27,50 @@ export type TelegramWorkspaceSlotAllocation =
   | { kind: "reclaim"; candidate: TelegramWorkspaceSlotOccupancy }
   | { 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 function selectTelegramWorkspaceReusableSlot(
+  candidates: readonly TelegramWorkspaceReusableSlot[],
+): TelegramWorkspaceReusableSlot | undefined {
+  const slots = new Set<string>();
+  const keys = new Set<string>();
+  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: string): boolean {
   return /^[a-z]$/u.test(slot);
 }

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

@@ -1,6 +1,6 @@
 {
   "name": "@llblab/pi-telegram",
-  "version": "0.57.3",
+  "version": "0.57.7",
   "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",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@llblab/pi-kit",
-  "version": "0.36.1",
+  "version": "0.36.2",
   "private": false,
   "publishConfig": {
     "access": "public"
@@ -45,12 +45,12 @@
   ],
   "dependencies": {
     "@llblab/pi-actors": "0.55.0",
-    "@llblab/pi-claude-usage": "0.2.2",
+    "@llblab/pi-claude-usage": "0.2.3",
     "@llblab/pi-clean-room": "0.3.0",
-    "@llblab/pi-codex-usage": "0.13.1",
+    "@llblab/pi-codex-usage": "0.13.2",
     "@llblab/pi-grow-loop": "0.9.0",
     "@llblab/pi-state-flow": "0.26.5",
-    "@llblab/pi-telegram": "0.57.3",
+    "@llblab/pi-telegram": "0.57.7",
     "@llblab/skills": "1.15.0"
   },
   "bundledDependencies": [