@llblab/pi-telegram 0.45.11 → 0.47.0

package/lib/outbound-markup.ts

@@ -504,14 +504,23 @@ function parseTelegramAdaptiveActionPayloadRows(
     return undefined;
   };
 
+  const parseVerticalSequence = (): Record<string, unknown>[][] | undefined => {
+    const rows: Record<string, unknown>[][] = [];
+    while (offset < source.length) {
+      skipWhitespace();
+      if (source[offset] !== "{") break;
+      const cell = parseCell();
+      if (!cell) return undefined;
+      rows.push([cell]);
+      if (!consumeOptionalSeparator()) return undefined;
+    }
+    return rows.length > 0 ? rows : undefined;
+  };
+
   skipWhitespace();
-  let rows: Record<string, unknown>[][] | undefined;
-  if (source[offset] === "{") {
-    const cell = parseCell();
-    rows = cell ? [[cell]] : undefined;
-  } else {
-    rows = parseMatrix();
-  }
+  const rows = source[offset] === "{"
+    ? parseVerticalSequence()
+    : parseMatrix();
   if (!rows) return undefined;
   skipWhitespace();
   if (!options.allowTrailing && offset !== source.length) return undefined;

package/lib/pi.ts

@@ -260,6 +260,10 @@ export function getExtensionContextCwd(ctx: ExtensionContext): string {
   return ctx.cwd;
 }
 
+export function getExtensionContextSessionId(ctx: ExtensionContext): string {
+  return ctx.sessionManager.getSessionId();
+}
+
 export function isExtensionContextIdle(ctx: ExtensionContext): boolean {
   return ctx.isIdle();
 }

package/lib/sync.ts

@@ -46,6 +46,7 @@ export interface TelegramLeaderThreadSyncDeps {
   getAllowedUserId: () => number | undefined;
   instanceId: string;
   cwd?: string;
+  sessionId?: string;
   telegramProfile?: string;
   forceFreshUnnamed?: boolean;
   requestedThreadName?: string;
@@ -654,6 +655,7 @@ export async function ensureTelegramLeaderThreadBinding(
         normalizedLeaderCwd,
         deps.instanceId,
         legacyLeaderRecord?.instanceId,
+        { sessionId: deps.sessionId },
       )
     : undefined;
   if (deps.cwd && !workspaceIdentity) {
@@ -715,6 +717,7 @@ export async function ensureTelegramLeaderThreadBinding(
     ? deps.topicTargetStore.getWorkspaceBinding(
         workspaceIdentity.cwd,
         workspaceIdentity.instanceSlot,
+        workspaceIdentity.sessionId,
       )
     : undefined;
   const legacyWorkspaceBinding =

package/lib/telegram-api.ts

@@ -964,7 +964,7 @@ export function isTelegramApiMethodRetrySafe(method: string): boolean {
   return TELEGRAM_RETRY_SAFE_METHODS.has(method);
 }
 
-function isRetryableTelegramApiError(error: unknown): boolean {
+export function isRetryableTelegramApiError(error: unknown): boolean {
   return (
     error instanceof TelegramApiHttpError &&
     (error.status === 429 ||
@@ -972,6 +972,17 @@ function isRetryableTelegramApiError(error: unknown): boolean {
   );
 }
 
+export function getTelegramApiRetryAfterMs(error: unknown): number | undefined {
+  return error instanceof TelegramApiHttpError && error.retryAfterSeconds !== undefined
+    ? Math.max(0, error.retryAfterSeconds * 1000)
+    : undefined;
+}
+
+export function isTelegramMessageUnavailableError(error: unknown): boolean {
+  return error instanceof TelegramApiHttpError && error.status === 400 &&
+    /Bad Request: (message to edit not found|message not found|message_id_invalid)/iu.test(error.message);
+}
+
 function getTelegramRetryDelayMs(
   error: unknown,
   attempt: number,

package/lib/thread-cleanup-manager.ts

@@ -17,6 +17,8 @@ import type { TelegramWorkspaceDeletionPermit,
 export interface TelegramThreadCleanupBindingSnapshot {
   cwd: string;
   workspaceKey: string;
+  sessionId?: string;
+  sessionKey?: string;
   instanceSlot: string;
   slot?: string;
   bindingKey: string;
@@ -40,6 +42,8 @@ export interface TelegramThreadCleanupCandidate {
   bindingKey: string;
   cwd: string;
   workspaceKey: string;
+  sessionId?: string;
+  sessionKey?: string;
   instanceSlot: string;
   slot: string;
   target: { chatId: number; threadId: number };
@@ -56,6 +60,21 @@ function validTarget(target: { chatId: number; threadId: number }): boolean {
     target.threadId > 0;
 }
 
+function validSessionIdentity(value: {
+  sessionId?: unknown;
+  sessionKey?: unknown;
+}): boolean {
+  if (value.sessionId === undefined && value.sessionKey === undefined) return true;
+  if (typeof value.sessionId !== "string" || !value.sessionId ||
+      value.sessionId !== value.sessionId.trim() ||
+      Buffer.byteLength(value.sessionId, "utf8") > 256 ||
+      typeof value.sessionKey !== "string" || !/^[a-f0-9]{64}$/u.test(value.sessionKey)) {
+    return false;
+  }
+  return createHash("sha256").update(value.sessionId).digest("hex") ===
+    value.sessionKey;
+}
+
 /** Returns no candidates when any identity/evidence ambiguity exists. */
 export function planTelegramInactiveThreadCleanup(input: {
   profileName: string;
@@ -72,7 +91,7 @@ export function planTelegramInactiveThreadCleanup(input: {
     const key = targetKey(binding.target);
     const slot = binding.slot;
     if (!binding.bindingKey || !binding.cwd || !binding.workspaceKey || !binding.instanceSlot ||
-        typeof slot !== "string" || !slot ||
+        typeof slot !== "string" || !slot || !validSessionIdentity(binding) ||
         !validTarget(binding.target) || bindingKeys.has(binding.bindingKey) || bindingTargets.has(key)) return [];
     bindingKeys.add(binding.bindingKey);
     bindingTargets.add(key);
@@ -101,8 +120,11 @@ export function planTelegramInactiveThreadCleanup(input: {
         evidence.liveOwner !== "clear" || evidence.acceptedWork !== "clear" ||
         evidence.deliveryAuthority !== "clear" || competing.has(targetKey(binding.target))) continue;
     candidates.push({ profileName: input.profileName, bindingKey: binding.bindingKey,
-      cwd: binding.cwd, workspaceKey: binding.workspaceKey, instanceSlot: binding.instanceSlot,
-      slot, target: { ...binding.target }, inactiveSinceMs,
+      cwd: binding.cwd, workspaceKey: binding.workspaceKey,
+      ...(binding.sessionId && binding.sessionKey
+        ? { sessionId: binding.sessionId, sessionKey: binding.sessionKey }
+        : {}),
+      instanceSlot: binding.instanceSlot, slot, target: { ...binding.target }, inactiveSinceMs,
       bindingUpdatedAtMs: binding.updatedAtMs });
   }
   return candidates.sort((left, right) => left.bindingKey.localeCompare(right.bindingKey));
@@ -124,7 +146,11 @@ export function captureTelegramInactiveThreadCleanupEvidence<
 }): Parameters<typeof planTelegramInactiveThreadCleanup>[0] {
   const sourceBindings = input.listBindings();
   const bindings = sourceBindings.map(binding => ({
-    cwd: binding.cwd, workspaceKey: binding.workspaceKey, instanceSlot: binding.instanceSlot,
+    cwd: binding.cwd, workspaceKey: binding.workspaceKey,
+    ...(binding.sessionId && binding.sessionKey
+      ? { sessionId: binding.sessionId, sessionKey: binding.sessionKey }
+      : {}),
+    instanceSlot: binding.instanceSlot,
     ...(binding.slot === undefined ? {} : { slot: binding.slot }), bindingKey: binding.bindingKey, target: { ...binding.target },
     ...(binding.inactiveSinceMs === undefined ? {} : { inactiveSinceMs: binding.inactiveSinceMs }),
     updatedAtMs: binding.updatedAtMs,
@@ -237,16 +263,20 @@ function validateWorkSet(value: unknown, profileName: string): TelegramThreadCle
   const createdAtMs = value.createdAtMs as number;
   const entries = value.entries.map(raw => {
     if (!isObject(raw) || !onlyKeys(raw, ["profileName", "bindingKey", "cwd", "workspaceKey",
-      "instanceSlot", "slot", "target", "inactiveSinceMs", "bindingUpdatedAtMs", "state", "updatedAtMs",
+      "sessionId", "sessionKey", "instanceSlot", "slot", "target", "inactiveSinceMs", "bindingUpdatedAtMs", "state", "updatedAtMs",
       "issuedAtMs", "permitOperationId", "permitIntentId", "permitLeaderEpoch", "deletedAtMs"]) || raw.profileName !== profileName || typeof raw.bindingKey !== "string" ||
       !raw.bindingKey || typeof raw.cwd !== "string" || !raw.cwd || typeof raw.workspaceKey !== "string" ||
-      !raw.workspaceKey || typeof raw.instanceSlot !== "string" || !raw.instanceSlot ||
+      !raw.workspaceKey || !validSessionIdentity(raw) ||
+      typeof raw.instanceSlot !== "string" || !raw.instanceSlot ||
       typeof raw.slot !== "string" || !raw.slot || !isObject(raw.target) ||
       !onlyKeys(raw.target, ["chatId", "threadId"]) || !validTarget(raw.target as unknown as { chatId: number; threadId: number }) ||
       !safeTime(raw.inactiveSinceMs) || !safeTime(raw.bindingUpdatedAtMs) ||
       (raw.bindingUpdatedAtMs as number) < (raw.inactiveSinceMs as number) || !safeTime(raw.updatedAtMs))
       throw new Error("Telegram Thread cleanup entry schema is invalid.");
     const base = { profileName, bindingKey: raw.bindingKey, cwd: raw.cwd, workspaceKey: raw.workspaceKey,
+      ...(typeof raw.sessionId === "string" && typeof raw.sessionKey === "string"
+        ? { sessionId: raw.sessionId, sessionKey: raw.sessionKey }
+        : {}),
       instanceSlot: raw.instanceSlot, slot: raw.slot, target: { chatId: raw.target.chatId as number,
         threadId: raw.target.threadId as number }, inactiveSinceMs: raw.inactiveSinceMs as number,
       bindingUpdatedAtMs: raw.bindingUpdatedAtMs as number, updatedAtMs: raw.updatedAtMs as number };

package/lib/thread-display.ts

@@ -26,30 +26,88 @@ function boundedLabel(base: string, suffix = ""): string {
   return `${prefix}${suffix}`;
 }
 
-function directoryLabel(cwd: string, directories: readonly string[]): string {
-  const parts = cwd.split("/").filter(Boolean);
-  if (!parts.length) return "/";
+function directorySegments(cwd: string): string[] {
+  return cwd.split("/").filter(Boolean);
+}
+
+function distinguishingDirectorySegments(cwd: string, directories: readonly string[]): string[] {
+  const parts = directorySegments(cwd);
+  if (!parts.length) return [];
   for (let depth = 1; depth <= parts.length; depth++) {
     const candidate = labelText(parts.slice(-depth).join("/"));
     const collides = directories.some((other) => other !== cwd &&
-      labelText(other.split("/").filter(Boolean).slice(-depth).join("/")).toLowerCase() ===
+      labelText(directorySegments(other).slice(-depth).join("/")).toLowerCase() ===
         candidate.toLowerCase(),
     );
-    if (!collides) return candidate;
+    if (!collides) return parts.slice(-depth);
   }
-  return labelText(cwd);
+  return parts;
+}
+
+function directoryLabel(cwd: string, directories: readonly string[]): string {
+  const parts = distinguishingDirectorySegments(cwd, directories);
+  return parts.length ? labelText(parts.join("/")) : "/";
+}
+
+/** Pure directory tokenization shared by previews, initial titles, and reconciliation. */
+export function tokenizeTelegramDirectorySegment(segment: string): string[] {
+  return segment
+    .replace(/([\p{Ll}\p{N}])(\p{Lu})/gu, "$1\u0000$2")
+    .replace(/(\p{Lu})(\p{Lu}\p{Ll})/gu, "$1\u0000$2")
+    .split(/[^\p{L}\p{N}]+|\u0000/gu)
+    .filter(Boolean);
+}
+
+function formatDirectoryLabel(
+  cwd: string,
+  directories: readonly string[],
+  mode: "directory-snake" | "directory-title",
+): string {
+  const segments = distinguishingDirectorySegments(cwd, directories);
+  if (!segments.length) return "/";
+  const formatted = segments.map((segment) => {
+    const tokens = tokenizeTelegramDirectorySegment(segment);
+    if (!tokens.length) return "";
+    if (mode === "directory-snake") return tokens.map((token) => token.toLowerCase()).join("_");
+    return tokens.map((token) => /\p{L}/u.test(token) && token === token.toUpperCase()
+      ? token
+      : `${token.slice(0, 1).toUpperCase()}${token.slice(1).toLowerCase()}`).join(" ");
+  }).filter(Boolean);
+  if (!formatted.length) return directoryLabel(cwd, directories);
+  return formatted.join(mode === "directory-snake" ? "_" : " / ");
+}
+
+/** Maps one leader-captured authenticated owner roster onto retained binding identities. */
+export function resolveTelegramLiveWorkspaceBindingKeys(
+  bindings: readonly TelegramWorkspaceThreadBinding[],
+  leaderTarget: { chatId: number; threadId?: number } | undefined,
+  followers: readonly { target?: { chatId: number; threadId?: number } }[],
+): ReadonlySet<string> {
+  const targets = new Set<string>();
+  const add = (target: { chatId: number; threadId?: number } | undefined) => {
+    if (target && typeof target.threadId === "number") {
+      targets.add(`${target.chatId}:${target.threadId}`);
+    }
+  };
+  add(leaderTarget);
+  for (const follower of followers) add(follower.target);
+  return new Set(bindings.filter((binding) =>
+    targets.has(`${binding.target.chatId}:${binding.target.threadId}`),
+  ).map((binding) => binding.bindingKey));
 }
 
 /** Missing or ambiguous metadata yields no label rather than inventing identity. */
 export function resolveTelegramWorkspaceDisplayNames(
   bindings: readonly TelegramWorkspaceDisplayBinding[],
   mode: TelegramThreadDisplayMode,
+  liveBindingKeys: ReadonlySet<string> = new Set(),
 ): Map<string, string> {
   const labels = new Map<string, string>();
   const directories = Array.from(new Set(bindings.map((binding) => binding.cwd)));
-  const directoryCounts = new Map<string, number>();
+  const liveDirectoryCounts = new Map<string, number>();
   for (const binding of bindings) {
-    directoryCounts.set(binding.cwd, (directoryCounts.get(binding.cwd) ?? 0) + 1);
+    if (!liveBindingKeys.has(binding.bindingKey)) continue;
+    liveDirectoryCounts.set(binding.cwd, (liveDirectoryCounts.get(binding.cwd) ?? 0) + 1);
   }
   const bases = new Map<string, string>();
   for (const binding of bindings) {
@@ -65,18 +123,27 @@ export function resolveTelegramWorkspaceDisplayNames(
       const name = binding.threadName ? labelText(binding.threadName) : slot;
       if (name) labels.set(binding.bindingKey, boundedLabel(name));
     } else {
-      const base = directoryLabel(binding.cwd, directories);
+      const base = mode === "directories"
+        ? directoryLabel(binding.cwd, directories)
+        : formatDirectoryLabel(binding.cwd, directories, mode);
       bases.set(binding.bindingKey, base);
-      const showSuffix = binding.showSlotSuffix ||
-        (directoryCounts.get(binding.cwd) ?? 0) > 1;
+      const showSuffix = mode === "directories"
+        ? binding.showSlotSuffix || bindings.filter((candidate) => candidate.cwd === binding.cwd).length > 1
+        : (liveDirectoryCounts.get(binding.cwd) ?? 0) > 1;
       if (showSuffix && !slot) continue;
-      labels.set(binding.bindingKey, boundedLabel(base, showSuffix ? `_${slot!.toLowerCase()}` : ""));
+      const suffix = !showSuffix ? "" : mode === "directory-title"
+        ? ` · ${slot}`
+        : `_${slot!.toLowerCase()}`;
+      labels.set(binding.bindingKey, boundedLabel(base, suffix));
     }
   }
   // Long or whitespace-normalized paths can collide even after qualification.
-  if (mode === "directories") {
+  if (mode === "directories" || mode === "directory-snake" || mode === "directory-title") {
     const counts = new Map<string, number>();
-    for (const label of labels.values()) {
+    for (const binding of bindings) {
+      const label = labels.get(binding.bindingKey);
+      if (!label || ((mode === "directory-snake" || mode === "directory-title") &&
+          !liveBindingKeys.has(binding.bindingKey))) continue;
       const key = label.toLowerCase();
       counts.set(key, (counts.get(key) ?? 0) + 1);
     }
@@ -84,16 +151,24 @@ export function resolveTelegramWorkspaceDisplayNames(
       const label = labels.get(binding.bindingKey);
       if (binding.manualThreadName || !label ||
           (counts.get(label.toLowerCase()) ?? 0) < 2) continue;
+      if ((mode === "directory-snake" || mode === "directory-title") &&
+          (liveDirectoryCounts.get(binding.cwd) ?? 0) < 2) {
+        labels.delete(binding.bindingKey);
+        continue;
+      }
       if (!binding.slot || !/^[A-Z]$/u.test(binding.slot)) {
         labels.delete(binding.bindingKey);
         continue;
       }
       labels.set(binding.bindingKey, boundedLabel(bases.get(binding.bindingKey)!,
-        `_${binding.slot.toLowerCase()}`));
+        mode === "directory-title" ? ` · ${binding.slot}` : `_${binding.slot.toLowerCase()}`));
     }
   }
   const counts = new Map<string, number>();
-  for (const label of labels.values()) {
+  for (const binding of bindings) {
+    const label = labels.get(binding.bindingKey);
+    if (!label || ((mode === "directory-snake" || mode === "directory-title") &&
+        !liveBindingKeys.has(binding.bindingKey))) continue;
     const key = label.toLowerCase();
     counts.set(key, (counts.get(key) ?? 0) + 1);
   }
@@ -108,6 +183,7 @@ export function resolveTelegramInitialWorkspaceDisplayName(input: {
   binding: TelegramWorkspaceDisplayBinding;
   mode: TelegramThreadDisplayMode;
   preserveRetainedManualName?: boolean;
+  liveBindingKeys?: ReadonlySet<string>;
 }): string | undefined {
   const retained = input.bindings.find((binding) =>
     binding.bindingKey === input.binding.bindingKey,
@@ -126,7 +202,7 @@ export function resolveTelegramInitialWorkspaceDisplayName(input: {
       candidate.bindingKey !== binding.bindingKey,
     ),
     binding,
-  ], input.mode).get(binding.bindingKey);
+  ], input.mode, new Set([...(input.liveBindingKeys ?? []), binding.bindingKey])).get(binding.bindingKey);
 }
 
 export async function applyTelegramThreadDisplaySetting(
@@ -155,6 +231,7 @@ export interface TelegramThreadDisplayReconcilerDeps {
   getProfileKey(): string;
   getLeaderEpoch(): string | number | undefined;
   captureBindingAuthority(binding: TelegramWorkspaceThreadBinding): (() => boolean) | undefined;
+  captureLiveBindingKeys(bindings: readonly TelegramWorkspaceThreadBinding[]): ReadonlySet<string>;
   callApi<TResponse>(
     method: string,
     body: Record<string, unknown>,
@@ -179,7 +256,8 @@ export function createTelegramThreadDisplayReconciler(
     };
     assertAuthority();
     const bindings = deps.store.listWorkspaceBindings();
-    const titles = resolveTelegramWorkspaceDisplayNames(bindings, mode);
+    const liveBindingKeys = deps.captureLiveBindingKeys(bindings);
+    const titles = resolveTelegramWorkspaceDisplayNames(bindings, mode, liveBindingKeys);
     let changed = 0;
     for (const binding of bindings) {
       const isBindingCurrent = deps.captureBindingAuthority(binding);