@howaboua/opencode-roadmap-plugin 0.1.6 → 0.1.9

package/dist/src/descriptions/createroadmap.txt

@@ -1,20 +1,24 @@
-Establish a durable project roadmap saved to disk. Provides shared context across sessions and Task tool subagents.
+Establish a durable project roadmap with a high-level spec and task list. Provides shared context across sessions and Task tool subagents.
 
 Use when:
-- User says "roadmap", "plan the project", "phases", or "milestones"  
-- Work will be delegated to Task tool subagents that need shared context
+- After a heavy planning session to lock in the spec and task list
+- When launching Task tool subagents that need shared context
+- User says "roadmap", "plan the project", "phases", or "milestones"
 - Deliverables group naturally into distinct features
 
-When launching Task tool subagents, instruct them to call readroadmap first to understand their work within the broader plan.
+When launching Task tool subagents, explicitly instruct them to: (1) call readroadmap first, and (2) call updateroadmap to mark their action in_progress at start and completed at finish with a short note.
 
 Structure: Features contain Actions. IDs are immutable once created.
 
-Format:
-- Feature: number "1", "2", title, description
-- Action: number "1.01", "1.02" (prefix matches parent feature), description, status "pending"
+Inputs:
+- feature: short label for the overall roadmap
+- spec: natural-language spec for the overall direction
+- features/actions: structured tasks with numbered IDs
 
 Example:
 {
+  "feature": "Core",
+  "spec": "Build the core workflow and key integrations.",
   "features": [{
     "number": "1", "title": "Auth", "description": "User authentication system",
     "actions": [

package/dist/src/descriptions/readroadmap.txt

@@ -1,8 +1,8 @@
-Load the persisted roadmap from disk to understand project state.
+Load the persisted roadmap to understand project state.
 
 When to use:
-1. Before starting a major feature - read roadmap first, then plan immediate steps with todowrite
-2. When launching Task tool subagents - instruct them to call readroadmap to understand their assigned work
+1. Before starting a major feature - call readroadmap first, then plan immediate steps with todowrite
+2. When launching Task tool subagents - explicitly instruct them to call readroadmap before doing any work, then updateroadmap when they start and finish
 3. To check overall progress across features
 
 Concurrent work awareness:

package/dist/src/descriptions/updateroadmap.txt

@@ -3,7 +3,7 @@ Advance action state within the persisted roadmap.
 Statuses: pending, in_progress, completed, cancelled
 Transitions: Flexible (can revert if needed), except cancelled is terminal.
 
-Update after completing work on an action. When delegating to Task tool subagents, instruct them to call updateroadmap when they finish their assigned action.
+Use after completing work on an action. When delegating to Task tool subagents, explicitly instruct them to call updateroadmap at start (set in_progress) and at finish (set completed with a short note).
 
 Archives roadmap automatically when all actions reach completed.
 

package/dist/src/errors/roadmap_corrupted.txt

@@ -1 +1 @@
-Roadmap file is corrupted or unreadable. Ask user to check roadmap.json file.
+Roadmap data is corrupted or unreadable. Ask user to recreate the roadmap.

package/dist/src/roadmap/document.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Parses and renders the roadmap markdown document.
+ * Keeps frontmatter simple and the task block machine-readable.
+ * Exposes a narrow API for the storage layer.
+ */
+import type { RoadmapDocument } from "../types.js";
+export declare const parseDocument: (data: string) => RoadmapDocument;
+export declare const buildDocument: (document: RoadmapDocument) => string;
+export declare const ensureDocument: (document: RoadmapDocument) => RoadmapDocument;

package/dist/src/roadmap/document.js

@@ -0,0 +1,117 @@
+import { Roadmap as RoadmapSchema } from "../types.js";
+const FRONTMATTER_START = "---\n";
+const FRONTMATTER_END = "\n---\n";
+const TASK_FENCE = "```json";
+const TASK_FENCE_END = "\n```";
+export const parseDocument = (data) => {
+    const { frontmatter, body } = splitFrontmatter(data);
+    const { feature, spec } = parseFrontmatter(frontmatter);
+    const roadmap = parseRoadmapBody(body);
+    return { feature, spec, roadmap };
+};
+export const buildDocument = (document) => {
+    const specValue = document.spec.trimEnd();
+    const specLines = specValue === "" ? [""] : specValue.split("\n");
+    const specBlock = specLines.map((line) => `  ${line}`).join("\n");
+    const tasks = JSON.stringify(document.roadmap, null, 2);
+    return [
+        "---",
+        `feature: ${JSON.stringify(document.feature)}`,
+        "spec: |",
+        specBlock,
+        "---",
+        "",
+        TASK_FENCE,
+        tasks,
+        "```",
+        "",
+    ].join("\n");
+};
+const splitFrontmatter = (data) => {
+    if (!data.startsWith(FRONTMATTER_START)) {
+        throw new Error("Roadmap format is invalid. Missing frontmatter.");
+    }
+    const endIndex = data.indexOf(FRONTMATTER_END, FRONTMATTER_START.length);
+    if (endIndex === -1) {
+        throw new Error("Roadmap format is invalid. Frontmatter is not closed.");
+    }
+    const frontmatter = data.slice(FRONTMATTER_START.length, endIndex);
+    const body = data.slice(endIndex + FRONTMATTER_END.length);
+    return { frontmatter, body };
+};
+const parseFrontmatter = (frontmatter) => {
+    const lines = frontmatter.split("\n");
+    let feature = null;
+    let specStart = -1;
+    for (let i = 0; i < lines.length; i += 1) {
+        const line = lines[i];
+        if (line.startsWith("feature:")) {
+            feature = parseScalar(line.slice("feature:".length));
+        }
+        if (line.startsWith("spec:")) {
+            if (line.trim() !== "spec: |") {
+                throw new Error("Roadmap format is invalid. Spec must use a block value.");
+            }
+            specStart = i;
+        }
+    }
+    if (!feature) {
+        throw new Error("Roadmap format is invalid. Missing feature.");
+    }
+    if (specStart === -1) {
+        throw new Error("Roadmap format is invalid. Missing spec.");
+    }
+    const specLines = lines.slice(specStart + 1);
+    const spec = normalizeSpec(specLines);
+    return { feature, spec };
+};
+const parseScalar = (value) => {
+    const trimmed = value.trim();
+    if (trimmed.startsWith('"') && trimmed.endsWith('"')) {
+        return trimmed.slice(1, -1);
+    }
+    if (trimmed.startsWith("'") && trimmed.endsWith("'")) {
+        return trimmed.slice(1, -1);
+    }
+    return trimmed;
+};
+const normalizeSpec = (lines) => {
+    if (lines.length === 0) {
+        return "";
+    }
+    const nonEmpty = lines.filter((line) => line.trim() !== "");
+    const indent = nonEmpty.length === 0
+        ? 0
+        : nonEmpty.reduce((min, line) => {
+            const match = line.match(/^\s+/);
+            const count = match ? match[0].length : 0;
+            return Math.min(min, count);
+        }, Number.MAX_SAFE_INTEGER);
+    const normalized = lines.map((line) => line.slice(indent));
+    return normalized.join("\n").trimEnd();
+};
+const parseRoadmapBody = (body) => {
+    const fenceStart = body.indexOf(TASK_FENCE);
+    if (fenceStart === -1) {
+        throw new Error("Roadmap format is invalid. Missing task block.");
+    }
+    const jsonStart = body.indexOf("\n", fenceStart + TASK_FENCE.length);
+    if (jsonStart === -1) {
+        throw new Error("Roadmap format is invalid. Task block is incomplete.");
+    }
+    const fenceEnd = body.indexOf(TASK_FENCE_END, jsonStart + 1);
+    if (fenceEnd === -1) {
+        throw new Error("Roadmap format is invalid. Task block is not closed.");
+    }
+    const jsonText = body.slice(jsonStart + 1, fenceEnd).trim();
+    const parsed = JSON.parse(jsonText);
+    return RoadmapSchema.parse(parsed);
+};
+export const ensureDocument = (document) => {
+    const validated = RoadmapSchema.parse(document.roadmap);
+    return {
+        feature: document.feature,
+        spec: document.spec,
+        roadmap: validated,
+    };
+};

package/dist/src/roadmap/files.d.ts

@@ -0,0 +1,4 @@
+export declare const ensureRoadmapDir: (base: string) => Promise<void>;
+export declare const readRoadmapFile: (base: string) => Promise<string>;
+export declare const writeRoadmapFile: (base: string, data: string) => Promise<void>;
+export declare const archiveRoadmapFile: (base: string) => Promise<string>;

package/dist/src/roadmap/files.js

@@ -0,0 +1,49 @@
+/**
+ * Handles roadmap file IO with atomic writes.
+ * Keeps filesystem concerns separate from document parsing.
+ */
+import { promises as fs } from "fs";
+import { roadmapDir, roadmapPath, tempPath } from "./paths.js";
+export const ensureRoadmapDir = async (base) => {
+    await fs.mkdir(roadmapDir(base), { recursive: true }).catch(() => { });
+};
+export const readRoadmapFile = async (base) => {
+    return await fs.readFile(roadmapPath(base), "utf-8");
+};
+const fsyncDir = async (dir) => {
+    const handle = await fs.open(dir, "r");
+    try {
+        await handle.sync();
+    }
+    finally {
+        await handle.close().catch(() => { });
+    }
+};
+export const writeRoadmapFile = async (base, data) => {
+    const suffix = `${Date.now()}.${Math.random().toString(36).slice(2, 8)}`;
+    const temp = tempPath(base, suffix);
+    const handle = await fs.open(temp, "w");
+    try {
+        await handle.writeFile(data, "utf-8");
+        await handle.sync();
+        await handle.close();
+        await fs.rename(temp, roadmapPath(base));
+        await fsyncDir(roadmapDir(base));
+    }
+    catch (error) {
+        await handle.close().catch(() => { });
+        await fs.unlink(temp).catch(() => { });
+        if (error instanceof Error) {
+            throw error;
+        }
+        throw new Error("Unknown error while persisting roadmap");
+    }
+};
+export const archiveRoadmapFile = async (base) => {
+    const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
+    const archiveFilename = `roadmap.archive.${timestamp}.md`;
+    const archivePath = `${roadmapDir(base)}/${archiveFilename}`;
+    await fs.rename(roadmapPath(base), archivePath);
+    await fsyncDir(roadmapDir(base));
+    return archiveFilename;
+};

package/dist/src/roadmap/lock.d.ts

@@ -0,0 +1 @@
+export declare const acquireLock: (base: string) => Promise<() => Promise<void>>;

package/dist/src/roadmap/lock.js

@@ -0,0 +1,33 @@
+/**
+ * Provides exclusive access for roadmap operations.
+ * Uses a lock file with stale detection to avoid deadlocks.
+ */
+import { promises as fs } from "fs";
+import { lockPath } from "./paths.js";
+const LOCK_TIMEOUT_MS = 5000;
+const LOCK_RETRY_MS = 50;
+const LOCK_STALE_MS = 30000;
+export const acquireLock = async (base) => {
+    const path = lockPath(base);
+    const start = Date.now();
+    while (Date.now() - start < LOCK_TIMEOUT_MS) {
+        try {
+            await fs.writeFile(path, String(process.pid), { flag: "wx" });
+            return async () => {
+                await fs.unlink(path).catch(() => { });
+            };
+        }
+        catch {
+            const isStale = await fs
+                .stat(path)
+                .then((stat) => Date.now() - stat.mtimeMs > LOCK_STALE_MS)
+                .catch(() => false);
+            if (isStale) {
+                await fs.unlink(path).catch(() => { });
+                continue;
+            }
+            await new Promise((resolve) => setTimeout(resolve, LOCK_RETRY_MS));
+        }
+    }
+    throw new Error("Could not acquire lock on roadmap data. Another operation may be in progress.");
+};

package/dist/src/roadmap/paths.d.ts

@@ -0,0 +1,7 @@
+export declare const ROADMAP_DIR = "roadmap";
+export declare const ROADMAP_FILE = "roadmap.md";
+export declare const LOCK_FILE = "roadmap.md.lock";
+export declare const roadmapDir: (base: string) => string;
+export declare const roadmapPath: (base: string) => string;
+export declare const lockPath: (base: string) => string;
+export declare const tempPath: (base: string, suffix: string) => string;

package/dist/src/roadmap/paths.js

@@ -0,0 +1,12 @@
+/**
+ * Centralizes file naming for the roadmap document.
+ * Keeps path logic consistent across storage helpers.
+ */
+import { join } from "path";
+export const ROADMAP_DIR = "roadmap";
+export const ROADMAP_FILE = "roadmap.md";
+export const LOCK_FILE = `${ROADMAP_FILE}.lock`;
+export const roadmapDir = (base) => join(base, ROADMAP_DIR);
+export const roadmapPath = (base) => join(roadmapDir(base), ROADMAP_FILE);
+export const lockPath = (base) => join(roadmapDir(base), LOCK_FILE);
+export const tempPath = (base, suffix) => join(roadmapDir(base), `${ROADMAP_FILE}.tmp.${suffix}`);

package/dist/src/storage.d.ts

@@ -1,26 +1,17 @@
-import type { Roadmap, RoadmapStorage, ValidationError } from "./types.js";
+import type { RoadmapDocument, RoadmapStorage } from "./types.js";
+type UpdateResult<T> = {
+    document: RoadmapDocument;
+    buildResult: (archiveName: string | null) => T;
+    archive?: boolean;
+};
 export declare class FileStorage implements RoadmapStorage {
     private readonly directory;
     constructor(directory: string);
     exists(): Promise<boolean>;
-    read(): Promise<Roadmap | null>;
-    private acquireLock;
-    write(roadmap: Roadmap): Promise<void>;
+    read(): Promise<RoadmapDocument | null>;
+    write(document: RoadmapDocument): Promise<void>;
+    update<T>(fn: (current: RoadmapDocument | null) => Promise<UpdateResult<T>> | UpdateResult<T>): Promise<T>;
     archive(): Promise<string>;
+    private readFromDisk;
 }
-export declare class RoadmapValidator {
-    static validateFeatureNumber(number: string): ValidationError | null;
-    static validateActionNumber(number: string): ValidationError | null;
-    static validateActionSequence(actions: {
-        number: string;
-    }[], globalSeenNumbers?: Set<string>, featureNumber?: string): ValidationError[];
-    static validateFeatureSequence(features: {
-        number: string;
-        actions: {
-            number: string;
-        }[];
-    }[]): ValidationError[];
-    static validateTitle(title: string, fieldType: "feature" | "action"): ValidationError | null;
-    static validateDescription(description: string, fieldType: "feature" | "action"): ValidationError | null;
-    static validateStatusProgression(currentStatus: string, newStatus: string): ValidationError | null;
-}
+export {};

package/dist/src/storage.js

@@ -1,15 +1,14 @@
 /**
- * File-based storage for roadmap data with atomic writes and validation.
- * Handles concurrent access via file locking and provides safe read/write operations.
+ * Persists the roadmap document with locking and atomic writes.
+ * Delegates parsing and formatting to the document helpers.
+ * Keeps IO logic focused on concurrency and filesystem safety.
  */
 import { promises as fs } from "fs";
-import { join } from "path";
 import { z } from "zod";
-import { Roadmap as RoadmapSchema } from "./types.js";
-const ROADMAP_FILE = "roadmap.json";
-const LOCK_FILE = `${ROADMAP_FILE}.lock`;
-const LOCK_TIMEOUT_MS = 5000;
-const LOCK_RETRY_MS = 50;
+import { parseDocument, buildDocument, ensureDocument } from "./roadmap/document.js";
+import { acquireLock } from "./roadmap/lock.js";
+import { ensureRoadmapDir, readRoadmapFile, writeRoadmapFile, archiveRoadmapFile } from "./roadmap/files.js";
+import { roadmapPath } from "./roadmap/paths.js";
 export class FileStorage {
     directory;
     constructor(directory) {
@@ -17,7 +16,7 @@ export class FileStorage {
     }
     async exists() {
         try {
-            await fs.access(join(this.directory, ROADMAP_FILE));
+            await fs.access(roadmapPath(this.directory));
             return true;
         }
         catch {
@@ -25,68 +24,29 @@ export class FileStorage {
         }
     }
     async read() {
+        return this.readFromDisk();
+    }
+    async write(document) {
+        await ensureRoadmapDir(this.directory);
+        const unlock = await acquireLock(this.directory);
         try {
-            const filePath = join(this.directory, ROADMAP_FILE);
-            const data = await fs.readFile(filePath, "utf-8");
-            if (!data.trim()) {
-                return null;
-            }
-            const parsed = JSON.parse(data);
-            const validated = RoadmapSchema.parse(parsed);
-            return validated;
-        }
-        catch (error) {
-            if (error instanceof SyntaxError) {
-                throw new Error("Roadmap file contains invalid JSON. File may be corrupted.");
-            }
-            if (error instanceof z.ZodError) {
-                const issues = error.errors.map((e) => `${e.path.join(".")}: ${e.message}`).join(", ");
-                throw new Error(`Roadmap file has invalid structure: ${issues}`);
-            }
-            if (error instanceof Error && error.message.includes("ENOENT")) {
-                return null;
-            }
-            if (error instanceof Error) {
-                throw error;
-            }
-            throw new Error("Unknown error while reading roadmap");
+            const data = buildDocument(ensureDocument(document));
+            await writeRoadmapFile(this.directory, data);
         }
-    }
-    async acquireLock() {
-        const lockPath = join(this.directory, LOCK_FILE);
-        const start = Date.now();
-        while (Date.now() - start < LOCK_TIMEOUT_MS) {
-            try {
-                await fs.writeFile(lockPath, String(process.pid), { flag: "wx" });
-                return async () => {
-                    await fs.unlink(lockPath).catch(() => { });
-                };
-            }
-            catch {
-                await new Promise((r) => setTimeout(r, LOCK_RETRY_MS));
-            }
+        finally {
+            await unlock();
         }
-        throw new Error("Could not acquire lock on roadmap file. Another operation may be in progress.");
     }
-    async write(roadmap) {
-        await fs.mkdir(this.directory, { recursive: true }).catch(() => { });
-        const unlock = await this.acquireLock();
+    async update(fn) {
+        await ensureRoadmapDir(this.directory);
+        const unlock = await acquireLock(this.directory);
         try {
-            const filePath = join(this.directory, ROADMAP_FILE);
-            const randomSuffix = Math.random().toString(36).slice(2, 8);
-            const tempPath = join(this.directory, `${ROADMAP_FILE}.tmp.${Date.now()}.${randomSuffix}`);
-            try {
-                const data = JSON.stringify(roadmap, null, 2);
-                await fs.writeFile(tempPath, data, "utf-8");
-                await fs.rename(tempPath, filePath);
-            }
-            catch (error) {
-                await fs.unlink(tempPath).catch(() => { });
-                if (error instanceof Error) {
-                    throw error;
-                }
-                throw new Error("Unknown error while writing roadmap");
-            }
+            const current = await this.readFromDisk();
+            const outcome = await fn(current);
+            const data = buildDocument(ensureDocument(outcome.document));
+            await writeRoadmapFile(this.directory, data);
+            const archiveName = outcome.archive ? await archiveRoadmapFile(this.directory) : null;
+            return outcome.buildResult(archiveName);
         }
         finally {
             await unlock();
@@ -94,152 +54,39 @@ export class FileStorage {
     }
     async archive() {
         if (!(await this.exists())) {
-            throw new Error("Cannot archive: roadmap file does not exist");
-        }
-        const filePath = join(this.directory, ROADMAP_FILE);
-        const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
-        const archiveFilename = `roadmap.archive.${timestamp}.json`;
-        const archivePath = join(this.directory, archiveFilename);
-        await fs.rename(filePath, archivePath);
-        return archiveFilename;
-    }
-}
-export class RoadmapValidator {
-    static validateFeatureNumber(number) {
-        if (!number || typeof number !== "string") {
-            return {
-                code: "INVALID_FEATURE_NUMBER",
-                message: "Invalid feature ID: must be a string.",
-            };
-        }
-        if (!/^\d+$/.test(number)) {
-            return {
-                code: "INVALID_FEATURE_NUMBER_FORMAT",
-                message: "Invalid feature ID format: must be a simple number.",
-            };
+            throw new Error("Roadmap not found.");
         }
-        return null;
-    }
-    static validateActionNumber(number) {
-        if (!number || typeof number !== "string") {
-            return {
-                code: "INVALID_ACTION_NUMBER",
-                message: "Invalid action ID: must be a string.",
-            };
+        const unlock = await acquireLock(this.directory);
+        try {
+            return await archiveRoadmapFile(this.directory);
         }
-        if (!/^\d+\.\d{2}$/.test(number)) {
-            return {
-                code: "INVALID_ACTION_NUMBER_FORMAT",
-                message: "Invalid action ID format: must be X.YY (e.g., 1.01).",
-            };
+        finally {
+            await unlock();
         }
-        return null;
     }
-    static validateActionSequence(actions, globalSeenNumbers, featureNumber) {
-        const errors = [];
-        const seenNumbers = new Set();
-        for (const action of actions) {
-            const numberError = this.validateActionNumber(action.number);
-            if (numberError) {
-                errors.push(numberError);
-                continue;
-            }
-            // Check action-feature mismatch
-            if (featureNumber) {
-                const actionFeaturePrefix = action.number.split(".")[0];
-                if (actionFeaturePrefix !== featureNumber) {
-                    errors.push({
-                        code: "ACTION_FEATURE_MISMATCH",
-                        message: `Action "${action.number}" does not belong to feature "${featureNumber}".`,
-                    });
-                }
+    async readFromDisk() {
+        try {
+            const data = await readRoadmapFile(this.directory);
+            if (!data.trim()) {
+                return null;
             }
-            // Check for duplicates within this feature
-            if (seenNumbers.has(action.number)) {
-                errors.push({
-                    code: "DUPLICATE_ACTION_NUMBER",
-                    message: `Duplicate action ID "${action.number}".`,
-                });
+            return ensureDocument(parseDocument(data));
+        }
+        catch (error) {
+            if (error instanceof SyntaxError) {
+                throw new Error("Roadmap data is invalid. Unable to parse tasks.");
             }
-            // Check for global duplicates
-            if (globalSeenNumbers?.has(action.number)) {
-                errors.push({
-                    code: "DUPLICATE_ACTION_NUMBER_GLOBAL",
-                    message: `Duplicate action ID "${action.number}" (exists in another feature).`,
-                });
+            if (error instanceof z.ZodError) {
+                const issues = error.errors.map((e) => `${e.path.join(".")}: ${e.message}`).join(", ");
+                throw new Error(`Roadmap data is invalid: ${issues}`);
             }
-            seenNumbers.add(action.number);
-            globalSeenNumbers?.add(action.number);
-        }
-        return errors;
-    }
-    static validateFeatureSequence(features) {
-        const errors = [];
-        const seenNumbers = new Set();
-        const seenActionNumbers = new Set();
-        for (const feature of features) {
-            const numberError = this.validateFeatureNumber(feature.number);
-            if (numberError) {
-                errors.push(numberError);
-                continue;
+            if (error instanceof Error && error.message.includes("ENOENT")) {
+                return null;
             }
-            if (seenNumbers.has(feature.number)) {
-                errors.push({
-                    code: "DUPLICATE_FEATURE_NUMBER",
-                    message: `Duplicate feature ID "${feature.number}".`,
-                });
+            if (error instanceof Error) {
+                throw error;
             }
-            seenNumbers.add(feature.number);
-            const actionErrors = this.validateActionSequence(feature.actions, seenActionNumbers, feature.number);
-            errors.push(...actionErrors);
-        }
-        return errors;
-    }
-    static validateTitle(title, fieldType) {
-        if (!title || typeof title !== "string") {
-            return {
-                code: "INVALID_TITLE",
-                message: `Invalid ${fieldType} title. Must be non-empty string.`,
-            };
-        }
-        if (title.trim() === "") {
-            return {
-                code: "EMPTY_TITLE",
-                message: `${fieldType.charAt(0).toUpperCase() + fieldType.slice(1)} title cannot be empty.`,
-            };
-        }
-        return null;
-    }
-    static validateDescription(description, fieldType) {
-        if (!description || typeof description !== "string") {
-            return {
-                code: "INVALID_DESCRIPTION",
-                message: `Invalid ${fieldType} description. Must be non-empty string.`,
-            };
-        }
-        if (description.trim() === "") {
-            return {
-                code: "EMPTY_DESCRIPTION",
-                message: `${fieldType.charAt(0).toUpperCase() + fieldType.slice(1)} description cannot be empty.`,
-            };
-        }
-        return null;
-    }
-    static validateStatusProgression(currentStatus, newStatus) {
-        const validStatuses = ["pending", "in_progress", "completed", "cancelled"];
-        if (!validStatuses.includes(newStatus)) {
-            return {
-                code: "INVALID_STATUS",
-                message: `Invalid status "${newStatus}". Valid: ${validStatuses.join(", ")}`,
-            };
-        }
-        // Allow any transition except from cancelled (terminal state for abandoned work)
-        if (currentStatus === "cancelled") {
-            return {
-                code: "INVALID_STATUS_TRANSITION",
-                message: `Cannot change status of cancelled action. Create a new action instead.`,
-            };
+            throw new Error("Unknown error while loading roadmap");
         }
-        return null;
     }
 }