pi-quests 0.6.2 → 0.8.0

package/src/quest/dataplane.ts

@@ -1,10 +1,12 @@
-import type { AgentToolResult, ExtensionContext } from "@mariozechner/pi-coding-agent";
+import type { AgentToolResult, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { DEFAULT_CONFIG, type ResolvedConfig } from "../config.js";
 import { logger } from "../logger.js";
 import { getQuestSkillDocument } from "../prompts.js";
 import {
   formatAddResult,
   formatBatchAddResult,
+  formatBatchDeleteResult,
+  formatBatchToggleResult,
   formatBlockedBySteps,
   formatDeleteResult,
   formatDescriptionRequiredError,
@@ -12,7 +14,8 @@ import {
   formatIdRequiredError,
   formatMissingDescriptionsError,
   formatNotFound,
-  formatNothingToRevertError,
+  formatNothingToRedoError,
+  formatNothingToUndoError,
   formatParentDoneError,
   formatParentNotFoundError,
   formatQuestList,
@@ -32,17 +35,17 @@ import {
 } from "./formatters.js";
 import { QUEST_ACTIONS, type Quest, type Step } from "./types.js";
 
+type DeletedQuestSnapshot = {
+  deletedIds: string[];
+  previousQuests: Quest[];
+  previousSteps: Step[];
+};
+
 export type HistoryEntry =
   | { type: typeof QUEST_ACTIONS.add; id: string; parentId?: string }
-  | { type: typeof QUEST_ACTIONS.toggle; id: string }
+  | { type: typeof QUEST_ACTIONS.toggle; ids: string[] }
   | { type: typeof QUEST_ACTIONS.update; id: string; previousDescription: string }
-  | {
-      type: typeof QUEST_ACTIONS.delete;
-      quest: Quest | Step;
-      index: number;
-      isStep?: boolean;
-      cascadeDeletedSteps?: Step[];
-    }
+  | ({ type: typeof QUEST_ACTIONS.delete; ids: string[] } & DeletedQuestSnapshot)
   | {
       type: typeof QUEST_ACTIONS.clear;
       previousQuests: Quest[];
@@ -69,17 +72,40 @@ export type QuestAction =
   | { type: typeof QUEST_ACTIONS.split; id?: string; descriptions?: string[] }
   | { type: typeof QUEST_ACTIONS.add_step; id?: string; descriptions?: string[] }
   | { type: typeof QUEST_ACTIONS.list }
-  | { type: typeof QUEST_ACTIONS.toggle; id?: string }
+  | { type: typeof QUEST_ACTIONS.toggle; id?: string; ids?: string[] }
   | { type: typeof QUEST_ACTIONS.update; id?: string; description?: string }
-  | { type: typeof QUEST_ACTIONS.delete; id?: string }
+  | { type: typeof QUEST_ACTIONS.delete; id?: string; ids?: string[] }
   | { type: typeof QUEST_ACTIONS.clear; all?: boolean }
   | { type: typeof QUEST_ACTIONS.reorder; id?: string; targetId?: string }
-  | { type: typeof QUEST_ACTIONS.revert }
+  | { type: typeof QUEST_ACTIONS.undo }
+  | { type: typeof QUEST_ACTIONS.redo }
   | { type: typeof QUEST_ACTIONS.reparent; id?: string; parentId?: string }
   | { type: typeof QUEST_ACTIONS.rules }
   | { type: typeof QUEST_ACTIONS.skill };
 
-export type QuestOperationResult = { success: boolean; message: string; quest?: Quest };
+export type RedoEntry =
+  | { type: typeof QUEST_ACTIONS.add; quest: Quest | Step }
+  | { type: typeof QUEST_ACTIONS.toggle; ids: string[] }
+  | { type: typeof QUEST_ACTIONS.update; id: string; description: string }
+  | { type: typeof QUEST_ACTIONS.delete; ids: string[] }
+  | { type: typeof QUEST_ACTIONS.clear; all: boolean }
+  | { type: typeof QUEST_ACTIONS.reorder; id: string; targetId: string }
+  | { type: typeof QUEST_ACTIONS.reparent; id: string; parentId?: string };
+
+export type QuestOperationResult = {
+  success: boolean;
+  message: string;
+  quest?: Quest;
+  quests?: Quest[];
+};
+
+type ToggleBatchResult =
+  | { quests: (Quest | Step)[]; ids: string[] }
+  | { error: "notFound" | "blocked"; id: string };
+
+type DeleteBatchResult =
+  | { quests: (Quest | Step)[]; ids: string[] }
+  | { error: "notFound" | "blocked"; id: string };
 
 /**
  * In-memory quest data plane.
@@ -92,6 +118,8 @@ export class QuestLog {
   private steps: Step[] = [];
   private usedIds: Set<string> = new Set();
   private history: HistoryEntry[] = [];
+  private redoStack: RedoEntry[] = [];
+  private inRedo = false;
 
   private readonly ID_LENGTH: number;
   private readonly MAX_IDS: number;
@@ -136,16 +164,30 @@ export class QuestLog {
       return { success: true, message: `Reverted add quest [${entry.id}]` };
     },
     [QUEST_ACTIONS.toggle]: (entry) => {
-      const quest = this.findById(entry.id);
+      const quests = entry.ids.map((id) => this.findById(id));
+      const missingId = entry.ids.find((_, index) => !quests[index]);
 
-      if (quest) {
+      if (missingId) {
+        logger.debug("quests:state", "revert-toggle-not-found", { ids: entry.ids, missingId });
+        return { success: false, message: formatNotFound(missingId) };
+      }
+
+      const resolvedQuests = quests.filter((quest): quest is Quest | Step => quest !== undefined);
+      for (const quest of resolvedQuests) {
         quest.done = !quest.done;
-        logger.debug("quests:state", "revert-toggle", { id: entry.id, done: quest.done });
-        return { success: true, message: `Reverted toggle for quest [${entry.id}]` };
       }
 
-      logger.debug("quests:state", "revert-toggle-not-found", { id: entry.id });
-      return { success: false, message: formatNotFound(entry.id) };
+      logger.debug("quests:state", "revert-toggle", {
+        ids: entry.ids,
+        done: resolvedQuests.map((quest) => quest.done),
+      });
+      return {
+        success: true,
+        message:
+          entry.ids.length === 1
+            ? `Reverted toggle for quest [${entry.ids[0]}]`
+            : `Reverted toggle for ${entry.ids.length} quests`,
+      };
     },
     [QUEST_ACTIONS.update]: (entry) => {
       const quest = this.findById(entry.id);
@@ -159,25 +201,21 @@ export class QuestLog {
       return { success: false, message: formatNotFound(entry.id) };
     },
     [QUEST_ACTIONS.delete]: (entry) => {
-      if (entry.isStep) {
-        this.steps.splice(entry.index, 0, entry.quest as Step);
-      } else {
-        this.quests.splice(entry.index, 0, entry.quest);
-        if (entry.cascadeDeletedSteps) {
-          for (const sub of entry.cascadeDeletedSteps) {
-            this.steps.push(sub);
-            this.usedIds.add(sub.id);
-          }
-        }
-      }
-      this.usedIds.add(entry.quest.id);
+      this.quests = [...entry.previousQuests];
+      this.steps = [...entry.previousSteps];
+      this.usedIds = new Set([...this.quests, ...this.steps].map((quest) => quest.id));
 
       logger.debug("quests:state", "revert-delete", {
-        id: entry.quest.id,
-        index: entry.index,
+        ids: entry.deletedIds,
         total: this.quests.length + this.steps.length,
       });
-      return { success: true, message: `Reverted delete for quest [${entry.quest.id}]` };
+      return {
+        success: true,
+        message:
+          entry.ids.length === 1
+            ? `Reverted delete for quest [${entry.ids[0]}]`
+            : `Reverted delete for ${entry.ids.length} tasks`,
+      };
     },
     [QUEST_ACTIONS.clear]: (entry) => {
       if ("previousQuests" in entry) {
@@ -230,6 +268,114 @@ export class QuestLog {
     },
   };
 
+  private redoHandlers: {
+    [K in RedoEntry["type"]]: (entry: Extract<RedoEntry, { type: K }>) => {
+      success: boolean;
+      message: string;
+    };
+  } = {
+    [QUEST_ACTIONS.add]: (entry) => {
+      if ("parentId" in entry.quest && entry.quest.parentId) {
+        this.steps.push(entry.quest as Step);
+        this.history.push({
+          type: QUEST_ACTIONS.add,
+          id: entry.quest.id,
+          parentId: entry.quest.parentId,
+        });
+      } else {
+        this.quests.push(entry.quest);
+        this.history.push({ type: QUEST_ACTIONS.add, id: entry.quest.id });
+      }
+      this.usedIds.add(entry.quest.id);
+      return { success: true, message: `Redone add quest [${entry.quest.id}]` };
+    },
+    [QUEST_ACTIONS.toggle]: (entry) => {
+      const result = this.toggleMany(entry.ids);
+      if ("error" in result) {
+        return {
+          success: false,
+          message:
+            result.error === "blocked"
+              ? formatBlockedBySteps(result.id)
+              : formatNotFound(result.id),
+        };
+      }
+
+      return {
+        success: true,
+        message:
+          entry.ids.length === 1
+            ? `Redone toggle for quest [${entry.ids[0]}]`
+            : `Redone toggle for ${entry.ids.length} quests`,
+      };
+    },
+    [QUEST_ACTIONS.update]: (entry) => {
+      const q = this.update(entry.id, entry.description);
+      if (q) return { success: true, message: `Redone update for quest [${entry.id}]` };
+      return { success: false, message: formatNotFound(entry.id) };
+    },
+    [QUEST_ACTIONS.delete]: (entry) => {
+      const result = this.deleteMany(entry.ids);
+      if ("error" in result) {
+        return {
+          success: false,
+          message:
+            result.error === "blocked"
+              ? formatBlockedBySteps(result.id)
+              : formatNotFound(result.id),
+        };
+      }
+
+      const firstQuest = result.quests[0];
+      return {
+        success: true,
+        message:
+          entry.ids.length === 1 && firstQuest
+            ? `Redone delete for quest [${firstQuest.id}]`
+            : `Redone delete for ${entry.ids.length} tasks`,
+      };
+    },
+    [QUEST_ACTIONS.clear]: (entry) => {
+      const count = this.clear(entry.all);
+      return {
+        success: true,
+        message: `Redone clear (${count} quests ${entry.all ? "" : "completed "}cleared)`,
+      };
+    },
+    [QUEST_ACTIONS.reorder]: (entry) => {
+      const q = this.reorder(entry.id, entry.targetId);
+      if (q) return { success: true, message: `Redone reorder for quest [${entry.id}]` };
+      return { success: false, message: formatReorderedQuestNotFoundError() };
+    },
+    [QUEST_ACTIONS.reparent]: (entry) => {
+      try {
+        const q = this.reparent(entry.id, entry.parentId);
+        if (q) return { success: true, message: `Redone reparent for quest [${entry.id}]` };
+        return { success: false, message: formatNotFound(entry.id) };
+      } catch (err) {
+        return {
+          success: false,
+          message: `Error: ${err instanceof Error ? err.message : String(err)}`,
+        };
+      }
+    },
+  };
+
+  redo(): QuestOperationResult {
+    const entry = this.redoStack.pop();
+    if (!entry) {
+      return { success: false, message: formatNothingToRedoError() };
+    }
+    const handler = this.redoHandlers[entry.type];
+    if (handler) {
+      this.inRedo = true;
+      const result = handler(entry as never);
+      this.inRedo = false;
+      return result;
+    }
+    return { success: false, message: "Unknown redo entry" };
+  }
+
   /*
    * Returns all quests including steps, inserted in order
    * steps are returned immediately after their parent quest
@@ -265,11 +411,73 @@ export class QuestLog {
     return this.quests.find((q) => q.id === id) ?? this.steps.find((step) => step.id === id);
   }
 
+  private normalizeIds(ids: string[]): string[] {
+    return [...new Set(ids)];
+  }
+
+  private validateToggleBatch(ids: string[]): ToggleBatchResult {
+    const normalizedIds = this.normalizeIds(ids);
+    const quests: (Quest | Step)[] = [];
+
+    for (const id of normalizedIds) {
+      const quest = this.findById(id);
+      if (!quest) {
+        logger.debug("quests:state", "toggle-not-found", { id });
+        return { error: "notFound", id };
+      }
+      quests.push(quest);
+    }
+
+    const toggledIds = new Set(normalizedIds);
+    for (const quest of quests) {
+      if (quest.done || "parentId" in quest) continue;
+
+      const steps = this.getSteps(quest.id);
+      const hasIncompleteSteps = steps.some((step) => {
+        const finalDone = toggledIds.has(step.id) ? !step.done : step.done;
+        return !finalDone;
+      });
+
+      if (hasIncompleteSteps) {
+        logger.debug("quests:state", "toggle-blocked-steps", { id: quest.id, ids: normalizedIds });
+        return { error: "blocked", id: quest.id };
+      }
+    }
+
+    return { quests, ids: normalizedIds };
+  }
+
+  private applyToggleBatch(quests: (Quest | Step)[], ids: string[]): Quest[] {
+    for (const quest of quests) {
+      quest.done = !quest.done;
+    }
+
+    this.history.push({ type: QUEST_ACTIONS.toggle, ids });
+    logger.debug("quests:state", QUEST_ACTIONS.toggle, {
+      ids,
+      total: this.quests.length + this.steps.length,
+    });
+
+    return quests;
+  }
+
+  toggleMany(ids: string[]): ToggleBatchResult {
+    if (!this.inRedo) this.redoStack = [];
+    const result = this.validateToggleBatch(ids);
+    if ("error" in result) return result;
+
+    return {
+      ids: result.ids,
+      quests: this.applyToggleBatch(result.quests, result.ids),
+    };
+  }
+
   getUsedIds(): string[] {
     return Array.from(this.usedIds);
   }
 
   add(description: string): Quest {
+    if (!this.inRedo) this.redoStack = [];
     const quest: Quest = {
       id: this.generateId(),
       description,
@@ -289,6 +497,7 @@ export class QuestLog {
   }
 
   addStep(description: string, parentId: string): Step {
+    if (!this.inRedo) this.redoStack = [];
     if (this.steps.some((step) => step.id === parentId)) {
       throw new Error(formatStepCannotHaveSteps(parentId));
     }
@@ -332,32 +541,16 @@ export class QuestLog {
   }
 
   toggle(id: string): Quest | Step | null | undefined {
-    const quest = this.findById(id);
-    if (!quest) {
-      logger.debug("quests:state", "toggle-not-found", { id });
-      return undefined;
-    }
-
-    if (!quest.done && !("parentId" in quest)) {
-      const steps = this.getSteps(id);
-      if (steps.some((q) => !q.done)) {
-        logger.debug("quests:state", "toggle-blocked-steps", { id });
-        return null;
-      }
+    const result = this.toggleMany([id]);
+    if ("error" in result) {
+      return result.error === "blocked" ? null : undefined;
     }
 
-    quest.done = !quest.done;
-    this.history.push({ type: QUEST_ACTIONS.toggle, id });
-
-    logger.debug("quests:state", QUEST_ACTIONS.toggle, {
-      id,
-      done: quest.done,
-      total: this.quests.length + this.steps.length,
-    });
-    return quest;
+    return result.quests[0];
   }
 
   update(id: string, description: string): Quest | Step | undefined {
+    if (!this.inRedo) this.redoStack = [];
     const quest = this.findById(id);
     if (!quest) {
       logger.debug("quests:state", "update-not-found", { id });
@@ -375,49 +568,91 @@ export class QuestLog {
     return quest;
   }
 
+  private validateDeleteBatch(
+    ids: string[],
+  ): { ids: string[]; deletedIds: string[] } | { error: "notFound" | "blocked"; id: string } {
+    const normalizedIds = this.normalizeIds(ids);
+    const selectedIds = new Set(normalizedIds);
+    const deletedIds = new Set<string>();
+
+    for (const id of normalizedIds) {
+      const quest = this.findById(id);
+      if (!quest) {
+        logger.debug("quests:state", "delete-not-found", { id });
+        return { error: "notFound", id };
+      }
+
+      if ("parentId" in quest) {
+        deletedIds.add(quest.id);
+        continue;
+      }
+
+      const steps = this.getSteps(quest.id);
+      const hasUnselectedIncompleteStep = steps.some(
+        (step) => !step.done && !selectedIds.has(step.id),
+      );
+      if (hasUnselectedIncompleteStep) {
+        logger.debug("quests:state", "delete-blocked-steps", { id: quest.id, ids: normalizedIds });
+        return { error: "blocked", id: quest.id };
+      }
+
+      deletedIds.add(quest.id);
+      for (const step of steps) {
+        deletedIds.add(step.id);
+      }
+    }
+
+    return { ids: normalizedIds, deletedIds: [...deletedIds] };
+  }
+
+  private applyDeleteBatch(ids: string[], deletedIds: string[]): Quest[] {
+    const deletedIdSet = new Set(deletedIds);
+    const previousQuests = [...this.quests];
+    const previousSteps = [...this.steps];
+    const deletedQuests = this.getAll().filter((quest) => deletedIdSet.has(quest.id));
+
+    this.quests = this.quests.filter((quest) => !deletedIdSet.has(quest.id));
+    this.steps = this.steps.filter((step) => !deletedIdSet.has(step.id));
+    this.usedIds = new Set([...this.quests, ...this.steps].map((quest) => quest.id));
+    this.history.push({
+      type: QUEST_ACTIONS.delete,
+      ids,
+      deletedIds,
+      previousQuests,
+      previousSteps,
+    });
+
+    logger.debug("quests:state", QUEST_ACTIONS.delete, {
+      ids,
+      deletedIds,
+      total: this.quests.length + this.steps.length,
+    });
+
+    return deletedQuests;
+  }
+
+  deleteMany(ids: string[]): DeleteBatchResult {
+    if (!this.inRedo) this.redoStack = [];
+    const result = this.validateDeleteBatch(ids);
+    if ("error" in result) return result;
+
+    return {
+      ids: result.ids,
+      quests: this.applyDeleteBatch(result.ids, result.deletedIds),
+    };
+  }
+
   delete(id: string): Quest | Step | null | undefined {
-    const index = this.quests.findIndex((q) => q.id === id);
-    if (index !== -1) {
-      const steps = this.getSteps(id);
-      if (steps.some((q) => !q.done)) {
-        logger.debug("quests:state", "delete-blocked-steps", { id });
-        return null;
-      }
-      const [quest] = this.quests.splice(index, 1);
-      this.usedIds.delete(quest.id);
-      const cascadeDeletedSteps = this.steps.filter((step) => step.parentId === id);
-      this.history.push({ type: QUEST_ACTIONS.delete, quest, index, cascadeDeletedSteps });
-      this.steps = this.steps.filter((step) => {
-        if (step.parentId === id) {
-          this.usedIds.delete(step.id);
-          return false;
-        }
-        return true;
-      });
-      logger.debug("quests:state", QUEST_ACTIONS.delete, {
-        id,
-        index,
-        total: this.quests.length + this.steps.length,
-      });
-      return quest;
-    }
-    const stepIndex = this.steps.findIndex((step) => step.id === id);
-    if (stepIndex !== -1) {
-      const [quest] = this.steps.splice(stepIndex, 1);
-      this.usedIds.delete(quest.id);
-      this.history.push({ type: QUEST_ACTIONS.delete, quest, index: stepIndex, isStep: true });
-      logger.debug("quests:state", QUEST_ACTIONS.delete, {
-        id,
-        index: stepIndex,
-        total: this.quests.length + this.steps.length,
-      });
-      return quest;
+    const result = this.deleteMany([id]);
+    if ("error" in result) {
+      return result.error === "blocked" ? null : undefined;
     }
-    logger.debug("quests:state", "delete-not-found", { id });
-    return undefined;
+
+    return result.quests[0];
   }
 
   clear(all = false): number {
+    if (!this.inRedo) this.redoStack = [];
     if (!all) {
       const doneParentIds = new Set(this.quests.filter((q) => q.done).map((q) => q.id));
       const done = this.quests.filter((q) => q.done);
@@ -458,6 +693,7 @@ export class QuestLog {
   }
 
   reorder(id: string, targetId: string): Quest | undefined {
+    if (!this.inRedo) this.redoStack = [];
     if (this.steps.some((step) => step.id === id || step.id === targetId)) {
       logger.debug("quests:state", "reorder-step-rejected", { id, targetId });
       return undefined;
@@ -498,6 +734,7 @@ export class QuestLog {
   }
 
   reparent(id: string, parentId?: string): Quest | Step | undefined {
+    if (!this.inRedo) this.redoStack = [];
     const quest = this.findById(id);
     if (!quest) return undefined;
 
@@ -553,29 +790,72 @@ export class QuestLog {
     return quest;
   }
 
-  revert(): QuestOperationResult {
+  undo(): QuestOperationResult {
     const entry = this.history.pop();
     if (!entry) {
-      logger.debug("quests:state", "revert-empty");
-      return { success: false, message: formatNothingToRevertError() };
+      logger.debug("quests:state", "undo-empty");
+      return { success: false, message: formatNothingToUndoError() };
     }
 
-    logger.debug("quests:state", "revert", { type: entry.type });
+    logger.debug("quests:state", "undo", { type: entry.type });
+    this.redoStack.push(this.buildRedoEntry(entry));
 
     const handler = this.undoHandlers[entry.type];
     if (handler) {
       return handler(entry as never);
     }
 
-    logger.debug("quests:state", "revert-unknown", { type: (entry as { type: string }).type });
+    logger.debug("quests:state", "undo-unknown", { type: (entry as { type: string }).type });
     return { success: false, message: "Unknown history entry" };
   }
 
+  private buildRedoEntry(entry: HistoryEntry): RedoEntry {
+    switch (entry.type) {
+      case QUEST_ACTIONS.add: {
+        const quest = this.findById(entry.id);
+        if (!quest) throw new Error(formatNotFound(entry.id));
+        return { type: QUEST_ACTIONS.add, quest };
+      }
+      case QUEST_ACTIONS.toggle:
+        return { type: QUEST_ACTIONS.toggle, ids: entry.ids };
+      case QUEST_ACTIONS.update:
+        return {
+          type: QUEST_ACTIONS.update,
+          id: entry.id,
+          description: this.findById(entry.id)?.description ?? entry.previousDescription,
+        };
+      case QUEST_ACTIONS.delete:
+        return { type: QUEST_ACTIONS.delete, ids: entry.ids };
+      case QUEST_ACTIONS.clear:
+        return { type: QUEST_ACTIONS.clear, all: entry.all };
+      case QUEST_ACTIONS.reorder:
+        return { type: QUEST_ACTIONS.reorder, id: entry.quest.id, targetId: entry.targetId };
+      case QUEST_ACTIONS.reparent: {
+        const quest = this.findById(entry.id);
+        if (!quest) throw new Error(formatNotFound(entry.id));
+        return {
+          type: QUEST_ACTIONS.reparent,
+          id: entry.id,
+          parentId: "parentId" in quest ? quest.parentId : undefined,
+        };
+      }
+    }
+  }
+
   /**
    * Execute a quest action and return a presentation-ready result.
    * This is the primary API for all adapter layers (commands, tools).
    */
   execute(action: QuestAction): QuestOperationResult {
+    if (
+      action.type !== QUEST_ACTIONS.list &&
+      action.type !== QUEST_ACTIONS.rules &&
+      action.type !== QUEST_ACTIONS.skill &&
+      action.type !== QUEST_ACTIONS.undo &&
+      action.type !== QUEST_ACTIONS.redo
+    ) {
+      this.redoStack = [];
+    }
     switch (action.type) {
       case QUEST_ACTIONS.add: {
         if (action.descriptions && action.descriptions.length > 0) {
@@ -623,19 +903,42 @@ export class QuestLog {
         return { success: true, message: formatQuestList(quests) };
       }
       case QUEST_ACTIONS.toggle: {
-        if (action.id === undefined) {
+        const ids = action.ids?.length ? action.ids : action.id ? [action.id] : undefined;
+        if (!ids || ids.length === 0) {
           return { success: false, message: formatIdRequiredError("toggle") };
         }
 
-        const q = this.toggle(action.id);
-        if (q === undefined) {
-          return { success: false, message: formatNotFound(action.id) };
+        const result = this.toggleMany(ids);
+        if ("error" in result) {
+          return {
+            success: false,
+            message:
+              result.error === "blocked"
+                ? formatBlockedBySteps(result.id)
+                : formatNotFound(result.id),
+          };
         }
-        if (q === null) {
-          return { success: false, message: formatBlockedBySteps(action.id) };
+
+        if (result.quests.length === 1) {
+          const quest = result.quests[0];
+          if (!quest) {
+            return { success: false, message: formatNotFound(result.ids[0]) };
+          }
+
+          return {
+            success: true,
+            message: formatToggleResult(result.ids[0], quest.done),
+            quest,
+          };
         }
 
-        return { success: true, message: formatToggleResult(action.id, q.done), quest: q };
+        return {
+          success: true,
+          message: formatBatchToggleResult(
+            result.quests.map((quest, index) => ({ id: result.ids[index], done: quest.done })),
+          ),
+          quests: result.quests,
+        };
       }
       case QUEST_ACTIONS.update: {
         if (action.id === undefined) {
@@ -654,19 +957,38 @@ export class QuestLog {
         return { success: true, message: formatUpdateResult(q), quest: q };
       }
       case QUEST_ACTIONS.delete: {
-        if (action.id === undefined) {
+        const ids = action.ids?.length ? action.ids : action.id ? [action.id] : undefined;
+        if (!ids || ids.length === 0) {
           return { success: false, message: formatIdRequiredError("delete") };
         }
 
-        const q = this.delete(action.id);
-        if (q === undefined) {
-          return { success: false, message: formatNotFound(action.id) };
+        const result = this.deleteMany(ids);
+        if ("error" in result) {
+          return {
+            success: false,
+            message:
+              result.error === "blocked"
+                ? formatBlockedBySteps(result.id)
+                : formatNotFound(result.id),
+          };
         }
-        if (q === null) {
-          return { success: false, message: formatBlockedBySteps(action.id) };
+
+        if (result.ids.length === 1) {
+          const quest = result.quests[0];
+          if (!quest) {
+            return { success: false, message: formatNotFound(result.ids[0]) };
+          }
+
+          return { success: true, message: formatDeleteResult(quest), quest };
         }
 
-        return { success: true, message: formatDeleteResult(q), quest: q };
+        return {
+          success: true,
+          message: formatBatchDeleteResult(
+            result.quests.map((quest) => ({ id: quest.id, description: quest.description })),
+          ),
+          quests: result.quests,
+        };
       }
       case QUEST_ACTIONS.clear: {
         const count = this.clear(action.all);
@@ -730,8 +1052,11 @@ export class QuestLog {
       case QUEST_ACTIONS.skill: {
         return { success: true, message: getQuestSkillDocument() };
       }
-      case QUEST_ACTIONS.revert: {
-        return this.revert();
+      case QUEST_ACTIONS.undo: {
+        return this.undo();
+      }
+      case QUEST_ACTIONS.redo: {
+        return this.redo();
       }
       default: {
         return {
@@ -787,6 +1112,7 @@ export function makeToolResult(
   text: string,
   questLog: QuestLog,
   displayQuests?: Quest[],
+  snapshotQuests?: Quest[],
 ): AgentToolResult<unknown> {
   return {
     content: [{ type: "text", text }],
@@ -794,6 +1120,7 @@ export function makeToolResult(
       quests: questLog.getAll(),
       usedIds: questLog.getUsedIds(),
       displayQuests,
+      snapshotQuests,
     },
   };
 }