bosun 0.41.2 → 0.41.3

package/task/task-store.mjs

@@ -652,6 +652,138 @@ function compareTaskDagOrder(taskA, taskB) {
   return String(taskA?.id || "").localeCompare(String(taskB?.id || ""));
 }
 
+function compareSprintDagOrder(sprintA, sprintB) {
+  const orderA = normalizeSprintOrder(sprintA?.order);
+  const orderB = normalizeSprintOrder(sprintB?.order);
+  if (orderA != null && orderB != null && orderA !== orderB) return orderA - orderB;
+  if (orderA != null && orderB == null) return -1;
+  if (orderA == null && orderB != null) return 1;
+  return String(sprintA?.name || sprintA?.id || "").localeCompare(String(sprintB?.name || sprintB?.id || ""));
+}
+
+function topoSortIds(seedIds, incomingMap, outgoingMap, compareEntries) {
+  const remaining = new Map();
+  for (const id of seedIds) remaining.set(id, incomingMap.get(id) || 0);
+  const ordered = [];
+  const ready = [...seedIds].filter((id) => (remaining.get(id) || 0) === 0);
+
+  while (ready.length > 0) {
+    ready.sort(compareEntries);
+    const current = ready.shift();
+    ordered.push(current);
+    for (const nextId of outgoingMap.get(current) || []) {
+      if (!remaining.has(nextId)) continue;
+      const nextCount = (remaining.get(nextId) || 0) - 1;
+      remaining.set(nextId, nextCount);
+      if (nextCount === 0) ready.push(nextId);
+    }
+    remaining.delete(current);
+  }
+
+  if (remaining.size > 0) {
+    ordered.push(...[...remaining.keys()].sort(compareEntries));
+  }
+
+  return ordered;
+}
+
+function hasDependencyPath(taskMap, fromTaskId, targetTaskId, visited = new Set()) {
+  const startId = String(fromTaskId || "").trim();
+  const targetId = String(targetTaskId || "").trim();
+  if (!startId || !targetId) return false;
+  if (startId === targetId) return true;
+  if (visited.has(startId)) return false;
+  visited.add(startId);
+  const task = taskMap.get(startId);
+  if (!task) return false;
+  for (const dependencyId of listTaskDependencyIds(task)) {
+    if (dependencyId === targetId) return true;
+    if (hasDependencyPath(taskMap, dependencyId, targetId, visited)) return true;
+  }
+  return false;
+}
+
+function collectDagRewriteSuggestions(taskMap, orderedTaskIds, sprint) {
+  const suggestions = [];
+  const sprintId = normalizeSprintId(sprint?.id);
+  const sprintMode = resolveSprintOrderMode(sprint?.executionMode || sprint?.taskOrderMode || "parallel");
+
+  // Cache for hasDependencyPath results to avoid repeated expensive traversals.
+  const pathCache = new Map();
+  function memoizedHasDependencyPath(fromTaskId, targetTaskId, initialVisited) {
+    const fromId = String(fromTaskId || "").trim();
+    const toId = String(targetTaskId || "").trim();
+    if (!fromId || !toId) return false;
+    const cacheKey = `${fromId}::${toId}`;
+    if (pathCache.has(cacheKey)) {
+      return pathCache.get(cacheKey);
+    }
+    const visited = initialVisited ? new Set(initialVisited) : new Set();
+    const result = hasDependencyPath(taskMap, fromId, toId, visited);
+    pathCache.set(cacheKey, result);
+    return result;
+  }
+
+  if (sprintMode === "sequential") {
+    for (let index = 1; index < orderedTaskIds.length; index += 1) {
+      const previousTaskId = orderedTaskIds[index - 1];
+      const currentTaskId = orderedTaskIds[index];
+      const currentTask = taskMap.get(currentTaskId);
+      if (!currentTask) continue;
+      if (new Set(listTaskDependencyIds(currentTask)).has(previousTaskId)) continue;
+      suggestions.push({
+        type: "missing_sequential_dependency",
+        sprintId,
+        taskId: currentTaskId,
+        dependencyTaskId: previousTaskId,
+        message: `Add dependency ${previousTaskId} -> ${currentTaskId} to encode sequential sprint order.`,
+      });
+    }
+  }
+
+  for (const taskId of orderedTaskIds) {
+    const task = taskMap.get(taskId);
+    if (!task) continue;
+    const directDependencies = listTaskDependencyIds(task);
+    for (const dependencyId of directDependencies) {
+      const redundant = directDependencies.some((otherDependencyId) => {
+        if (otherDependencyId === dependencyId) return false;
+        return memoizedHasDependencyPath(otherDependencyId, dependencyId, new Set([taskId]));
+      });
+      if (!redundant) continue;
+      suggestions.push({
+        type: "redundant_transitive_dependency",
+        sprintId,
+        taskId,
+        dependencyTaskId: dependencyId,
+        message: `Dependency ${dependencyId} -> ${taskId} is already implied transitively by another dependency.`,
+      });
+    }
+  }
+
+  return suggestions;
+}
+
+function getTaskEpicId(task) {
+  return String(task?.epicId ?? task?.meta?.epicId ?? "").trim();
+}
+
+function normalizeRecoveredTaskMeta(task, recoveredAt) {
+  const currentMeta = task?.meta && typeof task.meta === "object" ? task.meta : {};
+  const currentRecovery = currentMeta.autoRecovery && typeof currentMeta.autoRecovery === "object"
+    ? currentMeta.autoRecovery
+    : {};
+  return {
+    ...currentMeta,
+    autoRecovery: {
+      ...currentRecovery,
+      active: false,
+      recoveredAt,
+      recoveredStatus: "todo",
+    },
+  };
+}
+
 function recalcStats() {
   const stats = {
     draft: 0,
@@ -1320,6 +1452,56 @@ export function setTaskStatus(taskId, status, source) {
   return { ...task };
 }
 
+export function unblockTask(taskId, options = {}) {
+  ensureLoaded();
+  const task = _store.tasks[taskId];
+  if (!task) {
+    console.warn(TAG, `unblockTask: task ${taskId} not found`);
+    return null;
+  }
+
+  const previousStatus = normalizeTaskStatus(task.status);
+  const nextStatus = normalizeTaskStatus(
+    options.status || options.targetStatus || "todo",
+  );
+  const timestamp = now();
+  task.status = nextStatus;
+  task.cooldownUntil = null;
+  task.blockedReason = null;
+  if (task.meta && typeof task.meta === "object") {
+    const nextMeta = { ...task.meta };
+    delete nextMeta.autoRecovery;
+    task.meta = nextMeta;
+  }
+  task.updatedAt = timestamp;
+  task.lastActivityAt = timestamp;
+  task.syncDirty = options.source !== "external";
+
+  if (previousStatus !== nextStatus) {
+    task.statusHistory.push({
+      status: nextStatus,
+      timestamp,
+      source: options.source || "manual-unblock",
+    });
+    if (task.statusHistory.length > MAX_STATUS_HISTORY) {
+      task.statusHistory = task.statusHistory.slice(-MAX_STATUS_HISTORY);
+    }
+  }
+
+  pushTaskTimeline(task, {
+    type: "task.unblocked",
+    source: options.source || "manual-unblock",
+    fromStatus: previousStatus,
+    toStatus: nextStatus,
+    status: nextStatus,
+    action: "unblock_task",
+    message: `Cleared blocked state and moved task to ${nextStatus}`,
+  });
+
+  saveStore();
+  return { ...task };
+}
+
 export function validateTaskStatusTransition(currentStatus, nextStatus, options = {}) {
   return validateTaskTransition(currentStatus, nextStatus, options);
 }
@@ -2076,6 +2258,232 @@ export function canTaskStart(taskId, options = {}) {
   };
 }
 
+export function recoverAutoBlockedTasks(options = {}) {
+  ensureLoaded();
+  const recoveredAtMs = Number.isFinite(options.nowMs) ? options.nowMs : Date.now();
+  const recoveredAt = new Date(recoveredAtMs).toISOString();
+  const recoveredTaskIds = [];
+
+  for (const task of Object.values(_store.tasks)) {
+    if (!task || normalizeTaskStatus(task.status) !== "blocked") continue;
+    const autoRecovery = task.meta?.autoRecovery;
+    if (!autoRecovery || typeof autoRecovery !== "object") continue;
+    if (autoRecovery.active === false) continue;
+    if (String(autoRecovery.reason || "").trim() !== "worktree_failure") continue;
+    const retryAtMs = Date.parse(String(autoRecovery.retryAt || task.cooldownUntil || ""));
+    if (!Number.isFinite(retryAtMs) || retryAtMs > recoveredAtMs) continue;
+
+    const previousStatus = normalizeTaskStatus(task.status);
+    task.status = "todo";
+    task.cooldownUntil = null;
+    task.blockedReason = null;
+    task.meta = normalizeRecoveredTaskMeta(task, recoveredAt);
+    task.updatedAt = recoveredAt;
+    task.lastActivityAt = recoveredAt;
+    task.syncDirty = true;
+    task.statusHistory.push({
+      status: "todo",
+      timestamp: recoveredAt,
+      source: "auto-recovery",
+    });
+    if (task.statusHistory.length > MAX_STATUS_HISTORY) {
+      task.statusHistory = task.statusHistory.slice(-MAX_STATUS_HISTORY);
+    }
+    pushTaskTimeline(task, {
+      type: "status.transition",
+      source: "auto-recovery",
+      fromStatus: previousStatus,
+      toStatus: "todo",
+      status: "todo",
+      action: "recover_blocked_task",
+      message: "Recovered timed blocked task back to todo",
+    });
+    markTaskTouched(task, "auto-recovery");
+    recoveredTaskIds.push(task.id);
+  }
+
+  if (recoveredTaskIds.length > 0) saveStore();
+
+  return {
+    recoveredTaskIds,
+    recoveredCount: recoveredTaskIds.length,
+    recoveredAt,
+  };
+}
+
+export function organizeTaskDag(options = {}) {
+  ensureLoaded();
+  const sprintFilter = normalizeSprintId(options.sprintId);
+  const applyDependencySuggestions = options.applyDependencySuggestions !== false;
+  const syncEpicDependencies = options.syncEpicDependencies !== false;
+  const sprintMap = ensureSprintsMap();
+  const allTasks = Object.values(_store.tasks);
+  const taskMap = new Map(allTasks.map((task) => [task.id, task]));
+  const targetSprintIds = sprintFilter
+    ? (sprintMap[sprintFilter] ? [sprintFilter] : [])
+    : listSprints().map((sprint) => sprint.id);
+
+  const suggestions = [];
+  const orderedTaskIdsBySprint = {};
+  let updatedTaskCount = 0;
+  let appliedDependencySuggestionCount = 0;
+  let syncedEpicDependencyCount = 0;
+
+  for (const sprintId of targetSprintIds) {
+    const sprint = sprintMap[sprintId];
+    if (!sprint) continue;
+    const sprintTasks = allTasks
+      .filter((task) => normalizeSprintId(task?.sprintId) === sprintId)
+      .sort(compareTaskDagOrder);
+    const incomingCounts = new Map();
+    const outgoingMap = new Map();
+    for (const task of sprintTasks) {
+      incomingCounts.set(task.id, 0);
+      outgoingMap.set(task.id, new Set());
+    }
+    for (const task of sprintTasks) {
+      for (const dependencyId of listTaskDependencyIds(task)) {
+        const dependencyTask = taskMap.get(dependencyId);
+        if (!dependencyTask || normalizeSprintId(dependencyTask.sprintId) !== sprintId) continue;
+        outgoingMap.get(dependencyId).add(task.id);
+        incomingCounts.set(task.id, (incomingCounts.get(task.id) || 0) + 1);
+      }
+    }
+
+    const orderedTaskIds = topoSortIds(
+      sprintTasks.map((task) => task.id),
+      incomingCounts,
+      outgoingMap,
+      (leftId, rightId) => compareTaskDagOrder(taskMap.get(leftId), taskMap.get(rightId)),
+    );
+    orderedTaskIdsBySprint[sprintId] = orderedTaskIds;
+    const sprintSuggestions = collectDagRewriteSuggestions(taskMap, orderedTaskIds, sprint);
+    for (const suggestion of sprintSuggestions) {
+      if (applyDependencySuggestions !== true || suggestion?.type !== "missing_sequential_dependency") {
+        suggestions.push(suggestion);
+        continue;
+      }
+      const task = taskMap.get(suggestion.taskId);
+      const dependencyTask = taskMap.get(suggestion.dependencyTaskId);
+      if (!task || !dependencyTask) continue;
+      const currentDependencies = listTaskDependencyIds(task);
+      if (currentDependencies.includes(suggestion.dependencyTaskId)) continue;
+      task.dependencyTaskIds = uniqueStringList([...(task.dependencyTaskIds || []), suggestion.dependencyTaskId]);
+      task.dependsOn = uniqueStringList([...(task.dependsOn || []), suggestion.dependencyTaskId]);
+      dependencyTask.blockedByTaskIds = uniqueStringList([...(dependencyTask.blockedByTaskIds || []), task.id]);
+      markTaskTouched(task, "dag-organize");
+      markTaskTouched(dependencyTask, "dag-organize");
+      appliedDependencySuggestionCount += 1;
+    }
+
+    orderedTaskIds.forEach((taskId, index) => {
+      const task = taskMap.get(taskId);
+      if (!task) return;
+      const nextOrder = index + 1;
+      if (normalizeSprintOrder(task.sprintOrder) === nextOrder) return;
+      task.sprintOrder = nextOrder;
+      markTaskTouched(task, "dag-organize");
+      updatedTaskCount += 1;
+    });
+  }
+
+  const allSprintIds = listSprints().map((sprint) => sprint.id);
+  const sprintIncoming = new Map();
+  const sprintOutgoing = new Map();
+  for (const sprintId of allSprintIds) {
+    sprintIncoming.set(sprintId, 0);
+    sprintOutgoing.set(sprintId, new Set());
+  }
+  for (const task of allTasks) {
+    const taskSprintId = normalizeSprintId(task?.sprintId);
+    if (!taskSprintId) continue;
+    for (const dependencyId of listTaskDependencyIds(task)) {
+      const dependencyTask = taskMap.get(dependencyId);
+      const dependencySprintId = normalizeSprintId(dependencyTask?.sprintId);
+      if (!dependencySprintId || dependencySprintId === taskSprintId) continue;
+      if (!sprintOutgoing.get(dependencySprintId)?.has(taskSprintId)) {
+        sprintOutgoing.get(dependencySprintId).add(taskSprintId);
+        sprintIncoming.set(taskSprintId, (sprintIncoming.get(taskSprintId) || 0) + 1);
+      }
+    }
+  }
+
+  const orderedSprintIds = topoSortIds(
+    allSprintIds,
+    sprintIncoming,
+    sprintOutgoing,
+    (leftId, rightId) => compareSprintDagOrder(sprintMap[leftId], sprintMap[rightId]),
+  );
+  let updatedSprintCount = 0;
+  if (!sprintFilter) {
+    orderedSprintIds.forEach((sprintId, index) => {
+      const sprint = sprintMap[sprintId];
+      if (!sprint) return;
+      const nextOrder = index + 1;
+      if (normalizeSprintOrder(sprint.order) === nextOrder) return;
+      sprint.order = nextOrder;
+      sprint.updatedAt = now();
+      updatedSprintCount += 1;
+    });
+  }
+
+  if (syncEpicDependencies) {
+    const epicDependencyMap = ensureEpicDependenciesMap();
+    const relevantTasks = sprintFilter
+      ? allTasks.filter((task) => targetSprintIds.includes(normalizeSprintId(task?.sprintId)))
+      : allTasks;
+    const nextDependenciesByEpic = new Map(
+      Object.entries(epicDependencyMap).map(([epicId, dependencyIds]) => [epicId, uniqueStringList(dependencyIds)]),
+    );
+
+    for (const task of relevantTasks) {
+      const taskEpicId = getTaskEpicId(task);
+      if (!taskEpicId) continue;
+      const currentDependencies = nextDependenciesByEpic.get(taskEpicId) || [];
+      let nextDependencies = currentDependencies;
+      for (const dependencyTaskId of listTaskDependencyIds(task)) {
+        const dependencyTask = taskMap.get(dependencyTaskId);
+        const dependencyEpicId = getTaskEpicId(dependencyTask);
+        if (!dependencyEpicId || dependencyEpicId === taskEpicId) continue;
+        if (nextDependencies.includes(dependencyEpicId)) continue;
+        nextDependencies = uniqueStringList([...nextDependencies, dependencyEpicId]);
+      }
+      nextDependenciesByEpic.set(taskEpicId, nextDependencies);
+    }
+
+    for (const [epicId, nextDependencies] of nextDependenciesByEpic.entries()) {
+      const currentDependencies = uniqueStringList(epicDependencyMap[epicId] || []);
+      if (
+        currentDependencies.length === nextDependencies.length &&
+        currentDependencies.every((dependencyId, index) => dependencyId === nextDependencies[index])
+      ) {
+        continue;
+      }
+      if (nextDependencies.length > 0) {
+        epicDependencyMap[epicId] = nextDependencies;
+      } else {
+        delete epicDependencyMap[epicId];
+      }
+      syncedEpicDependencyCount += 1;
+    }
+  }
+
+  if (updatedTaskCount > 0 || updatedSprintCount > 0 || appliedDependencySuggestionCount > 0 || syncedEpicDependencyCount > 0) {
+    saveStore();
+  }
+
+  return {
+    sprintId: sprintFilter || null,
+    orderedSprintIds,
+    orderedTaskIdsBySprint,
+    updatedSprintCount,
+    updatedTaskCount,
+    appliedDependencySuggestionCount,
+    syncedEpicDependencyCount,
+    suggestions,
+  };
+}
+
 // ---------------------------------------------------------------------------
 // Agent tracking
 // ---------------------------------------------------------------------------
@@ -2423,4 +2831,4 @@ export function getStaleInReviewTasks(maxAgeMs) {
     (t) => t.status === "inreview" && t.lastActivityAt < cutoff,
   );
 }
-
+

package/telegram/telegram-bot.mjs

@@ -1126,6 +1126,11 @@ let agentChatId = null; // latest chat where an agent is running
 const stickyMenuState = new Map();
 const stickyMenuTimers = new Map();
 const STICKY_MENU_BUMP_MS = 600;
+const callbackActionDeduper = new Map();
+const CALLBACK_ACTION_DEDUPE_MS = Math.max(
+  150,
+  Number(process.env.TELEGRAM_CALLBACK_ACTION_DEDUPE_MS || "1200") || 1200,
+);
 
 // ── Queues ──────────────────────────────────────────────────────────────────
 
@@ -1383,6 +1388,18 @@ function setStickyMenuState(chatId, patch) {
   stickyMenuState.set(chatId, { ...current, ...patch });
 }
 
+function logTelegramStructured(event, payload = {}) {
+  try {
+    console.log(`[telegram-bot] ${JSON.stringify({
+      event,
+      at: new Date().toISOString(),
+      ...payload,
+    })}`);
+  } catch {
+    console.log(`[telegram-bot] ${event}`);
+  }
+}
+
 function clearStickyMenuTimer(chatId) {
   const timer = stickyMenuTimers.get(chatId);
   if (timer) {
@@ -1396,6 +1413,94 @@ function isStickyMenuInteractive(chatId) {
   return stickyMenuState.get(chatId)?.mode === "interactive";
 }
 
+function isMenuCallbackData(data) {
+  if (typeof data !== "string") return false;
+  return data.startsWith("ui:") || data.startsWith("cb:");
+}
+
+function shouldRecoverStickyFromCallback(query) {
+  const data = String(query?.data || "");
+  if (!isMenuCallbackData(data)) return false;
+  const messageId = query?.message?.message_id;
+  const chatId = String(query?.message?.chat?.id || "");
+  if (!chatId || !messageId) return false;
+  const current = stickyMenuState.get(chatId);
+  if (current?.enabled && current?.messageId) return false;
+  return true;
+}
+
+function recoverStickyMenuContextFromCallback(query, reason = "callback") {
+  if (!shouldRecoverStickyFromCallback(query)) return false;
+  const chatId = String(query.message.chat.id || "");
+  const messageId = query.message.message_id;
+  const data = String(query.data || "");
+  const prev = stickyMenuState.get(chatId) || {};
+  const screenId = prev.screenId || "home";
+  const params = prev.params || {};
+  const mode = data === "cb:dismiss" || data === "ui:cancel"
+    ? "interactive"
+    : "menu";
+  setStickyMenuState(chatId, {
+    enabled: true,
+    messageId,
+    screenId,
+    params,
+    mode,
+    restoreScreenId: prev.restoreScreenId || screenId,
+    restoreParams: prev.restoreParams || params,
+  });
+  logTelegramStructured("sticky_menu.context_recovered", {
+    reason,
+    chatId,
+    messageId,
+    mode,
+    data,
+  });
+  return true;
+}
+
+function pruneCallbackActionDeduper(now = Date.now()) {
+  for (const [key, entry] of callbackActionDeduper.entries()) {
+    if (!entry || now - entry.atMs > CALLBACK_ACTION_DEDUPE_MS) {
+      callbackActionDeduper.delete(key);
+    }
+  }
+}
+
+function dedupeMenuCallbackAction({
+  chatId,
+  fromId,
+  messageId,
+  data,
+  callbackId,
+}) {
+  if (!isMenuCallbackData(data)) return { duplicate: false };
+  const now = Date.now();
+  pruneCallbackActionDeduper(now);
+  const key = [
+    String(chatId || ""),
+    String(fromId || ""),
+    String(messageId || ""),
+    String(data || ""),
+  ].join("|");
+  const prev = callbackActionDeduper.get(key);
+  callbackActionDeduper.set(key, {
+    atMs: now,
+    callbackId: String(callbackId || ""),
+  });
+  if (!prev) return { duplicate: false };
+  if (String(prev.callbackId || "") === String(callbackId || "")) {
+    return { duplicate: false };
+  }
+  const ageMs = now - prev.atMs;
+  if (ageMs > CALLBACK_ACTION_DEDUPE_MS) return { duplicate: false };
+  return {
+    duplicate: true,
+    key,
+    ageMs,
+  };
+}
+
 function getStickyMenuRestoreTarget(chatId) {
   const state = stickyMenuState.get(chatId) || {};
   return {
@@ -2607,6 +2712,7 @@ async function handleCallbackQuery(query) {
   const fromId = String(query.from?.id || "");
   const data = query.data || "";
   const callbackId = query.id;
+  const messageId = query.message?.message_id || null;
 
   // Security: only accept from configured chat/user allow-list
   if (!isAuthorizedTelegramActor(chatId, fromId)) {
@@ -2614,6 +2720,27 @@ async function handleCallbackQuery(query) {
     return;
   }
 
+  recoverStickyMenuContextFromCallback(query, "reconnect");
+
+  const dedupe = dedupeMenuCallbackAction({
+    chatId,
+    fromId,
+    messageId,
+    data,
+    callbackId,
+  });
+  if (dedupe.duplicate) {
+    logTelegramStructured("sticky_menu.callback_deduped", {
+      chatId,
+      fromId,
+      messageId,
+      data,
+      ageMs: dedupe.ageMs,
+    });
+    await answerCallbackQuery(callbackId, "Already processing...");
+    return;
+  }
+
   console.log(`[telegram-bot] callback: "${data}" from chat ${chatId}`);
 
   // Always acknowledge the callback to dismiss loading indicator