clisbot 0.1.45-beta.7 → 0.1.45-beta.8

package/README.md

@@ -139,7 +139,7 @@ Need the step-by-step setup docs instead of the shortest path?
 
 - Telegram: [Telegram Bot Setup](docs/user-guide/telegram-setup.md)
 - Slack: [Slack App Setup](docs/user-guide/slack-setup.md)
-- Release history: [CHANGELOG.md](CHANGELOG.md), [release notes](docs/releases/README.md), [update guide](docs/update/README.md), [operator updates](docs/updates/README.md), and [migration index](docs/migrations/index.md)
+- Release history: [CHANGELOG.md](CHANGELOG.md), [release notes](docs/releases/README.md), [update guide](docs/updates/update-guide.md), [release guides](docs/updates/README.md), and [migration index](docs/migrations/index.md)
 - Slack app manifest template: [app-manifest.json](templates/slack/default/app-manifest.json)
 - Slack app manifest guide: [app-manifest-guide.md](templates/slack/default/app-manifest-guide.md)
 

package/dist/main.js

@@ -54803,7 +54803,7 @@ function renderCliHelp() {
     "  status             Show runtime process, config, log, tmux socket status, and recent runner sessions.",
     "  version            Show the installed clisbot version.",
     "  logs               Print the most recent clisbot log lines.",
-    "  update             Print the AI-readable package update guide and release/migration doc links.",
+    "  update             Print the update guide and release/migration doc links.",
     `                     See ${renderCliCommand("update --help", { inline: true })} before asking an agent to update clisbot.`,
     "  timezone           Manage the app-wide wall-clock timezone used by schedules and loops.",
     `                     See ${renderCliCommand("timezone --help", { inline: true })} for override guidance.`,
@@ -66541,19 +66541,6 @@ class AgentSessionState {
       agentId: target.agentId
     };
   }
-  async listActiveSessionRuntimes() {
-    const entries = await this.sessionStore.list();
-    return entries.filter(hasActiveRuntime).map((entry) => ({
-      state: entry.runtime.state,
-      startedAt: entry.runtime.startedAt,
-      detachedAt: entry.runtime.detachedAt,
-      finalReplyAt: entry.runtime.finalReplyAt,
-      lastMessageToolReplyAt: entry.runtime.lastMessageToolReplyAt,
-      messageToolFinalReplyAt: entry.runtime.messageToolFinalReplyAt,
-      sessionKey: entry.sessionKey,
-      agentId: entry.agentId
-    }));
-  }
   async listIntervalLoops(params) {
     const entries = await this.sessionStore.list();
     return entries.flatMap((entry) => getStoredLoops(entry).filter((loop) => !params?.sessionKey || entry.sessionKey === params.sessionKey).map((loop) => ({
@@ -66811,6 +66798,10 @@ class AgentSessionState {
     const entry = await this.sessionStore.get(sessionKey);
     return getStoredQueues(entry).some((item) => item.status === "pending" || item.status === "running");
   }
+  async hasQueuedItem(sessionKey, queueId) {
+    const entry = await this.sessionStore.get(sessionKey);
+    return getStoredQueues(entry).some((item) => item.id === queueId);
+  }
   async resetStaleRunningQueuedItems(activeSessionKeys) {
     const entries = await this.sessionStore.list();
     let reset = 0;
@@ -66891,9 +66882,6 @@ function getStoredLoops(entry) {
 function getStoredQueues(entry) {
   return entry?.queues ?? [];
 }
-function hasActiveRuntime(entry) {
-  return entry.runtime?.state === "running" || entry.runtime?.state === "detached";
-}
 
 // src/agents/session-key.ts
 var DEFAULT_MAIN_KEY = "main";
@@ -67146,39 +67134,15 @@ class AgentJobQueue {
     if (!state) {
       return 0;
     }
-    const keptEntries = state.entries.filter((entry) => entry.status === "running");
-    const removedEntries = state.entries.filter((entry) => entry.status === "pending");
-    state.entries = keptEntries;
-    for (const entry of removedEntries) {
-      Promise.resolve(entry.lifecycle?.onClear?.()).catch(() => {
-        return;
-      });
-      entry.reject(new ClearedQueuedTaskError);
-    }
-    if (state.entries.length === 0 && !state.running) {
-      this.states.delete(key);
-    }
-    return removedEntries.length;
+    return this.clearPendingEntriesForState(key, state, () => true);
   }
-  clearPendingByIds(ids) {
-    const idSet = new Set(ids);
-    let cleared = 0;
-    for (const [key, state] of this.states.entries()) {
-      const keptEntries = state.entries.filter((entry) => entry.status === "running" || !idSet.has(entry.id));
-      const removedEntries = state.entries.filter((entry) => entry.status === "pending" && idSet.has(entry.id));
-      state.entries = keptEntries;
-      cleared += removedEntries.length;
-      for (const entry of removedEntries) {
-        Promise.resolve(entry.lifecycle?.onClear?.()).catch(() => {
-          return;
-        });
-        entry.reject(new ClearedQueuedTaskError);
-      }
-      if (state.entries.length === 0 && !state.running) {
-        this.states.delete(key);
-      }
+  clearPendingByIdsForKey(key, ids) {
+    const state = this.states.get(key);
+    if (!state) {
+      return 0;
     }
-    return cleared;
+    const idSet = new Set(ids);
+    return this.clearPendingEntriesForState(key, state, (entry) => idSet.has(entry.id));
   }
   getOrCreateState(key) {
     const existing = this.states.get(key);
@@ -67203,6 +67167,21 @@ class AgentJobQueue {
       return left.sequence - right.sequence;
     });
   }
+  clearPendingEntriesForState(key, state, shouldClear) {
+    const keptEntries = state.entries.filter((entry) => entry.status === "running" || !shouldClear(entry));
+    const removedEntries = state.entries.filter((entry) => entry.status === "pending" && shouldClear(entry));
+    state.entries = keptEntries;
+    for (const entry of removedEntries) {
+      Promise.resolve(entry.lifecycle?.onClear?.()).catch(() => {
+        return;
+      });
+      entry.reject(new ClearedQueuedTaskError);
+    }
+    if (state.entries.length === 0 && !state.running) {
+      this.states.delete(key);
+    }
+    return removedEntries.length;
+  }
   async drain(key, state) {
     if (state.running) {
       return;
@@ -67542,87 +67521,86 @@ class ManagedLoopController {
   }
   async reconcilePersistedIntervalLoops() {
     const persistedLoops = await this.deps.sessionState.listIntervalLoops();
-    const persistedIds = new Set;
+    const persistedKeys = new Set;
     for (const persisted of persistedLoops) {
-      persistedIds.add(persisted.id);
+      const managedKey = this.buildManagedLoopKey(persisted.sessionKey, persisted.id);
+      persistedKeys.add(managedKey);
       if (persisted.attemptedRuns >= persisted.maxRuns) {
-        this.dropManagedIntervalLoop(persisted.id);
+        this.dropManagedIntervalLoop(managedKey);
         continue;
       }
-      if (this.intervalLoops.has(persisted.id)) {
+      if (this.intervalLoops.has(managedKey)) {
         continue;
       }
-      this.intervalLoops.set(persisted.id, {
+      this.intervalLoops.set(managedKey, {
         target: {
           agentId: persisted.agentId,
           sessionKey: persisted.sessionKey
         },
         loop: persisted
       });
-      this.scheduleIntervalLoopTimer(persisted.id, Math.max(0, persisted.nextRunAt - Date.now()));
+      this.scheduleIntervalLoopTimer(managedKey, Math.max(0, persisted.nextRunAt - Date.now()));
     }
-    for (const loopId of this.intervalLoops.keys()) {
-      if (!persistedIds.has(loopId)) {
-        this.dropManagedIntervalLoop(loopId);
+    for (const managedKey of this.intervalLoops.keys()) {
+      if (!persistedKeys.has(managedKey)) {
+        this.dropManagedIntervalLoop(managedKey);
       }
     }
   }
   async createIntervalLoop(params) {
     this.assertActiveLoopCapacity();
     const loop = createStoredIntervalLoop(params);
+    const managedKey = this.buildManagedLoopKey(params.target.sessionKey, loop.id);
     await this.deps.sessionState.setIntervalLoop(this.deps.resolveTarget(params.target), loop);
-    this.intervalLoops.set(loop.id, {
+    this.intervalLoops.set(managedKey, {
       target: params.target,
       loop
     });
-    await this.runIntervalLoopIteration(loop.id, {
+    await this.runIntervalLoopIteration(managedKey, {
       notifyStart: false
     });
-    return this.getIntervalLoop(loop.id);
+    return this.getIntervalLoop(params.target.sessionKey, loop.id);
   }
   async createCalendarLoop(params) {
     this.assertActiveLoopCapacity();
     const loop = createStoredCalendarLoop(params);
+    const managedKey = this.buildManagedLoopKey(params.target.sessionKey, loop.id);
     await this.deps.sessionState.setIntervalLoop(this.deps.resolveTarget(params.target), loop);
-    this.intervalLoops.set(loop.id, {
+    this.intervalLoops.set(managedKey, {
       target: params.target,
       loop
     });
-    this.scheduleIntervalLoopTimer(loop.id, Math.max(0, loop.nextRunAt - Date.now()));
-    return this.getIntervalLoop(loop.id);
+    this.scheduleIntervalLoopTimer(managedKey, Math.max(0, loop.nextRunAt - Date.now()));
+    return this.getIntervalLoop(params.target.sessionKey, loop.id);
   }
-  async cancelIntervalLoop(loopId) {
-    const managed = this.intervalLoops.get(loopId);
+  async cancelIntervalLoop(target, loopId) {
+    const managedKey = this.buildManagedLoopKey(target.sessionKey, loopId);
+    const managed = this.intervalLoops.get(managedKey);
     if (!managed) {
       return false;
     }
-    if (managed.timer) {
-      clearTimeout(managed.timer);
-      this.loopTimers.delete(managed.timer);
-    }
-    this.intervalLoops.delete(loopId);
-    await this.deps.sessionState.removeIntervalLoop(this.deps.resolveTarget(managed.target), loopId);
+    await this.cancelManagedIntervalLoop(managedKey, managed);
     return true;
   }
   async cancelIntervalLoopsForSession(target) {
-    const matching = [...this.intervalLoops.values()].filter((managed) => managed.target.sessionKey === target.sessionKey).map((managed) => managed.loop.id);
-    for (const loopId of matching) {
-      await this.cancelIntervalLoop(loopId);
+    const matching = [...this.intervalLoops.entries()].filter(([, managed]) => managed.target.sessionKey === target.sessionKey);
+    for (const [managedKey, managed] of matching) {
+      await this.cancelManagedIntervalLoop(managedKey, managed);
     }
     return matching.length;
   }
   async cancelAllIntervalLoops() {
-    const ids = [...this.intervalLoops.keys()];
-    for (const loopId of ids) {
-      await this.cancelIntervalLoop(loopId);
+    const matching = [...this.intervalLoops.entries()];
+    for (const [managedKey, managed] of matching) {
+      await this.cancelManagedIntervalLoop(managedKey, managed);
     }
-    return ids.length;
+    return matching.length;
   }
   listIntervalLoops(params) {
     return [...this.intervalLoops.values()].filter((managed) => !params?.sessionKey || managed.target.sessionKey === params.sessionKey).map((managed) => this.toLoopStatus(managed)).sort((left, right) => left.nextRunAt - right.nextRunAt);
   }
-  getIntervalLoop(loopId) {
-    const managed = this.intervalLoops.get(loopId);
+  getIntervalLoop(sessionKey, loopId) {
+    const managed = this.intervalLoops.get(this.buildManagedLoopKey(sessionKey, loopId));
     return managed ? this.toLoopStatus(managed) : null;
   }
   getActiveIntervalLoopCount() {
@@ -67646,8 +67624,8 @@ class ManagedLoopController {
     const entry = await this.deps.sessionState.getEntry(managed.target.sessionKey);
     return (entry?.loops ?? entry?.intervalLoops ?? []).some((loop) => loop.id === managed.loop.id);
   }
-  dropManagedIntervalLoop(loopId) {
-    const managed = this.intervalLoops.get(loopId);
+  dropManagedIntervalLoop(managedKey) {
+    const managed = this.intervalLoops.get(managedKey);
     if (!managed) {
       return;
     }
@@ -67655,30 +67633,34 @@ class ManagedLoopController {
       clearTimeout(managed.timer);
       this.loopTimers.delete(managed.timer);
     }
-    this.intervalLoops.delete(loopId);
+    this.intervalLoops.delete(managedKey);
   }
-  async runIntervalLoopIteration(loopId, options = {}) {
-    const managed = this.intervalLoops.get(loopId);
+  async cancelManagedIntervalLoop(managedKey, managed) {
+    this.dropManagedIntervalLoop(managedKey);
+    await this.deps.sessionState.removeIntervalLoop(this.deps.resolveTarget(managed.target), managed.loop.id);
+  }
+  async runIntervalLoopIteration(managedKey, options = {}) {
+    const managed = this.intervalLoops.get(managedKey);
     if (!managed) {
       return;
     }
     if (!await this.isManagedLoopPersisted(managed)) {
-      this.dropManagedIntervalLoop(loopId);
+      this.dropManagedIntervalLoop(managedKey);
       return;
     }
     const attemptedRuns = managed.loop.attemptedRuns + 1;
     const now = Date.now();
     const nextLoopState = this.buildNextLoopState(managed.loop, attemptedRuns, now);
     if (await this.deps.isSessionBusy(managed.target)) {
-      await this.skipLoopIteration(loopId, managed, nextLoopState, attemptedRuns, now);
+      await this.skipLoopIteration(managedKey, managed, nextLoopState, attemptedRuns, now);
       return;
     }
     nextLoopState.executedRuns += 1;
     if (!await this.updateManagedIntervalLoop(managed, nextLoopState)) {
-      this.dropManagedIntervalLoop(loopId);
+      this.dropManagedIntervalLoop(managedKey);
       return;
     }
-    await this.executeLoopIteration(loopId, managed.target, nextLoopState, attemptedRuns, now, options.notifyStart !== false);
+    await this.executeLoopIteration(managedKey, managed.target, nextLoopState, attemptedRuns, now, options.notifyStart !== false);
   }
   buildNextLoopState(loop, attemptedRuns, now) {
     return {
@@ -67688,33 +67670,35 @@ class ManagedLoopController {
       nextRunAt: this.computeNextManagedLoopRunAtMs(loop, now)
     };
   }
-  async skipLoopIteration(loopId, managed, nextLoopState, attemptedRuns, now) {
+  async skipLoopIteration(managedKey, managed, nextLoopState, attemptedRuns, now) {
     nextLoopState.skippedRuns += 1;
     if (!await this.updateManagedIntervalLoop(managed, nextLoopState)) {
-      this.dropManagedIntervalLoop(loopId);
+      this.dropManagedIntervalLoop(managedKey);
       return;
     }
     if (attemptedRuns >= managed.loop.maxRuns) {
-      await this.cancelIntervalLoop(loopId);
+      this.dropManagedIntervalLoop(managedKey);
+      await this.deps.sessionState.removeIntervalLoop(this.deps.resolveTarget(managed.target), managed.loop.id);
       return;
     }
-    this.scheduleIntervalLoopTimer(loopId, Math.max(0, nextLoopState.nextRunAt - now));
+    this.scheduleIntervalLoopTimer(managedKey, Math.max(0, nextLoopState.nextRunAt - now));
   }
-  async executeLoopIteration(loopId, target, nextLoopState, attemptedRuns, now, notifyStart) {
-    await this.notifyAndEnqueueLoop(loopId, target, nextLoopState, attemptedRuns, notifyStart);
+  async executeLoopIteration(managedKey, target, nextLoopState, attemptedRuns, now, notifyStart) {
+    await this.notifyAndEnqueueLoop(managedKey, target, nextLoopState, attemptedRuns, notifyStart);
     if (attemptedRuns >= nextLoopState.maxRuns) {
-      await this.cancelIntervalLoop(loopId);
+      this.dropManagedIntervalLoop(managedKey);
+      await this.deps.sessionState.removeIntervalLoop(this.deps.resolveTarget(target), nextLoopState.id);
       return;
     }
-    this.scheduleIntervalLoopTimer(loopId, Math.max(0, nextLoopState.nextRunAt - now));
+    this.scheduleIntervalLoopTimer(managedKey, Math.max(0, nextLoopState.nextRunAt - now));
   }
-  async notifyAndEnqueueLoop(loopId, target, nextLoopState, attemptedRuns, notifyStart) {
+  async notifyAndEnqueueLoop(managedKey, target, nextLoopState, attemptedRuns, notifyStart) {
     if (notifyStart) {
       await this.deps.surfaceRuntime.notifyManagedLoopStart(target, nextLoopState);
     }
     const promptText = await this.deps.surfaceRuntime.buildManagedLoopPrompt(target.agentId, nextLoopState);
     const { result } = this.deps.enqueuePrompt(target, promptText, {
-      observerId: `loop:${loopId}:${attemptedRuns}`,
+      observerId: `loop:${managedKey}:${attemptedRuns}`,
       onUpdate: async () => {
         return;
       }
@@ -67725,8 +67709,8 @@ class ManagedLoopController {
       }
     });
   }
-  scheduleIntervalLoopTimer(loopId, delayMs) {
-    const managed = this.intervalLoops.get(loopId);
+  scheduleIntervalLoopTimer(managedKey, delayMs) {
+    const managed = this.intervalLoops.get(managedKey);
     if (!managed) {
       return;
     }
@@ -67736,12 +67720,12 @@ class ManagedLoopController {
     }
     const timer = setTimeout(() => {
       this.loopTimers.delete(timer);
-      const current = this.intervalLoops.get(loopId);
+      const current = this.intervalLoops.get(managedKey);
       if (!current) {
         return;
       }
       current.timer = undefined;
-      this.runIntervalLoopIteration(loopId, { notifyStart: true }).catch((error) => {
+      this.runIntervalLoopIteration(managedKey, { notifyStart: true }).catch((error) => {
         if (!this.deps.shouldSuppressShutdownError(error)) {
           console.error("loop execution failed", error);
         }
@@ -67758,6 +67742,9 @@ class ManagedLoopController {
     managed.loop = nextLoopState;
     return true;
   }
+  buildManagedLoopKey(sessionKey, loopId) {
+    return `${sessionKey}::${loopId}`;
+  }
   computeNextManagedLoopRunAtMs(loop, nowMs) {
     if (loop.kind === "calendar") {
       return computeNextCalendarLoopRunAtMs({
@@ -67798,7 +67785,7 @@ class ManagedQueueController {
   }
   async clearQueuedPrompts(target) {
     const clearedStored = await this.deps.sessionState.clearPendingQueuedItemsForSessionKey(target.sessionKey);
-    this.deps.queue.clearPendingByIds(clearedStored.map((item) => item.id));
+    this.deps.queue.clearPendingByIdsForKey(target.sessionKey, clearedStored.map((item) => item.id));
     return clearedStored.length;
   }
   enqueuePrompt(target, prompt, callbacks) {
@@ -67836,8 +67823,8 @@ class ManagedQueueController {
       return;
     }
     this.setManagedQueueItem(target, item, true);
-    return this.persistQueueItem(this.deps.resolveTarget(target), item).then(() => this.markPersisted(item)).catch((error) => {
-      this.clearPendingById(item);
+    return this.persistQueueItem(this.deps.resolveTarget(target), item).then(() => this.markPersisted(target, item)).catch((error) => {
+      this.clearPendingById(target, item);
       throw error;
     });
   }
@@ -67848,16 +67835,32 @@ class ManagedQueueController {
     await reconciledBeforeStart;
     return !await this.deps.hasBlockingActiveRun(target);
   }
+  async canStartPersistedQueueItem(target, item) {
+    if (await this.deps.hasBlockingActiveRun(target)) {
+      return false;
+    }
+    if (!await this.deps.sessionState.hasQueuedItem(target.sessionKey, item.id)) {
+      this.clearPendingById(target, item);
+      return false;
+    }
+    return true;
+  }
   async reconcilePersistedQueueItems() {
     const persistedItems = await this.deps.sessionState.listQueuedItems({
       statuses: ["pending", "running"]
     });
-    const persistedIds = new Set(persistedItems.map((item) => item.id));
-    const removedIds = [...this.queuedItems.entries()].filter(([id, managed]) => !managed.persisting && !persistedIds.has(id)).map(([id]) => id);
-    if (removedIds.length > 0) {
-      this.deps.queue.clearPendingByIds(removedIds);
-      for (const id of removedIds) {
-        this.queuedItems.delete(id);
+    const persistedKeys = new Set(persistedItems.map((item) => this.buildManagedQueueKey(item.sessionKey, item.id)));
+    const removedManagedItems = [...this.queuedItems.entries()].filter(([key, managed]) => !managed.persisting && !persistedKeys.has(key));
+    if (removedManagedItems.length > 0) {
+      const removedBySession = new Map;
+      for (const [key, managed] of removedManagedItems) {
+        const ids = removedBySession.get(managed.target.sessionKey) ?? [];
+        ids.push(managed.item.id);
+        removedBySession.set(managed.target.sessionKey, ids);
+        this.queuedItems.delete(key);
+      }
+      for (const [sessionKey, itemIds] of removedBySession.entries()) {
+        this.deps.queue.clearPendingByIdsForKey(sessionKey, itemIds);
       }
     }
     for (const persisted of persistedItems) {
@@ -67865,14 +67868,14 @@ class ManagedQueueController {
         await this.clearStaleRunningQueueItem(persisted);
         continue;
       }
-      if (this.queuedItems.has(persisted.id)) {
+      if (this.queuedItems.has(this.buildManagedQueueKey(persisted.sessionKey, persisted.id))) {
         continue;
       }
       this.enqueuePersistedQueueItem(persisted);
     }
   }
   async clearStaleRunningQueueItem(item) {
-    if (this.queuedItems.has(item.id)) {
+    if (this.queuedItems.has(this.buildManagedQueueKey(item.sessionKey, item.id))) {
       return;
     }
     const target = {
@@ -67896,21 +67899,22 @@ class ManagedQueueController {
     });
   }
   setManagedQueueItem(target, item, persisting) {
-    this.queuedItems.set(item.id, {
+    this.queuedItems.set(this.buildManagedQueueKey(target.sessionKey, item.id), {
       target,
       item,
       persisting
     });
   }
-  markPersisted(item) {
-    const managed = this.queuedItems.get(item.id);
+  markPersisted(target, item) {
+    const key = this.buildManagedQueueKey(target.sessionKey, item.id);
+    const managed = this.queuedItems.get(key);
     if (managed) {
-      this.queuedItems.set(item.id, { ...managed, persisting: false });
+      this.queuedItems.set(key, { ...managed, persisting: false });
     }
   }
-  clearPendingById(item) {
-    this.deps.queue.clearPendingByIds([item.id]);
-    this.queuedItems.delete(item.id);
+  clearPendingById(target, item) {
+    this.deps.queue.clearPendingByIdsForKey(target.sessionKey, [item.id]);
+    this.queuedItems.delete(this.buildManagedQueueKey(target.sessionKey, item.id));
   }
   async markQueueItemRunning(target, item) {
     if (!item) {
@@ -67923,7 +67927,7 @@ class ManagedQueueController {
       startedAt: now,
       updatedAt: now
     };
-    this.queuedItems.set(item.id, {
+    this.queuedItems.set(this.buildManagedQueueKey(target.sessionKey, item.id), {
       target,
       item: next
     });
@@ -67934,7 +67938,7 @@ class ManagedQueueController {
     if (!item) {
       return;
     }
-    this.queuedItems.delete(item.id);
+    this.queuedItems.delete(this.buildManagedQueueKey(target.sessionKey, item.id));
     await this.deps.sessionState.removeQueuedItem(this.deps.resolveTarget(target), item.id);
   }
   enqueuePersistedQueueItem(item) {
@@ -67942,7 +67946,7 @@ class ManagedQueueController {
       agentId: item.agentId,
       sessionKey: item.sessionKey
     };
-    this.queuedItems.set(item.id, {
+    this.queuedItems.set(this.buildManagedQueueKey(target.sessionKey, item.id), {
       target,
       item
     });
@@ -67974,7 +67978,7 @@ class ManagedQueueController {
       id: item.id,
       createdAt: item.createdAt,
       text: item.promptSummary,
-      canStart: async () => !await this.deps.hasBlockingActiveRun(target),
+      canStart: async () => this.canStartPersistedQueueItem(target, item),
       onComplete: async (value) => {
         if (!value.messageToolFinalAlreadySent && !await this.hasMessageToolFinalForQueueItem(target, item)) {
           await this.deps.surfaceRuntime.notifyManagedQueueSettlement(target, item, value);
@@ -67988,6 +67992,9 @@ class ManagedQueueController {
       onClear: () => this.removeManagedQueueItem(target, item)
     });
     queued.result.catch((error) => {
+      if (error instanceof ClearedQueuedTaskError) {
+        return;
+      }
       if (this.deps.shouldSuppressShutdownError(error)) {
         return;
       }
@@ -68004,7 +68011,7 @@ class ManagedQueueController {
     return false;
   }
   async hasMessageToolFinalForQueueItem(target, item) {
-    const startedAt = this.queuedItems.get(item.id)?.item.startedAt ?? item.startedAt;
+    const startedAt = this.queuedItems.get(this.buildManagedQueueKey(target.sessionKey, item.id))?.item.startedAt ?? item.startedAt;
     if (typeof startedAt !== "number" || !Number.isFinite(startedAt)) {
       return false;
     }
@@ -68025,6 +68032,9 @@ class ManagedQueueController {
       messageToolFinalAlreadySent: true
     };
   }
+  buildManagedQueueKey(sessionKey, itemId) {
+    return `${sessionKey}::${itemId}`;
+  }
 }
 
 // src/agents/runner-service.ts
@@ -69731,7 +69741,11 @@ class RunnerService {
       args: args.map((value) => applyTemplate(value, values))
     };
   }
-  async syncSessionIdentity(resolved) {
+  async syncStoredSessionId(target) {
+    const resolved = this.resolveTarget(target);
+    return this.syncStoredSessionIdForResolvedTarget(resolved);
+  }
+  async syncStoredSessionIdForResolvedTarget(resolved) {
     const existing = await this.sessionState.getEntry(resolved.sessionKey);
     if (existing?.sessionId) {
       this.sessionIdentityCaptureRetryAt.delete(resolved.sessionKey);
@@ -69793,12 +69807,41 @@ class RunnerService {
       remainingFreshRetries: remainingFreshRetries - 1
     });
   }
-  async retryAfterStartupFault(target, resolved, error, remainingFreshRetries) {
+  async retryAfterStartupFault(target, resolved, error, remainingFreshRetries, allowFreshResumeFallback) {
+    if (allowFreshResumeFallback) {
+      const resumedFresh = await this.retryFreshStartAfterStoredResumeFailure(target, resolved, error, remainingFreshRetries);
+      if (resumedFresh) {
+        return resumedFresh;
+      }
+    }
     if (!isRetryableFreshStartFault(error)) {
       return null;
     }
     return this.retryRunnerRestartPreservingSessionId(target, resolved, remainingFreshRetries);
   }
+  async retryFreshStartAfterStoredResumeFailure(target, resolved, error, remainingFreshRetries) {
+    if (!isRecoverableStartupSessionLoss(error)) {
+      return null;
+    }
+    if (resolved.runner.sessionId.resume.mode !== "command" || resolved.runner.sessionId.create.mode !== "runner") {
+      return null;
+    }
+    const existing = await this.sessionState.getEntry(resolved.sessionKey);
+    if (!existing?.sessionId) {
+      return null;
+    }
+    const exitRecord = await readRunnerExitRecord(this.loadedConfig.stateDir, resolved.sessionName);
+    if (!exitRecord || exitRecord.exitCode === 0) {
+      return null;
+    }
+    console.log(`clisbot clearing stored sessionId after failed runner resume startup ${resolved.sessionName}`);
+    await this.sessionState.clearSessionIdEntry(resolved, {
+      runnerCommand: resolved.runner.command
+    });
+    return this.ensureSessionReady(target, {
+      remainingFreshRetries
+    });
+  }
   async retryAfterStartupTimeout(target, resolved, remainingFreshRetries) {
     return this.retryRunnerRestartPreservingSessionId(target, resolved, remainingFreshRetries);
   }
@@ -69897,7 +69940,7 @@ class RunnerService {
       });
       try {
         await clearRunnerExitRecord(this.loadedConfig.stateDir, resolved.sessionName);
-        await this.syncSessionIdentity(resolved);
+        await this.syncStoredSessionIdForResolvedTarget(resolved);
       } catch (error) {
         throw await this.mapSessionError(error, resolved.sessionName, "during startup");
       }
@@ -69967,7 +70010,7 @@ class RunnerService {
         runnerCommand: runnerLaunch.command
       });
     } catch (error) {
-      const retried = await this.retryAfterStartupFault(target, resolved, error, remainingFreshRetries);
+      const retried = await this.retryAfterStartupFault(target, resolved, error, remainingFreshRetries, options.allowFreshRetry !== false);
       if (retried) {
         return retried;
       }
@@ -69989,7 +70032,7 @@ class RunnerService {
       });
       return;
     }
-    await this.syncSessionIdentity(resolved);
+    await this.syncStoredSessionIdForResolvedTarget(resolved);
   }
   async dismissTrustPrompt(resolved) {
     if (!resolved.runner.trustWorkspace) {
@@ -70522,16 +70565,21 @@ class SessionService {
     this.resolveTarget = resolveTarget;
   }
   async recoverPersistedRuns() {
+    const activeSessionKeys = new Set;
     const entries = await this.sessionState.listEntries();
     for (const entry of entries) {
       if (!entry.runtime || entry.runtime.state === "idle") {
         continue;
       }
-      await this.reconcilePersistedActiveRun({
+      const run = await this.reconcilePersistedActiveRun({
         agentId: entry.agentId,
         sessionKey: entry.sessionKey
       });
+      if (run) {
+        activeSessionKeys.add(run.resolved.sessionKey);
+      }
     }
+    return activeSessionKeys;
   }
   async clearLostPersistedActiveRuns() {
     const entries = await this.sessionState.listEntries();
@@ -70762,6 +70810,14 @@ class SessionService {
     }
     this.activeRuns.clear();
   }
+  listLiveSessionRuntimes() {
+    return [...this.activeRuns.values()].map((run) => ({
+      state: run.latestUpdate.status === "detached" ? "detached" : "running",
+      startedAt: run.startedAt,
+      sessionKey: run.resolved.sessionKey,
+      agentId: run.resolved.agentId
+    }));
+  }
   buildDetachedNote(resolved) {
     return `This session has been running for over ${resolved.stream.maxRuntimeLabel}. clisbot left it running and will post the final result here when it completes. Use \`/attach\` for live updates, \`/watch every <duration>\` for periodic updates, or \`/stop\` to interrupt it.`;
   }
@@ -72407,9 +72463,8 @@ class AgentService {
     });
   }
   async start() {
-    await this.activeRuns.recoverPersistedRuns();
-    const activeSessions = new Set((await this.sessionState.listActiveSessionRuntimes()).map((runtime) => runtime.sessionKey));
-    await this.sessionState.resetStaleRunningQueuedItems(activeSessions);
+    const activeSessionKeys = await this.activeRuns.recoverPersistedRuns();
+    await this.sessionState.resetStaleRunningQueuedItems(activeSessionKeys);
     await this.managedQueues.reconcilePersistedQueueItems();
     this.queueReconcileTimer = setInterval(() => {
       this.managedQueues.reconcilePersistedQueueItems().catch((error) => {
@@ -72492,14 +72547,13 @@ class AgentService {
     const storedSessionId = entry?.sessionId?.trim() || undefined;
     return {
       sessionName: resolved.sessionName,
-      sessionId: storedSessionId,
       storedSessionId,
       resumeCommand: buildResumeCommandPreview(resolved, storedSessionId)
     };
   }
-  async listActiveSessionRuntimes() {
+  async listLiveSessionRuntimes() {
     await this.activeRuns.clearLostPersistedActiveRuns();
-    return this.sessionState.listActiveSessionRuntimes();
+    return this.activeRuns.listLiveSessionRuntimes();
   }
   async setConversationFollowUpMode(target, mode) {
     return this.sessionState.setConversationFollowUpMode(this.resolveTarget(target), mode);
@@ -72600,8 +72654,8 @@ class AgentService {
   async createCalendarLoop(params) {
     return this.managedLoops.createCalendarLoop(params);
   }
-  async cancelIntervalLoop(loopId) {
-    return this.managedLoops.cancelIntervalLoop(loopId);
+  async cancelIntervalLoop(target, loopId) {
+    return this.managedLoops.cancelIntervalLoop(target, loopId);
   }
   async cancelIntervalLoopsForSession(target) {
     return this.managedLoops.cancelIntervalLoopsForSession(target);
@@ -72612,8 +72666,8 @@ class AgentService {
   listIntervalLoops(params) {
     return this.managedLoops.listIntervalLoops(params);
   }
-  getIntervalLoop(loopId) {
-    return this.managedLoops.getIntervalLoop(loopId);
+  getIntervalLoop(target, loopId) {
+    return this.managedLoops.getIntervalLoop(target.sessionKey, loopId);
   }
   getActiveIntervalLoopCount() {
     return this.managedLoops.getActiveIntervalLoopCount();
@@ -72919,7 +72973,6 @@ function renderStartupSteeringUnavailableMessage() {
 `);
 }
 function renderWhoAmIMessage(params) {
-  const storedSessionId = params.sessionDiagnostics.storedSessionId ?? params.sessionDiagnostics.sessionId;
   const lines = [
     "Who am I",
     "",
@@ -72927,7 +72980,7 @@ function renderWhoAmIMessage(params) {
     `conversationKind: \`${params.identity.conversationKind}\``,
     `agentId: \`${params.route.agentId}\``,
     `sessionName: \`${params.sessionDiagnostics.sessionName ?? "(not available)"}\``,
-    `storedSessionId: \`${storedSessionId ?? "(not captured yet)"}\``
+    `storedSessionId: \`${params.sessionDiagnostics.storedSessionId ?? "(not captured yet)"}\``
   ];
   if (params.identity.senderId) {
     lines.push(`senderId: \`${params.identity.senderId}\``);
@@ -72949,7 +73002,6 @@ function renderWhoAmIMessage(params) {
 `);
 }
 function renderRouteStatusMessage(params) {
-  const storedSessionId = params.sessionDiagnostics.storedSessionId ?? params.sessionDiagnostics.sessionId;
   const lines = [
     "Status",
     "",
@@ -72957,7 +73009,7 @@ function renderRouteStatusMessage(params) {
     `conversationKind: \`${params.identity.conversationKind}\``,
     `agentId: \`${params.route.agentId}\``,
     `sessionName: \`${params.sessionDiagnostics.sessionName ?? "(not available)"}\``,
-    `storedSessionId: \`${storedSessionId ?? "(not captured yet)"}\``
+    `storedSessionId: \`${params.sessionDiagnostics.storedSessionId ?? "(not captured yet)"}\``
   ];
   if (params.identity.senderId) {
     lines.push(`senderId: \`${params.identity.senderId}\``);
@@ -74047,7 +74099,7 @@ async function processChannelInteraction(params) {
       await params.agentService.recordConversationReply(params.sessionTarget);
       return interactionResult;
     }
-    const cancelled = await params.agentService.cancelIntervalLoop(targetLoopId);
+    const cancelled = await params.agentService.cancelIntervalLoop(params.sessionTarget, targetLoopId);
     await params.postText(cancelled ? `Cancelled loop \`${targetLoopId}\`.` : `No active loop found with id \`${targetLoopId}\`.`);
     await params.agentService.recordConversationReply(params.sessionTarget);
     return interactionResult;
@@ -84282,18 +84334,27 @@ function renderUpdateHelp() {
     "  2. Read docs in priority order and follow them before installing.",
     "  3. npm install -g clisbot@<target> && clisbot restart",
     `  4. ${renderCliCommand("status")}`,
-    "  5. Report version, health, manual action, and useful release-note highlights.",
+    "  5. Report version, health, manual action, and useful release highlights.",
     "",
     "Docs, read in order:",
     `  1. Migration index: ${GITHUB_RAW_BASE}/docs/migrations/index.md`,
     "     If Manual action: required, follow its runbook. If none, continue.",
-    `  2. Release quick info: ${GITHUB_RAW_BASE}/docs/releases/README.md`,
-    "     Use for release-note map and current release highlights.",
-    `  3. Update guide: ${GITHUB_RAW_BASE}/docs/update/README.md`,
-    "     Use for release notes, useful new features, things to try, and user-guide links.",
-    "  4. Full docs: https://github.com/longbkit/clisbot/tree/main/docs",
+    `  2. Update guide: ${GITHUB_RAW_BASE}/docs/updates/update-guide.md`,
+    "     Use for target choice, install flow, verification, and wrong-publish recovery.",
+    `  3. Release notes: ${GITHUB_RAW_BASE}/docs/releases/README.md`,
+    "     Use for the canonical version map and full version notes.",
+    `  4. Release guides: ${GITHUB_RAW_BASE}/docs/updates/README.md`,
+    "     Use for shorter catch-up notes: what changed, what to try, and what to watch.",
+    "  5. Full docs: https://github.com/longbkit/clisbot/tree/main/docs",
     "     Use for deep questions. If needed, fetch or clone docs and inspect relevant files.",
     "",
+    "Recovery:",
+    "  - If a version was published by mistake, publish the corrected target or tag first.",
+    "  - Then deprecate the wrong version.",
+    "  - Start with `npm login` in an attached session.",
+    "  - If npm returns a browser approval URL, keep that same session open and continue it after approval.",
+    "  - If the write command still returns EOTP, ask the operator for a current OTP and rerun the exact command with --otp=<code>.",
+    "",
     "Rules:",
     "  - Use npm dist-tags, not highest semver.",
     "  - Stable/latest is default; beta only when the user asks.",
@@ -84847,7 +84908,7 @@ async function getRuntimeOperatorSummary(params) {
     },
     agentSummaries,
     channelSummaries,
-    activeRuns: await agentService.listActiveSessionRuntimes(),
+    activeRuns: await agentService.listLiveSessionRuntimes(),
     configuredAgents: agentSummaries.length,
     bootstrapPendingAgents: agentSummaries.filter((item) => item.bootstrapState === "missing" || item.bootstrapState === "not-bootstrapped").length,
     bootstrappedAgents: agentSummaries.filter((item) => item.bootstrapState === "bootstrapped").length,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clisbot",
-  "version": "0.1.45-beta.7",
+  "version": "0.1.45-beta.8",
   "private": false,
   "description": "Chat surfaces for durable AI coding agents running in tmux",
   "license": "MIT",