@projitive/mcp 1.0.7 → 1.1.1

package/output/source/index.js

@@ -1,17 +1,15 @@
 #!/usr/bin/env node
-import fs from "node:fs/promises";
 import path from "node:path";
 import process from "node:process";
 import { fileURLToPath } from "node:url";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { z } from "zod";
 import packageJson from "../package.json" with { type: "json" };
-import { registerProjectTools } from "./projitive.js";
-import { registerTaskTools } from "./tasks.js";
-import { registerRoadmapTools } from "./roadmap.js";
+import { registerTools } from "./tools/index.js";
+import { registerResources } from "./resources/index.js";
+import { registerPrompts } from "./prompts/index.js";
 import { registerDesignContextResources, registerDesignContextPrompts } from "./design-context.js";
-const PROJITIVE_SPEC_VERSION = "1.0.0";
+const PROJITIVE_SPEC_VERSION = "1.1.0";
 const currentFilePath = fileURLToPath(import.meta.url);
 const sourceDir = path.dirname(currentFilePath);
 const repoRoot = path.resolve(sourceDir, "..", "..", "..");
@@ -23,193 +21,10 @@ const server = new McpServer({
     version: MCP_RUNTIME_VERSION,
     description: "Semantic Projitive MCP for project/task discovery and agent guidance with markdown-first outputs",
 });
-function resolveRepoFile(relativePath) {
-    return path.join(repoRoot, relativePath);
-}
-async function readMarkdownOrFallback(relativePath, fallbackTitle) {
-    const absolutePath = resolveRepoFile(relativePath);
-    const content = await fs.readFile(absolutePath, "utf-8").catch(() => undefined);
-    if (typeof content === "string" && content.trim().length > 0) {
-        return content;
-    }
-    return [
-        `# ${fallbackTitle}`,
-        "",
-        `- file: ${relativePath}`,
-        "- status: missing-or-empty",
-        "- next: create this file or ensure it has readable markdown content",
-    ].join("\n");
-}
-function renderMethodCatalogMarkdown() {
-    return [
-        "# MCP Method Catalog",
-        "",
-        "## Start Here",
-        "- Unknown project path: `projectScan` -> `projectLocate` -> `projectContext` -> `taskNext`.",
-        "- Known project path: `projectContext` -> `taskNext` (or `taskList`) -> `taskContext`.",
-        "- Need to bootstrap governance: call `projectInit(projectPath=\"<project-dir>\")` only when `.projitive` is missing.",
-        "",
-        "## Methods",
-        "| Order | Group | Method | Agent Use |",
-        "|---|---|---|---|",
-        "| 1 | Project | projectScan | discover governance roots when project is unknown |",
-        "| 2 | Project | projectLocate | lock nearest governance root from any path |",
-        "| 3 | Project | projectContext | load project summary before task decisions |",
-        "| 4 | Task | taskNext | auto-pick highest-priority actionable task |",
-        "| 5 | Task | taskList | list/filter tasks for manual selection |",
-        "| 6 | Task | taskContext | inspect one task with evidence and read order |",
-        "| 7 | Roadmap | roadmapList | inspect roadmap-task linkage |",
-        "| 8 | Roadmap | roadmapContext | inspect one roadmap with references |",
-        "| 9 | Project | projectNext | rank actionable projects across workspace |",
-        "| 10 | Project | projectInit | bootstrap governance files if missing |"
-    ].join("\n");
-}
-function registerGovernanceResources() {
-    server.registerResource("governanceWorkspace", "projitive://governance/workspace", {
-        title: "Governance Workspace",
-        description: "Primary governance README under .projitive",
-        mimeType: "text/markdown",
-    }, async () => ({
-        contents: [
-            {
-                uri: "projitive://governance/workspace",
-                text: await readMarkdownOrFallback(".projitive/README.md", "Governance Workspace"),
-            },
-        ],
-    }));
-    server.registerResource("governanceTasks", "projitive://governance/tasks", {
-        title: "Governance Tasks",
-        description: "Current task pool and status under .projitive/tasks.md",
-        mimeType: "text/markdown",
-    }, async () => ({
-        contents: [
-            {
-                uri: "projitive://governance/tasks",
-                text: await readMarkdownOrFallback(".projitive/tasks.md", "Governance Tasks"),
-            },
-        ],
-    }));
-    server.registerResource("governanceRoadmap", "projitive://governance/roadmap", {
-        title: "Governance Roadmap",
-        description: "Current roadmap under .projitive/roadmap.md",
-        mimeType: "text/markdown",
-    }, async () => ({
-        contents: [
-            {
-                uri: "projitive://governance/roadmap",
-                text: await readMarkdownOrFallback(".projitive/roadmap.md", "Governance Roadmap"),
-            },
-        ],
-    }));
-    server.registerResource("mcpMethodCatalog", "projitive://mcp/method-catalog", {
-        title: "MCP Method Catalog",
-        description: "Method naming and purpose map for agent routing",
-        mimeType: "text/markdown",
-    }, async () => ({
-        contents: [
-            {
-                uri: "projitive://mcp/method-catalog",
-                text: renderMethodCatalogMarkdown(),
-            },
-        ],
-    }));
-}
-function asUserPrompt(text) {
-    return {
-        messages: [
-            {
-                role: "user",
-                content: {
-                    type: "text",
-                    text,
-                },
-            },
-        ],
-    };
-}
-function registerGovernancePrompts() {
-    server.registerPrompt("executeTaskWorkflow", {
-        title: "Execute Task Workflow",
-        description: "Primary execution prompt: select one task, execute, and verify evidence consistency",
-        argsSchema: {
-            projectPath: z.string().optional(),
-            taskId: z.string().optional(),
-        },
-    }, async ({ projectPath, taskId }) => {
-        const taskEntry = taskId && projectPath
-            ? `1) Run taskContext(projectPath=\"${projectPath}\", taskId=\"${taskId}\").`
-            : "1) Run taskNext().";
-        const text = [
-            "You are executing Projitive governance workflow in agent-first mode.",
-            "",
-            "Fast path:",
-            taskEntry,
-            "2) Follow Suggested Read Order and identify execution blockers.",
-            "3) Edit governance markdown only (tasks/designs/reports/roadmap).",
-            "4) Re-run taskContext for the selected task and verify references.",
-            "",
-            "Fallbacks:",
-            "- If `.projitive` is missing for a known project, run `projectInit(projectPath=\"<project-dir>\")` first.",
-            "- If taskNext returns no actionable task, follow its no-task checklist and create 1-3 TODO tasks.",
-            "- If project is unknown, run projectScan -> projectLocate -> projectContext before task tools.",
-            "",
-            "Hard rules:",
-            "- Keep TASK/ROADMAP IDs immutable.",
-            "- Every status transition must have report evidence.",
-            "- Do not introduce non-governance file edits unless task scope requires.",
-        ].join("\n");
-        return asUserPrompt(text);
-    });
-    server.registerPrompt("updateTaskStatusWithEvidence", {
-        title: "Update Task Status With Evidence",
-        description: "Safe status transition playbook with mandatory evidence backfill",
-        argsSchema: {
-            projectPath: z.string(),
-            taskId: z.string(),
-            targetStatus: z.enum(["TODO", "IN_PROGRESS", "BLOCKED", "DONE"]),
-        },
-    }, async ({ projectPath, taskId, targetStatus }) => {
-        const text = [
-            "Perform a safe task status update with evidence alignment.",
-            "",
-            `1) Run taskContext(projectPath=\"${projectPath}\", taskId=\"${taskId}\").`,
-            `2) Confirm transition to ${targetStatus} is valid.`,
-            "3) Update tasks.md status and updatedAt.",
-            "4) Add or update a report under reports/ with concrete evidence.",
-            "5) Re-run taskContext and confirm status/evidence/reference consistency.",
-            "6) If lint remains, fix and re-run taskContext once more.",
-            "",
-            "Checklist:",
-            "- Transition is valid per status machine.",
-            "- links/roadmapRefs remain parseable and consistent.",
-            "- Only `hooks/task_no_actionable.md` is used as global background hook for no-task discovery.",
-        ].join("\n");
-        return asUserPrompt(text);
-    });
-    server.registerPrompt("triageProjectGovernance", {
-        title: "Triage Project Governance",
-        description: "Discovery-first triage prompt to pick project and next executable task",
-        argsSchema: {},
-    }, async () => {
-        const text = [
-            "Triage governance and pick one execution target quickly.",
-            "",
-            "0) If known project has no `.projitive`, run projectInit(projectPath=<project-dir>) first.",
-            "1) If project path is unknown, run projectScan() and pick one discovered project.",
-            "2) Run projectNext() to rank projects.",
-            "3) Run projectContext(projectPath=<selectedProject>).",
-            "4) Run taskNext() for best actionable task.",
-            "5) If manual filtering is needed, run taskList(projectPath=<selectedProject>, status=IN_PROGRESS).",
-            "6) Continue with taskContext(projectPath=<selectedProject>, taskId=<selectedTaskId>).",
-        ].join("\n");
-        return asUserPrompt(text);
-    });
-}
-registerProjectTools(server);
-registerTaskTools(server);
-registerRoadmapTools(server);
-registerGovernanceResources();
-registerGovernancePrompts();
+// Register all modules
+registerTools(server);
+registerResources(server, repoRoot);
+registerPrompts(server);
 registerDesignContextResources(server);
 registerDesignContextPrompts(server);
 async function main() {

package/output/source/index.test.js

@@ -0,0 +1,116 @@
+import { describe, it, expect, beforeAll, afterAll, vi, beforeEach } from "vitest";
+import fs from "node:fs/promises";
+import path from "node:path";
+import os from "node:os";
+import { fileURLToPath } from "node:url";
+const currentFilePath = fileURLToPath(import.meta.url);
+const sourceDir = path.dirname(currentFilePath);
+// Mock McpServer and StdioServerTransport
+vi.mock("@modelcontextprotocol/sdk/server/mcp.js", () => ({
+    McpServer: vi.fn().mockImplementation(() => ({
+        registerResource: vi.fn(),
+        registerPrompt: vi.fn(),
+        connect: vi.fn().mockResolvedValue(undefined),
+    })),
+}));
+vi.mock("@modelcontextprotocol/sdk/server/stdio.js", () => ({
+    StdioServerTransport: vi.fn().mockImplementation(() => ({})),
+}));
+// Mock the registration functions
+vi.mock("./tools/project.js", () => ({
+    registerProjectTools: vi.fn(),
+}));
+vi.mock("./tools/task.js", () => ({
+    registerTaskTools: vi.fn(),
+}));
+vi.mock("./tools/roadmap.js", () => ({
+    registerRoadmapTools: vi.fn(),
+}));
+vi.mock("./design-context.js", () => ({
+    registerDesignContextResources: vi.fn(),
+    registerDesignContextPrompts: vi.fn(),
+}));
+vi.mock("./resources/governance.js", () => ({
+    registerGovernanceResources: vi.fn(),
+}));
+vi.mock("./resources/designs.js", () => ({
+    registerDesignFilesResources: vi.fn(),
+}));
+vi.mock("./prompts/governance.js", () => ({
+    registerGovernancePrompts: vi.fn(),
+}));
+describe("index module", () => {
+    let tempDir;
+    let testProjectDir;
+    beforeAll(async () => {
+        tempDir = await fs.mkdtemp(path.join(os.tmpdir(), "projitive-index-test-"));
+        testProjectDir = path.join(tempDir, "test-project");
+        await fs.mkdir(testProjectDir);
+    });
+    afterAll(async () => {
+        await fs.rm(tempDir, { recursive: true, force: true });
+    });
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    it("should export the main server entry point", async () => {
+        const indexPath = path.join(sourceDir, "index.ts");
+        const exists = await fs.access(indexPath).then(() => true).catch(() => false);
+        expect(exists).toBe(true);
+    });
+    it("should have the correct shebang and imports", async () => {
+        const indexPath = path.join(sourceDir, "index.ts");
+        const content = await fs.readFile(indexPath, "utf-8");
+        expect(content.startsWith("#!/usr/bin/env node")).toBe(true);
+        expect(content).toContain("McpServer");
+        expect(content).toContain("StdioServerTransport");
+        expect(content).toContain("registerTools");
+        expect(content).toContain("registerResources");
+        expect(content).toContain("registerPrompts");
+    });
+    it("should define PROJITIVE_SPEC_VERSION as 1.1.0", async () => {
+        const indexPath = path.join(sourceDir, "index.ts");
+        const content = await fs.readFile(indexPath, "utf-8");
+        expect(content).toContain("PROJITIVE_SPEC_VERSION");
+        expect(content).toContain('"1.1.0"');
+    });
+    it("should have main function with server startup", async () => {
+        const indexPath = path.join(sourceDir, "index.ts");
+        const content = await fs.readFile(indexPath, "utf-8");
+        expect(content).toContain("async function main");
+        expect(content).toContain("server.connect");
+        expect(content).toContain("StdioServerTransport");
+    });
+    it("should register all tool categories", async () => {
+        const indexPath = path.join(sourceDir, "index.ts");
+        const content = await fs.readFile(indexPath, "utf-8");
+        expect(content).toContain("registerTools(server)");
+        expect(content).toContain("registerResources(server, repoRoot)");
+        expect(content).toContain("registerPrompts(server)");
+        expect(content).toContain("registerDesignContextResources(server)");
+        expect(content).toContain("registerDesignContextPrompts(server)");
+    });
+    it("should have proper error handling in main", async () => {
+        const indexPath = path.join(sourceDir, "index.ts");
+        const content = await fs.readFile(indexPath, "utf-8");
+        expect(content).toContain("void main().catch");
+        expect(content).toContain("console.error(\"Server error:\", error)");
+        expect(content).toContain("process.exit(1)");
+    });
+    it("should log server startup information", async () => {
+        const indexPath = path.join(sourceDir, "index.ts");
+        const content = await fs.readFile(indexPath, "utf-8");
+        expect(content).toContain("console.error(`[projitive-mcp] starting server`)");
+        expect(content).toContain("console.error(`[projitive-mcp] version=");
+        expect(content).toContain("spec=");
+        expect(content).toContain("transport=stdio");
+        expect(content).toContain("pid=");
+    });
+    it("should define MCP server with correct metadata", async () => {
+        const indexPath = path.join(sourceDir, "index.ts");
+        const content = await fs.readFile(indexPath, "utf-8");
+        expect(content).toContain("name: \"projitive\"");
+        expect(content).toContain("version: MCP_RUNTIME_VERSION");
+        expect(content).toContain("description:");
+    });
+});

package/output/source/prompts/index.js

@@ -0,0 +1,9 @@
+// Governance workflow prompts
+import { registerQuickStartPrompt } from "./quickStart.js";
+import { registerTaskDiscoveryPrompt } from "./taskDiscovery.js";
+import { registerTaskExecutionPrompt } from "./taskExecution.js";
+export function registerPrompts(server) {
+    registerQuickStartPrompt(server);
+    registerTaskDiscoveryPrompt(server);
+    registerTaskExecutionPrompt(server);
+}

package/output/source/prompts/quickStart.js

@@ -0,0 +1,94 @@
+import { z } from "zod";
+function asUserPrompt(text) {
+    return {
+        messages: [
+            {
+                role: "user",
+                content: {
+                    type: "text",
+                    text,
+                },
+            },
+        ],
+    };
+}
+export function registerQuickStartPrompt(server) {
+    server.registerPrompt("quickStart", {
+        title: "Quick Start",
+        description: "Complete workflow to discover project, load context, and start task execution",
+        argsSchema: {
+            projectPath: z.string().optional(),
+        },
+    }, async ({ projectPath }) => {
+        const text = [
+            "# How to Govern a Project",
+            "",
+            "You are a Projitive governance assistant. Here is the complete workflow:",
+            "",
+            "## Step 1: Discover the Project",
+            "",
+            projectPath
+                ? [
+                    `- Known project path: "${projectPath}"`,
+                    "- Call `projectContext(projectPath=\"" + projectPath + "\")` directly to load project overview",
+                ].join("\n")
+                : [
+                    "- Unknown project path:",
+                    "  1. Call `projectScan()` to discover all governance roots",
+                    "  2. Select a target project",
+                    "  3. Call `projectLocate(inputPath=\"<selected-path>\")` to lock governance root",
+                    "  4. Call `projectContext(projectPath=\"<project-path>\")` to load project overview",
+                ].join("\n"),
+            "",
+            "## Step 2: Understand the Project",
+            "",
+            "After loading project context, read these resources:",
+            "- projitive://governance/workspace - Project overview",
+            "- projitive://governance/tasks - Current task pool",
+            "- projitive://governance/roadmap - Project roadmap",
+            "- projitive://designs/* - Design documents",
+            "",
+            "## Step 3: Discover Tasks",
+            "",
+            "Two ways to discover tasks:",
+            "",
+            "### Option A: Auto-select (Recommended)",
+            "Call `taskNext()` to get highest-priority actionable task.",
+            "",
+            "### Option B: Manual select",
+            "1. Call `taskList()` to list all tasks",
+            "2. Select a task based on status and priority",
+            "3. Call `taskContext(projectPath=\"...\", taskId=\"...\")` for details",
+            "",
+            "## Step 4: Execute the Task",
+            "",
+            "After getting task context:",
+            "1. Read evidence links in Suggested Read Order",
+            "2. Understand task requirements and acceptance criteria",
+            "3. Edit governance markdown only (tasks/designs/reports/roadmap)",
+            "4. Update task status:",
+            "   - TODO → IN_PROGRESS (when starting execution)",
+            "   - IN_PROGRESS → DONE (when completed)",
+            "   - IN_PROGRESS → BLOCKED (when blocked)",
+            "5. Re-run taskContext() to verify changes",
+            "",
+            "## Special Cases",
+            "",
+            "### Case 1: No .projitive directory",
+            "Call `projectInit(projectPath=\"<project-dir>\")` to initialize governance structure.",
+            "",
+            "### Case 2: No actionable tasks",
+            "1. Check if tasks.md is missing",
+            "2. Read design documents in projitive://designs/",
+            "3. Create 1-3 new TODO tasks",
+            "",
+            "## Hard Rules",
+            "",
+            "- **NEVER modify TASK/ROADMAP IDs** - Keep them immutable once assigned",
+            "- **Every status transition must have report evidence** - Create execution reports in reports/ directory",
+            "- **Only edit files under .projitive/** - Unless task scope explicitly requires otherwise",
+            "- **Always verify after updates** - Re-run taskContext() to confirm reference consistency",
+        ].join("\n");
+        return asUserPrompt(text);
+    });
+}

package/output/source/prompts/taskDiscovery.js

@@ -0,0 +1,190 @@
+import { z } from "zod";
+function asUserPrompt(text) {
+    return {
+        messages: [
+            {
+                role: "user",
+                content: {
+                    type: "text",
+                    text,
+                },
+            },
+        ],
+    };
+}
+export function registerTaskDiscoveryPrompt(server) {
+    server.registerPrompt("taskDiscovery", {
+        title: "Task Discovery",
+        description: "Minimal steps to find, context, and execute the first actionable task",
+        argsSchema: {
+            projectPath: z.string().optional(),
+        },
+    }, async ({ projectPath }) => {
+        const text = [
+            "# How to Discover Tasks",
+            "",
+            "You are a Projitive task discovery assistant. Here is the complete workflow to discover and execute your first task:",
+            "",
+            "## Step 1: Locate the Project",
+            "",
+            projectPath
+                ? [
+                    `- Known project path: "${projectPath}"`,
+                    "- Call `projectContext(projectPath=\"" + projectPath + "\")` directly to load project context",
+                ].join("\n")
+                : [
+                    "- Unknown project path:",
+                    "  1. Call `projectScan()` to discover all governance roots",
+                    "  2. Select a project",
+                    "  3. Call `projectLocate(inputPath=\"<selected-path>\")` to lock governance root",
+                    "  4. Call `projectContext(projectPath=\"<project-path>\")` to load project context",
+                ].join("\n"),
+            "",
+            "## Step 2: Read Project Context",
+            "",
+            "After loading project context, focus on:",
+            "",
+            "### Task Summary",
+            "- total: Total tasks",
+            "- TODO: Pending tasks (highest priority)",
+            "- IN_PROGRESS: In-progress tasks (priority to continue)",
+            "- BLOCKED: Blocked tasks (need to resolve first)",
+            "- DONE: Completed tasks",
+            "",
+            "### Artifacts",
+            "Check if these files exist:",
+            "- \u2705 tasks.md - Task list (required)",
+            "- \u2705 roadmap.md - Roadmap",
+            "- \u2705 README.md - Project description",
+            "- \u2705 designs/ - Design documents directory",
+            "- \u2705 reports/ - Reports directory",
+            "",
+            "## Step 3: Select a Task",
+            "",
+            "### Priority Order",
+            "Select tasks in this priority order:",
+            "",
+            "1. **IN_PROGRESS** - Priority to continue in-progress tasks first",
+            "   - These tasks have already started, should continue to finish",
+            "   - Check updatedAt time, most recent first",
+            "",
+            "2. **TODO** - Next select pending tasks",
+            "   - Tasks with roadmapRefs first",
+            "   - Tasks with explicit owner first",
+            "",
+            "3. **BLOCKED** - Last consider blocked tasks",
+            "   - Need to analyze blocker reason first",
+            "   - May need to create sub-task to resolve blocker",
+            "",
+            "### Discovery Methods",
+            "",
+            "#### Method A: Auto-select with taskNext() (Recommended)",
+            "",
+            "Call `taskNext()`, the tool will automatically:",
+            "- Sort all tasks by priority",
+            "- Select highest-priority actionable task",
+            "- Return task ID and summary",
+            "",
+            "Then call `taskContext(projectPath=\"...\", taskId=\"<task-id>\")` for task details.",
+            "",
+            "#### Method B: Manual select with taskList()",
+            "",
+            "1. Call `taskList()` to get all tasks",
+            "2. Select based on these factors:",
+            "   - status (IN_PROGRESS > TODO > BLOCKED)",
+            "   - updatedAt time (most recent first)",
+            "   - owner assigned (with owner first)",
+            "   - roadmapRefs (with refs first)",
+            "3. Call `taskContext(projectPath=\"...\", taskId=\"<selected-id>\")` for details",
+            "",
+            "## Step 4: Understand Task Context",
+            "",
+            "After getting taskContext, read carefully:",
+            "",
+            "### Summary",
+            "- taskId: Task ID (NEVER modify this)",
+            "- status: Current status",
+            "- owner: Assignee",
+            "- roadmapRefs: Related roadmap",
+            "- updatedAt: Last updated time",
+            "",
+            "### Evidence",
+            "- Candidate Files - Related file list",
+            "- Reference Locations - Reference locations",
+            "",
+            "### Suggested Read Order",
+            "Read files in order, understand:",
+            "- Task background and motivation",
+            "- Task acceptance criteria",
+            "- Related design decisions",
+            "- Previous execution history",
+            "",
+            "### Lint Suggestions",
+            "Check if any warnings need to be resolved first.",
+            "",
+            "## Step 5: Execute the Task",
+            "",
+            "After understanding the task:",
+            "",
+            "1. **If status is TODO",
+            "   - First call `taskUpdate()` to change status to IN_PROGRESS",
+            "   - Set owner (if empty)",
+            "   - Fill subState (optional, Spec v1.1.0)",
+            "",
+            "2. **If status is IN_PROGRESS",
+            "   - Continue previous work",
+            "   - Reference history reports in reports/",
+            "",
+            "3. **Execute task content**",
+            "   - Edit governance files (tasks.md / designs/*.md / reports/*.md / roadmap.md)",
+            "   - Create execution report (reports/ directory)",
+            "   - Update task status to DONE",
+            "",
+            "4. **Verify changes**",
+            "   - Re-run `taskContext()`",
+            "   - Confirm all references still valid",
+            "   - Confirm no new lint suggestions",
+            "",
+            "## Special Cases",
+            "",
+            "### Case 1: No tasks at all",
+            "",
+            "If taskNext() returns empty:",
+            "1. Check if tasks.md exists",
+            "2. Read design documents in designs/ directory",
+            "3. Read roadmap.md to understand project goals",
+            "4. Create 1-3 new TODO tasks",
+            "5. Each task must have:",
+            "   - Unique TASK-xxxx ID",
+            "   - Clear title",
+            "   - Detailed summary",
+            "   - Linked roadmapRefs (if applicable)",
+            "",
+            "### Case 2: All tasks are BLOCKED",
+            "",
+            "1. Select one blocked task and call `taskContext()`",
+            "2. Understand blocker reason (check blocker field, Spec v1.1.0)",
+            "3. Create a new TODO task to resolve blocker",
+            "4. Execute this new task first",
+            "",
+            "### Case 3: Missing required governance files",
+            "",
+            "If tasks.md does not exist:",
+            "1. Call `projectInit(projectPath=\"...\")` to initialize governance structure",
+            "2. Then restart discovery flow",
+            "",
+            "## Quick Reference",
+            "",
+            "| Tool | Purpose |",
+            "|------|---------|",
+            "| `projectScan()` | Discover all governance roots |",
+            "| `projectLocate()` | Lock governance root |",
+            "| `projectContext()` | Load project overview |",
+            "| `taskNext()` | Auto-select best task |",
+            "| `taskList()` | List all tasks |",
+            "| `taskContext()` | Get task details |",
+            "| `taskUpdate()` | Update task status |",
+        ].join("\n");
+        return asUserPrompt(text);
+    });
+}