@llblab/pi-kit 0.35.1 → 0.35.3

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

@@ -6,6 +6,16 @@
 
 import * as Machine from "./machine.ts";
 
+/**
+ * Structural port for run-collapsing diagnostics: a repeated identical failure extends its run instead of logging
+ * again, and the closing success records one outcome. The composition root owns the collapsed implementation.
+ */
+export interface TelegramRepeatedFailureLogPort {
+  record: (error: unknown, details?: Record<string, unknown>) => void;
+  settled: () => void;
+  reset: () => void;
+}
+
 const TELEGRAM_TYPING_ACTION_INTERVAL_MS = 3_000;
 const TELEGRAM_TYPING_IDLE_DRAIN_MAX_MS = 250;
 
@@ -344,6 +354,8 @@ function updateTelegramRuntimeStatusSafely<TContext>(
 export interface TelegramTypingLoopStarterDeps<
   TContext,
 > extends TelegramRuntimeEventRecorderPort {
+  /** Collapses one sustained presence failure run; the caller supplies its owner. */
+  failureLog: TelegramRepeatedFailureLogPort;
   typing: TelegramRuntimeTypingPort;
   getDefaultChatId: () => number | undefined;
   sendTypingAction: (
@@ -374,6 +386,31 @@ export function createTelegramTypingLoopStarter<TContext>(
     threadId: number | undefined;
     canContinue: () => boolean;
   } | undefined;
+  // An unreachable transport repeats one identical presence failure every tick; the port collapses the run.
+  // Running it through one guard keeps a faulty diagnostics port from escaping the in-flight action owner.
+  const typingFailureLog: TelegramRepeatedFailureLogPort = {
+    record(error, details) {
+      try {
+        deps.failureLog.record(error, details);
+      } catch {
+        // Typing diagnostics cannot escape the in-flight action owner.
+      }
+    },
+    settled() {
+      try {
+        deps.failureLog.settled();
+      } catch {
+        // A successful presence outranks its own diagnostic.
+      }
+    },
+    reset() {
+      try {
+        deps.failureLog.reset();
+      } catch {
+        // Typing diagnostics cannot fail a loop stop.
+      }
+    },
+  };
   return (ctx, chatId, options) => {
     const sessionGeneration = deps.getSessionGeneration?.();
     const transportAuthority = deps.getTransportAuthority?.();
@@ -422,24 +459,20 @@ export function createTelegramTypingLoopStarter<TContext>(
               if (!active || !canContinue()) throw new Error("Typing context authority changed.");
             },
           });
+          typingFailureLog.settled();
         } catch (error) {
           if (!active) return;
           if (!canContinue()) {
             deps.typing.stop();
             return;
           }
-          try {
-            deps.recordRuntimeEvent?.("typing", error, {
-              chatId: targetChatId,
-            });
-          } catch {
-            // Typing diagnostics cannot escape the in-flight action owner.
-          }
+          typingFailureLog.record(error, { chatId: targetChatId });
         }
       },
       shouldContinue: canContinue,
       onStopped: () => {
         active = false;
+        typingFailureLog.reset();
         if (currentOwner === owner) currentOwner = undefined;
       },
     });

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

@@ -401,6 +401,8 @@ export interface TelegramApiCallOptions {
   sleep?: (ms: number) => Promise<void>;
   /** Observability hook fired before a 429 retry wait, never for 5xx waits. */
   onRetryWait?: (wait: TelegramApiRetryWait) => void;
+  /** Caller-owned expected failure: still thrown, but the caller records the outcome instead of the API log. */
+  isExpectedError?: (error: unknown) => boolean;
 }
 
 export class TelegramApiAuthorityError extends Error {
@@ -2197,11 +2199,12 @@ export function createTelegramBridgeApiRuntime(
       ) {
         return true as TResponse;
       }
-      deps.recordRuntimeEvent(
-        "api",
-        error,
-        withTelegramTransportDiagnostics(error, { method }),
-      );
+      if (!options?.isExpectedError?.(error))
+        deps.recordRuntimeEvent(
+          "api",
+          error,
+          withTelegramTransportDiagnostics(error, { method }),
+        );
       throw error;
     }
   };

package/node_modules/@llblab/pi-telegram/lib/thread-reconciler.ts

@@ -719,7 +719,12 @@ export async function applyThreadReconciliationPlan(
       }
       let deleteConfirmed = false;
       let superseded = false;
-      for (const method of ports.skipCloseBeforeDelete
+      // Private-chat topics (positive chat ids) cannot be closed; Telegram only supports closeForumTopic in forums.
+      const skipClose =
+        ports.skipCloseBeforeDelete ||
+        (action.kind === "close-delete-graceful-shutdown-topic" &&
+          action.target.chatId > 0);
+      for (const method of skipClose
         ? ["deleteForumTopic"]
         : ["closeForumTopic", "deleteForumTopic"]) {
         if (ports.isCleanupTargetProtected?.(action.target, action)) {

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

@@ -252,6 +252,13 @@ export interface TelegramWorkspaceExternalProtectionEvidence {
   deliveryAuthority: TelegramWorkspaceProtectionState;
 }
 
+/** Per-binding probe; `withSnapshot` lets one occupancy capture share binding-independent evidence reads. */
+export type TelegramWorkspaceExternalProtectionCapture = ((
+  binding: TelegramWorkspaceThreadBinding,
+) => TelegramWorkspaceExternalProtectionEvidence) & {
+  withSnapshot?: <T>(capture: () => T) => T;
+};
+
 export interface TelegramWorkspaceSlotOccupancySnapshot {
   bindings: TelegramWorkspaceSlotOccupancy[];
   reservedSlots: string[];
@@ -876,9 +883,7 @@ export interface TelegramTopicTargetStore {
   ) => Promise<boolean>;
   /** Caller must separately prove no external live owner, accepted work, or delivery authority. */
   captureWorkspaceSlotOccupancy: (
-    getExternalProtection: (
-      binding: TelegramWorkspaceThreadBinding,
-    ) => TelegramWorkspaceExternalProtectionEvidence,
+    getExternalProtection: TelegramWorkspaceExternalProtectionCapture,
     options?: { expectedRetirement?: TelegramWorkspaceRetirementIntent },
   ) => TelegramWorkspaceSlotOccupancySnapshot;
   hasWorkspaceBinding: (cwd: string, sessionId?: string) => boolean;
@@ -7359,7 +7364,9 @@ export function createTelegramTopicTargetStore(
     },
     captureWorkspaceSlotOccupancy(getExternalProtection, options) {
       const nowMs = getNowMs();
-      const bindings = Array.from(workspaceBindings.values()).map((binding) => {
+      const inSnapshot =
+        getExternalProtection.withSnapshot ?? ((capture) => capture());
+      const bindings = inSnapshot(() => Array.from(workspaceBindings.values()).map((binding) => {
         const slot = binding.slot?.toLowerCase() ?? "";
         const locallyProtected = isWorkspaceBindingLocallyProtected(
           binding,
@@ -7398,7 +7405,7 @@ export function createTelegramTopicTargetStore(
             : {}),
           protection,
         };
-      });
+      }));
       const localReservedSlots = [
         ...Array.from(workspaceClaims.values()).map(
           (claim) => claim.identity.slot,

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

@@ -146,6 +146,8 @@ export function captureTelegramWorkspaceJournalProtectionSources(input: {
       path: string,
     ) => () => TelegramWorkspaceJournalReader | undefined;
   };
+  /** Snapshot-scoped reuse of binding-independent (shared/discovered) source reads. */
+  sharedSourceReads?: Map<string, TelegramWorkspaceJournalProtectionSource>;
 }): TelegramWorkspaceJournalProtectionCapture {
   const sources: TelegramWorkspaceJournalProtectionSource[] = [];
   let complete =
@@ -155,26 +157,43 @@ export function captureTelegramWorkspaceJournalProtectionSources(input: {
     scope: TelegramWorkspaceJournalProtectionSource["scope"],
     resolve: () => TelegramWorkspaceJournalReader | undefined,
   ): void => {
+    const sharedKey =
+      scope.kind === "shared"
+        ? "shared"
+        : scope.kind === "discovered"
+          ? `discovered:${scope.path}`
+          : undefined;
+    let source =
+      sharedKey === undefined
+        ? undefined
+        : input.sharedSourceReads?.get(sharedKey);
+    if (!source) {
+      source = readSource(scope, resolve);
+      if (sharedKey !== undefined)
+        input.sharedSourceReads?.set(sharedKey, source);
+    }
+    if (source.kind === "unknown") complete = false;
+    sources.push(source);
+  };
+  const readSource = (
+    scope: TelegramWorkspaceJournalProtectionSource["scope"],
+    resolve: () => TelegramWorkspaceJournalReader | undefined,
+  ): TelegramWorkspaceJournalProtectionSource => {
     try {
       const binding = resolve();
-      if (!binding) {
-        complete = false;
-        sources.push({ kind: "unknown", scope });
-        return;
-      }
+      if (!binding) return { kind: "unknown", scope };
       const read = binding.readForProtection ?? binding.journal.read;
       const snapshot = input.withJournalReference
         ? input.withJournalReference(binding, read)
         : read();
-      sources.push({
+      return {
         kind: "available",
         scope,
         entries: snapshot.entries,
         ...(snapshot.exists === undefined ? {} : { exists: snapshot.exists }),
-      });
+      };
     } catch {
-      complete = false;
-      sources.push({ kind: "unknown", scope });
+      return { kind: "unknown", scope };
     }
   };
   capture({ kind: "shared" }, input.resolveLeader);
@@ -586,10 +605,12 @@ interface TelegramWorkspaceProtectionObserverDeps {
 }
 
 export interface TelegramWorkspaceProtectionObserver {
-  capture: (
+  capture: ((
     binding: TelegramWorkspaceThreadBinding,
     options?: { requireBindingProvenance?: boolean },
-  ) => TelegramWorkspaceExternalProtectionEvidence;
+  ) => TelegramWorkspaceExternalProtectionEvidence) & {
+    withSnapshot?: <T>(capture: () => T) => T;
+  };
   captureJournalSources: (
     binding: TelegramWorkspaceThreadBinding,
   ) => TelegramWorkspaceJournalProtectionCapture;
@@ -602,9 +623,39 @@ export interface TelegramWorkspaceProtectionObserver {
 export function createTelegramWorkspaceProtectionObserver(
   deps: TelegramWorkspaceProtectionObserverDeps,
 ): TelegramWorkspaceProtectionObserver {
+  // One occupancy snapshot probes every binding synchronously; namespace and shared/discovered
+  // journal reads are binding-independent, so read them once per snapshot instead of per binding.
+  // Never widen this beyond one synchronous capture: post-fence rechecks need fresh evidence.
+  let snapshot:
+    | {
+        namespace?: { value?: TelegramJournalNamespaceInspection; error?: unknown };
+        reads: Map<string, TelegramWorkspaceJournalProtectionSource>;
+      }
+    | undefined;
+  const inspectNamespace = (): TelegramJournalNamespaceInspection | undefined => {
+    if (!snapshot) return deps.inspectJournalNamespace?.();
+    if (!snapshot.namespace) {
+      try {
+        snapshot.namespace = { value: deps.inspectJournalNamespace?.() };
+      } catch (error) {
+        snapshot.namespace = { error };
+      }
+    }
+    if ("error" in snapshot.namespace) throw snapshot.namespace.error;
+    return snapshot.namespace.value;
+  };
+  const withSnapshot = <T>(run: () => T): T => {
+    if (snapshot) return run();
+    snapshot = { reads: new Map() };
+    try {
+      return run();
+    } finally {
+      snapshot = undefined;
+    }
+  };
   const captureJournalSources: TelegramWorkspaceProtectionObserver["captureJournalSources"] =
     (candidate) => {
-      const namespace = deps.inspectJournalNamespace?.();
+      const namespace = inspectNamespace();
       if (
         deps.inspectJournalNamespace &&
         (!namespace ||
@@ -658,12 +709,13 @@ export function createTelegramWorkspaceProtectionObserver(
               },
             }
           : {}),
+        ...(snapshot ? { sharedSourceReads: snapshot.reads } : {}),
       });
     };
-  const capture: TelegramWorkspaceProtectionObserver["capture"] = function (
-    binding,
-    options,
-  ) {
+  const captureOne = function (
+    binding: TelegramWorkspaceThreadBinding,
+    options?: { requireBindingProvenance?: boolean },
+  ): TelegramWorkspaceExternalProtectionEvidence {
     return captureTelegramWorkspaceExternalProtection({
       binding,
       requireBindingProvenance: options?.requireBindingProvenance,
@@ -714,7 +766,7 @@ export function createTelegramWorkspaceProtectionObserver(
     });
   };
   return {
-    capture,
+    capture: Object.assign(captureOne, { withSnapshot }),
     captureJournalSources,
     getJournalWriterProtection:
       deps.getJournalWriterProtection ?? (() => "unknown"),

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

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@llblab/pi-kit",
-  "version": "0.35.1",
+  "version": "0.35.3",
   "private": false,
   "publishConfig": {
     "access": "public"
@@ -33,6 +33,7 @@
     "validate": "npm test && npm run audit && npm run pack:check"
   },
   "files": [
+    "extensions/",
     "README.md",
     "AGENTS.md",
     "BACKLOG.md",
@@ -47,7 +48,7 @@
     "@llblab/pi-codex-usage": "0.13.1",
     "@llblab/pi-grow-loop": "0.9.0",
     "@llblab/pi-state-flow": "0.26.4",
-    "@llblab/pi-telegram": "0.57.1",
+    "@llblab/pi-telegram": "0.57.2",
     "@llblab/skills": "1.15.0"
   },
   "bundledDependencies": [
@@ -62,13 +63,13 @@
   ],
   "pi": {
     "extensions": [
-      "./node_modules/@llblab/pi-actors/dist/pi-actors/index.js",
-      "./node_modules/@llblab/pi-claude-usage/index.ts",
-      "./node_modules/@llblab/pi-clean-room/index.ts",
-      "./node_modules/@llblab/pi-codex-usage/index.ts",
-      "./node_modules/@llblab/pi-grow-loop/dist/pi-grow-loop/index.js",
-      "./node_modules/@llblab/pi-state-flow/dist/pi-state-flow/index.js",
-      "./node_modules/@llblab/pi-telegram/dist/pi-telegram/index.js"
+      "./extensions/pi-actors/index.js",
+      "./extensions/pi-claude-usage/index.ts",
+      "./extensions/pi-clean-room/index.ts",
+      "./extensions/pi-codex-usage/index.ts",
+      "./extensions/pi-grow-loop/index.js",
+      "./extensions/pi-state-flow/index.js",
+      "./extensions/pi-telegram/index.js"
     ],
     "skills": [
       "./node_modules/@llblab/pi-actors/dist/skills",