pi-quests 0.6.2 → 0.7.0

package/CHANGELOG.md

@@ -2,6 +2,12 @@
 
 ## [Unreleased]
 
+## [0.7.0] - 2026-04-26
+
+- feat: add batch toggle and batch delete support for quests (#2) — @pascal-de-ladurantaye
+- feat: add redo action and rename revert to undo
+- chore: migrate from taskfile to npm scripts and update dependencies
+
 ## [0.6.2] - 2026-04-17
 
 - fix: system prompt was too weak

package/README.md

@@ -1,6 +1,6 @@
 # pi-quests
 
-[![version 0.6.2](https://img.shields.io/badge/version-0.6.2-blue)](CHANGELOG.md)
+[![version 0.7.0](https://img.shields.io/badge/version-0.7.0-blue)](CHANGELOG.md)
 [![MIT license](https://img.shields.io/badge/license-MIT-green)](LICENSE.md)
 [![pi extension](https://img.shields.io/badge/pi-extension-purple)](https://github.com/badlogic/pi-mono/tree/main/packages/coding-agent)
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-quests",
-  "version": "0.6.2",
+  "version": "0.7.0",
   "description": "A quest-log for your pi. Keep your agent on track, one quest at a time.",
   "type": "module",
   "keywords": [
@@ -35,22 +35,27 @@
     "@mariozechner/pi-ai": "*",
     "@mariozechner/pi-coding-agent": "*",
     "@mariozechner/pi-tui": "*",
-    "@sinclair/typebox": "*"
+    "typebox": "*"
   },
   "devDependencies": {
-    "@biomejs/biome": "^2.4.10",
-    "@mariozechner/pi-coding-agent": "^0.63.2",
-    "@mariozechner/pi-tui": "^0.63.0",
-    "typescript": "^5.7.0",
-    "vitest": "^3.0.0"
+    "@biomejs/biome": "^2.4.13",
+    "@mariozechner/pi-coding-agent": "^0.70.2",
+    "@mariozechner/pi-tui": "^0.70.2",
+    "typebox": "^1.1.33",
+    "typescript": "^6.0.3",
+    "vitest": "^4.1.5"
   },
   "scripts": {
     "test": "vitest run",
     "test:watch": "vitest",
     "typecheck": "tsc --noEmit",
-    "style": "biome check ./src ./test",
-    "style:fix": "biome check --write --unsafe --no-errors-on-unmatched ./src ./test",
+    "style": "biome check --error-on-warnings ./src ./test",
+    "style:fix": "biome check --write --unsafe --no-errors-on-unmatched --error-on-warnings ./src ./test",
     "format": "biome format --write --no-errors-on-unmatched ./src ./test",
-    "prepublishOnly": "npx tsc --noEmit && npx vitest run"
+    "prepublishOnly": "npx tsc --noEmit && npx vitest run",
+    "prepare": "bash scripts/setup.sh",
+    "cleanup": "bash scripts/cleanup.sh",
+    "dev": "bash scripts/dev.sh",
+    "logs": "bash scripts/logs.sh"
   }
 }

package/src/commands/handler.ts

@@ -25,7 +25,8 @@ type MutatingCommand = Extract<
       | typeof QUEST_ACTIONS.clear
       | typeof QUEST_ACTIONS.reorder
       | typeof QUEST_ACTIONS.reparent
-      | typeof QUEST_ACTIONS.revert;
+      | typeof QUEST_ACTIONS.undo
+      | typeof QUEST_ACTIONS.redo;
   }
 >["action"];
 
@@ -41,13 +42,13 @@ const commandActionBuilders: {
     id: p.id,
     descriptions: p.descriptions,
   }),
-  [QUEST_ACTIONS.toggle]: (p) => ({ type: QUEST_ACTIONS.toggle, id: p.id }),
+  [QUEST_ACTIONS.toggle]: (p) => ({ type: QUEST_ACTIONS.toggle, ids: p.ids }),
   [QUEST_ACTIONS.update]: (p) => ({
     type: QUEST_ACTIONS.update,
     id: p.id,
     description: p.description,
   }),
-  [QUEST_ACTIONS.delete]: (p) => ({ type: QUEST_ACTIONS.delete, id: p.id }),
+  [QUEST_ACTIONS.delete]: (p) => ({ type: QUEST_ACTIONS.delete, ids: p.ids }),
   [QUEST_ACTIONS.clear]: (p) => ({ type: QUEST_ACTIONS.clear, all: p.all }),
   [QUEST_ACTIONS.reorder]: (p) => ({
     type: QUEST_ACTIONS.reorder,
@@ -59,7 +60,8 @@ const commandActionBuilders: {
     id: p.id,
     parentId: p.parentId,
   }),
-  [QUEST_ACTIONS.revert]: () => ({ type: QUEST_ACTIONS.revert }),
+  [QUEST_ACTIONS.undo]: () => ({ type: QUEST_ACTIONS.undo }),
+  [QUEST_ACTIONS.redo]: () => ({ type: QUEST_ACTIONS.redo }),
 };
 
 export function openQuestList(
@@ -143,7 +145,8 @@ export function createQuestsHandler(
       case QUEST_ACTIONS.clear:
       case QUEST_ACTIONS.reorder:
       case QUEST_ACTIONS.reparent:
-      case QUEST_ACTIONS.revert: {
+      case QUEST_ACTIONS.undo:
+      case QUEST_ACTIONS.redo: {
         const builder = commandActionBuilders[parsed.action];
         const action = builder(parsed as never);
         const result = questLog.execute(action);
@@ -161,12 +164,13 @@ export function createQuestsHandler(
         lines.push("  add <description>           - Add a new top-level quest");
         lines.push("  add-step <id> <description> - Split a quest into a step");
         lines.push("  list               - List all quests");
-        lines.push("  toggle <id>        - Toggle quest completion");
-        lines.push("  delete <id>        - Delete a quest");
+        lines.push("  toggle <id> [moreIds...] - Toggle one or more quests");
+        lines.push("  delete <id> [moreIds...] - Delete one or more quests");
         lines.push("  update <id> <desc> - Update a quest description");
         lines.push("  reparent <id> [parentId] - Reparent a quest/step (omit parentId to promote)");
         lines.push("  reorder <id> <targetId> - Reorder a quest before the target quest");
-        lines.push("  revert             - Revert the last quest change");
+        lines.push("  undo               - Undo the last quest change");
+        lines.push("  redo               - Redo the last undone action");
         lines.push("  clear [all]        - Clear completed quests, or optionally all quests");
         lines.push("  version            - Show version");
         lines.push("  changelog          - Show changelog");

package/src/commands/parse-args.ts

@@ -5,12 +5,13 @@ export type ParsedArgs =
   | { action: typeof QUEST_ACTIONS.add; descriptions: string[] }
   | { action: typeof QUEST_ACTIONS.split; id: string; descriptions: string[] }
   | { action: typeof QUEST_ACTIONS.list }
-  | { action: typeof QUEST_ACTIONS.toggle; id: string }
+  | { action: typeof QUEST_ACTIONS.toggle; ids: string[] }
   | { action: typeof QUEST_ACTIONS.update; id: string; description: string }
-  | { action: typeof QUEST_ACTIONS.delete; id: string }
+  | { action: typeof QUEST_ACTIONS.delete; ids: string[] }
   | { action: typeof QUEST_ACTIONS.clear; all?: boolean }
   | { action: typeof QUEST_ACTIONS.reorder; id: string; targetId: string }
-  | { action: typeof QUEST_ACTIONS.revert }
+  | { action: typeof QUEST_ACTIONS.undo }
+  | { action: typeof QUEST_ACTIONS.redo }
   | { action: typeof QUEST_ACTIONS.reparent; id: string; parentId?: string }
   | { action: "help" }
   | { action: "version" }
@@ -40,13 +41,14 @@ export function parseQuestArgs(args: string, idLength = 2): ParsedArgs {
   // Quest actions without arguments
   if (command === QUEST_ACTIONS.list) return { action: QUEST_ACTIONS.list };
   if (command === QUEST_ACTIONS.clear) return parseClearArgs(rest);
-  if (command === QUEST_ACTIONS.revert) return { action: QUEST_ACTIONS.revert };
+  if (command === QUEST_ACTIONS.undo) return { action: QUEST_ACTIONS.undo };
+  if (command === QUEST_ACTIONS.redo) return { action: QUEST_ACTIONS.redo };
 
   // Quest actions with arguments
   if (command === QUEST_ACTIONS.add) return parseAddArgs(rest);
   if (command === "add-step") return parseAddStepArgs(rest, idLength);
-  if (command === QUEST_ACTIONS.toggle) return parseIdAction(QUEST_ACTIONS.toggle, rest, idLength);
-  if (command === QUEST_ACTIONS.delete) return parseIdAction(QUEST_ACTIONS.delete, rest, idLength);
+  if (command === QUEST_ACTIONS.toggle) return parseToggleArgs(rest, idLength);
+  if (command === QUEST_ACTIONS.delete) return parseDeleteArgs(rest, idLength);
   if (command === QUEST_ACTIONS.update) return parseUpdateArgs(rest, idLength);
   if (command === QUEST_ACTIONS.reorder) return parseReorderArgs(rest, idLength);
   if (command === QUEST_ACTIONS.reparent) return parseReparentArgs(rest, idLength);
@@ -70,16 +72,26 @@ function parseAddStepArgs(tokens: string[], idLength: number): ParsedArgs {
   return { action: QUEST_ACTIONS.split, id, descriptions: [description] };
 }
 
-function parseIdAction(
-  action: typeof QUEST_ACTIONS.toggle | typeof QUEST_ACTIONS.delete,
-  tokens: string[],
-  idLength: number,
-): ParsedArgs {
-  const id = tokens[0] ? tokens[0].toLowerCase() : "";
+function parseToggleArgs(tokens: string[], idLength: number): ParsedArgs {
   const pattern = new RegExp(`^[0-9a-f]{${idLength}}$`);
-  if (!pattern.test(id)) return { error: `Usage: /quests ${action} <id>` };
+  const ids = tokens.map((token) => token.toLowerCase());
+
+  if (ids.length === 0 || ids.some((id) => !pattern.test(id))) {
+    return { error: "Usage: /quests toggle <id> [moreIds...]" };
+  }
+
+  return { action: QUEST_ACTIONS.toggle, ids };
+}
+
+function parseDeleteArgs(tokens: string[], idLength: number): ParsedArgs {
+  const pattern = new RegExp(`^[0-9a-f]{${idLength}}$`);
+  const ids = tokens.map((token) => token.toLowerCase());
+
+  if (ids.length === 0 || ids.some((id) => !pattern.test(id))) {
+    return { error: "Usage: /quests delete <id> [moreIds...]" };
+  }
 
-  return { action, id };
+  return { action: QUEST_ACTIONS.delete, ids };
 }
 
 function parseUpdateArgs(tokens: string[], idLength: number): ParsedArgs {

package/src/prompts/skill.md

@@ -20,7 +20,8 @@ This skill provides guidelines and best practices for using the quest management
 | `clear` | — | Remove completed quests. `all: true` removes everything. |
 | `reorder` | `id`, `targetId` | Move a top-level quest before `targetId`. Steps cannot be reordered. |
 | `reparent` | `id`, `parentId?` | Demote to step under `parentId`, or promote to top-level if `parentId` omitted. |
-| `revert` | — | Undo the most recent mutating action. One level only. |
+| `undo` | — | Undo the most recent mutating action. One level only. |
+| `redo` | — | Redo the most recently undone action. |
 | `rules` / `skill` | — | Return this document. |
 
 ## Workflows
@@ -51,7 +52,8 @@ This skill provides guidelines and best practices for using the quest management
 - NEVER try to nest steps. Only top-level quests can be parents.
 - NEVER mark a parent as done if they have incomplete steps.
 - NEVER delete a quest with incomplete steps.
-- Use revert if you make a mistake to undo an action.
+- Use undo if you make a mistake to undo an action.
+- Use redo to replay an action you just undid. Redo is cleared when a new mutation happens.
 - ALWAYS use the hex ID, never the positional number when referring to quests in actions.
 - ALWAYS Use `toggle` for done states. NEVER use `update` to append "DONE" or any completion marker to a description.
 - If a parent toggle is blocked, check that all its steps are done first.

package/src/quest/dataplane.ts

@@ -5,6 +5,8 @@ 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,
     },
   };
 }

package/src/quest/formatters.ts

@@ -44,6 +44,12 @@ export function formatToggleResult(id: string, done: boolean): string {
   return `Quest [${id}] ${done ? "done" : "undone"}`;
 }
 
+export function formatBatchToggleResult(toggled: { id: string; done: boolean }[]): string {
+  return `Toggled ${toggled.length} tasks:\n${toggled
+    .map((quest) => `[${quest.id}] ${quest.done ? "done" : "undone"}`)
+    .join("\n")}`;
+}
+
 export function formatUpdateResult(q: { id: string; description: string }): string {
   return `Updated quest [${q.id}]: ${q.description}`;
 }
@@ -52,6 +58,10 @@ export function formatDeleteResult(q: { id: string; description: string }): stri
   return `Deleted quest [${q.id}]: ${q.description}`;
 }
 
+export function formatBatchDeleteResult(deleted: { id: string; description: string }[]): string {
+  return `Deleted ${deleted.length} tasks:\n${deleted.map((quest) => `[${quest.id}] ${quest.description}`).join("\n")}`;
+}
+
 export function formatNotFound(id: string): string {
   return `Quest [${id}] not found. IDs are random hex strings shown in brackets. Use the list action to see valid IDs.`;
 }
@@ -100,8 +110,12 @@ export function formatUnknownActionError(action: string): string {
   return `Unknown action: ${action}. Use the list action or check the tool schema for supported actions.`;
 }
 
-export function formatNothingToRevertError(): string {
-  return `Nothing to revert. The history is empty because no mutating actions have been performed yet.`;
+export function formatNothingToUndoError(): string {
+  return `Nothing to undo. The history is empty because no mutating actions have been performed yet.`;
+}
+
+export function formatNothingToRedoError(): string {
+  return `Nothing to redo. The redo stack is empty because no actions have been undone yet.`;
 }
 
 export function formatReorderedQuestNotFoundError(): string {

package/src/quest/types.ts

@@ -10,7 +10,8 @@ export const QUEST_ACTIONS = {
   delete: "delete",
   clear: "clear",
   reorder: "reorder",
-  revert: "revert",
+  undo: "undo",
+  redo: "redo",
   reparent: "reparent",
   rules: "rules",
   skill: "skill",
@@ -26,7 +27,8 @@ export const QUEST_ACTION_VALUES = [
   QUEST_ACTIONS.delete,
   QUEST_ACTIONS.clear,
   QUEST_ACTIONS.reorder,
-  QUEST_ACTIONS.revert,
+  QUEST_ACTIONS.undo,
+  QUEST_ACTIONS.redo,
   QUEST_ACTIONS.reparent,
   QUEST_ACTIONS.rules,
   QUEST_ACTIONS.skill,

package/src/renderers/tools.ts

@@ -11,6 +11,7 @@ type QuestArgs = {
   descriptions?: string[];
   targetId?: string;
   id?: string;
+  ids?: string[];
   all?: boolean;
 };
 
@@ -31,12 +32,29 @@ export function renderQuestCall(args: QuestArgs, theme: Theme, _context: unknown
     );
   }
 
-  if (
-    (args.action === QUEST_ACTIONS.toggle ||
-      args.action === QUEST_ACTIONS.update ||
-      args.action === QUEST_ACTIONS.delete) &&
-    args.id !== undefined
-  ) {
+  if (args.action === QUEST_ACTIONS.toggle) {
+    if (args.ids && args.ids.length > 1) {
+      return new Text(`${actionText} ${theme.fg("muted", `[${args.ids.length} tasks]`)}`, 0, 0);
+    }
+
+    const toggleId = args.id ?? args.ids?.[0];
+    if (toggleId !== undefined) {
+      return new Text(`${actionText} ${theme.fg("muted", `[${toggleId}]`)}`, 0, 0);
+    }
+  }
+
+  if (args.action === QUEST_ACTIONS.delete) {
+    if (args.ids && args.ids.length > 1) {
+      return new Text(`${actionText} ${theme.fg("muted", `[${args.ids.length} tasks]`)}`, 0, 0);
+    }
+
+    const deleteId = args.id ?? args.ids?.[0];
+    if (deleteId !== undefined) {
+      return new Text(`${actionText} ${theme.fg("muted", `[${deleteId}]`)}`, 0, 0);
+    }
+  }
+
+  if (args.action === QUEST_ACTIONS.update && args.id !== undefined) {
     return new Text(`${actionText} ${theme.fg("muted", `[${args.id}]`)}`, 0, 0);
   }
 
@@ -59,8 +77,11 @@ export function renderQuestResult(config: ResolvedConfig) {
       isPartial: options.isPartial,
     });
     const details = result.details as Record<string, unknown> | undefined;
-    const allQuests = details?.quests as Quest[] | undefined;
-    const questsToRender = (details?.displayQuests ?? details?.quests) as Quest[] | undefined;
+    const snapshotQuests = details?.snapshotQuests as Quest[] | undefined;
+    const allQuests = (snapshotQuests ?? details?.quests) as Quest[] | undefined;
+    const questsToRender = (snapshotQuests ?? details?.displayQuests ?? details?.quests) as
+      | Quest[]
+      | undefined;
 
     if (
       !Array.isArray(questsToRender) ||

package/src/tools/handler.ts

@@ -1,17 +1,18 @@
-import type { AgentToolResult, ExtensionAPI } from "@mariozechner/pi-coding-agent";
-import { type Static, Type } from "@sinclair/typebox";
+import type { AgentToolResult, ExtensionAPI, Theme } from "@mariozechner/pi-coding-agent";
+import { type Static, Type } from "typebox";
 import type { ResolvedConfig } from "../config.js";
 import { logger } from "../logger.js";
 import { QUEST_PROMPT_GATE, QUEST_PROMPT_REMINDER } from "../prompts.js";
 import { makeToolResult, type QuestAction, type QuestLog } from "../quest/dataplane.js";
-import { QUEST_ACTIONS } from "../quest/types.js";
+import { QUEST_ACTIONS, type QuestActionType } from "../quest/types.js";
 
 const SPLIT_DISPLAY_ACTIONS = [
   QUEST_ACTIONS.add,
   QUEST_ACTIONS.list,
   QUEST_ACTIONS.split,
   QUEST_ACTIONS.add_step,
-  QUEST_ACTIONS.revert,
+  QUEST_ACTIONS.undo,
+  QUEST_ACTIONS.redo,
 ] as const;
 
 import { invalidateQuestListWidget } from "../renderers/commands.js";
@@ -20,75 +21,72 @@ import { createQuestParams, type QuestParamsType } from "./params.js";
 
 type QuestToolParams = Static<QuestParamsType>;
 
-const toolHandlers: {
-  [K in QuestToolParams["action"]]: (
-    questLog: QuestLog,
-    params: QuestToolParams,
-    toolCallId: string,
-  ) => AgentToolResult<unknown>;
-} = {
-  [QUEST_ACTIONS.add](questLog, params, toolCallId) {
-    return runTool(questLog, toolCallId, {
+type ToolHandler = (
+  questLog: QuestLog,
+  params: QuestToolParams,
+  toolCallId: string,
+) => AgentToolResult<unknown>;
+
+const toolHandlers: Record<QuestActionType, ToolHandler> = {
+  [QUEST_ACTIONS.add]: (questLog, params, toolCallId) =>
+    runTool(questLog, toolCallId, {
       type: QUEST_ACTIONS.add,
       descriptions: params.descriptions,
-    });
-  },
-  [QUEST_ACTIONS.split](questLog, params, toolCallId) {
-    return runTool(questLog, toolCallId, {
+    }),
+  [QUEST_ACTIONS.split]: (questLog, params, toolCallId) =>
+    runTool(questLog, toolCallId, {
       type: QUEST_ACTIONS.split,
       id: params.id,
       descriptions: params.descriptions,
-    });
-  },
-  [QUEST_ACTIONS.add_step](questLog, params, toolCallId) {
-    return runTool(questLog, toolCallId, {
+    }),
+  [QUEST_ACTIONS.add_step]: (questLog, params, toolCallId) =>
+    runTool(questLog, toolCallId, {
       type: QUEST_ACTIONS.add_step,
       id: params.id,
       descriptions: params.descriptions,
-    });
-  },
-  [QUEST_ACTIONS.list](questLog, _params, toolCallId) {
-    return runTool(questLog, toolCallId, { type: QUEST_ACTIONS.list });
-  },
-  [QUEST_ACTIONS.toggle](questLog, params, toolCallId) {
-    return runTool(questLog, toolCallId, { type: QUEST_ACTIONS.toggle, id: params.id });
-  },
-  [QUEST_ACTIONS.update](questLog, params, toolCallId) {
-    return runTool(questLog, toolCallId, {
+    }),
+  [QUEST_ACTIONS.list]: (questLog, _params, toolCallId) =>
+    runTool(questLog, toolCallId, { type: QUEST_ACTIONS.list }),
+  [QUEST_ACTIONS.toggle]: (questLog, params, toolCallId) =>
+    runTool(questLog, toolCallId, {
+      type: QUEST_ACTIONS.toggle,
+      id: params.id,
+      ids: params.ids,
+    }),
+  [QUEST_ACTIONS.update]: (questLog, params, toolCallId) =>
+    runTool(questLog, toolCallId, {
       type: QUEST_ACTIONS.update,
       id: params.id,
       description: params.description,
-    });
-  },
-  [QUEST_ACTIONS.delete](questLog, params, toolCallId) {
-    return runTool(questLog, toolCallId, { type: QUEST_ACTIONS.delete, id: params.id });
-  },
-  [QUEST_ACTIONS.clear](questLog, params, toolCallId) {
-    return runTool(questLog, toolCallId, { type: QUEST_ACTIONS.clear, all: params.all });
-  },
-  [QUEST_ACTIONS.reorder](questLog, params, toolCallId) {
-    return runTool(questLog, toolCallId, {
+    }),
+  [QUEST_ACTIONS.delete]: (questLog, params, toolCallId) =>
+    runTool(questLog, toolCallId, {
+      type: QUEST_ACTIONS.delete,
+      id: params.id,
+      ids: params.ids,
+    }),
+  [QUEST_ACTIONS.clear]: (questLog, params, toolCallId) =>
+    runTool(questLog, toolCallId, { type: QUEST_ACTIONS.clear, all: params.all }),
+  [QUEST_ACTIONS.reorder]: (questLog, params, toolCallId) =>
+    runTool(questLog, toolCallId, {
       type: QUEST_ACTIONS.reorder,
       id: params.id,
       targetId: params.targetId,
-    });
-  },
-  [QUEST_ACTIONS.reparent](questLog, params, toolCallId) {
-    return runTool(questLog, toolCallId, {
+    }),
+  [QUEST_ACTIONS.reparent]: (questLog, params, toolCallId) =>
+    runTool(questLog, toolCallId, {
       type: QUEST_ACTIONS.reparent,
       id: params.id,
       parentId: params.parentId,
-    });
-  },
-  [QUEST_ACTIONS.rules](questLog, _params, toolCallId) {
-    return runTool(questLog, toolCallId, { type: QUEST_ACTIONS.rules });
-  },
-  [QUEST_ACTIONS.skill](questLog, _params, toolCallId) {
-    return runTool(questLog, toolCallId, { type: QUEST_ACTIONS.skill });
-  },
-  [QUEST_ACTIONS.revert](questLog, _params, toolCallId) {
-    return runTool(questLog, toolCallId, { type: QUEST_ACTIONS.revert });
-  },
+    }),
+  [QUEST_ACTIONS.rules]: (questLog, _params, toolCallId) =>
+    runTool(questLog, toolCallId, { type: QUEST_ACTIONS.rules }),
+  [QUEST_ACTIONS.skill]: (questLog, _params, toolCallId) =>
+    runTool(questLog, toolCallId, { type: QUEST_ACTIONS.skill }),
+  [QUEST_ACTIONS.undo]: (questLog, _params, toolCallId) =>
+    runTool(questLog, toolCallId, { type: QUEST_ACTIONS.undo }),
+  [QUEST_ACTIONS.redo]: (questLog, _params, toolCallId) =>
+    runTool(questLog, toolCallId, { type: QUEST_ACTIONS.redo }),
 };
 
 function runTool(
@@ -104,11 +102,10 @@ function runTool(
     action.type as (typeof SPLIT_DISPLAY_ACTIONS)[number],
   )
     ? questLog.getAll()
-    : result.quest
-      ? [result.quest]
-      : [];
+    : (result.quests ?? (result.quest ? [result.quest] : []));
+  const snapshotQuests = action.type === QUEST_ACTIONS.delete ? displayQuests : undefined;
 
-  return makeToolResult(result.message, questLog, displayQuests);
+  return makeToolResult(result.message, questLog, displayQuests, snapshotQuests);
 }
 
 export async function questToolExecute(
@@ -116,8 +113,13 @@ export async function questToolExecute(
   toolCallId: string,
   params: QuestToolParams,
 ): Promise<AgentToolResult<unknown>> {
-  logger.debug("quests:tool", "execute", { toolCallId, action: params.action, id: params.id });
-  const handler = toolHandlers[params.action];
+  logger.debug("quests:tool", "execute", {
+    toolCallId,
+    action: params.action,
+    id: params.id,
+    ids: params.ids,
+  });
+  const handler = toolHandlers[params.action as QuestActionType];
   return handler(questLog, params, toolCallId);
 }
 
@@ -140,7 +142,11 @@ export function registerQuestTool(
     parameters: createQuestParams(config.ids.length),
     execute: (toolCallId, params, _signal, _onUpdate, _ctx) =>
       questToolExecute(questLog, toolCallId, params),
-    renderCall: renderQuestCall,
+    renderCall: renderQuestCall as unknown as (
+      args: object,
+      theme: Theme,
+      context: unknown,
+    ) => ReturnType<typeof renderQuestCall>,
     renderResult: renderQuestResult(config),
   });
 
@@ -159,8 +165,12 @@ export function registerQuestTool(
     ),
     execute: async (_toolCallId, _params, _signal, _onUpdate, _ctx) =>
       questToolExecute(questLog, "learn_quests", { action: QUEST_ACTIONS.skill }),
-    renderCall: (_args, theme, context) =>
-      renderQuestCall({ action: QUEST_ACTIONS.skill }, theme, context),
+    renderCall: ((_args: object, theme: Theme, context: unknown) =>
+      renderQuestCall({ action: QUEST_ACTIONS.skill }, theme, context)) as unknown as (
+      args: object,
+      theme: Theme,
+      context: unknown,
+    ) => ReturnType<typeof renderQuestCall>,
     renderResult: renderQuestResult(config),
   });
 }

package/src/tools/params.ts

@@ -1,5 +1,5 @@
 import { StringEnum } from "@mariozechner/pi-ai";
-import { Type } from "@sinclair/typebox";
+import { Type } from "typebox";
 import { QUEST_ACTION_VALUES } from "../quest/types.js";
 
 export function createQuestParams(idLength: number) {
@@ -22,7 +22,13 @@ export function createQuestParams(idLength: number) {
     id: Type.Optional(
       Type.String({
         pattern,
-        description: `Quest ID (required for toggle, update, delete, reorder actions). ALWAYS use the ${idLength}-digit hex ID shown in brackets, never the positional number.`,
+        description: `Quest ID (required for update, reorder, and reparent actions. For toggle and delete, provide either id or ids. ALWAYS use the ${idLength}-digit hex ID shown in brackets, never the positional number.`,
+      }),
+    ),
+    ids: Type.Optional(
+      Type.Array(Type.String({ pattern }), {
+        minItems: 1,
+        description: `Quest IDs for batch toggle or delete actions. Use this when operating on more than one ${idLength}-digit hex quest ID at once.`,
       }),
     ),
     targetId: Type.Optional(