@projitive/mcp 1.2.0 → 2.0.1

package/output/source/tools/task.test.js

@@ -1,5 +1,5 @@
 import { describe, expect, it } from "vitest";
-import { TASKS_END, TASKS_START, collectTaskLintSuggestions, isValidTaskId, normalizeTask, parseTasksBlock, rankActionableTaskCandidates, resolveNoTaskDiscoveryGuidance, renderTaskSeedTemplate, renderTasksMarkdown, taskPriority, toTaskUpdatedAtMs, validateTransition, findTaskIdsOutsideMarkers, } from "./task.js";
+import { collectTaskLintSuggestions, isValidTaskId, normalizeTask, rankActionableTaskCandidates, resolveNoTaskDiscoveryGuidance, renderTaskSeedTemplate, renderTasksMarkdown, loadTasksDocument, saveTasks, taskPriority, toTaskUpdatedAtMs, validateTransition, } from "./task.js";
 import fs from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
@@ -12,7 +12,6 @@ function buildCandidate(partial) {
     });
     return {
         governanceDir: partial.governanceDir ?? "/workspace/a",
-        tasksPath: partial.tasksPath ?? "/workspace/a/tasks.md",
         task,
         projectScore: partial.projectScore ?? 1,
         projectLatestUpdatedAt: partial.projectLatestUpdatedAt ?? "2026-01-01T00:00:00.000Z",
@@ -21,87 +20,6 @@ function buildCandidate(partial) {
     };
 }
 describe("tasks module", () => {
-    it("parses markdown task block and normalizes task fields", async () => {
-        const markdown = [
-            "# Tasks",
-            TASKS_START,
-            "## TASK-0001 | TODO | hello",
-            "- owner: alice",
-            "- summary: first task",
-            "- updatedAt: 2026-02-17T00:00:00.000Z",
-            "- roadmapRefs: ROADMAP-0001",
-            "- links:",
-            "  - ./designs/example.md",
-            TASKS_END,
-        ].join("\n");
-        const tasks = await parseTasksBlock(markdown);
-        expect(tasks).toHaveLength(1);
-        expect(tasks[0].id).toBe("TASK-0001");
-        expect(tasks[0].status).toBe("TODO");
-        expect(tasks[0].roadmapRefs).toEqual(["ROADMAP-0001"]);
-        expect(tasks[0].links).toEqual(["./designs/example.md"]);
-    });
-    it("renders markdown containing markers", () => {
-        const task = normalizeTask({ id: "TASK-0002", title: "render", status: "IN_PROGRESS" });
-        const markdown = renderTasksMarkdown([task]);
-        expect(markdown.includes(TASKS_START)).toBe(true);
-        expect(markdown.includes(TASKS_END)).toBe(true);
-        expect(markdown.includes("## TASK-0002 | IN_PROGRESS | render")).toBe(true);
-    });
-    it("parses task with subState metadata (Spec v1.1.0)", async () => {
-        const markdown = [
-            "# Tasks",
-            TASKS_START,
-            "## TASK-0003 | IN_PROGRESS | feature with substate",
-            "- owner: bob",
-            "- summary: implementing feature",
-            "- updatedAt: 2026-02-20T00:00:00.000Z",
-            "- roadmapRefs: ROADMAP-0001",
-            "- links:",
-            "  - ./designs/feature.md",
-            "- subState:",
-            "  - phase: implementation",
-            "  - confidence: 0.85",
-            "  - estimatedCompletion: 2026-02-25T15:00:00Z",
-            TASKS_END,
-        ].join("\n");
-        const tasks = await parseTasksBlock(markdown);
-        expect(tasks).toHaveLength(1);
-        expect(tasks[0].id).toBe("TASK-0003");
-        expect(tasks[0].subState).toBeDefined();
-        expect(tasks[0].subState?.phase).toBe("implementation");
-        expect(tasks[0].subState?.confidence).toBe(0.85);
-        expect(tasks[0].subState?.estimatedCompletion).toBe("2026-02-25T15:00:00Z");
-    });
-    it("parses task with blocker metadata (Spec v1.1.0)", async () => {
-        const markdown = [
-            "# Tasks",
-            TASKS_START,
-            "## TASK-0004 | BLOCKED | waiting for api",
-            "- owner: charlie",
-            "- summary: Waiting for payment API v2.0",
-            "- updatedAt: 2026-02-20T00:00:00.000Z",
-            "- roadmapRefs: ROADMAP-0001",
-            "- links:",
-            "  - ./docs/api-waiting.md",
-            "- blocker:",
-            "  - type: external_dependency",
-            "  - description: Waiting for payment API v2.0",
-            "  - blockingEntity: third-party/payment-provider",
-            "  - unblockCondition: API v2.0 GA announced",
-            "  - escalationPath: contact-pm-for-workaround",
-            TASKS_END,
-        ].join("\n");
-        const tasks = await parseTasksBlock(markdown);
-        expect(tasks).toHaveLength(1);
-        expect(tasks[0].id).toBe("TASK-0004");
-        expect(tasks[0].blocker).toBeDefined();
-        expect(tasks[0].blocker?.type).toBe("external_dependency");
-        expect(tasks[0].blocker?.description).toBe("Waiting for payment API v2.0");
-        expect(tasks[0].blocker?.blockingEntity).toBe("third-party/payment-provider");
-        expect(tasks[0].blocker?.unblockCondition).toBe("API v2.0 GA announced");
-        expect(tasks[0].blocker?.escalationPath).toBe("contact-pm-for-workaround");
-    });
     it("validates task IDs", () => {
         expect(isValidTaskId("TASK-0001")).toBe(true);
         expect(isValidTaskId("TASK-001")).toBe(false);
@@ -130,125 +48,12 @@ describe("tasks module", () => {
         expect(ranked[1].task.id).toBe("TASK-0002");
         expect(ranked[2].task.id).toBe("TASK-0001");
     });
-    it("renders lint lines with stable code prefix", () => {
-        const task = normalizeTask({
-            id: "TASK-0001",
-            title: "lint",
-            status: "IN_PROGRESS",
-            owner: "",
-            roadmapRefs: [],
-        });
-        const lint = collectTaskLintSuggestions([task]);
-        expect(lint.some((line) => line.startsWith("- [TASK_IN_PROGRESS_OWNER_EMPTY]"))).toBe(true);
-        expect(lint.some((line) => line.startsWith("- [TASK_ROADMAP_REFS_EMPTY]"))).toBe(true);
-    });
-    it("scopes outside-marker lint to provided task IDs", () => {
-        const tasks = [
-            normalizeTask({ id: "TASK-0001", title: "A", status: "TODO", roadmapRefs: ["ROADMAP-0001"] }),
-            normalizeTask({ id: "TASK-0002", title: "B", status: "TODO", roadmapRefs: ["ROADMAP-0001"] }),
-        ];
-        const markdown = [
-            "# Tasks",
-            "TASK-0002 outside",
-            "TASK-0003 outside",
-            TASKS_START,
-            "## TASK-0001 | TODO | A",
-            "- owner: (none)",
-            "- summary: (none)",
-            "- updatedAt: 2026-02-18T00:00:00.000Z",
-            "- roadmapRefs: ROADMAP-0001",
-            "- links:",
-            "  - (none)",
-            "## TASK-0002 | TODO | B",
-            "- owner: (none)",
-            "- summary: (none)",
-            "- updatedAt: 2026-02-18T00:00:00.000Z",
-            "- roadmapRefs: ROADMAP-0001",
-            "- links:",
-            "  - (none)",
-            TASKS_END,
-        ].join("\n");
-        const scoped = collectTaskLintSuggestions(tasks, markdown, new Set(["TASK-0001"]));
-        const scopedOutside = scoped.find((line) => line.includes("TASK IDs found outside marker block"));
-        expect(scopedOutside).toBeUndefined();
-        const all = collectTaskLintSuggestions(tasks, markdown);
-        const allOutside = all.find((line) => line.includes("TASK IDs found outside marker block"));
-        expect(allOutside).toContain("TASK-0002");
-        expect(allOutside).toContain("TASK-0003");
-    });
-    it("renders seed task template with provided roadmap ref", () => {
-        const lines = renderTaskSeedTemplate("ROADMAP-0099");
-        const markdown = lines.join("\n");
-        expect(markdown).toContain("## TASK-0001 | TODO | Define initial executable objective");
-        expect(markdown).toContain("- roadmapRefs: ROADMAP-0099");
-        expect(markdown).toContain("- links:");
-        expect(markdown).not.toContain("- hooks:");
-    });
-    it("uses default no-task guidance when hook file is absent", async () => {
-        const guidance = await resolveNoTaskDiscoveryGuidance("/path/that/does/not/exist");
-        expect(guidance.length).toBeGreaterThan(3);
-        expect(guidance.some((line) => line.includes("TODO/FIXME/HACK"))).toBe(true);
-    });
-    it("uses hook checklist when task_no_actionable hook exists", async () => {
-        const dir = await fs.mkdtemp(path.join(os.tmpdir(), "projitive-mcp-test-"));
-        const hooksDir = path.join(dir, "hooks");
-        await fs.mkdir(hooksDir, { recursive: true });
-        await fs.writeFile(path.join(hooksDir, "task_no_actionable.md"), [
-            "Objective:",
-            "- custom-item-1",
-            "- custom-item-2",
-        ].join("\n"), "utf-8");
-        const guidance = await resolveNoTaskDiscoveryGuidance(dir);
-        expect(guidance).toContain("- custom-item-1");
-        expect(guidance).toContain("- custom-item-2");
-        await fs.rm(dir, { recursive: true, force: true });
-    });
-    // Additional tests for improved coverage
-    it("finds task IDs outside marker blocks", () => {
-        const markdown = [
-            "# Tasks",
-            "Reference to TASK-0001 outside",
-            "Another reference to TASK-0002",
-            TASKS_START,
-            "## TASK-0001 | TODO | A",
-            "- owner: (none)",
-            "- summary: (none)",
-            "- updatedAt: 2026-02-18T00:00:00.000Z",
-            "- roadmapRefs: ROADMAP-0001",
-            "- links:",
-            "  - (none)",
-            TASKS_END,
-            "Postscript with TASK-0003",
-        ].join("\n");
-        const ids = findTaskIdsOutsideMarkers(markdown);
-        expect(ids).toContain("TASK-0001");
-        expect(ids).toContain("TASK-0002");
-        expect(ids).toContain("TASK-0003");
-        expect(ids).toHaveLength(3);
-    });
-    it("normalizes task with optional fields", () => {
-        const task = normalizeTask({
-            id: "TASK-0001",
-            title: "Test Task",
-            status: "TODO",
-            subState: {
-                phase: "discovery",
-                confidence: 0.75,
-                estimatedCompletion: "2026-03-01T00:00:00Z"
-            },
-            blocker: {
-                type: "internal_dependency",
-                description: "Waiting for team review"
-            }
-        });
-        expect(task.id).toBe("TASK-0001");
-        expect(task.title).toBe("Test Task");
-        expect(task.status).toBe("TODO");
-        expect(task.subState).toBeDefined();
-        expect(task.subState?.phase).toBe("discovery");
-        expect(task.subState?.confidence).toBe(0.75);
-        expect(task.blocker).toBeDefined();
-        expect(task.blocker?.type).toBe("internal_dependency");
+    it("renders task markdown without legacy markers", () => {
+        const task = normalizeTask({ id: "TASK-0002", title: "render", status: "IN_PROGRESS" });
+        const markdown = renderTasksMarkdown([task]);
+        expect(markdown.includes("PROJITIVE:TASKS:START")).toBe(false);
+        expect(markdown.includes("PROJITIVE:TASKS:END")).toBe(false);
+        expect(markdown.includes("## TASK-0002 | IN_PROGRESS | render")).toBe(true);
     });
     it("renders tasks with subState and blocker metadata", () => {
         const task1 = normalizeTask({
@@ -257,8 +62,8 @@ describe("tasks module", () => {
             status: "IN_PROGRESS",
             subState: {
                 phase: "implementation",
-                confidence: 0.85
-            }
+                confidence: 0.85,
+            },
         });
         const task2 = normalizeTask({
             id: "TASK-0002",
@@ -266,8 +71,8 @@ describe("tasks module", () => {
             status: "BLOCKED",
             blocker: {
                 type: "external_dependency",
-                description: "Waiting for API"
-            }
+                description: "Waiting for API",
+            },
         });
         const markdown = renderTasksMarkdown([task1, task2]);
         expect(markdown).toContain("phase: implementation");
@@ -275,199 +80,90 @@ describe("tasks module", () => {
         expect(markdown).toContain("type: external_dependency");
         expect(markdown).toContain("description: Waiting for API");
     });
-    it("parses empty task block correctly", async () => {
-        const markdown = [
-            "# Tasks",
-            TASKS_START,
-            "(no tasks)",
-            TASKS_END,
-        ].join("\n");
-        const tasks = await parseTasksBlock(markdown);
-        expect(tasks).toHaveLength(0);
-    });
-    it("parses task block without markers returns empty", async () => {
-        const markdown = [
-            "# Tasks",
-            "## TASK-0001 | TODO | No Markers",
-            "- owner: alice",
-        ].join("\n");
-        const tasks = await parseTasksBlock(markdown);
-        expect(tasks).toHaveLength(0);
-    });
-    it("collects lint suggestions for duplicate IDs", () => {
-        const tasks = [
-            normalizeTask({ id: "TASK-0001", title: "A", status: "TODO", roadmapRefs: ["ROADMAP-0001"] }),
-            normalizeTask({ id: "TASK-0001", title: "B", status: "TODO", roadmapRefs: ["ROADMAP-0001"] }),
-        ];
-        const lint = collectTaskLintSuggestions(tasks);
-        expect(lint.some((line) => line.includes("Duplicate task IDs"))).toBe(true);
-    });
-    it("collects lint suggestions for DONE without links", () => {
-        const tasks = [
-            normalizeTask({ id: "TASK-0001", title: "Done Task", status: "DONE", roadmapRefs: ["ROADMAP-0001"], links: [] }),
-        ];
-        const lint = collectTaskLintSuggestions(tasks);
-        expect(lint.some((line) => line.includes("DONE task(s) have no links evidence"))).toBe(true);
-    });
-    it("collects lint suggestions for BLOCKED without summary", () => {
-        const tasks = [
-            normalizeTask({ id: "TASK-0001", title: "Blocked", status: "BLOCKED", summary: "", roadmapRefs: ["ROADMAP-0001"] }),
-        ];
-        const lint = collectTaskLintSuggestions(tasks);
-        expect(lint.some((line) => line.includes("BLOCKED task(s) have empty summary"))).toBe(true);
-    });
-    it("collects lint suggestions for invalid updatedAt", () => {
-        const tasks = [
-            normalizeTask({ id: "TASK-0001", title: "Invalid Date", status: "TODO", updatedAt: "not-a-date", roadmapRefs: ["ROADMAP-0001"] }),
-        ];
-        const lint = collectTaskLintSuggestions(tasks);
-        expect(lint.some((line) => line.includes("invalid updatedAt format"))).toBe(true);
-    });
-    it("collects lint suggestions for Spec v1.1.0 blocker validation", () => {
-        const tasks = [
-            normalizeTask({
-                id: "TASK-0001",
-                title: "Blocked Without Metadata",
-                status: "BLOCKED",
-                summary: "Blocked but no metadata",
-                roadmapRefs: ["ROADMAP-0001"]
-            }),
-        ];
-        const lint = collectTaskLintSuggestions(tasks);
-        expect(lint.some((line) => line.includes("BLOCKED task(s) have no blocker metadata"))).toBe(true);
-    });
-    it("collects lint suggestions for Spec v1.1.0 subState validation", () => {
-        const tasks = [
-            normalizeTask({
-                id: "TASK-0001",
-                title: "In Progress Without SubState",
-                status: "IN_PROGRESS",
-                owner: "ai-copilot",
-                roadmapRefs: ["ROADMAP-0001"]
-            }),
-        ];
-        const lint = collectTaskLintSuggestions(tasks);
-        expect(lint.some((line) => line.includes("IN_PROGRESS task(s) have no subState metadata"))).toBe(true);
-    });
-    it("validates all status transitions correctly", () => {
-        // TODO transitions
-        expect(validateTransition("TODO", "TODO")).toBe(true);
-        expect(validateTransition("TODO", "IN_PROGRESS")).toBe(true);
-        expect(validateTransition("TODO", "BLOCKED")).toBe(true);
-        expect(validateTransition("TODO", "DONE")).toBe(false);
-        // IN_PROGRESS transitions
-        expect(validateTransition("IN_PROGRESS", "IN_PROGRESS")).toBe(true);
-        expect(validateTransition("IN_PROGRESS", "BLOCKED")).toBe(true);
-        expect(validateTransition("IN_PROGRESS", "DONE")).toBe(true);
-        expect(validateTransition("IN_PROGRESS", "TODO")).toBe(false);
-        // BLOCKED transitions
-        expect(validateTransition("BLOCKED", "BLOCKED")).toBe(true);
-        expect(validateTransition("BLOCKED", "IN_PROGRESS")).toBe(true);
-        expect(validateTransition("BLOCKED", "TODO")).toBe(true);
-        expect(validateTransition("BLOCKED", "DONE")).toBe(false);
-        // DONE transitions
-        expect(validateTransition("DONE", "DONE")).toBe(true);
-        expect(validateTransition("DONE", "TODO")).toBe(false);
-        expect(validateTransition("DONE", "IN_PROGRESS")).toBe(false);
-        expect(validateTransition("DONE", "BLOCKED")).toBe(false);
-    });
-    it("ranks candidates with same project score by task priority", () => {
-        const candidates = [
-            buildCandidate({ id: "TASK-0001", title: "TODO Task", status: "TODO", projectScore: 2 }),
-            buildCandidate({ id: "TASK-0002", title: "IN_PROGRESS Task", status: "IN_PROGRESS", projectScore: 2 }),
-        ];
-        const ranked = rankActionableTaskCandidates(candidates);
-        expect(ranked[0].task.id).toBe("TASK-0002");
-        expect(ranked[1].task.id).toBe("TASK-0001");
+    it("collects lint lines with stable code prefix", () => {
+        const task = normalizeTask({
+            id: "TASK-0001",
+            title: "lint",
+            status: "IN_PROGRESS",
+            owner: "",
+            roadmapRefs: [],
+        });
+        const lint = collectTaskLintSuggestions([task]);
+        expect(lint.some((line) => line.startsWith("- [TASK_IN_PROGRESS_OWNER_EMPTY]"))).toBe(true);
+        expect(lint.some((line) => line.startsWith("- [TASK_ROADMAP_REFS_EMPTY]"))).toBe(true);
     });
-    it("ranks candidates with same project score and priority by recency", () => {
-        const older = buildCandidate({
+    it("collects blocker/substate lint rules", () => {
+        const blocked = normalizeTask({
             id: "TASK-0001",
-            title: "Older Task",
-            status: "TODO",
-            projectScore: 2,
-            taskUpdatedAtMs: toTaskUpdatedAtMs("2026-01-01T00:00:00.000Z")
+            title: "Blocked",
+            status: "BLOCKED",
+            summary: "blocked reason",
+            roadmapRefs: ["ROADMAP-0001"],
         });
-        const newer = buildCandidate({
+        const inProgress = normalizeTask({
             id: "TASK-0002",
-            title: "Newer Task",
+            title: "In Progress",
+            status: "IN_PROGRESS",
+            owner: "ai-copilot",
+            roadmapRefs: ["ROADMAP-0001"],
+        });
+        const lint = collectTaskLintSuggestions([blocked, inProgress]);
+        expect(lint.some((line) => line.includes("BLOCKED_WITHOUT_BLOCKER"))).toBe(true);
+        expect(lint.some((line) => line.includes("IN_PROGRESS_WITHOUT_SUBSTATE"))).toBe(true);
+    });
+    it("normalizes links to project-root-relative format without leading slash", () => {
+        const task = normalizeTask({
+            id: "TASK-0003",
+            title: "link normalize",
             status: "TODO",
-            projectScore: 2,
-            taskUpdatedAtMs: toTaskUpdatedAtMs("2026-02-01T00:00:00.000Z")
+            links: ["/reports/a.md", "./designs/b.md", "reports/c.md", "https://example.com/evidence"],
         });
-        const ranked = rankActionableTaskCandidates([older, newer]);
-        expect(ranked[0].task.id).toBe("TASK-0002");
-        expect(ranked[1].task.id).toBe("TASK-0001");
+        expect(task.links).toContain("reports/a.md");
+        expect(task.links).toContain("designs/b.md");
+        expect(task.links).toContain("reports/c.md");
+        expect(task.links).toContain("https://example.com/evidence");
+        expect(task.links.some((item) => item.startsWith("/"))).toBe(false);
     });
-    it("renders tasks without subState or blocker when not applicable", () => {
+    it("lints invalid links path format", () => {
         const task = normalizeTask({
-            id: "TASK-0001",
-            title: "Simple TODO Task",
-            status: "TODO"
+            id: "TASK-0004",
+            title: "invalid link",
+            status: "TODO",
+            links: ["../outside.md"],
+            roadmapRefs: ["ROADMAP-0001"],
         });
-        const markdown = renderTasksMarkdown([task]);
-        expect(markdown).not.toContain("subState:");
-        expect(markdown).not.toContain("blocker:");
+        const lint = collectTaskLintSuggestions([task]);
+        expect(lint.some((line) => line.includes("TASK_LINK_PATH_FORMAT_INVALID"))).toBe(true);
     });
-    it("parses task with invalid subState phase gracefully", async () => {
-        const markdown = [
-            "# Tasks",
-            TASKS_START,
-            "## TASK-0001 | IN_PROGRESS | Invalid Phase",
-            "- owner: test",
-            "- summary: test",
-            "- updatedAt: 2026-02-22T00:00:00.000Z",
-            "- roadmapRefs: ROADMAP-0001",
-            "- links:",
-            "  - (none)",
-            "- subState:",
-            "  - phase: invalid_phase",
-            TASKS_END,
-        ].join("\n");
-        const tasks = await parseTasksBlock(markdown);
-        expect(tasks).toHaveLength(1);
-        // Invalid phase should be ignored
-        expect(tasks[0].subState?.phase).toBeUndefined();
+    it("renders seed task template with provided roadmap ref", () => {
+        const lines = renderTaskSeedTemplate("ROADMAP-0099");
+        const markdown = lines.join("\n");
+        expect(markdown).toContain("- roadmapRefs: ROADMAP-0099");
     });
-    it("parses task with invalid confidence score gracefully", async () => {
-        const markdown = [
-            "# Tasks",
-            TASKS_START,
-            "## TASK-0001 | IN_PROGRESS | Invalid Confidence",
-            "- owner: test",
-            "- summary: test",
-            "- updatedAt: 2026-02-22T00:00:00.000Z",
-            "- roadmapRefs: ROADMAP-0001",
-            "- links:",
-            "  - (none)",
-            "- subState:",
-            "  - confidence: 2.5",
-            TASKS_END,
-        ].join("\n");
-        const tasks = await parseTasksBlock(markdown);
-        expect(tasks).toHaveLength(1);
-        // Invalid confidence should be ignored
-        expect(tasks[0].subState?.confidence).toBeUndefined();
+    it("uses default no-task guidance when hook file is absent", async () => {
+        const guidance = await resolveNoTaskDiscoveryGuidance("/path/that/does/not/exist");
+        expect(guidance.length).toBeGreaterThan(3);
     });
-    it("parses task with invalid blocker type gracefully", async () => {
-        const markdown = [
-            "# Tasks",
-            TASKS_START,
-            "## TASK-0001 | BLOCKED | Invalid Blocker Type",
-            "- owner: test",
-            "- summary: test",
-            "- updatedAt: 2026-02-22T00:00:00.000Z",
-            "- roadmapRefs: ROADMAP-0001",
-            "- links:",
-            "  - (none)",
-            "- blocker:",
-            "  - type: invalid_type",
-            "  - description: test",
-            TASKS_END,
-        ].join("\n");
-        const tasks = await parseTasksBlock(markdown);
-        expect(tasks).toHaveLength(1);
-        // Invalid blocker type should use default
-        expect(tasks[0].blocker?.type).toBe("external_dependency");
+    it("returns same default no-task guidance regardless of path", async () => {
+        const guidanceA = await resolveNoTaskDiscoveryGuidance("/path/that/does/not/exist");
+        const guidanceB = await resolveNoTaskDiscoveryGuidance("/another/path");
+        expect(guidanceA).toEqual(guidanceB);
+    });
+    it("loads and saves tasks from sqlite and keeps newest-first order", async () => {
+        const root = await fs.mkdtemp(path.join(os.tmpdir(), "projitive-mcp-task-"));
+        const governanceDir = path.join(root, ".projitive");
+        await fs.mkdir(governanceDir, { recursive: true });
+        await fs.writeFile(path.join(governanceDir, ".projitive"), "", "utf-8");
+        const tasksPath = path.join(governanceDir, ".projitive");
+        await saveTasks(tasksPath, [
+            normalizeTask({ id: "TASK-0001", title: "older", status: "TODO", updatedAt: "2026-01-01T00:00:00.000Z" }),
+            normalizeTask({ id: "TASK-0002", title: "newer", status: "TODO", updatedAt: "2026-02-01T00:00:00.000Z" }),
+        ]);
+        const loaded = await loadTasksDocument(governanceDir);
+        expect(loaded.tasks[0].id).toBe("TASK-0002");
+        expect(loaded.tasks[1].id).toBe("TASK-0001");
+        const markdown = await fs.readFile(path.join(governanceDir, "tasks.md"), "utf-8");
+        expect(markdown).toContain("generated from .projitive sqlite tables");
+        await fs.rm(root, { recursive: true, force: true });
     });
 });

package/output/source/types.js

@@ -26,12 +26,6 @@ export const BLOCKER_TYPES = [
     "resource",
     "approval"
 ];
-// ============================================================================
-// Parser Constants
-// ============================================================================
-export const TASKS_START = "<!-- PROJITIVE:TASKS:START -->";
-export const TASKS_END = "<!-- PROJITIVE:TASKS:END -->";
-export const TASK_ID_REGEX = /^TASK-\d{4}$/;
 export const TASK_LINT_CODES = {
     DUPLICATE_ID: "TASK_DUPLICATE_ID",
     IN_PROGRESS_OWNER_EMPTY: "TASK_IN_PROGRESS_OWNER_EMPTY",
@@ -42,9 +36,7 @@ export const TASK_LINT_CODES = {
     OUTSIDE_MARKER: "TASK_OUTSIDE_MARKER",
     FILTER_EMPTY: "TASK_FILTER_EMPTY",
     LINK_TARGET_MISSING: "TASK_LINK_TARGET_MISSING",
-    HOOK_FILE_MISSING: "TASK_HOOK_FILE_MISSING",
-    CONTEXT_HOOK_HEAD_MISSING: "TASK_CONTEXT_HOOK_HEAD_MISSING",
-    CONTEXT_HOOK_FOOTER_MISSING: "TASK_CONTEXT_HOOK_FOOTER_MISSING",
+    LINK_PATH_FORMAT_INVALID: "TASK_LINK_PATH_FORMAT_INVALID",
     // Spec v1.1.0 - Blocker Categorization
     BLOCKED_WITHOUT_BLOCKER: "TASK_BLOCKED_WITHOUT_BLOCKER",
     BLOCKER_TYPE_INVALID: "TASK_BLOCKER_TYPE_INVALID",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@projitive/mcp",
-  "version": "1.2.0",
+  "version": "2.0.1",
   "description": "Projitive MCP Server for project and task discovery/update",
   "license": "ISC",
   "author": "",
@@ -25,11 +25,14 @@
     "output"
   ],
   "dependencies": {
+    "@duckdb/node-api": "1.5.0-r.1",
     "@modelcontextprotocol/sdk": "^1.17.5",
+    "sql.js": "^1.14.1",
     "zod": "^3.23.8"
   },
   "devDependencies": {
     "@types/node": "^24.3.0",
+    "@types/sql.js": "^1.4.9",
     "@vitest/coverage-v8": "^3.2.4",
     "tsx": "^4.20.5",
     "typescript": "^5.9.2",