@projitive/mcp 1.0.2 → 1.0.3

package/output/source/tasks.test.js

@@ -0,0 +1,152 @@
+import { describe, expect, it } from "vitest";
+import { TASKS_END, TASKS_START, collectTaskLintSuggestions, isValidTaskId, normalizeTask, parseTasksBlock, rankActionableTaskCandidates, resolveNoTaskDiscoveryGuidance, renderTaskSeedTemplate, renderTasksMarkdown, taskPriority, toTaskUpdatedAtMs, validateTransition, } from "./tasks.js";
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+function buildCandidate(partial) {
+    const task = normalizeTask({
+        id: partial.id,
+        title: partial.title,
+        status: partial.status,
+        updatedAt: partial.task?.updatedAt ?? "2026-01-01T00:00:00.000Z",
+    });
+    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",
+        taskUpdatedAtMs: partial.taskUpdatedAtMs ?? toTaskUpdatedAtMs(task.updatedAt),
+        taskPriority: partial.taskPriority ?? taskPriority(task.status),
+    };
+}
+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("validates task IDs", () => {
+        expect(isValidTaskId("TASK-0001")).toBe(true);
+        expect(isValidTaskId("TASK-001")).toBe(false);
+    });
+    it("allows and rejects expected transitions", () => {
+        expect(validateTransition("TODO", "IN_PROGRESS")).toBe(true);
+        expect(validateTransition("IN_PROGRESS", "DONE")).toBe(true);
+        expect(validateTransition("DONE", "IN_PROGRESS")).toBe(false);
+    });
+    it("assigns priority for actionable statuses", () => {
+        expect(taskPriority("IN_PROGRESS")).toBe(2);
+        expect(taskPriority("TODO")).toBe(1);
+        expect(taskPriority("BLOCKED")).toBe(0);
+    });
+    it("returns zero timestamp for invalid date", () => {
+        expect(toTaskUpdatedAtMs("invalid")).toBe(0);
+    });
+    it("ranks by project score, then task priority, then recency", () => {
+        const candidates = [
+            buildCandidate({ id: "TASK-0001", title: "A", status: "TODO", projectScore: 2 }),
+            buildCandidate({ id: "TASK-0002", title: "B", status: "IN_PROGRESS", projectScore: 2 }),
+            buildCandidate({ id: "TASK-0003", title: "C", status: "IN_PROGRESS", projectScore: 3 }),
+        ];
+        const ranked = rankActionableTaskCandidates(candidates);
+        expect(ranked[0].task.id).toBe("TASK-0003");
+        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 });
+    });
+});

package/output/tasks.js

@@ -48,11 +48,34 @@ async function readOptionalMarkdown(filePath) {
     const trimmed = content.trim();
     return trimmed.length > 0 ? trimmed : undefined;
 }
-async function readTaskContextHooks(governanceDir) {
-    const headPath = path.join(governanceDir, "hooks", "task_get_head.md");
-    const footerPath = path.join(governanceDir, "hooks", "task_get_footer.md");
-    const [head, footer] = await Promise.all([readOptionalMarkdown(headPath), readOptionalMarkdown(footerPath)]);
-    return { head, footer, headPath, footerPath };
+const NO_TASK_DISCOVERY_HOOK_FILE = "task_no_actionable.md";
+const DEFAULT_NO_TASK_DISCOVERY_GUIDANCE = [
+    "- Check whether current code violates project guide/spec conventions; create TODO tasks for each actionable gap.",
+    "- Check unit/integration test coverage and identify high-value missing tests; create TODO tasks for meaningful coverage improvements.",
+    "- Check development/testing workflow for bottlenecks (slow feedback, fragile scripts, unclear runbooks); create TODO tasks to improve reliability.",
+    "- Scan for TODO/FIXME/HACK comments and convert feasible items into governed TODO tasks with evidence links.",
+    "- Check dependency freshness and security advisories; create tasks for safe upgrades when needed.",
+    "- Check repeated manual operations that can be automated (lint/test/release checks); create tasks to reduce operational toil.",
+];
+function parseHookChecklist(markdown) {
+    return markdown
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter((line) => line.length > 0)
+        .filter((line) => /^[-*+]\s+/.test(line))
+        .map((line) => (line.startsWith("*") ? `-${line.slice(1)}` : line));
+}
+export async function resolveNoTaskDiscoveryGuidance(governanceDir) {
+    if (!governanceDir) {
+        return DEFAULT_NO_TASK_DISCOVERY_GUIDANCE;
+    }
+    const hookPath = path.join(governanceDir, "hooks", NO_TASK_DISCOVERY_HOOK_FILE);
+    const markdown = await readOptionalMarkdown(hookPath);
+    if (typeof markdown !== "string") {
+        return DEFAULT_NO_TASK_DISCOVERY_GUIDANCE;
+    }
+    const checklist = parseHookChecklist(markdown);
+    return checklist.length > 0 ? checklist : DEFAULT_NO_TASK_DISCOVERY_GUIDANCE;
 }
 function latestTaskUpdatedAt(tasks) {
     const timestamps = tasks
@@ -67,6 +90,31 @@ function actionableScore(tasks) {
     return tasks.filter((task) => task.status === "IN_PROGRESS").length * 2
         + tasks.filter((task) => task.status === "TODO").length;
 }
+async function readRoadmapIds(governanceDir) {
+    const roadmapPath = path.join(governanceDir, "roadmap.md");
+    try {
+        const markdown = await fs.readFile(roadmapPath, "utf-8");
+        const matches = markdown.match(/ROADMAP-\d{4}/g) ?? [];
+        return Array.from(new Set(matches));
+    }
+    catch {
+        return [];
+    }
+}
+export function renderTaskSeedTemplate(roadmapRef) {
+    return [
+        "```markdown",
+        "## TASK-0001 | TODO | Define initial executable objective",
+        "- owner: ai-copilot",
+        "- summary: Convert one roadmap milestone or report gap into an actionable task.",
+        "- updatedAt: 2026-01-01T00:00:00.000Z",
+        `- roadmapRefs: ${roadmapRef}`,
+        "- links:",
+        "  - ./README.md",
+        "  - ./roadmap.md",
+        "```",
+    ];
+}
 async function readActionableTaskCandidates(governanceDirs) {
     const snapshots = await Promise.all(governanceDirs.map(async (governanceDir) => {
         const snapshot = await loadTasks(governanceDir);
@@ -130,14 +178,6 @@ export function normalizeTask(task) {
     const normalizedRoadmapRefs = Array.isArray(task.roadmapRefs)
         ? task.roadmapRefs.map(String).filter((value) => isValidRoadmapId(value))
         : [];
-    const inputHooks = task.hooks ?? {};
-    const normalizedHooks = {};
-    for (const key of ["onAssigned", "onCompleted", "onBlocked", "onReopened"]) {
-        const value = inputHooks[key];
-        if (typeof value === "string" && value.trim().length > 0) {
-            normalizedHooks[key] = value;
-        }
-    }
     return {
         id: String(task.id),
         title: String(task.title),
@@ -147,7 +187,6 @@ export function normalizeTask(task) {
         updatedAt: task.updatedAt ? String(task.updatedAt) : nowIso(),
         links: Array.isArray(task.links) ? task.links.map(String) : [],
         roadmapRefs: Array.from(new Set(normalizedRoadmapRefs)),
-        hooks: normalizedHooks,
     };
 }
 export async function parseTasksBlock(markdown) {
@@ -182,7 +221,6 @@ export async function parseTasksBlock(markdown) {
             updatedAt: nowIso(),
             links: [],
             roadmapRefs: [],
-            hooks: {},
         };
         let inLinks = false;
         let inHooks = false;
@@ -245,14 +283,7 @@ export async function parseTasksBlock(markdown) {
                 continue;
             }
             if (inHooks) {
-                const hookMatch = nestedValue.match(/^(onAssigned|onCompleted|onBlocked|onReopened):\s+(.+)$/);
-                if (hookMatch) {
-                    const [, hookKey, hookPath] = hookMatch;
-                    taskDraft.hooks = {
-                        ...(taskDraft.hooks ?? {}),
-                        [hookKey]: hookPath.trim(),
-                    };
-                }
+                continue;
             }
         }
         tasks.push(normalizeTask(taskDraft));
@@ -399,18 +430,6 @@ async function collectTaskFileLintSuggestions(governanceDir, task) {
             });
         }
     }
-    const hookEntries = Object.entries(task.hooks)
-        .filter(([, value]) => typeof value === "string" && value.trim().length > 0);
-    for (const [hookKey, hookPath] of hookEntries) {
-        const resolvedPath = path.resolve(governanceDir, hookPath);
-        const exists = await fs.access(resolvedPath).then(() => true).catch(() => false);
-        if (!exists) {
-            suggestions.push({
-                code: TASK_LINT_CODES.HOOK_FILE_MISSING,
-                message: `Hook file not found for ${hookKey}: ${hookPath} (resolved: ${resolvedPath}).`,
-            });
-        }
-    }
     return renderLintSuggestions(suggestions);
 }
 export function renderTasksMarkdown(tasks) {
@@ -419,12 +438,6 @@ export function renderTasksMarkdown(tasks) {
         const links = task.links.length > 0
             ? ["- links:", ...task.links.map((link) => `  - ${link}`)]
             : ["- links:", "  - (none)"];
-        const hookEntries = Object.entries(task.hooks)
-            .filter(([, value]) => typeof value === "string" && value.trim().length > 0)
-            .map(([key, value]) => `  - ${key}: ${value}`);
-        const hooks = hookEntries.length > 0
-            ? ["- hooks:", ...hookEntries]
-            : ["- hooks:", "  - (none)"];
         return [
             `## ${task.id} | ${task.status} | ${task.title}`,
             `- owner: ${task.owner || "(none)"}`,
@@ -432,7 +445,6 @@ export function renderTasksMarkdown(tasks) {
             `- updatedAt: ${task.updatedAt}`,
             `- roadmapRefs: ${roadmapRefs}`,
             ...links,
-            ...hooks,
         ].join("\n");
     });
     return [
@@ -543,6 +555,27 @@ export function registerTaskTools(server) {
         const projects = await discoverProjects(root, depth);
         const rankedCandidates = rankActionableTaskCandidates(await readActionableTaskCandidates(projects));
         if (rankedCandidates.length === 0) {
+            const projectSnapshots = await Promise.all(projects.map(async (governanceDir) => {
+                const { tasksPath, tasks } = await loadTasks(governanceDir);
+                const roadmapIds = await readRoadmapIds(governanceDir);
+                const todo = tasks.filter((task) => task.status === "TODO").length;
+                const inProgress = tasks.filter((task) => task.status === "IN_PROGRESS").length;
+                const blocked = tasks.filter((task) => task.status === "BLOCKED").length;
+                const done = tasks.filter((task) => task.status === "DONE").length;
+                return {
+                    governanceDir,
+                    tasksPath,
+                    roadmapIds,
+                    total: tasks.length,
+                    todo,
+                    inProgress,
+                    blocked,
+                    done,
+                };
+            }));
+            const preferredProject = projectSnapshots[0];
+            const preferredRoadmapRef = preferredProject?.roadmapIds[0] ?? "ROADMAP-0001";
+            const noTaskDiscoveryGuidance = await resolveNoTaskDiscoveryGuidance(preferredProject?.governanceDir);
             const markdown = renderToolResponseMarkdown({
                 toolName: "taskNext",
                 sections: [
@@ -552,13 +585,33 @@ export function registerTaskTools(server) {
                         `- matchedProjects: ${projects.length}`,
                         "- actionableTasks: 0",
                     ]),
-                    evidenceSection(["- candidates:", "- (none)"]),
+                    evidenceSection([
+                        "### Project Snapshots",
+                        ...(projectSnapshots.length > 0
+                            ? projectSnapshots.map((item, index) => `${index + 1}. ${item.governanceDir} | total=${item.total} | todo=${item.todo} | in_progress=${item.inProgress} | blocked=${item.blocked} | done=${item.done} | roadmapIds=${item.roadmapIds.join(", ") || "(none)"} | tasksPath=${item.tasksPath}`)
+                            : ["- (none)"]),
+                        "",
+                        "### Seed Task Template",
+                        ...renderTaskSeedTemplate(preferredRoadmapRef),
+                    ]),
                     guidanceSection([
                         "- No TODO/IN_PROGRESS task is available.",
-                        "- Create or reopen tasks in tasks.md, then rerun `taskNext`.",
+                        "- Use no-task discovery checklist below to proactively find and create meaningful TODO tasks.",
+                        "",
+                        "### No-Task Discovery Checklist",
+                        ...noTaskDiscoveryGuidance,
+                        "",
+                        "- If no tasks exist, derive 1-3 TODO tasks from roadmap milestones, README scope, or unresolved report gaps.",
+                        "- If only BLOCKED/DONE tasks exist, reopen one blocked item or create a follow-up TODO task.",
+                        "- After adding tasks inside marker block, rerun `taskNext` to re-rank actionable work.",
+                    ]),
+                    lintSection([
+                        "- No actionable tasks found. Verify task statuses and required fields in marker block.",
+                        "- Ensure each new task has stable TASK-xxxx ID and at least one roadmapRefs item.",
                     ]),
-                    lintSection(["- No actionable tasks found. Verify task statuses and required fields in marker block."]),
-                    nextCallSection(`projectNext(rootPath=\"${root}\", maxDepth=${depth})`),
+                    nextCallSection(preferredProject
+                        ? `projectContext(projectPath=\"${preferredProject.governanceDir}\")`
+                        : `projectScan(rootPath=\"${root}\", maxDepth=${depth})`),
                 ],
             });
             return asText(markdown);
@@ -641,7 +694,6 @@ export function registerTaskTools(server) {
         }
         const governanceDir = await resolveGovernanceDir(projectPath);
         const { tasksPath, tasks, markdown: tasksMarkdown } = await loadTasksDocument(governanceDir);
-        const taskContextHooks = await readTaskContextHooks(governanceDir);
         const task = tasks.find((item) => item.id === taskId);
         if (!task) {
             return {
@@ -669,28 +721,6 @@ export function registerTaskTools(server) {
         const referenceLocations = (await Promise.all(fileCandidates.map((file) => findTextReferences(file, taskId)))).flat();
         const relatedArtifacts = Array.from(new Set(referenceLocations.map((item) => item.filePath)));
         const suggestedReadOrder = [tasksPath, ...relatedArtifacts.filter((item) => item !== tasksPath)];
-        const hookPaths = Object.values(task.hooks)
-            .filter((value) => typeof value === "string" && value.trim().length > 0)
-            .map((value) => path.resolve(governanceDir, value));
-        const hookStatus = `head=${taskContextHooks.head ? "loaded" : "missing"}, footer=${taskContextHooks.footer ? "loaded" : "missing"}`;
-        if (!taskContextHooks.head) {
-            appendLintSuggestions(lintSuggestions, [
-                {
-                    code: TASK_LINT_CODES.CONTEXT_HOOK_HEAD_MISSING,
-                    message: `Missing ${taskContextHooks.headPath}.`,
-                    fixHint: "Add a task context head hook template if you need standardized preface.",
-                },
-            ]);
-        }
-        if (!taskContextHooks.footer) {
-            appendLintSuggestions(lintSuggestions, [
-                {
-                    code: TASK_LINT_CODES.CONTEXT_HOOK_FOOTER_MISSING,
-                    message: `Missing ${taskContextHooks.footerPath}.`,
-                    fixHint: "Add a task context footer hook template for standardized close-out checks.",
-                },
-            ]);
-        }
         const coreMarkdown = renderToolResponseMarkdown({
             toolName: "taskContext",
             sections: [
@@ -703,7 +733,6 @@ export function registerTaskTools(server) {
                     `- updatedAt: ${task.updatedAt}`,
                     `- roadmapRefs: ${task.roadmapRefs.join(", ") || "(none)"}`,
                     `- taskLocation: ${taskLocation ? `${taskLocation.filePath}#L${taskLocation.line}` : tasksPath}`,
-                    `- hookStatus: ${hookStatus}`,
                 ]),
                 evidenceSection([
                     "### Related Artifacts",
@@ -714,9 +743,6 @@ export function registerTaskTools(server) {
                         ? referenceLocations.map((item) => `- ${item.filePath}#L${item.line}: ${item.text}`)
                         : ["- (none)"]),
                     "",
-                    "### Hook Paths",
-                    ...(hookPaths.length > 0 ? hookPaths.map((item) => `- ${item}`) : ["- (none)"]),
-                    "",
                     "### Suggested Read Order",
                     ...suggestedReadOrder.map((item, index) => `${index + 1}. ${item}`),
                 ]),
@@ -731,12 +757,6 @@ export function registerTaskTools(server) {
                 nextCallSection(`taskContext(projectPath=\"${governanceDir}\", taskId=\"${task.id}\")`),
             ],
         });
-        const markdownParts = [
-            taskContextHooks.head,
-            coreMarkdown,
-            taskContextHooks.footer,
-        ].filter((value) => typeof value === "string" && value.trim().length > 0);
-        const markdown = markdownParts.join("\n\n---\n\n");
-        return asText(markdown);
+        return asText(coreMarkdown);
     });
 }

package/output/tasks.test.js

@@ -1,5 +1,8 @@
 import { describe, expect, it } from "vitest";
-import { TASKS_END, TASKS_START, collectTaskLintSuggestions, isValidTaskId, normalizeTask, parseTasksBlock, rankActionableTaskCandidates, renderTasksMarkdown, taskPriority, toTaskUpdatedAtMs, validateTransition, } from "./tasks.js";
+import { TASKS_END, TASKS_START, collectTaskLintSuggestions, isValidTaskId, normalizeTask, parseTasksBlock, rankActionableTaskCandidates, resolveNoTaskDiscoveryGuidance, renderTaskSeedTemplate, renderTasksMarkdown, taskPriority, toTaskUpdatedAtMs, validateTransition, } from "./tasks.js";
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
 function buildCandidate(partial) {
     const task = normalizeTask({
         id: partial.id,
@@ -29,8 +32,6 @@ describe("tasks module", () => {
             "- roadmapRefs: ROADMAP-0001",
             "- links:",
             "  - ./designs/example.md",
-            "- hooks:",
-            "  - onAssigned: ./hooks/on_task_assigned.md",
             TASKS_END,
         ].join("\n");
         const tasks = await parseTasksBlock(markdown);
@@ -38,7 +39,7 @@ describe("tasks module", () => {
         expect(tasks[0].id).toBe("TASK-0001");
         expect(tasks[0].status).toBe("TODO");
         expect(tasks[0].roadmapRefs).toEqual(["ROADMAP-0001"]);
-        expect(tasks[0].hooks).toEqual({ onAssigned: "./hooks/on_task_assigned.md" });
+        expect(tasks[0].links).toEqual(["./designs/example.md"]);
     });
     it("renders markdown containing markers", () => {
         const task = normalizeTask({ id: "TASK-0002", title: "render", status: "IN_PROGRESS" });
@@ -104,8 +105,6 @@ describe("tasks module", () => {
             "- roadmapRefs: ROADMAP-0001",
             "- links:",
             "  - (none)",
-            "- hooks:",
-            "  - (none)",
             "## TASK-0002 | TODO | B",
             "- owner: (none)",
             "- summary: (none)",
@@ -113,8 +112,6 @@ describe("tasks module", () => {
             "- roadmapRefs: ROADMAP-0001",
             "- links:",
             "  - (none)",
-            "- hooks:",
-            "  - (none)",
             TASKS_END,
         ].join("\n");
         const scoped = collectTaskLintSuggestions(tasks, markdown, new Set(["TASK-0001"]));
@@ -125,4 +122,31 @@ describe("tasks module", () => {
         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 });
+    });
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@projitive/mcp",
-  "version": "1.0.2",
+  "version": "1.0.3",
   "description": "Projitive MCP Server for project and task discovery/update",
   "license": "ISC",
   "author": "",