@llblab/pi-telegram 0.51.6 → 0.52.1

package/lib/extension.ts

@@ -47,7 +47,9 @@ import * as Sync from "./sync.ts";
 import * as TelegramApi from "./telegram-api.ts";
 import * as TextGroups from "./text-groups.ts";
 import * as ThreadReconciler from "./thread-reconciler.ts";
+import * as Targets from "./target.ts";
 import * as ThreadDisplay from "./thread-display.ts";
+import * as ThreadNaming from "./thread-naming.ts";
 import * as Threads from "./threads.ts";
 import * as TimeInjection from "./time-injection.ts";
 import * as Updates from "./updates.ts";
@@ -66,6 +68,7 @@ const telegramBusProtocolIdentity =
     Bus.TELEGRAM_BUS_CAPABILITY_THREAD_DISPLAY_MODE,
     Bus.TELEGRAM_BUS_CAPABILITY_DIRECTORY_DISPLAY_FORMAT,
     Bus.TELEGRAM_BUS_CAPABILITY_SESSION_REPLACEMENT_INTENT,
+    Bus.TELEGRAM_BUS_CAPABILITY_WORKSPACE_RESTORE,
   ]);
 
 // --- Extension Runtime ---
@@ -85,12 +88,13 @@ export default function (pi: Pi.ExtensionAPI) {
   } = piRuntime;
   const bridgeRuntime = Runtime.createTelegramBridgeRuntime();
   const runtimeDiagnostics =
-    Logging.createTelegramRuntimeDiagnosticsRuntime<Pi.ExtensionContext>();
+    Logging.createTelegramRuntimeDiagnosticsRuntime<Pi.ExtensionContext>({ sharedFile: true });
   const runtimeEvents = runtimeDiagnostics.events;
   const recordRuntimeEvent = runtimeDiagnostics.recordRuntimeEvent;
   const configStore = Config.createTelegramConfigStore({ recordRuntimeEvent });
   const busProcessRuntime = Bus.createCurrentTelegramBusProcessRuntime({
     getActiveProfileName: configStore.getActiveProfileName,
+    endpointLayout: "consolidated",
   });
   const {
     instanceId: telegramInstanceId,
@@ -105,7 +109,7 @@ export default function (pi: Pi.ExtensionAPI) {
     WorkspaceAdmission.createTelegramWorkspaceAdmissionRuntimeBinding({
       getProfileName: configStore.getActiveProfileName,
       getBotToken: configStore.getBotToken,
-      getPath: Paths.resolveTelegramWorkspaceAdmissionPathForProfile,
+      getStatePath: Paths.resolveTelegramStatePath,
       owner: {
         processId: telegramProcessId,
         processBirthId: telegramQueueProcessBirthId,
@@ -157,24 +161,30 @@ export default function (pi: Pi.ExtensionAPI) {
       getBotToken: configStore.getBotToken,
       getBotId: getTelegramBotId,
     });
+  const telegramLeaderJournalPath = Locks.createTelegramLeaderJournalPathResolver({
+    getNamedJournalPath() { return lockRuntime.getJournalPath(); },
+    getSessionId() { return Pi.getExtensionContextSessionId(telegramSessionContextStore.get()); },
+    getProfileName: configStore.getActiveProfileName,
+  });
   const telegramJournalBindingRuntime =
     Journal.createTelegramUpdateJournalBindingRuntime({
       base: {
         getProfileName: configStore.getActiveProfileName,
         getBotToken: configStore.getBotToken,
         getBotId: getTelegramBotId,
+        withSourceSerialization: configStore.withSourceSerialization,
         onRecovery(event) {
           recordRuntimeEvent(
             "recovery",
             event.kind === "repaired"
               ? "Telegram update journal was repaired automatically."
-              : "Telegram update journal was reset after its damaged files were quarantined.",
+              : "Telegram update journal was reset after its damaged files were deleted.",
             {
               phase: "journal-auto-recovery",
               recoveryKind: event.kind,
               journalPath: event.path,
               revision: event.revision,
-              quarantinePath: event.quarantinePath,
+              deletedPaths: event.deletedPaths,
               reason: event.reason,
             },
           );
@@ -188,8 +198,12 @@ export default function (pi: Pi.ExtensionAPI) {
         },
         getWorkspaceAdmission: workspaceAdmissionRuntime.resolve,
       },
-      getLeaderJournalPath: Paths.resolveTelegramUpdateJournalPathForProfile,
-      getFollowerJournalPath(bindingKey, profileName) {
+      getLeaderJournalPath: telegramLeaderJournalPath.resolve,
+      getRuntimeDir: Paths.resolveTelegramTempDir,
+      getFollowerJournalPath(bindingKey, profileName, sessionId) {
+        if (sessionId !== undefined) return Paths.resolveTelegramSessionJournalPath(
+          sessionId, bindingKey, undefined, profileName,
+        );
         return Paths.resolveTelegramFollowerJournalPath(
           bindingKey,
           undefined,
@@ -197,6 +211,11 @@ export default function (pi: Pi.ExtensionAPI) {
         );
       },
       getActiveFollowerBindingKey: getTelegramManualFollowerProfileKey,
+      getActiveFollowerSessionId() {
+        return telegramBusFollowerRegistrationState.getSessionId(
+          Pi.getExtensionContextSessionId(telegramSessionContextStore.get()),
+        );
+      },
       isFollowerRegistered: telegramBusFollowerRegistrationState.isRegistered,
     });
   const telegramJournalReferenceRegistry =
@@ -213,31 +232,46 @@ export default function (pi: Pi.ExtensionAPI) {
   const configControls = Config.createTelegramConfigControls(configStore);
   const lockRuntime = Locks.createTelegramLockRuntime<Pi.ExtensionContext>({
     key: Locks.createTelegramLockKeyResolver(configStore),
+    statePath: Paths.resolveTelegramStatePath(),
     instanceId: telegramInstanceId,
     busSecret: telegramBusAuthSecret,
     staleHeartbeatMs: Locks.TELEGRAM_BUS_LEADER_STALE_HEARTBEAT_MS,
+    legacyLocksPath: Paths.resolveLegacyTelegramOwnersPath(),
+    createJournalPath() { return telegramLeaderJournalPath.createJournalPath(); },
   });
+  const telegramSessionContextStore =
+    Lifecycle.createTelegramSessionContextStore<Pi.ExtensionContext>({
+      getIdentity(ctx) {
+        return ctx.sessionManager ?? ctx.cwd;
+      },
+    });
+  const captureTelegramStateAuthority = Locks.createTelegramOwnedStateAuthorityCapture(
+    lockRuntime, telegramSessionContextStore);
   const threadStore = Threads.createTelegramTopicTargetStore({
-    path: function () {
-      return Threads.getTelegramTopicTargetsPath(
-        undefined,
-        configStore.getActiveProfileName(),
-      );
-    },
+    path: Paths.resolveTelegramStatePath,
     telegramProfile: function () {
       return configStore.getActiveProfileName();
     },
     canPersist: lockRuntime.owns,
-    commitPersist: lockRuntime.commitIfOwned,
+    consolidated: {
+      captureAuthority: captureTelegramStateAuthority,
+      publishIfOwned: lockRuntime.publishStateSectionIfOwned!,
+    },
     getExternalReservedSlots: function () {
       return workspaceAdmissionRuntime.resolve()?.listReservedSlots() ?? [];
     },
   });
+  const resolveWorkspaceRestoreStore = Threads.createTelegramWorkspaceRestoreResolver({
+    getProfileName: configStore.getActiveProfileName,
+    getBotToken: configStore.getBotToken,
+    threadStore,
+  });
   runtimeDiagnostics.bindStorage({
     getBotToken: configStore.getBotToken,
     getProfileName: configStore.getActiveProfileName,
     canReset: lockRuntime.owns,
     commitReset: lockRuntime.commitIfOwned,
+    captureAuthority: captureTelegramStateAuthority,
   });
   const sessionActionAssembly = Commands.createTelegramSessionActionAssembly({
     registerCommand,
@@ -276,12 +310,6 @@ export default function (pi: Pi.ExtensionAPI) {
   const lockOwnershipGuard =
     Locks.createTelegramLockOwnershipGuard(lockRuntime);
   const getCurrentLeaderEpoch = lockRuntime.getOwnedLeaderEpoch;
-  const telegramSessionContextStore =
-    Lifecycle.createTelegramSessionContextStore<Pi.ExtensionContext>({
-      getIdentity(ctx) {
-        return ctx.sessionManager ?? ctx.cwd;
-      },
-    });
   const ownsTelegramDirectDelivery =
     Locks.createTelegramDirectDeliveryOwnershipChecker({
       lock: lockRuntime,
@@ -360,13 +388,15 @@ export default function (pi: Pi.ExtensionAPI) {
   );
   const telegramApiTargetActivityRuntime =
     TelegramApi.createTelegramApiTargetActivityRuntime();
-  const captureWorkspaceExternalProtection =
-    WorkspaceRetirement.createTelegramWorkspaceExternalProtectionCapture({
+  const workspaceProtectionObserver =
+    WorkspaceRetirement.createTelegramWorkspaceProtectionObserver({
       listFollowers: telegramBusFollowerRegistry.list,
       getActiveTurnTarget: activeTurnRuntime.getTarget,
       getQueuedItems: telegramQueueStore.getQueuedItems,
       resolveLeaderJournal: resolveTelegramUpdateJournalBinding,
       createFollowerJournalResolver:
+        telegramJournalBindingRuntime.createLegacyRecipientResolver,
+      createSessionJournalResolver:
         telegramJournalBindingRuntime.createRecipientResolver,
       withJournalReference(binding, operation) {
         if (!binding.recoveryKey) throw new Error(
@@ -378,12 +408,24 @@ export default function (pi: Pi.ExtensionAPI) {
         }, operation);
       },
       discoverFollowerJournals() {
-        return Journal.discoverTelegramFollowerJournalPaths({
+        return Journal.discoverTelegramRecipientJournalPaths({
           directory: Paths.resolveTelegramTempDir(),
           profileName: configStore.getActiveProfileName(),
         });
       },
       createJournalPathResolver: telegramJournalBindingRuntime.createPathResolver,
+      inspectJournalNamespace() {
+        const botToken = configStore.getBotToken();
+        if (!botToken) throw new Error("Telegram namespace inspection requires current bot identity.");
+        return Journal.inspectTelegramSessionJournalNamespace({
+          directory: Paths.resolveTelegramTempDir(),
+          profile: configStore.getActiveProfileName() ?? "default",
+          pollingPath: telegramLeaderJournalPath.resolve(configStore.getActiveProfileName()),
+          botIdentity: Journal.createTelegramUpdateJournalBotIdentity({ botToken, botId: getTelegramBotId() }),
+          limits: { maxDirectoryEntries: 10_000, maxFiles: 4096, maxBytes: 64 * 1024 * 1024,
+            maxEntries: 10_000, maxWork: 100_000 },
+        });
+      },
       getJournalWriterProtection(journalBindingKey) {
         const owner = Threads.getTelegramThreadOwnerFromProfileKey(
           journalBindingKey,
@@ -397,11 +439,24 @@ export default function (pi: Pi.ExtensionAPI) {
           : liveness === "dead" ? "clear" : "unknown";
       },
       getDeliveryAuthorityProtection(binding) {
-        return telegramApiTargetActivityRuntime.hasPendingTarget(binding.target)
+        const retainedRestore = resolveWorkspaceRestoreStore()?.list().some(function (intent) {
+          return intent.request.binding.bindingKey === binding.bindingKey ||
+            Targets.areTelegramTargetsEqual(intent.request.binding.target, binding.target) ||
+            Targets.areTelegramTargetsEqual(intent.request.target, binding.target);
+        });
+        return retainedRestore || telegramApiTargetActivityRuntime.hasPendingTarget(binding.target)
           ? "protected"
           : "clear";
       },
     });
+  const captureWorkspaceExternalProtection = workspaceProtectionObserver.capture;
+  const pruneWorkspaceJournalEvidence = WorkspaceRetirement.createTelegramWorkspaceJournalEvidencePruner({
+    store: threadStore,
+    getAdmission: workspaceAdmissionRuntime.resolve,
+    getLeaderEpoch: getCurrentLeaderEpoch,
+    runExclusive: telegramWorkspaceOperationRuntime.runExclusive,
+    protection: workspaceProtectionObserver,
+  });
   const reclaimTelegramWorkspaceDeadOwnerQueue =
     WorkspaceRetirement.createTelegramWorkspaceDeadOwnerQueueReclaimer({
       getExternalProtection: captureWorkspaceExternalProtection,
@@ -409,9 +464,11 @@ export default function (pi: Pi.ExtensionAPI) {
       getQueuedItems: telegramQueueStore.getQueuedItems,
       resolveLeaderJournal: resolveTelegramUpdateJournalBinding,
       createFollowerJournalResolver:
+        telegramJournalBindingRuntime.createLegacyRecipientResolver,
+      createSessionJournalResolver:
         telegramJournalBindingRuntime.createRecipientResolver,
       discoverFollowerJournals() {
-        return Journal.discoverTelegramFollowerJournalPaths({
+        return Journal.discoverTelegramRecipientJournalPaths({
           directory: Paths.resolveTelegramTempDir(),
           profileName: configStore.getActiveProfileName(),
         });
@@ -460,7 +517,7 @@ export default function (pi: Pi.ExtensionAPI) {
         const botToken = configStore.getBotToken();
         if (!botToken) throw new Error("Telegram Thread cleanup review requires an active bot token.");
         return ThreadCleanupManager.createTelegramThreadCleanupWorkStore({
-          path: Paths.resolveTelegramThreadCleanupWorkPath(undefined, profileName),
+          ...Paths.resolveTelegramServiceJournalStorage("thread-cleanup", undefined, profileName),
           profileName,
           tokenSha256: Journal.createTelegramUpdateJournalBotIdentity({ botToken }).tokenSha256,
         });
@@ -573,9 +630,10 @@ export default function (pi: Pi.ExtensionAPI) {
     instanceId: telegramInstanceId,
     updateStatus: statusRuntime.updateStatus,
     getStatusState: statusRuntime.getStatusState,
+    session: telegramSessionContextStore,
     async persistSnapshot(snapshot) {
       threadStore.setStatusSnapshot(snapshot);
-      await threadStore.persist();
+      await threadStore.persistStatus();
     },
   });
   const updateStatus = runtimeDiagnostics.updateStatus;
@@ -592,6 +650,10 @@ export default function (pi: Pi.ExtensionAPI) {
   const directTelegramApiRuntime =
     TelegramApi.createDefaultTelegramBridgeApiRuntime({
       getBotToken: configStore.getBotToken,
+      getBotScope() {
+        const config = configStore.get();
+        return config.botUsername ?? (config.botId === undefined ? undefined : String(config.botId));
+      },
       recordRuntimeEvent,
       targetActivity: telegramApiTargetActivityRuntime,
       workspaceAdmission: workspaceAdmissionRuntime.resolve,
@@ -896,6 +958,10 @@ export default function (pi: Pi.ExtensionAPI) {
     getActiveModel: currentModelRuntime.get,
     getThinkingLevel,
     getQueueItemCount,
+    getPendingCancellationCount() {
+      return getCurrentLeaderEpoch() === undefined ? 0 :
+        updateAdmissionRuntimeBinding.getActive()?.getState()?.abandoningClaimCount ?? 0;
+    },
     buildStatusHtml: Commands.createTelegramAppMenuHtmlBuilder({
       buildStatusHtml: Status.createTelegramStatusHtmlBuilder({
         getActiveModel: currentModelRuntime.get,
@@ -988,21 +1054,12 @@ export default function (pi: Pi.ExtensionAPI) {
 
   const foreignOwnedUpdateForwarder =
     telegramBusFollowerClients.foreignOwnedUpdateForwarder;
-  const followerTargetController = telegramBusFollowerClients.targetController;
-  const restoreFollowerThreadTarget =
-    Bus.createTelegramBusFollowerThreadRestoreHandler({
-      followerRegistry: telegramBusFollowerRegistry,
-      followerTargetController,
-      onRestored() {
-        telegramSyncStateRuntime.markSliceFresh(
-          Sync.TELEGRAM_SYNC_SLICE_TARGET_BINDINGS,
-          {
-            nowMs: Date.now(),
-            action: "follower-thread-restore",
-          },
-        );
-      },
-    });
+  const workspaceRestoreFollowerController = Bus.createTelegramBusWorkspaceRestoreController({
+    getFollower: telegramBusFollowerRegistry.get,
+    localProtocolIdentity: telegramBusProtocolIdentity,
+    createRequestId: telegramBusFollowerClients.createRequestId,
+    getAuthSecret() { return telegramBusAuthSecret; },
+  });
   const observedThreadTargetBinding =
     Polling.createTelegramThreadTargetObservationBinding<Pi.ExtensionContext>();
   const topicLifecycleSync =
@@ -1057,7 +1114,66 @@ export default function (pi: Pi.ExtensionAPI) {
       return observedThreadTargetBinding.handle(ctx);
     },
     foreignOwnedUpdateForwarder,
-    replaceFollowerThreadTarget: restoreFollowerThreadTarget,
+    workspaceRestoreRecipient: {
+      getSessionId: Pi.getExtensionContextSessionId,
+      getCwd: Pi.getExtensionContextCwd,
+      getLeaderIdentity: telegramBusLeaderState.getIdentity,
+      followerRegistry: telegramBusFollowerRegistry,
+      runFollower: workspaceRestoreFollowerController,
+    },
+    getWorkspaceRestoreStore: resolveWorkspaceRestoreStore,
+    captureWorkspaceExternalProtection,
+    inspectRestoreSourceCompletion(expected) {
+      return telegramJournalReferenceRegistry.withReference({ referenceClass: "operator-disposition",
+        recoveryKey: expected.journalBindingKey }, function () {
+          const observed = telegramJournalBindingRuntime.inspectSourceCompletion(expected.journalBindingKey, { updateId: expected.updateId,
+            sourceSha256: expected.sourceSha256, completionSha256: expected.completionSha256 });
+          return observed && { journalBindingKey: expected.journalBindingKey, ...observed };
+        });
+    },
+    inspectRestoreQueuedReceipt(expected) {
+      return telegramJournalReferenceRegistry.withReference({ referenceClass: "operator-disposition",
+        recoveryKey: expected.journalBindingKey }, function () {
+          return telegramJournalBindingRuntime.inspectQueuedReceipt(expected.journalBindingKey, { queueKind: expected.queueKind, receiptId: expected.receiptId,
+            sourceUpdateIds: [...expected.sourceUpdateIds], queueOwner: { ...expected.queueOwner } });
+        });
+    },
+    inspectRestoreSourceAbandonment(updateId, journalBindingKey) {
+      return telegramJournalReferenceRegistry.withReference({
+        referenceClass: "operator-disposition",
+        recoveryKey: journalBindingKey,
+      }, function () {
+        return telegramJournalBindingRuntime.inspectSourceAbandonment(journalBindingKey, updateId);
+      });
+    },
+    inspectRoutingInputGroupExpiry(input) {
+      return telegramJournalReferenceRegistry.withReference({ referenceClass: "operator-disposition", recoveryKey: input.journalBindingKey },
+        function () { return telegramJournalBindingRuntime.inspectSourceGroupExpiry(input.journalBindingKey, input.updateIds); });
+    },
+    inspectTemporaryThreadSources(_target, requiredJournalBindingKeys) {
+      const binding = resolveTelegramUpdateJournalBinding();
+      const botToken = configStore.getBotToken();
+      if (!binding || !botToken) return undefined;
+      const profile = configStore.getActiveProfileName() ?? "default";
+      const botIdentity = Journal.createTelegramUpdateJournalBotIdentity({ botToken, botId: getTelegramBotId() });
+      return configStore.withSourceSerialization(function () {
+        return Journal.isTelegramThreadCleanupJournalNamespaceClear({
+          directory: Paths.resolveTelegramTempDir(), profile, botIdentity,
+          pollingPath: telegramLeaderJournalPath.resolve(configStore.getActiveProfileName()),
+          requiredJournalBindingKeys: [binding.recoveryKey, ...requiredJournalBindingKeys],
+          limits: { maxDirectoryEntries: 10_000, maxFiles: 4096, maxBytes: 64 * 1024 * 1024,
+            maxEntries: 10_000, maxWork: 100_000 },
+          withSourceReference(path, operation) {
+            return telegramJournalReferenceRegistry.withReference({ referenceClass: "operator-disposition",
+              recoveryKey: Journal.createTelegramUpdateJournalBindingKey({ path, profileName: profile, botIdentity }) }, operation);
+          },
+        }) ? [] : undefined;
+      });
+    },
+    hasWorkspaceRestoreAuthority() {
+      return lockRuntime.owns() && Bus.hasTelegramBusCapability(telegramBusProtocolIdentity, Bus.TELEGRAM_BUS_CAPABILITY_WORKSPACE_RESTORE);
+    },
+    getSessionGeneration: telegramSessionContextStore.getGeneration,
     bridgeRuntime,
     requestNewSession(source) {
       const updateId = Updates.getTelegramUpdateExecutionFence(source)?.updateId;
@@ -1131,7 +1247,7 @@ export default function (pi: Pi.ExtensionAPI) {
     sendTextReply,
     setMyCommands,
     validateThreadName(threadName) {
-      return Threads.getTelegramManualThreadDisplayNameValidationError(
+      return ThreadNaming.getTelegramManualThreadDisplayNameValidationError(
         threadName,
       );
     },
@@ -1197,10 +1313,43 @@ export default function (pi: Pi.ExtensionAPI) {
       dispatchNext: dispatchNextQueuedTelegramTurn,
       requestQueueHandoffReconciliation:
         queueHandoffReconciliationBinding.request,
-      afterUpdateCompleted: sessionActionsRuntime.onUpdateCompleted,
+      afterQueueReceiptCommitted: inboundRouteRuntime.onQueueReceiptCommitted,
+      afterUpdateCompleted(updateId, ctx, journalBindingKey) {
+        sessionActionsRuntime.onUpdateCompleted(updateId);
+        inboundRouteRuntime.onUpdateCompleted(updateId, ctx, journalBindingKey);
+      },
     },
     worker: {
+      expireRoutingInput: inboundRouteRuntime.expireRoutingInput,
+      beforeQueueReceiptPublished: inboundRouteRuntime.beforeQueueReceiptPublished,
+      onQueueReceiptCompleted: inboundRouteRuntime.onQueueReceiptCompleted,
       defaultHandle: inboundRouteRuntime.handleUpdate,
+      async shouldReviewHistoricalInput(entry, ctx, signal) {
+        if (signal.aborted || !telegramSessionContextStore.isCurrent(ctx)) {
+          throw new Error("Workspace Restore source generation ended.");
+        }
+        const verdict = await inboundRouteRuntime.shouldReviewHistoricalInput(entry, ctx, signal);
+        if (signal.aborted || !telegramSessionContextStore.isCurrent(ctx)) {
+          throw new Error("Workspace Restore source generation ended.");
+        }
+        if (verdict === "retain") return verdict;
+        const journalBindingKey = getTelegramQueueJournalBinding();
+        if (journalBindingKey && resolveWorkspaceRestoreStore()?.list().some(function (intent) {
+          return intent.request.source.journalBindingKey === journalBindingKey &&
+            intent.request.source.updateIds.includes(entry.updateId);
+        })) return true;
+        return verdict;
+      },
+      spendHistoricalInput: true,
+      onHeldSourcesPrepared(input): Promise<void> {
+        return inboundRouteRuntime.forgetPreviousWorld(input, lockedPollingRuntime.captureTransportAuthority).then(function () {});
+      },
+      async shouldHoldPendingInput(entry, ctx, signal) {
+        if (signal.aborted || !telegramSessionContextStore.isCurrent(ctx)) {
+          throw new Error("Temporary Thread source generation ended.");
+        }
+        return inboundRouteRuntime.shouldHoldPendingInput(entry, ctx, signal);
+      },
       onStateChange: runtimeDiagnostics.scheduleSnapshotPersist,
       settleTerminalExecutionFailure(error) {
         return Sync.settleStaleTelegramTopicExecutionFailure(
@@ -1217,6 +1366,11 @@ export default function (pi: Pi.ExtensionAPI) {
       resolveBinding: resolveTelegramFollowerJournalBinding,
       isRegistered: telegramBusFollowerRegistrationState.isRegistered,
       getGeneration: telegramBusFollowerRegistrationState.getGeneration,
+      prepareBinding(binding) {
+        telegramJournalBindingRuntime.prepareActiveFollowerSuccession(function isCurrent() {
+          return binding.hasAuthority?.() === true;
+        });
+      },
       prepareUpdateForExecution(update) {
         return BusFollower.prepareTelegramBusFollowerJournaledUpdateForExecution(
           update,
@@ -1296,6 +1450,32 @@ export default function (pi: Pi.ExtensionAPI) {
       local: agentMessageRuntime,
       follower: telegramBusFollowerClients.agentMessages,
     });
+  const followerWorkspaceRestore = BusFollower.createTelegramBusFollowerWorkspaceRestoreHandler({
+    instanceId: telegramInstanceId,
+    getContextAuthority: BusFollower.createTelegramBusFollowerRestoreContextGetter({
+      isContextCurrent: telegramSessionContextStore.isCurrent,
+      getSessionId: Pi.getExtensionContextSessionId,
+      getCwd: Pi.getExtensionContextCwd,
+      getGeneration: telegramSessionContextStore.getGeneration,
+      getProfileBindingKey() {
+        return workspaceAdmissionRuntime.resolve()?.getProfileKey();
+      },
+      getOperatorUserId: configStore.getAllowedUserId,
+      getLeaderState: lockRuntime.getState,
+      getAuthenticatedSecret: telegramBusFollowerControlState.getActiveAuthSecret,
+      getLeaderProtocol: telegramBusFollowerRegistrationState.getLeaderProtocol,
+    }),
+    readRestoreIntent(operationId, profileBindingKey) {
+      if (profileBindingKey !== workspaceAdmissionRuntime.resolve()?.getProfileKey()) return undefined;
+      return resolveWorkspaceRestoreStore()?.list().find(function (intent) {
+        return intent.request.operationId === operationId;
+      });
+    },
+    topicTargetStore: threadStore,
+    registrationState: telegramBusFollowerRegistrationState,
+    getWorkspaceAdmission: workspaceAdmissionRuntime.resolve,
+    recordRuntimeEvent,
+  });
   const telegramBusFollowerAssembly: BusFollower.TelegramBusFollowerRuntimeAssembly<Pi.ExtensionContext> =
     BusFollower.createTelegramBusFollowerRuntimeAssembly<Pi.ExtensionContext>({
       instanceId: telegramInstanceId,
@@ -1308,15 +1488,11 @@ export default function (pi: Pi.ExtensionAPI) {
         getRecipientBindingKey: getTelegramManualFollowerProfileKey,
         durableAdmission: followerDurableAdmissionRuntime,
         handleQueueHandoff: acceptStagedQueueHandoff,
-      },
-      targetReplacement: {
-        topicTargetStore: threadStore,
-        getManualFollowerProfileKey: getTelegramManualFollowerProfileKey,
-        manualFollowerOwnerId: telegramManualFollowerOwnerId,
-        getWorkspaceAdmission: workspaceAdmissionRuntime.resolve,
-        getSyncState: telegramSyncStateRuntime.getState,
-        setSyncState: telegramSyncStateRuntime.setState,
-        updateStatus,
+        handleWorkspaceRestore: followerWorkspaceRestore,
+        isWorkspaceRestoreEnabled() {
+          return Bus.hasTelegramBusCapability(telegramBusProtocolIdentity, Bus.TELEGRAM_BUS_CAPABILITY_WORKSPACE_RESTORE) &&
+            Bus.hasTelegramBusCapability(telegramBusFollowerRegistrationState.getLeaderProtocol(), Bus.TELEGRAM_BUS_CAPABILITY_WORKSPACE_RESTORE);
+        },
       },
       recovery: {
         getLeaderState: lockRuntime.getState,
@@ -1424,6 +1600,17 @@ export default function (pi: Pi.ExtensionAPI) {
   const authorizeFollowerApiCall = Bus.createTelegramFollowerApiCallAuthorizer({
     isMessageOwned: messageOwnershipRuntime.isOwnedByFollower,
   });
+  const telegramSessionFolderSweeper = Recovery.createTelegramSessionFolderSweeper({
+    getSessionsDir: Paths.resolveTelegramSessionsDir,
+    getProfileName: configStore.getActiveProfileName,
+    getKeptSessionIds() {
+      return [
+        ...threadStore.listWorkspaceBindings().map(function bindingSession(binding) { return binding.sessionId; }),
+        ...telegramBusFollowerRegistry.list().map(function followerSession(follower) { return follower.sessionId; }),
+        Pi.getExtensionContextSessionId(telegramSessionContextStore.get()),
+      ];
+    },
+  });
   const telegramBusLeaderRuntime =
     BusLeader.createTelegramBusLeaderRuntimeAssembly<Pi.ExtensionContext>({
       runtime: {
@@ -1448,11 +1635,15 @@ export default function (pi: Pi.ExtensionAPI) {
           });
         },
         isFollowerProcessAlive: Locks.isProcessAlive,
+        afterFollowerPrune() { telegramSessionFolderSweeper.sweep(); },
         shouldCleanupConfirmedDeadFollower:
           configControls.resolveAutomaticThreadCleanupEnabled,
         recordFollowerMessageOwnership(record) {
           messageOwnershipRuntime.recordFollower(record);
         },
+        onWorkspaceRestoreRecipientObserved(follower, isCurrent) {
+          return inboundRouteRuntime.onWorkspaceRestoreRecipientObserved(follower, isCurrent, telegramSessionContextStore.get());
+        },
       },
       getAllowedUserId: configStore.getAllowedUserId,
       instanceId: telegramInstanceId,
@@ -1481,6 +1672,7 @@ export default function (pi: Pi.ExtensionAPI) {
         getAdmission: workspaceAdmissionRuntime.resolve,
         runExclusive: telegramWorkspaceOperationRuntime.runExclusive,
         deleteThread: directTelegramApiRuntime.deleteWorkspaceThread,
+        pruneJournalEvidence: pruneWorkspaceJournalEvidence,
         reclaimDeadOwnerQueuedWork(binding, isCurrent) {
           return telegramWorkspaceOperationRuntime.run({
             operationId: WorkspaceAdmission.createTelegramWorkspaceAdmissionOperationId(),
@@ -1583,6 +1775,12 @@ export default function (pi: Pi.ExtensionAPI) {
   const threadAwarePollingPorts = telegramThreadCapabilityRuntime.pollingPorts;
   const lockedPollingRuntime = Locks.createTelegramLockedPollingRuntime({
     lock: lockRuntime,
+    resetDamagedState() {
+      return Locks.resetDamagedTelegramRuntimeState(Paths.resolveTelegramStatePath(), function (profile, sections) {
+        Threads.parseTelegramWorkspaceStateSection(sections.workspace, profile);
+        WorkspaceAdmission.assertTelegramConsolidatedAdmissionSection(sections.admission, profile);
+      });
+    },
     transportMonitor: telegramThreadCapabilityMonitor,
     hasBotToken: configStore.hasBotToken,
     getBotTokenDiagnostic: configStore.getBotTokenDiagnostic,
@@ -1666,7 +1864,10 @@ export default function (pi: Pi.ExtensionAPI) {
         syncCounters: queue.syncCounters,
         syncFlags: lifecycle.syncFlags,
         bindDeferredDispatchContext: deferredQueueDispatchRuntime.bind,
-        prepareTempDir,
+        prepareTempDir() {
+          Recovery.removeTelegramLegacyRecoveryStorage(Paths.resolveTelegramTempDir());
+          return prepareTempDir();
+        },
         updateStatus,
         unbindDeferredDispatchContext: deferredQueueDispatchRuntime.unbind,
         discardQueuedItems: queueMutationRuntime.clear,
@@ -1824,20 +2025,7 @@ export default function (pi: Pi.ExtensionAPI) {
     activeTurnRuntime,
     lockedPollingRuntime,
     stopPolling: disconnectTelegramAndDeleteCurrentThread,
-    recoverPollingStart: Recovery.createTelegramPollingStartRecoveryHandler({
-      getOwnersPath: Paths.resolveTelegramOwnersPath,
-      getStatePaths() {
-        return [
-          Threads.getTelegramTopicTargetsPath(
-            undefined,
-            configStore.getActiveProfileName(),
-          ),
-        ];
-      },
-      suspendPolling: lockedPollingRuntime.suspend,
-      releaseOwnership: lockRuntime.release,
-      recordRuntimeEvent,
-    }),
+    // Consolidated envelope failures remain protective; legacy whole-file recovery cannot reset sibling authority.
     getDisconnectThreadName() {
       const record = findCurrentThreadRecord();
       if (!record?.target.threadId) return undefined;
@@ -1862,7 +2050,7 @@ export default function (pi: Pi.ExtensionAPI) {
       const botToken = configStore.getBotToken();
       if (!botToken) throw new Error("Telegram channel delivery requires an active bot token.");
       const store = ChannelPosts.createTelegramChannelPostJournalStore({
-        path: Paths.resolveTelegramChannelPostJournalPath(undefined, profileName),
+        ...Paths.resolveTelegramServiceJournalStorage("channel-posts", undefined, profileName),
         profileName,
         tokenSha256: Journal.createTelegramUpdateJournalBotIdentity({ botToken }).tokenSha256,
       });
@@ -1893,7 +2081,7 @@ export default function (pi: Pi.ExtensionAPI) {
       const caption = Replies.renderTelegramMarkdownToHtmlDraft(markdown);
       ChannelPosts.assertTelegramChannelPostCaptionWithinLimit(caption);
       const store = ChannelPosts.createTelegramChannelPostJournalStore({
-        path: Paths.resolveTelegramChannelPostJournalPath(undefined, profileName),
+        ...Paths.resolveTelegramServiceJournalStorage("channel-posts", undefined, profileName),
         profileName,
         tokenSha256: Journal.createTelegramUpdateJournalBotIdentity({ botToken }).tokenSha256,
       });
@@ -1922,7 +2110,7 @@ export default function (pi: Pi.ExtensionAPI) {
       const botToken = configStore.getBotToken();
       if (!botToken) throw new Error("Telegram channel posts require an active bot token.");
       return ChannelPosts.createTelegramChannelPostJournalStore({
-        path: Paths.resolveTelegramChannelPostJournalPath(undefined, profileName),
+        ...Paths.resolveTelegramServiceJournalStorage("channel-posts", undefined, profileName),
         profileName,
         tokenSha256: Journal.createTelegramUpdateJournalBotIdentity({ botToken }).tokenSha256,
       }).list(input);
@@ -1933,7 +2121,7 @@ export default function (pi: Pi.ExtensionAPI) {
       const botToken = configStore.getBotToken();
       if (!botToken) throw new Error("Telegram channel post mutation requires an active bot token.");
       const store = ChannelPosts.createTelegramChannelPostJournalStore({
-        path: Paths.resolveTelegramChannelPostJournalPath(undefined, profileName), profileName,
+        ...Paths.resolveTelegramServiceJournalStorage("channel-posts", undefined, profileName), profileName,
         tokenSha256: Journal.createTelegramUpdateJournalBotIdentity({ botToken }).tokenSha256,
       });
       if (input.action === "edit") {
@@ -1995,6 +2183,7 @@ export default function (pi: Pi.ExtensionAPI) {
     },
     activityRuntime,
     activityVerbosityRuntime,
+    diagnostics: runtimeDiagnostics,
     assistantOutputRuntime,
     publicationRuntime,
     configStore,

package/lib/generative-apps.ts

@@ -44,28 +44,6 @@ export type GenerativeAppJsonValue =
   | GenerativeAppJsonValue[]
   | { [key: string]: GenerativeAppJsonValue };
 
-export interface GenerativeAppProcessInput {
-  command: string;
-  args?: string[];
-  cwd: string;
-  timeoutMs?: number;
-}
-
-export interface GenerativeAppProcessResult {
-  code: number;
-  killed: boolean;
-  stderr: string;
-  stdout: string;
-}
-
-export interface GenerativeAppMethodContext {
-  argument?: GenerativeAppJsonValue;
-  revision: number;
-  run: (input: GenerativeAppProcessInput) => Promise<GenerativeAppProcessResult>;
-  signal: AbortSignal;
-  state?: GenerativeAppJsonValue;
-}
-
 export interface GenerativeAppMethodResult {
   output: string;
   refreshAfterMs?: number;