pi-quests 0.3.0 → 0.5.0

package/src/quest/dataplane.ts

@@ -1,38 +1,83 @@
 import type { AgentToolResult, ExtensionContext } from "@mariozechner/pi-coding-agent";
+import { DEFAULT_CONFIG, type ResolvedConfig } from "../config.js";
 import { logger } from "../logger.js";
+import { getQuestSkillDocument } from "../prompts.js";
 import {
+  formatAddResult,
   formatBatchAddResult,
+  formatBlockedBySteps,
   formatDeleteResult,
+  formatDescriptionRequiredError,
+  formatEmptyDescriptionsError,
+  formatIdRequiredError,
+  formatMissingDescriptionsError,
   formatNotFound,
+  formatNothingToRevertError,
+  formatParentDoneError,
+  formatParentNotFoundError,
   formatQuestList,
+  formatReorderedQuestNotFoundError,
+  formatReorderNotFoundError,
+  formatReparentDemoteHasStepsError,
+  formatReparentResult,
+  formatReparentSelfParentError,
+  formatReparentTargetDoneError,
+  formatReparentTargetIsStepError,
+  formatReparentTargetNotFoundError,
+  formatStepCannotHaveSteps,
+  formatTargetIdRequiredError,
   formatToggleResult,
+  formatUnknownActionError,
   formatUpdateResult,
 } from "./formatters.js";
-import { QUEST_ACTIONS, type Quest } from "./types.js";
+import { QUEST_ACTIONS, type Quest, type Step } from "./types.js";
 
 export type HistoryEntry =
-  | { type: typeof QUEST_ACTIONS.add; id: number }
-  | { type: typeof QUEST_ACTIONS.toggle; id: number }
-  | { type: typeof QUEST_ACTIONS.update; id: number; previousDescription: string }
-  | { type: typeof QUEST_ACTIONS.delete; quest: Quest; index: number }
+  | { type: typeof QUEST_ACTIONS.add; id: string; parentId?: string }
+  | { type: typeof QUEST_ACTIONS.toggle; id: 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.clear;
       previousQuests: Quest[];
-      previousNextId: number;
+      previousSteps?: Step[];
       all: false;
     }
-  | { type: typeof QUEST_ACTIONS.clear; quests: Quest[]; nextId: number; all: true }
-  | { type: typeof QUEST_ACTIONS.reorder; quest: Quest; oldIndex: number; previousIds: number[] };
+  | { type: typeof QUEST_ACTIONS.clear; quests: Quest[]; steps?: Step[]; all: true }
+  | {
+      type: typeof QUEST_ACTIONS.reorder;
+      quest: Quest;
+      oldIndex: number;
+      previousIds: string[];
+      targetId: string;
+    }
+  | {
+      type: typeof QUEST_ACTIONS.reparent;
+      id: string;
+      previousParentId?: string;
+      previousQuestIndex?: number;
+    };
 
 export type QuestAction =
   | { type: typeof QUEST_ACTIONS.add; descriptions?: string[] }
+  | { 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?: number }
-  | { type: typeof QUEST_ACTIONS.update; id?: number; description?: string }
-  | { type: typeof QUEST_ACTIONS.delete; id?: number }
+  | { type: typeof QUEST_ACTIONS.toggle; id?: string }
+  | { type: typeof QUEST_ACTIONS.update; id?: string; description?: string }
+  | { type: typeof QUEST_ACTIONS.delete; id?: string }
   | { type: typeof QUEST_ACTIONS.clear; all?: boolean }
-  | { type: typeof QUEST_ACTIONS.reorder; id?: number; targetIndex?: number }
-  | { type: typeof QUEST_ACTIONS.revert };
+  | { type: typeof QUEST_ACTIONS.reorder; id?: string; targetId?: string }
+  | { type: typeof QUEST_ACTIONS.revert }
+  | { 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 };
 
@@ -44,8 +89,35 @@ export type QuestOperationResult = { success: boolean; message: string; quest?:
  */
 export class QuestLog {
   private quests: Quest[] = [];
-  private nextId = 1;
+  private steps: Step[] = [];
+  private usedIds: Set<string> = new Set();
   private history: HistoryEntry[] = [];
+
+  private readonly ID_LENGTH: number;
+  private readonly MAX_IDS: number;
+
+  constructor(config: ResolvedConfig = DEFAULT_CONFIG) {
+    this.ID_LENGTH = config.ids.length;
+    this.MAX_IDS = 16 ** this.ID_LENGTH;
+  }
+
+  private generateId(): string {
+    if (this.usedIds.size >= this.MAX_IDS) {
+      logger.debug("quests:state", "generate-id-exhausted", { usedIds: this.usedIds.size });
+      throw new Error("No available quest IDs. Clear done or all quests to free up IDs.");
+    }
+
+    let id: string;
+    do {
+      id = Math.floor(Math.random() * this.MAX_IDS)
+        .toString(16)
+        .padStart(this.ID_LENGTH, "0")
+        .toLowerCase();
+    } while (this.usedIds.has(id));
+
+    this.usedIds.add(id);
+    return id;
+  }
   private undoHandlers: {
     [K in HistoryEntry["type"]]: (entry: Extract<HistoryEntry, { type: K }>) => {
       success: boolean;
@@ -54,51 +126,68 @@ export class QuestLog {
   } = {
     [QUEST_ACTIONS.add]: (entry) => {
       this.quests = this.quests.filter((q) => q.id !== entry.id);
+      this.steps = this.steps.filter((q) => q.id !== entry.id);
+      this.usedIds.delete(entry.id);
 
-      const maxId = this.quests.reduce((max, q) => Math.max(max, q.id), 0);
-      this.nextId = Math.max(maxId + 1, entry.id);
-
-      logger.debug("quests:state", "revert-add", { id: entry.id, total: this.quests.length });
-      return { success: true, message: `Reverted add quest #${entry.id}` };
+      logger.debug("quests:state", "revert-add", {
+        id: entry.id,
+        total: this.quests.length + this.steps.length,
+      });
+      return { success: true, message: `Reverted add quest [${entry.id}]` };
     },
     [QUEST_ACTIONS.toggle]: (entry) => {
-      const quest = this.quests.find((q) => q.id === entry.id);
+      const quest = this.findById(entry.id);
 
       if (quest) {
         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}` };
+        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: `Quest #${entry.id} not found` };
+      return { success: false, message: formatNotFound(entry.id) };
     },
     [QUEST_ACTIONS.update]: (entry) => {
-      const quest = this.quests.find((q) => q.id === entry.id);
+      const quest = this.findById(entry.id);
       if (quest) {
         quest.description = entry.previousDescription;
         logger.debug("quests:state", "revert-update", { id: entry.id });
-        return { success: true, message: `Reverted update for quest #${entry.id}` };
+        return { success: true, message: `Reverted update for quest [${entry.id}]` };
       }
 
       logger.debug("quests:state", "revert-update-not-found", { id: entry.id });
-      return { success: false, message: `Quest #${entry.id} not found` };
+      return { success: false, message: formatNotFound(entry.id) };
     },
     [QUEST_ACTIONS.delete]: (entry) => {
-      this.quests.splice(entry.index, 0, entry.quest);
+      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);
 
       logger.debug("quests:state", "revert-delete", {
         id: entry.quest.id,
         index: entry.index,
-        total: this.quests.length,
+        total: this.quests.length + this.steps.length,
       });
-      return { success: true, message: `Reverted delete for quest #${entry.quest.id}` };
+      return { success: true, message: `Reverted delete for quest [${entry.quest.id}]` };
     },
     [QUEST_ACTIONS.clear]: (entry) => {
       if ("previousQuests" in entry) {
-        const restoredCount = entry.previousQuests.length - this.quests.length;
+        const restoredCount =
+          entry.previousQuests.length +
+          (entry.previousSteps?.length ?? 0) -
+          (this.quests.length + this.steps.length);
         this.quests = [...entry.previousQuests];
-        this.nextId = entry.previousNextId;
+        this.steps = [...(entry.previousSteps ?? [])];
+        this.usedIds = new Set([...this.quests, ...this.steps].map((q) => q.id));
 
         return {
           success: true,
@@ -107,13 +196,15 @@ export class QuestLog {
       }
 
       this.quests = [...entry.quests];
-      this.nextId = entry.nextId;
+      this.steps = [...(entry.steps ?? [])];
+      this.usedIds = new Set([...this.quests, ...this.steps].map((q) => q.id));
 
       return { success: true, message: `Reverted clear (${entry.quests.length} quests restored)` };
     },
     [QUEST_ACTIONS.reorder]: (entry) => {
       const currentIndex = this.quests.indexOf(entry.quest);
-      if (currentIndex === -1) return { success: false, message: "Reordered quest not found" };
+      if (currentIndex === -1)
+        return { success: false, message: formatReorderedQuestNotFoundError() };
 
       this.quests.splice(currentIndex, 1);
       this.quests.splice(entry.oldIndex, 0, entry.quest);
@@ -121,24 +212,67 @@ export class QuestLog {
         this.quests[i].id = entry.previousIds[i];
       }
 
-      this.nextId = Math.max(...entry.previousIds, 0) + 1;
-      return { success: true, message: `Reverted reorder for quest #${entry.quest.id}` };
+      return { success: true, message: `Reverted reorder for quest [${entry.quest.id}]` };
+    },
+    [QUEST_ACTIONS.reparent]: (entry) => {
+      const quest = this.findById(entry.id);
+      if (!quest) return { success: false, message: formatNotFound(entry.id) };
+      if (entry.previousParentId !== undefined) {
+        this.quests = this.quests.filter((q) => q.id !== entry.id);
+        (quest as Step).parentId = entry.previousParentId;
+        if (!this.steps.some((s) => s.id === entry.id)) this.steps.push(quest as Step);
+      } else if (entry.previousQuestIndex !== undefined) {
+        this.steps = this.steps.filter((s) => s.id !== entry.id);
+        delete (quest as Partial<Step>).parentId;
+        this.quests.splice(entry.previousQuestIndex, 0, quest);
+      }
+      return { success: true, message: `Reverted reparent for quest [${entry.id}]` };
     },
   };
 
+  /*
+   * Returns all quests including steps, inserted in order
+   * steps are returned immediately after their parent quest
+   */
   getAll(): Quest[] {
+    const result: Quest[] = [];
+    for (const q of this.quests) {
+      result.push(q);
+      result.push(...this.steps.filter((step) => step.parentId === q.id));
+    }
+    return result;
+  }
+
+  /*
+   * Returns only top-level quests. Steps should be accessed via `getSteps()`.
+   */
+  getQuests(): Quest[] {
     return [...this.quests];
   }
 
-  getNextId(): number {
-    return this.nextId;
+  /*
+   * Returns steps for a given parent quest ID. Steps are not included in `getQuests()`.
+   */
+  getSteps(parentId: string): Step[] {
+    return this.steps.filter((step) => step.parentId === parentId);
+  }
+
+  getParent(step: Step): Quest | undefined {
+    return this.quests.find((q) => q.id === step.parentId);
   }
 
-  add(description: string, additionalContext?: string): Quest {
+  private findById(id: string): Quest | Step | undefined {
+    return this.quests.find((q) => q.id === id) ?? this.steps.find((step) => step.id === id);
+  }
+
+  getUsedIds(): string[] {
+    return Array.from(this.usedIds);
+  }
+
+  add(description: string): Quest {
     const quest: Quest = {
-      id: this.nextId++,
+      id: this.generateId(),
       description,
-      additionalContext,
       done: false,
       createdAt: Date.now(),
     };
@@ -154,26 +288,77 @@ export class QuestLog {
     return quest;
   }
 
-  toggle(id: number): Quest | undefined {
-    const quest = this.quests.find((q) => q.id === id);
+  addStep(description: string, parentId: string): Step {
+    if (this.steps.some((step) => step.id === parentId)) {
+      throw new Error(formatStepCannotHaveSteps(parentId));
+    }
+    const parent = this.quests.find((q) => q.id === parentId);
+    if (!parent) {
+      throw new Error(formatParentNotFoundError(parentId));
+    }
+    if (parent.done) {
+      throw new Error(formatParentDoneError(parentId));
+    }
+    const step: Step = {
+      id: this.generateId(),
+      description,
+      done: false,
+      createdAt: Date.now(),
+      parentId,
+    };
+    this.steps.push(step);
+    this.history.push({ type: QUEST_ACTIONS.add, id: step.id, parentId });
+    logger.debug("quests:state", "add-step", {
+      id: step.id,
+      parentId,
+      description,
+      totalSteps: this.steps.length,
+    });
+    return step;
+  }
+
+  split(id: string, descriptions: string[]): Step[] {
+    if (this.steps.some((step) => step.id === id)) {
+      throw new Error(formatStepCannotHaveSteps(id));
+    }
+    const parent = this.quests.find((q) => q.id === id);
+    if (!parent) throw new Error(formatNotFound(id));
+    if (parent.done) throw new Error(formatParentDoneError(id));
+    const created: Step[] = [];
+    for (const desc of descriptions) {
+      created.push(this.addStep(desc, id));
+    }
+    return created;
+  }
+
+  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;
+      }
+    }
+
     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,
+      total: this.quests.length + this.steps.length,
     });
     return quest;
   }
 
-  update(id: number, description: string): Quest | undefined {
-    const quest = this.quests.find((q) => q.id === id);
+  update(id: string, description: string): Quest | Step | undefined {
+    const quest = this.findById(id);
     if (!quest) {
       logger.debug("quests:state", "update-not-found", { id });
       return undefined;
@@ -185,77 +370,184 @@ export class QuestLog {
     logger.debug("quests:state", QUEST_ACTIONS.update, {
       id,
       description,
-      total: this.quests.length,
+      total: this.quests.length + this.steps.length,
     });
     return quest;
   }
 
-  delete(id: number): Quest | undefined {
+  delete(id: string): Quest | Step | null | undefined {
     const index = this.quests.findIndex((q) => q.id === id);
-    if (index === -1) {
-      logger.debug("quests:state", "delete-not-found", { id });
-      return undefined;
+    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 [quest] = this.quests.splice(index, 1);
-    this.history.push({ type: QUEST_ACTIONS.delete, quest, index });
-
-    logger.debug("quests:state", QUEST_ACTIONS.delete, { id, index, total: this.quests.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;
+    }
+    logger.debug("quests:state", "delete-not-found", { id });
+    return undefined;
   }
 
   clear(all = false): number {
     if (!all) {
+      const doneParentIds = new Set(this.quests.filter((q) => q.done).map((q) => q.id));
       const done = this.quests.filter((q) => q.done);
-      const previousQuests = this.quests.map((q) => ({ ...q }));
-      const previousNextId = this.nextId;
+      const removedSteps = this.steps.filter(
+        (step) => step.done || doneParentIds.has(step.parentId),
+      );
+      const keptSteps = this.steps.filter(
+        (step) => !step.done && !doneParentIds.has(step.parentId),
+      );
+      const previousQuests = [...this.quests];
+      const previousSteps = [...this.steps];
+      for (const q of done) this.usedIds.delete(q.id);
+      for (const q of removedSteps) this.usedIds.delete(q.id);
       this.quests = this.quests.filter((q) => !q.done);
-      for (let i = 0; i < this.quests.length; i++) {
-        this.quests[i].id = i + 1;
-      }
-      this.nextId = this.quests.length + 1;
+      this.steps = keptSteps;
       this.history.push({
         type: QUEST_ACTIONS.clear,
         previousQuests,
-        previousNextId,
+        previousSteps,
         all: false,
       });
-      logger.debug("quests:state", QUEST_ACTIONS.clear, { count: done.length, all });
-      return done.length;
+      const count = done.length + removedSteps.length;
+      logger.debug("quests:state", QUEST_ACTIONS.clear, { count, all });
+      return count;
     }
-    const count = this.quests.length;
+    const count = this.quests.length + this.steps.length;
     this.history.push({
       type: QUEST_ACTIONS.clear,
       quests: [...this.quests],
-      nextId: this.nextId,
+      steps: [...this.steps],
       all: true,
     });
     this.quests = [];
-    this.nextId = 1;
+    this.steps = [];
+    this.usedIds.clear();
     logger.debug("quests:state", QUEST_ACTIONS.clear, { count, all });
     return count;
   }
 
-  reorder(id: number, targetIndex: number): Quest | undefined {
+  reorder(id: string, targetId: string): Quest | undefined {
+    if (this.steps.some((step) => step.id === id || step.id === targetId)) {
+      logger.debug("quests:state", "reorder-step-rejected", { id, targetId });
+      return undefined;
+    }
     const idx = this.quests.findIndex((q) => q.id === id);
     if (idx === -1) {
       logger.debug("quests:state", "reorder-not-found", { id });
       return undefined;
     }
 
+    const targetIdx = this.quests.findIndex((q) => q.id === targetId);
+    if (targetIdx === -1) {
+      logger.debug("quests:state", "reorder-target-not-found", { id, targetId });
+      return undefined;
+    }
+
+    if (idx === targetIdx) {
+      return this.quests[idx];
+    }
+
     const previousIds = this.quests.map((q) => q.id);
     const [quest] = this.quests.splice(idx, 1);
-    this.quests.splice(targetIndex, 0, quest);
-    for (let i = 0; i < this.quests.length; i++) {
-      this.quests[i].id = i + 1;
+
+    let insertIndex = targetIdx;
+    if (idx < targetIdx) {
+      insertIndex = targetIdx - 1;
     }
 
-    this.nextId = this.quests.length + 1;
-    this.history.push({ type: QUEST_ACTIONS.reorder, quest, oldIndex: idx, previousIds });
+    this.quests.splice(insertIndex, 0, quest);
+    this.history.push({ type: QUEST_ACTIONS.reorder, quest, oldIndex: idx, previousIds, targetId });
     logger.debug("quests:state", QUEST_ACTIONS.reorder, {
       id: quest.id,
-      targetIndex,
-      total: this.quests.length,
+      targetId,
+      total: this.quests.length + this.steps.length,
+    });
+
+    return quest;
+  }
+
+  reparent(id: string, parentId?: string): Quest | Step | undefined {
+    const quest = this.findById(id);
+    if (!quest) return undefined;
+
+    if (parentId) {
+      if (id === parentId) {
+        throw new Error(formatReparentSelfParentError(id));
+      }
+      const target = this.findById(parentId);
+      if (!target) {
+        throw new Error(formatReparentTargetNotFoundError(parentId));
+      }
+      if ("parentId" in target) {
+        throw new Error(formatReparentTargetIsStepError(parentId));
+      }
+      if (target.done) {
+        throw new Error(formatReparentTargetDoneError(parentId));
+      }
+      if (!("parentId" in quest)) {
+        const steps = this.getSteps(id);
+        if (steps.length > 0) {
+          throw new Error(formatReparentDemoteHasStepsError(id));
+        }
+      }
+      const previousQuestIndex = this.quests.findIndex((q) => q.id === id);
+      const previousParentId = "parentId" in quest ? quest.parentId : undefined;
+      this.quests = this.quests.filter((q) => q.id !== id);
+      this.steps = this.steps.filter((s) => s.id !== id);
+      (quest as Step).parentId = parentId;
+      this.steps.push(quest as Step);
+      this.history.push({
+        type: QUEST_ACTIONS.reparent,
+        id,
+        previousParentId,
+        previousQuestIndex: previousQuestIndex === -1 ? undefined : previousQuestIndex,
+      });
+    } else {
+      if (!("parentId" in quest)) {
+        return quest;
+      }
+      const previousParentId = quest.parentId;
+      this.steps = this.steps.filter((s) => s.id !== id);
+      delete (quest as Partial<Step>).parentId;
+      this.quests.push(quest);
+      this.history.push({ type: QUEST_ACTIONS.reparent, id, previousParentId });
+    }
+
+    logger.debug("quests:state", QUEST_ACTIONS.reparent, {
+      id,
+      parentId,
+      total: this.quests.length + this.steps.length,
     });
 
     return quest;
@@ -265,7 +557,7 @@ export class QuestLog {
     const entry = this.history.pop();
     if (!entry) {
       logger.debug("quests:state", "revert-empty");
-      return { success: false, message: "Nothing to revert" };
+      return { success: false, message: formatNothingToRevertError() };
     }
 
     logger.debug("quests:state", "revert", { type: entry.type });
@@ -290,20 +582,40 @@ export class QuestLog {
           if (action.descriptions.some((d) => !d || d.trim().length === 0)) {
             return {
               success: false,
-              message: "Error: all descriptions in a batch must be non-empty",
+              message: formatEmptyDescriptionsError(),
             };
           }
-          const added: { id: number; description: string }[] = [];
-          for (const desc of action.descriptions) {
-            const q = this.add(desc);
-            added.push({ id: q.id, description: q.description });
+          if (action.descriptions.length === 1) {
+            try {
+              const [firstDesc] = action.descriptions;
+              const q = this.add(firstDesc);
+
+              return { success: true, message: formatAddResult(q) };
+            } catch (err) {
+              return {
+                success: false,
+                message: `Error: ${err instanceof Error ? err.message : String(err)}`,
+              };
+            }
+          }
+          try {
+            const added: { id: string; description: string }[] = [];
+            for (const desc of action.descriptions) {
+              const q = this.add(desc);
+              added.push({ id: q.id, description: q.description });
+            }
+
+            return { success: true, message: formatBatchAddResult(added) };
+          } catch (err) {
+            return {
+              success: false,
+              message: `Error: ${err instanceof Error ? err.message : String(err)}`,
+            };
           }
-
-          return { success: true, message: formatBatchAddResult(added) };
         }
         return {
           success: false,
-          message: "Error: at least one description is required for add action",
+          message: formatMissingDescriptionsError(),
         };
       }
       case QUEST_ACTIONS.list: {
@@ -312,23 +624,26 @@ export class QuestLog {
       }
       case QUEST_ACTIONS.toggle: {
         if (action.id === undefined) {
-          return { success: false, message: "Error: id is required for toggle action" };
+          return { success: false, message: formatIdRequiredError("toggle") };
         }
 
         const q = this.toggle(action.id);
-        if (!q) {
+        if (q === undefined) {
           return { success: false, message: formatNotFound(action.id) };
         }
+        if (q === null) {
+          return { success: false, message: formatBlockedBySteps(action.id) };
+        }
 
         return { success: true, message: formatToggleResult(action.id, q.done), quest: q };
       }
       case QUEST_ACTIONS.update: {
         if (action.id === undefined) {
-          return { success: false, message: "Error: id is required for update action" };
+          return { success: false, message: formatIdRequiredError("update") };
         }
 
-        if (!action.description) {
-          return { success: false, message: "Error: description is required for update action" };
+        if (!action.description || action.description.trim().length === 0) {
+          return { success: false, message: formatDescriptionRequiredError() };
         }
 
         const q = this.update(action.id, action.description);
@@ -340,13 +655,16 @@ export class QuestLog {
       }
       case QUEST_ACTIONS.delete: {
         if (action.id === undefined) {
-          return { success: false, message: "Error: id is required for delete action" };
+          return { success: false, message: formatIdRequiredError("delete") };
         }
 
         const q = this.delete(action.id);
-        if (!q) {
+        if (q === undefined) {
           return { success: false, message: formatNotFound(action.id) };
         }
+        if (q === null) {
+          return { success: false, message: formatBlockedBySteps(action.id) };
+        }
 
         return { success: true, message: formatDeleteResult(q), quest: q };
       }
@@ -360,21 +678,66 @@ export class QuestLog {
       }
       case QUEST_ACTIONS.reorder: {
         if (action.id === undefined)
-          return { success: false, message: "Error: id is required for reorder action" };
+          return { success: false, message: formatIdRequiredError("reorder") };
 
-        if (action.targetIndex === undefined)
-          return { success: false, message: "Error: targetIndex is required for reorder action" };
+        if (action.targetId === undefined)
+          return { success: false, message: formatTargetIdRequiredError() };
 
-        const q = this.reorder(action.id, action.targetIndex);
-        if (!q) return { success: false, message: formatNotFound(action.id) };
+        const q = this.reorder(action.id, action.targetId);
+        if (!q) return { success: false, message: formatReorderNotFoundError() };
 
-        return { success: true, message: `Reordered quest #${q.id}: ${q.description}`, quest: q };
+        return { success: true, message: `Reordered quest [${q.id}]: ${q.description}`, quest: q };
+      }
+      case QUEST_ACTIONS.split:
+      case QUEST_ACTIONS.add_step: {
+        if (action.id === undefined) {
+          return { success: false, message: formatIdRequiredError("split") };
+        }
+        if (!action.descriptions || action.descriptions.length === 0) {
+          return { success: false, message: formatMissingDescriptionsError("split") };
+        }
+        if (action.descriptions.some((d) => !d || d.trim().length === 0)) {
+          return { success: false, message: formatEmptyDescriptionsError() };
+        }
+        try {
+          const steps = this.split(action.id, action.descriptions);
+          return {
+            success: true,
+            message: `Split quest [${action.id}] into ${steps.length} steps`,
+          };
+        } catch (err) {
+          return {
+            success: false,
+            message: `Error: ${err instanceof Error ? err.message : String(err)}`,
+          };
+        }
+      }
+      case QUEST_ACTIONS.reparent: {
+        if (action.id === undefined)
+          return { success: false, message: formatIdRequiredError("reparent") };
+        try {
+          const q = this.reparent(action.id, action.parentId);
+          if (!q) return { success: false, message: formatNotFound(action.id) };
+          return { success: true, message: formatReparentResult(q, action.parentId), quest: q };
+        } catch (err) {
+          return {
+            success: false,
+            message: `Error: ${err instanceof Error ? err.message : String(err)}`,
+          };
+        }
+      }
+      case QUEST_ACTIONS.rules:
+      case QUEST_ACTIONS.skill: {
+        return { success: true, message: getQuestSkillDocument() };
       }
       case QUEST_ACTIONS.revert: {
         return this.revert();
       }
       default: {
-        return { success: false, message: `Unknown action: ${(action as { type: string }).type}` };
+        return {
+          success: false,
+          message: formatUnknownActionError((action as { type: string }).type),
+        };
       }
     }
   }
@@ -398,15 +761,21 @@ export class QuestLog {
 
     if (lastState) {
       const quests = lastState.quests;
-      const nextId = lastState.nextId;
       const questCount = Array.isArray(quests) ? quests.length : 0;
 
-      this.quests = Array.isArray(quests) ? [...(quests as Quest[])] : [];
-      this.nextId = typeof nextId === "number" ? nextId : 1;
-      logger.debug("quests:state", "reconstruct", { toolResults, questCount, nextId: this.nextId });
+      if (Array.isArray(quests)) {
+        this.quests = (quests as Quest[]).filter((q) => !("parentId" in q && q.parentId));
+        this.steps = (quests as Quest[]).filter((q) => "parentId" in q && q.parentId) as Step[];
+      } else {
+        this.quests = [];
+        this.steps = [];
+      }
+      this.usedIds = new Set([...this.quests, ...this.steps].map((q) => q.id));
+      logger.debug("quests:state", "reconstruct", { toolResults, questCount });
     } else {
       this.quests = [];
-      this.nextId = 1;
+      this.steps = [];
+      this.usedIds.clear();
       logger.debug("quests:state", "reconstruct-empty", { toolResults });
     }
 
@@ -423,7 +792,7 @@ export function makeToolResult(
     content: [{ type: "text", text }],
     details: {
       quests: questLog.getAll(),
-      nextId: questLog.getNextId(),
+      usedIds: questLog.getUsedIds(),
       displayQuests,
     },
   };