@projitive/mcp 2.0.1 → 2.0.3

package/README.md

@@ -21,6 +21,17 @@ Why teams use it:
 - Better evidence traceability
 - More predictable multi-agent delivery
 
+## Outcomes You Can Expect
+
+After onboarding Projitive MCP, teams typically get these outcomes quickly:
+
+- Faster execution bootstrapping: create missing work items with taskCreate/roadmapCreate.
+- Better state integrity: task and roadmap transitions remain traceable and verifiable.
+- Stronger delivery continuity: discover -> execute -> verify -> reprioritize loops stay stable.
+- Easier adoption: new contributors follow a deterministic call sequence.
+
+Key point: best results come from autonomous execution agents such as OpenClaw.
+
 ## What It Is Useful For
 
 Projitive MCP helps agents move work forward in governed projects without losing traceability.
@@ -82,7 +93,7 @@ Recommended minimal sequence:
 
 1. taskNext
 2. taskContext
-3. taskUpdate and/or roadmapUpdate
+3. taskCreate/taskUpdate and/or roadmapCreate/roadmapUpdate
 4. taskContext
 5. taskNext
 
@@ -124,9 +135,11 @@ sequenceDiagram
 | Task | taskList | List tasks |
 | Task | taskNext | Select best actionable task |
 | Task | taskContext | Get task evidence and reading order |
+| Task | taskCreate | Create task |
 | Task | taskUpdate | Update task state and metadata |
 | Roadmap | roadmapList | List roadmaps and linked tasks |
 | Roadmap | roadmapContext | Get roadmap context |
+| Roadmap | roadmapCreate | Create roadmap milestone |
 | Roadmap | roadmapUpdate | Update roadmap milestone fields |
 
 ### Resources

package/output/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@projitive/mcp",
-    "version": "2.0.1",
+    "version": "2.0.3",
     "description": "Projitive MCP Server for project and task discovery/update",
     "license": "ISC",
     "author": "",
@@ -25,14 +25,11 @@
         "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",

package/output/source/common/store.js

@@ -1,13 +1,8 @@
 import fs from "node:fs/promises";
 import path from "node:path";
-import duckdb from "@duckdb/node-api";
-import initSqlJs from "sql.js";
 const STORE_SCHEMA_VERSION = 3;
-const SQL_HEADER = Buffer.from("SQLite format 3\0", "utf8");
-const sqlRuntimePromise = initSqlJs();
 const storeCache = new Map();
 const storeLocks = new Map();
-let duckdbConnectionPromise;
 function defaultViewState(name) {
     return {
         name,
@@ -37,17 +32,6 @@ function defaultStore() {
 function nowIso() {
     return new Date().toISOString();
 }
-function parseJsonOr(raw, fallback) {
-    if (typeof raw !== "string" || raw.trim().length === 0) {
-        return fallback;
-    }
-    try {
-        return JSON.parse(raw);
-    }
-    catch {
-        return fallback;
-    }
-}
 function normalizeTaskStatus(status) {
     if (status === "IN_PROGRESS" || status === "BLOCKED" || status === "DONE") {
         return status;
@@ -57,12 +41,6 @@ function normalizeTaskStatus(status) {
 function normalizeRoadmapStatus(status) {
     return status === "done" ? "done" : "active";
 }
-function isSqliteBuffer(data) {
-    if (data.length < SQL_HEADER.length) {
-        return false;
-    }
-    return data.subarray(0, SQL_HEADER.length).equals(SQL_HEADER);
-}
 function normalizeStore(input) {
     const base = defaultStore();
     const meta = input.meta ?? {};
@@ -129,106 +107,6 @@ function normalizeStore(input) {
         migration_history: Array.isArray(input.migration_history) ? input.migration_history : [],
     };
 }
-async function migrateSqliteToJson(data) {
-    const SQL = await sqlRuntimePromise;
-    const db = new SQL.Database(new Uint8Array(data));
-    try {
-        const tasksResult = db.exec(`
-      SELECT id, title, status, owner, summary, updated_at, links_json, roadmap_refs_json, sub_state_json, blocker_json, COALESCE(record_version, 1)
-      FROM tasks
-    `);
-        const roadmapsResult = db.exec(`
-      SELECT id, title, status, time, updated_at, COALESCE(record_version, 1)
-      FROM roadmaps
-    `);
-        const metaResult = db.exec(`
-      SELECT key, value
-      FROM meta
-      WHERE key IN ('tasks_version', 'roadmaps_version', 'store_schema_version')
-    `);
-        const viewStateResult = db.exec(`
-      SELECT name, dirty, last_source_version, last_built_at, COALESCE(record_version, 1)
-      FROM view_state
-      WHERE name IN ('tasks_markdown', 'roadmaps_markdown')
-    `);
-        const tasks = tasksResult[0]?.values?.map((row) => ({
-            id: String(row[0]),
-            title: String(row[1]),
-            status: normalizeTaskStatus(String(row[2])),
-            owner: String(row[3]),
-            summary: String(row[4]),
-            updatedAt: String(row[5]),
-            links: parseJsonOr(row[6], []),
-            roadmapRefs: parseJsonOr(row[7], []),
-            subState: parseJsonOr(row[8], undefined),
-            blocker: parseJsonOr(row[9], undefined),
-            recordVersion: Number(row[10]) || 1,
-        })) ?? [];
-        const roadmaps = roadmapsResult[0]?.values?.map((row) => ({
-            id: String(row[0]),
-            title: String(row[1]),
-            status: normalizeRoadmapStatus(String(row[2])),
-            time: row[3] == null ? undefined : String(row[3]),
-            updatedAt: String(row[4]),
-            recordVersion: Number(row[5]) || 1,
-        })) ?? [];
-        const meta = defaultStore().meta;
-        const metaRows = metaResult[0]?.values ?? [];
-        for (const row of metaRows) {
-            const key = String(row[0]);
-            const value = Number.parseInt(String(row[1]), 10);
-            if (!Number.isFinite(value)) {
-                continue;
-            }
-            if (key === "tasks_version")
-                meta.tasks_version = value;
-            if (key === "roadmaps_version")
-                meta.roadmaps_version = value;
-            if (key === "store_schema_version")
-                meta.store_schema_version = value;
-        }
-        const tasksView = defaultViewState("tasks_markdown");
-        const roadmapsView = defaultViewState("roadmaps_markdown");
-        const viewRows = viewStateResult[0]?.values ?? [];
-        for (const row of viewRows) {
-            const name = String(row[0]);
-            const dirty = Number(row[1]) === 1;
-            const lastSourceVersion = Number(row[2]) || 0;
-            const lastBuiltAt = String(row[3] ?? "");
-            const recordVersion = Number(row[4]) || 1;
-            if (name === "tasks_markdown") {
-                tasksView.dirty = dirty;
-                tasksView.lastSourceVersion = lastSourceVersion;
-                tasksView.lastBuiltAt = lastBuiltAt;
-                tasksView.recordVersion = recordVersion;
-            }
-            if (name === "roadmaps_markdown") {
-                roadmapsView.dirty = dirty;
-                roadmapsView.lastSourceVersion = lastSourceVersion;
-                roadmapsView.lastBuiltAt = lastBuiltAt;
-                roadmapsView.recordVersion = recordVersion;
-            }
-        }
-        return normalizeStore({
-            schema: "projitive-json-store",
-            tasks,
-            roadmaps,
-            meta: {
-                tasks_version: meta.tasks_version,
-                roadmaps_version: meta.roadmaps_version,
-                store_schema_version: STORE_SCHEMA_VERSION,
-            },
-            view_state: {
-                tasks_markdown: tasksView,
-                roadmaps_markdown: roadmapsView,
-            },
-            migration_history: [],
-        });
-    }
-    finally {
-        db.close();
-    }
-}
 async function persistStore(dbPath, store) {
     await fs.mkdir(path.dirname(dbPath), { recursive: true });
     const tempPath = `${dbPath}.tmp-${process.pid}-${Date.now()}`;
@@ -241,10 +119,6 @@ async function loadStoreFromDisk(dbPath) {
     if (!file || file.length === 0) {
         return { store: defaultStore(), shouldPersist: true };
     }
-    if (isSqliteBuffer(file)) {
-        const migrated = await migrateSqliteToJson(file);
-        return { store: migrated, shouldPersist: true };
-    }
     const text = file.toString("utf8").trim();
     if (text.length === 0) {
         return { store: defaultStore(), shouldPersist: true };
@@ -337,119 +211,6 @@ function normalizeStatusForSort(status) {
         return 1;
     return 0;
 }
-async function getDuckdbConnection() {
-    if (!duckdbConnectionPromise) {
-        duckdbConnectionPromise = (async () => {
-            const instance = await duckdb.DuckDBInstance.create(":memory:");
-            return instance.connect();
-        })();
-    }
-    return duckdbConnectionPromise;
-}
-function normalizeStoredTaskLike(raw) {
-    if (!raw || typeof raw !== "object") {
-        return null;
-    }
-    const value = raw;
-    const id = value.id;
-    const title = value.title;
-    if (typeof id !== "string" || typeof title !== "string") {
-        return null;
-    }
-    const statusRaw = typeof value.status === "string" ? value.status : "TODO";
-    const owner = typeof value.owner === "string" ? value.owner : "";
-    const summary = typeof value.summary === "string" ? value.summary : "";
-    const updatedAt = typeof value.updatedAt === "string"
-        ? value.updatedAt
-        : (typeof value.updated_at === "string" ? value.updated_at : nowIso());
-    const links = Array.isArray(value.links) ? value.links.map((item) => String(item)) : [];
-    const roadmapRefs = Array.isArray(value.roadmapRefs)
-        ? value.roadmapRefs.map((item) => String(item))
-        : (Array.isArray(value.roadmap_refs) ? value.roadmap_refs.map((item) => String(item)) : []);
-    const recordVersionRaw = value.recordVersion ?? value.record_version;
-    const recordVersion = Number.isFinite(Number(recordVersionRaw)) ? Number(recordVersionRaw) : 1;
-    return {
-        id,
-        title,
-        status: normalizeTaskStatus(statusRaw),
-        owner,
-        summary,
-        updatedAt,
-        links,
-        roadmapRefs,
-        subState: value.subState,
-        blocker: value.blocker,
-        recordVersion,
-    };
-}
-function normalizeStoredRoadmapLike(raw) {
-    if (!raw || typeof raw !== "object") {
-        return null;
-    }
-    const value = raw;
-    const id = value.id;
-    const title = value.title;
-    if (typeof id !== "string" || typeof title !== "string") {
-        return null;
-    }
-    const statusRaw = typeof value.status === "string" ? value.status : "active";
-    const time = typeof value.time === "string" ? value.time : undefined;
-    const updatedAt = typeof value.updatedAt === "string"
-        ? value.updatedAt
-        : (typeof value.updated_at === "string" ? value.updated_at : nowIso());
-    const recordVersionRaw = value.recordVersion ?? value.record_version;
-    const recordVersion = Number.isFinite(Number(recordVersionRaw)) ? Number(recordVersionRaw) : 1;
-    return {
-        id,
-        title,
-        status: normalizeRoadmapStatus(statusRaw),
-        time,
-        updatedAt,
-        recordVersion,
-    };
-}
-async function runDuckdbQuery(sql) {
-    try {
-        const connection = await getDuckdbConnection();
-        const result = await connection.run(sql);
-        const rows = await result.getRowObjectsJS();
-        if (!rows || rows.length === 0) {
-            return undefined;
-        }
-        return rows;
-    }
-    catch {
-        return undefined;
-    }
-}
-async function loadTasksFromDuckdb(dbPath) {
-    const sql = `SELECT tasks FROM read_json_auto('${dbPath.replace(/'/g, "''")}') LIMIT 1;`;
-    const rows = await runDuckdbQuery(sql);
-    if (!rows || rows.length === 0) {
-        return undefined;
-    }
-    const rawTasks = rows[0]?.tasks;
-    if (!Array.isArray(rawTasks)) {
-        return undefined;
-    }
-    return rawTasks
-        .map((item) => normalizeStoredTaskLike(item))
-        .filter((item) => item != null);
-}
-async function loadRoadmapsFromDuckdb(dbPath) {
-    const sql = `SELECT roadmaps FROM read_json_auto('${dbPath.replace(/'/g, "''")}') LIMIT 1;`;
-    const rows = await runDuckdbQuery(sql);
-    if (!rows || rows.length === 0) {
-        return undefined;
-    }
-    const rawRoadmaps = rows[0]?.roadmaps;
-    if (!Array.isArray(rawRoadmaps)) {
-        return undefined;
-    }
-    return rawRoadmaps
-        .map((item) => normalizeStoredRoadmapLike(item))
-        .filter((item) => item != null);
-}
 export async function ensureStore(dbPath) {
     await openStore(dbPath);
 }
@@ -487,11 +248,8 @@ export async function markMarkdownViewDirty(dbPath, viewName) {
     });
 }
 export async function loadTasksFromStore(dbPath) {
-    const tasksFromDuckdb = await loadTasksFromDuckdb(dbPath);
-    if (!tasksFromDuckdb) {
-        throw new Error("DuckDB task query failed");
-    }
-    return tasksFromDuckdb.map(toPublicTask);
+    const store = await openStore(dbPath);
+    return store.tasks.map(toPublicTask);
 }
 export async function loadTaskStatusStatsFromStore(dbPath) {
     const tasks = await loadTasksFromStore(dbPath);
@@ -568,11 +326,8 @@ export async function replaceTasksInStore(dbPath, tasks) {
     });
 }
 export async function loadRoadmapsFromStore(dbPath) {
-    const roadmapsFromDuckdb = await loadRoadmapsFromDuckdb(dbPath);
-    if (!roadmapsFromDuckdb) {
-        throw new Error("DuckDB roadmap query failed");
-    }
-    return roadmapsFromDuckdb.map(toPublicRoadmap);
+    const store = await openStore(dbPath);
+    return store.roadmaps.map(toPublicRoadmap);
 }
 export async function loadRoadmapIdsFromStore(dbPath) {
     const roadmaps = await loadRoadmapsFromStore(dbPath);

package/output/source/index.js

@@ -18,7 +18,7 @@ const MCP_RUNTIME_VERSION = typeof packageJson.version === "string" && packageJs
 const server = new McpServer({
     name: "projitive",
     version: MCP_RUNTIME_VERSION,
-    description: "Semantic Projitive MCP for project/task discovery and agent guidance with sqlite-first governance outputs",
+    description: "Semantic Projitive MCP for project/task discovery and agent guidance with governance-store-first outputs",
 });
 // 注册所有模块
 registerTools(server);

package/output/source/prompts/quickStart.js

@@ -54,7 +54,7 @@ export function registerQuickStartPrompt(server) {
             "",
             "### Option A: Auto-select (Recommended)",
             "Call `taskNext()` to get highest-priority actionable task.",
-            "If no actionable tasks are returned and roadmap has active goals, analyze roadmap context and create 1-3 TODO tasks manually.",
+            "If no actionable tasks are returned and roadmap has active goals, analyze roadmap context and create 1-3 TODO tasks via `taskCreate()`.",
             "Then call `taskNext()` again to re-rank.",
             "",
             "### Option B: Manual select",
@@ -67,9 +67,9 @@ export function registerQuickStartPrompt(server) {
             "After getting task context:",
             "1. Read evidence links in Suggested Read Order",
             "2. Understand task requirements and acceptance criteria",
-            "3. Write governance source via tools (`taskUpdate` / `roadmapUpdate`) instead of editing tasks.md/roadmap.md directly",
+            "3. Write governance source via tools (`taskCreate` / `taskUpdate` / `roadmapCreate` / `roadmapUpdate`) instead of editing tasks.md/roadmap.md directly",
             "4. Update docs (`designs/` / `reports/`) as required by evidence",
-            "5. If immediate markdown snapshots are needed, call `syncViews(projectPath=..., force=true)`",
+            "5. taskCreate/taskUpdate/roadmapCreate/roadmapUpdate will auto-sync corresponding markdown views",
             "6. Update task status:",
             "   - TODO → IN_PROGRESS (when starting execution)",
             "   - IN_PROGRESS → DONE (when completed)",
@@ -80,7 +80,7 @@ export function registerQuickStartPrompt(server) {
             "",
             "Keep this loop until no high-value actionable work remains:",
             "1. Discover: `taskNext()`",
-            "2. Execute: update sqlite + docs + report evidence",
+            "2. Execute: update governance store + docs + report evidence",
             "3. Verify: `taskContext()`",
             "4. Re-prioritize: `taskNext()`",
             "",
@@ -105,14 +105,14 @@ export function registerQuickStartPrompt(server) {
             "   - Distinct scope: avoid overlap with existing DONE/BLOCKED tasks",
             "4. Prefer unblocking tasks that unlock multiple follow-up tasks",
             "5. Re-run `taskNext()` to pick the new tasks",
-            "6. If still no tasks, read design documents in projitive://designs/ and create TODO tasks manually",
+            "6. If still no tasks, read design documents in projitive://designs/ and create TODO tasks via `taskCreate()`",
             "",
             "## 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",
-            "- **SQLite is source of truth** - tasks.md/roadmap.md are generated views and may be overwritten",
-            "- **Prefer tool writes over manual table/view edits** - Use taskUpdate/roadmapUpdate/syncViews",
+            "- **.projitive governance store is source of truth** - tasks.md/roadmap.md are generated views and may be overwritten",
+            "- **Prefer tool writes over manual table/view edits** - Use taskCreate/taskUpdate/roadmapCreate/roadmapUpdate",
             "- **Always verify after updates** - Re-run taskContext() to confirm reference consistency",
         ].join("\n");
         return asUserPrompt(text);

package/output/source/prompts/taskDiscovery.js

@@ -53,7 +53,7 @@ export function registerTaskDiscoveryPrompt(server) {
             "",
             "### Artifacts",
             "Check if these files exist:",
-            "- \u2705 .projitive - SQLite governance database (required)",
+            "- \u2705 .projitive - Governance store file (required)",
             "- \u2705 tasks.md - Generated task view",
             "- \u2705 roadmap.md - Generated roadmap view",
             "- \u2705 README.md - Project description",
@@ -145,7 +145,7 @@ export function registerTaskDiscoveryPrompt(server) {
             "   - Reference history reports in reports/",
             "",
             "3. **Execute task content**",
-            "   - Update sqlite task/roadmap tables via MCP tools; edit designs/*.md and reports/*.md as needed",
+            "   - Update governance store via MCP tools; edit designs/*.md and reports/*.md as needed",
             "   - If immediate markdown snapshots are required by another agent/session, call syncViews(force=true)",
             "   - Create execution report (reports/ directory)",
             "   - Update task status to DONE",
@@ -163,11 +163,13 @@ export function registerTaskDiscoveryPrompt(server) {
             "1. Check if .projitive exists",
             "2. Analyze active roadmap milestones and derive 1-3 executable TODO tasks",
             "3. Prioritize milestone slices that unblock multiple downstream tasks",
-            "4. Re-run taskNext() and continue execution if tasks are available",
-            "5. If still empty, read design documents in designs/ directory",
-            "6. Read roadmap.md to understand project goals",
-            "7. Create 1-3 new TODO tasks",
-            "8. Each task must have:",
+            "3.5 If roadmap milestone is missing, create it first via `roadmapCreate()`",
+            "4. Create tasks via `taskCreate(projectPath=\"...\", taskId=\"TASK-xxxx\", title=\"...\", roadmapRefs=[\"ROADMAP-xxxx\"], summary=\"...\")`",
+            "5. Re-run taskNext() and continue execution if tasks are available",
+            "6. If still empty, read design documents in designs/ directory",
+            "7. Read roadmap.md to understand project goals",
+            "8. Create 1-3 new TODO tasks",
+            "9. Each task must have:",
             "   - Unique TASK-xxxx ID",
             "   - Clear title",
             "   - Detailed summary",
@@ -177,7 +179,7 @@ export function registerTaskDiscoveryPrompt(server) {
             "",
             "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",
+            "3. Create a new TODO task via `taskCreate()` to resolve blocker",
             "4. Execute this new task first",
             "",
             "### Case 3: Missing required governance files",
@@ -196,8 +198,10 @@ export function registerTaskDiscoveryPrompt(server) {
             "| `taskNext()` | Auto-select best task |",
             "| `taskList()` | List all tasks |",
             "| `taskContext()` | Get task details |",
+            "| `taskCreate()` | Create a new task |",
             "| `taskUpdate()` | Update task status |",
-            "| `syncViews()` | Force materialize tasks.md/roadmap.md from sqlite |",
+            "| `roadmapCreate()` | Create a new roadmap milestone |",
+            "| `syncViews()` | Force materialize tasks.md/roadmap.md from governance store |",
         ].join("\n");
         return asUserPrompt(text);
     });

package/output/source/prompts/taskExecution.js

@@ -70,12 +70,12 @@ export function registerTaskExecutionPrompt(server) {
             "   - Fill subState (optional, Spec v1.1.0)",
             "",
             "2. **Execute task content**",
-            "   - Prefer MCP tool writes for sqlite source (`taskUpdate` / `roadmapUpdate`)",
+            "   - Prefer MCP tool writes for governance store (`taskUpdate` / `roadmapUpdate`)",
             "   - .projitive (task table) - Update task status and metadata",
             "   - designs/*.md - Add or update design documents",
             "   - reports/*.md - Create execution reports",
             "   - .projitive (roadmap table) - Update roadmap (if needed)",
-            "   - If downstream consumers require immediate markdown snapshots, call `syncViews(..., force=true)`",
+            "   - taskCreate/taskUpdate/roadmapCreate/roadmapUpdate auto-sync corresponding markdown views",
             "",
             "3. **Create execution report**",
             "   - Create new report file in reports/ directory",
@@ -125,15 +125,16 @@ export function registerTaskExecutionPrompt(server) {
             "   - type: Blocker type (dependency/missing-info/technical-debt/other)",
             "   - description: Blocker description",
             "   - relatedLinks: Related links (optional)",
-            "3. Create a new TODO task to resolve blocker",
+            "3. Create a new TODO task via `taskCreate()` to resolve blocker",
             "",
             "### Case 2: No actionable tasks",
             "",
             "If taskNext() returns empty:",
             "1. Call `projectContext()` to recheck project state",
             "2. Analyze active roadmap milestones and find smallest executable slices",
+            "2.5 If roadmap milestones are missing, create them via `roadmapCreate()`",
             "3. Read design documents in designs/ directory to find delivery gaps",
-            "4. Create 1-3 new TODO tasks only if each task has clear done condition and evidence output",
+            "4. Create 1-3 new TODO tasks via `taskCreate()` only if each task has clear done condition and evidence output",
             "5. Re-run `taskNext()` and continue",
             "",
             "### Case 3: Need to initialize governance",
@@ -153,7 +154,7 @@ export function registerTaskExecutionPrompt(server) {
             "   - IN_PROGRESS \u2192 DONE: Report REQUIRED",
             "   - IN_PROGRESS \u2192 BLOCKED: Report recommended to explain blocker",
             "",
-            "3. **SQLite-first writes only**",
+            "3. **Governance-store-first writes only**",
             "   - tasks.md/roadmap.md are generated views, not authoritative source",
             "   - Use taskUpdate/roadmapUpdate as primary write path",
             "",

package/output/source/resources/governance.js

@@ -15,7 +15,7 @@ export function registerGovernanceResources(server, repoRoot) {
     }));
     server.registerResource("governanceTasks", "projitive://governance/tasks", {
         title: "Governance Tasks",
-        description: "Current task pool markdown view generated from .projitive sqlite task table",
+        description: "Current task pool markdown view generated from .projitive governance store",
         mimeType: "text/markdown",
     }, async () => ({
         contents: [
@@ -27,7 +27,7 @@ export function registerGovernanceResources(server, repoRoot) {
     }));
     server.registerResource("governanceRoadmap", "projitive://governance/roadmap", {
         title: "Governance Roadmap",
-        description: "Current roadmap markdown view generated from .projitive sqlite roadmap table",
+        description: "Current roadmap markdown view generated from .projitive governance store",
         mimeType: "text/markdown",
     }, async () => ({
         contents: [

package/output/source/tools/project.js

@@ -255,9 +255,11 @@ const DEFAULT_TOOL_TEMPLATE_NAMES = [
     "taskList",
     "taskNext",
     "taskContext",
+    "taskCreate",
     "taskUpdate",
     "roadmapList",
     "roadmapContext",
+    "roadmapCreate",
     "roadmapUpdate",
 ];
 async function pathExists(targetPath) {
@@ -279,8 +281,8 @@ function defaultReadmeMarkdown(governanceDirName) {
         `This directory (\`${governanceDirName}/\`) is the governance root for this project.`,
         "",
         "## Conventions",
-        "- Keep roadmap/task source of truth in .projitive sqlite tables.",
-        "- Treat roadmap.md/tasks.md as generated views from sqlite.",
+        "- Keep roadmap/task source of truth in .projitive governance store.",
+        "- Treat roadmap.md/tasks.md as generated views from governance store.",
         "- Keep IDs stable (TASK-xxxx / ROADMAP-xxxx).",
         "- Update report evidence before status transitions.",
     ].join("\n");
@@ -435,7 +437,7 @@ export function registerProjectTools(server) {
                 ]),
                 lintSection([
                     "- After init, fill owner/roadmapRefs/links in .projitive task table before marking DONE.",
-                    "- Keep task source-of-truth inside sqlite tables.",
+                    "- Keep task source-of-truth inside .projitive governance store.",
                 ]),
                 nextCallSection(`projectContext(projectPath=\"${initialized.projectPath}\")`),
             ],
@@ -449,7 +451,8 @@ export function registerProjectTools(server) {
     }, async () => {
         const roots = resolveScanRoots();
         const depth = resolveScanDepth();
-        const projects = await discoverProjectsAcrossRoots(roots, depth);
+        const governanceDirs = await discoverProjectsAcrossRoots(roots, depth);
+        const projects = Array.from(new Set(governanceDirs.map((governanceDir) => toProjectPath(governanceDir)))).sort();
         const markdown = renderToolResponseMarkdown({
             toolName: "projectScan",
             sections: [
@@ -529,7 +532,7 @@ export function registerProjectTools(server) {
                 ]),
                 evidenceSection([
                     "- rankedProjects:",
-                    ...ranked.map((item, index) => `${index + 1}. ${item.governanceDir} | actionable=${item.actionable} | in_progress=${item.inProgress} | todo=${item.todo} | blocked=${item.blocked} | done=${item.done} | latest=${item.latestUpdatedAt}${item.tasksExists ? "" : " | store=missing"}`),
+                    ...ranked.map((item, index) => `${index + 1}. ${toProjectPath(item.governanceDir)} | actionable=${item.actionable} | in_progress=${item.inProgress} | todo=${item.todo} | blocked=${item.blocked} | done=${item.done} | latest=${item.latestUpdatedAt}${item.tasksExists ? "" : " | store=missing"}`),
                 ]),
                 guidanceSection([
                     "- Pick top 1 project and call `projectContext` with its projectPath.",
@@ -571,7 +574,7 @@ export function registerProjectTools(server) {
     });
     server.registerTool("syncViews", {
         title: "Sync Views",
-        description: "Materialize markdown views from .projitive sqlite tables (tasks.md / roadmap.md)",
+        description: "Materialize markdown views from .projitive governance store (tasks.md / roadmap.md)",
         inputSchema: {
             projectPath: z.string(),
             views: z.array(z.enum(["tasks", "roadmap"])).optional(),
@@ -579,6 +582,7 @@ export function registerProjectTools(server) {
         },
     }, async ({ projectPath, views, force }) => {
         const governanceDir = await resolveGovernanceDir(projectPath);
+        const normalizedProjectPath = toProjectPath(governanceDir);
         const dbPath = path.join(governanceDir, PROJECT_MARKER);
         const selectedViews = views && views.length > 0
             ? Array.from(new Set(views))
@@ -606,6 +610,7 @@ export function registerProjectTools(server) {
             toolName: "syncViews",
             sections: [
                 summarySection([
+                    `- projectPath: ${normalizedProjectPath}`,
                     `- governanceDir: ${governanceDir}`,
                     `- views: ${selectedViews.join(", ")}`,
                     `- force: ${forceSync ? "true" : "false"}`,
@@ -619,7 +624,7 @@ export function registerProjectTools(server) {
                     "Routine workflows can rely on lazy sync and usually do not require force=true.",
                 ]),
                 lintSection([]),
-                nextCallSection(`projectContext(projectPath="${toProjectPath(governanceDir)}")`),
+                nextCallSection(`projectContext(projectPath="${normalizedProjectPath}")`),
             ],
         });
         return asText(markdown);

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

@@ -340,5 +340,27 @@ describe("projitive module", () => {
             expect(() => registerProjectTools(mockServer)).not.toThrow();
             expect(mockServer.registerTool).toHaveBeenCalled();
         });
+        it("projectScan lists project root paths instead of governance directories", async () => {
+            const root = await createTempDir();
+            const projectRoot = path.join(root, "app");
+            const governanceDir = path.join(projectRoot, ".projitive");
+            const templateDir = await createTempDir();
+            await fs.mkdir(governanceDir, { recursive: true });
+            await fs.writeFile(path.join(governanceDir, ".projitive"), "", "utf-8");
+            vi.stubEnv("PROJITIVE_SCAN_ROOT_PATHS", root);
+            vi.stubEnv("PROJITIVE_SCAN_MAX_DEPTH", "3");
+            vi.stubEnv("PROJITIVE_MESSAGE_TEMPLATE_PATH", templateDir);
+            const mockServer = {
+                registerTool: vi.fn(),
+            };
+            registerProjectTools(mockServer);
+            const projectScanCall = mockServer.registerTool.mock.calls.find((call) => call[0] === "projectScan");
+            expect(projectScanCall).toBeTruthy();
+            const projectScanHandler = projectScanCall?.[2];
+            const result = await projectScanHandler();
+            const markdown = result.content[0]?.text ?? "";
+            expect(markdown).toContain(`1. ${projectRoot}`);
+            expect(markdown).not.toContain(`1. ${governanceDir}`);
+        });
     });
 });

package/output/source/tools/roadmap.js

@@ -10,6 +10,17 @@ export const ROADMAP_MARKDOWN_FILE = "roadmap.md";
 function nowIso() {
     return new Date().toISOString();
 }
+function nextRoadmapId(milestones) {
+    const maxSuffix = milestones
+        .map((item) => toRoadmapIdNumericSuffix(item.id))
+        .filter((value) => Number.isFinite(value) && value >= 0)
+        .reduce((max, value) => Math.max(max, value), 0);
+    const next = maxSuffix + 1;
+    if (next > 9999) {
+        throw new Error("ROADMAP ID overflow: maximum supported ID is ROADMAP-9999");
+    }
+    return `ROADMAP-${String(next).padStart(4, "0")}`;
+}
 function toRoadmapIdNumericSuffix(roadmapId) {
     const match = roadmapId.match(/^(?:ROADMAP-)(\d{4})$/);
     if (!match) {
@@ -53,7 +64,7 @@ export function renderRoadmapMarkdown(milestones) {
     return [
         "# Roadmap",
         "",
-        "This file is generated from .projitive sqlite tables by Projitive MCP. Manual edits will be overwritten.",
+        "This file is generated from .projitive governance store by Projitive MCP. Manual edits will be overwritten.",
         "",
         "## Active Milestones",
         ...(lines.length > 0 ? lines : ["- (no milestones)"]),
@@ -161,6 +172,7 @@ export function registerRoadmapTools(server) {
         },
     }, async ({ projectPath }) => {
         const governanceDir = await resolveGovernanceDir(projectPath);
+        const normalizedProjectPath = toProjectPath(governanceDir);
         const roadmapIds = await loadRoadmapIds(governanceDir);
         const { tasks } = await loadTasks(governanceDir);
         const lintSuggestions = collectRoadmapLintSuggestions(roadmapIds, tasks);
@@ -168,6 +180,7 @@ export function registerRoadmapTools(server) {
             toolName: "roadmapList",
             sections: [
                 summarySection([
+                    `- projectPath: ${normalizedProjectPath}`,
                     `- governanceDir: ${governanceDir}`,
                     `- roadmapCount: ${roadmapIds.length}`,
                 ]),
@@ -202,6 +215,7 @@ export function registerRoadmapTools(server) {
             };
         }
         const governanceDir = await resolveGovernanceDir(projectPath);
+        const normalizedProjectPath = toProjectPath(governanceDir);
         const artifacts = await discoverGovernanceArtifacts(governanceDir);
         const fileCandidates = candidateFilesFromArtifacts(artifacts);
         const referenceLocations = (await Promise.all(fileCandidates.map((file) => findTextReferences(file, roadmapId)))).flat();
@@ -221,6 +235,7 @@ export function registerRoadmapTools(server) {
             toolName: "roadmapContext",
             sections: [
                 summarySection([
+                    `- projectPath: ${normalizedProjectPath}`,
                     `- governanceDir: ${governanceDir}`,
                     `- roadmapId: ${roadmapId}`,
                     `- relatedTasks: ${relatedTasks.length}`,
@@ -244,9 +259,75 @@ export function registerRoadmapTools(server) {
         });
         return asText(markdown);
     });
+    server.registerTool("roadmapCreate", {
+        title: "Roadmap Create",
+        description: "Create one roadmap milestone in governance store",
+        inputSchema: {
+            projectPath: z.string(),
+            roadmapId: z.string().optional(),
+            title: z.string(),
+            status: z.enum(["active", "done"]).optional(),
+            time: z.string().optional(),
+        },
+    }, async ({ projectPath, roadmapId, title, status, time }) => {
+        if (roadmapId && !isValidRoadmapId(roadmapId)) {
+            return {
+                ...asText(renderErrorMarkdown("roadmapCreate", `Invalid roadmap ID format: ${roadmapId}`, ["expected format: ROADMAP-0001", "omit roadmapId to auto-generate next ID"], `roadmapCreate(projectPath=\"${projectPath}\", title=\"Define milestone\", time=\"2026-Q2\")`)),
+                isError: true,
+            };
+        }
+        const governanceDir = await resolveGovernanceDir(projectPath);
+        const normalizedProjectPath = toProjectPath(governanceDir);
+        const doc = await loadRoadmapDocument(governanceDir);
+        const finalRoadmapId = roadmapId ?? nextRoadmapId(doc.milestones);
+        const duplicated = doc.milestones.some((item) => item.id === finalRoadmapId);
+        if (duplicated) {
+            return {
+                ...asText(renderErrorMarkdown("roadmapCreate", `Roadmap milestone already exists: ${finalRoadmapId}`, ["roadmap IDs must be unique", "use roadmapUpdate for existing milestone"], `roadmapUpdate(projectPath=\"${normalizedProjectPath}\", roadmapId=\"${finalRoadmapId}\", updates={...})`)),
+                isError: true,
+            };
+        }
+        const created = normalizeMilestone({
+            id: finalRoadmapId,
+            title,
+            status: status ?? "active",
+            time,
+            updatedAt: nowIso(),
+        });
+        await upsertRoadmapInStore(doc.roadmapPath, created);
+        const refreshed = await loadRoadmapDocumentWithOptions(governanceDir, true);
+        const { tasks } = await loadTasks(governanceDir);
+        const lintSuggestions = collectRoadmapLintSuggestions(refreshed.milestones.map((item) => item.id), tasks);
+        const markdown = renderToolResponseMarkdown({
+            toolName: "roadmapCreate",
+            sections: [
+                summarySection([
+                    `- projectPath: ${normalizedProjectPath}`,
+                    `- governanceDir: ${governanceDir}`,
+                    `- roadmapId: ${created.id}`,
+                    `- status: ${created.status}`,
+                    `- updatedAt: ${created.updatedAt}`,
+                ]),
+                evidenceSection([
+                    "### Created Milestone",
+                    `- ${created.id} | ${created.status} | ${created.title}${created.time ? ` | time=${created.time}` : ""}`,
+                    "",
+                    "### Roadmap Count",
+                    `- total: ${refreshed.milestones.length}`,
+                ]),
+                guidanceSection([
+                    "Milestone created successfully and roadmap.md has been synced.",
+                    "Re-run roadmapContext to verify linked task traceability.",
+                ]),
+                lintSection(lintSuggestions),
+                nextCallSection(`roadmapContext(projectPath=\"${normalizedProjectPath}\", roadmapId=\"${created.id}\")`),
+            ],
+        });
+        return asText(markdown);
+    });
     server.registerTool("roadmapUpdate", {
         title: "Roadmap Update",
-        description: "Update one roadmap milestone fields incrementally in sqlite table",
+        description: "Update one roadmap milestone fields incrementally in governance store",
         inputSchema: {
             projectPath: z.string(),
             roadmapId: z.string(),
@@ -264,6 +345,7 @@ export function registerRoadmapTools(server) {
             };
         }
         const governanceDir = await resolveGovernanceDir(projectPath);
+        const normalizedProjectPath = toProjectPath(governanceDir);
         const doc = await loadRoadmapDocument(governanceDir);
         const existing = doc.milestones.find((item) => item.id === roadmapId);
         if (!existing) {
@@ -285,6 +367,7 @@ export function registerRoadmapTools(server) {
             toolName: "roadmapUpdate",
             sections: [
                 summarySection([
+                    `- projectPath: ${normalizedProjectPath}`,
                     `- governanceDir: ${governanceDir}`,
                     `- roadmapId: ${roadmapId}`,
                     `- newStatus: ${updated.status}`,
@@ -298,10 +381,9 @@ export function registerRoadmapTools(server) {
                     `- total: ${refreshed.milestones.length}`,
                 ]),
                 guidanceSection([
-                    "Milestone updated successfully.",
+                    "Milestone updated successfully and roadmap.md has been synced.",
                     "Re-run roadmapContext to verify linked task traceability.",
-                    "SQLite is source of truth; roadmap.md is a generated view and may be overwritten.",
-                    "Call `syncViews(projectPath=..., views=[\"roadmap\"], force=true)` when immediate markdown materialization is required.",
+                    ".projitive governance store is source of truth; roadmap.md is a generated view and may be overwritten.",
                 ]),
                 lintSection([]),
                 nextCallSection(`roadmapContext(projectPath="${toProjectPath(governanceDir)}", roadmapId="${roadmapId}")`),

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

@@ -1,8 +1,8 @@
-import { describe, it, expect, beforeAll, afterAll } from "vitest";
+import { describe, it, expect, beforeAll, afterAll, vi } from "vitest";
 import fs from "node:fs/promises";
 import path from "node:path";
 import os from "node:os";
-import { isValidRoadmapId, collectRoadmapLintSuggestions, loadRoadmapDocument, renderRoadmapMarkdown } from "./roadmap.js";
+import { isValidRoadmapId, collectRoadmapLintSuggestions, loadRoadmapDocument, renderRoadmapMarkdown, registerRoadmapTools } from "./roadmap.js";
 describe("roadmap module", () => {
     let tempDir;
     beforeAll(async () => {
@@ -45,7 +45,7 @@ describe("roadmap module", () => {
             const suggestions = collectRoadmapLintSuggestions(["ROADMAP-0001"], tasks);
             expect(suggestions.some(s => s.includes("TASK_REFS_EMPTY"))).toBe(true);
         });
-        it("loads from sqlite and rewrites roadmap markdown view", async () => {
+        it("loads from governance store and rewrites roadmap markdown view", async () => {
             const governanceDir = path.join(tempDir, ".projitive-db");
             await fs.mkdir(governanceDir, { recursive: true });
             await fs.writeFile(path.join(governanceDir, ".projitive"), "", "utf-8");
@@ -53,7 +53,7 @@ describe("roadmap module", () => {
             expect(doc.roadmapPath.endsWith(".projitive")).toBe(true);
             expect(doc.markdownPath.endsWith("roadmap.md")).toBe(true);
             const markdown = await fs.readFile(path.join(governanceDir, "roadmap.md"), "utf-8");
-            expect(markdown).toContain("generated from .projitive sqlite tables");
+            expect(markdown).toContain("generated from .projitive governance store");
         });
         it("renders milestones in newest-first order", () => {
             const markdown = renderRoadmapMarkdown([
@@ -63,5 +63,13 @@ describe("roadmap module", () => {
             expect(markdown.indexOf("ROADMAP-0002")).toBeLessThan(markdown.indexOf("ROADMAP-0001"));
             expect(markdown).toContain("[x] ROADMAP-0002");
         });
+        it("registers roadmapCreate tool", () => {
+            const mockServer = {
+                registerTool: (..._args) => undefined,
+            };
+            const spy = vi.spyOn(mockServer, "registerTool");
+            registerRoadmapTools(mockServer);
+            expect(spy.mock.calls.some((call) => call[0] === "roadmapCreate")).toBe(true);
+        });
     });
 });

package/output/source/tools/task.js

@@ -39,6 +39,7 @@ function taskStatusGuidance(task) {
 }
 const DEFAULT_NO_TASK_DISCOVERY_GUIDANCE = [
     "- Recheck project state first: run projectContext and confirm there is truly no TODO/IN_PROGRESS task to execute.",
+    "- Create new tasks via `taskCreate(...)` (do not edit tasks.md directly).",
     "- If all remaining tasks are BLOCKED, create one unblock task with explicit unblock condition and dependency owner.",
     "- Start from active roadmap milestones and split into the smallest executable slices with a single done condition each.",
     "- Prefer slices that unlock multiple downstream tasks before isolated refactors or low-impact cleanups.",
@@ -546,7 +547,7 @@ export function renderTasksMarkdown(tasks) {
     return [
         "# Tasks",
         "",
-        "This file is generated from .projitive sqlite tables by Projitive MCP. Manual edits will be overwritten.",
+        "This file is generated from .projitive governance store by Projitive MCP. Manual edits will be overwritten.",
         "",
         ...(sections.length > 0 ? sections : ["(no tasks)"]),
         "",
@@ -605,6 +606,7 @@ export function registerTaskTools(server) {
         },
     }, async ({ projectPath, status, limit }) => {
         const governanceDir = await resolveGovernanceDir(projectPath);
+        const normalizedProjectPath = toProjectPath(governanceDir);
         const { tasks } = await loadTasksDocument(governanceDir);
         const filtered = tasks
             .filter((task) => (status ? task.status === status : true))
@@ -624,6 +626,7 @@ export function registerTaskTools(server) {
             toolName: "taskList",
             sections: [
                 summarySection([
+                    `- projectPath: ${normalizedProjectPath}`,
                     `- governanceDir: ${governanceDir}`,
                     `- filter.status: ${status ?? "(none)"}`,
                     `- returned: ${filtered.length}`,
@@ -641,6 +644,94 @@ export function registerTaskTools(server) {
         });
         return asText(markdown);
     });
+    server.registerTool("taskCreate", {
+        title: "Task Create",
+        description: "Create a new task in governance store with stable TASK-xxxx ID",
+        inputSchema: {
+            projectPath: z.string(),
+            taskId: z.string(),
+            title: z.string(),
+            status: z.enum(["TODO", "IN_PROGRESS", "BLOCKED", "DONE"]).optional(),
+            owner: z.string().optional(),
+            summary: z.string().optional(),
+            roadmapRefs: z.array(z.string()).optional(),
+            links: z.array(z.string()).optional(),
+            subState: z.object({
+                phase: z.enum(["discovery", "design", "implementation", "testing"]).optional(),
+                confidence: z.number().min(0).max(1).optional(),
+                estimatedCompletion: z.string().optional(),
+            }).optional(),
+            blocker: z.object({
+                type: z.enum(["internal_dependency", "external_dependency", "resource", "approval"]),
+                description: z.string(),
+                blockingEntity: z.string().optional(),
+                unblockCondition: z.string().optional(),
+                escalationPath: z.string().optional(),
+            }).optional(),
+        },
+    }, async ({ projectPath, taskId, title, status, owner, summary, roadmapRefs, links, subState, blocker }) => {
+        if (!isValidTaskId(taskId)) {
+            return {
+                ...asText(renderErrorMarkdown("taskCreate", `Invalid task ID format: ${taskId}`, ["expected format: TASK-0001", "retry with a valid task ID"], `taskCreate(projectPath=\"${projectPath}\", taskId=\"TASK-0001\", title=\"Define executable objective\")`)),
+                isError: true,
+            };
+        }
+        const governanceDir = await resolveGovernanceDir(projectPath);
+        const normalizedProjectPath = toProjectPath(governanceDir);
+        const { tasksPath, tasks } = await loadTasksDocument(governanceDir);
+        const duplicated = tasks.some((item) => item.id === taskId);
+        if (duplicated) {
+            return {
+                ...asText(renderErrorMarkdown("taskCreate", `Task already exists: ${taskId}`, ["task IDs must be unique", "use taskUpdate for existing tasks"], `taskUpdate(projectPath=\"${normalizedProjectPath}\", taskId=\"${taskId}\", updates={...})`)),
+                isError: true,
+            };
+        }
+        const createdTask = normalizeTask({
+            id: taskId,
+            title,
+            status: status ?? "TODO",
+            owner,
+            summary,
+            roadmapRefs,
+            links,
+            subState,
+            blocker,
+            updatedAt: nowIso(),
+        });
+        await upsertTaskInStore(tasksPath, createdTask);
+        await loadTasksDocumentWithOptions(governanceDir, true);
+        const lintSuggestions = [
+            ...collectSingleTaskLintSuggestions(createdTask),
+            ...(await collectTaskFileLintSuggestions(governanceDir, createdTask)),
+        ];
+        const markdown = renderToolResponseMarkdown({
+            toolName: "taskCreate",
+            sections: [
+                summarySection([
+                    `- projectPath: ${normalizedProjectPath}`,
+                    `- governanceDir: ${governanceDir}`,
+                    `- taskId: ${createdTask.id}`,
+                    `- status: ${createdTask.status}`,
+                    `- owner: ${createdTask.owner || "(none)"}`,
+                    `- updatedAt: ${createdTask.updatedAt}`,
+                ]),
+                evidenceSection([
+                    "### Created Task",
+                    `- ${createdTask.id} | ${createdTask.status} | ${createdTask.title}`,
+                    `- summary: ${createdTask.summary || "(none)"}`,
+                    `- roadmapRefs: ${createdTask.roadmapRefs.join(", ") || "(none)"}`,
+                    `- links: ${createdTask.links.join(", ") || "(none)"}`,
+                ]),
+                guidanceSection([
+                    "Task created in governance store successfully and tasks.md has been synced.",
+                    "Run taskContext to verify references and lint guidance.",
+                ]),
+                lintSection(lintSuggestions),
+                nextCallSection(`taskContext(projectPath=\"${normalizedProjectPath}\", taskId=\"${createdTask.id}\")`),
+            ],
+        });
+        return asText(markdown);
+    });
     server.registerTool("taskNext", {
         title: "Task Next",
         description: "Start here to auto-select the highest-priority actionable task",
@@ -684,7 +775,7 @@ export function registerTaskTools(server) {
                     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)"}`)
+                            ? projectSnapshots.map((item, index) => `${index + 1}. ${toProjectPath(item.governanceDir)} | total=${item.total} | todo=${item.todo} | in_progress=${item.inProgress} | blocked=${item.blocked} | done=${item.done} | roadmapIds=${item.roadmapIds.join(", ") || "(none)"}`)
                             : ["- (none)"]),
                         "",
                         "### Seed Task Template",
@@ -692,6 +783,7 @@ export function registerTaskTools(server) {
                     ]),
                     guidanceSection([
                         "- No TODO/IN_PROGRESS task is available.",
+                        "- Create 1-3 new TODO tasks using `taskCreate(...)` from active roadmap slices.",
                         "- Use no-task discovery checklist below to proactively find and create meaningful TODO tasks.",
                         "- If roadmap has active milestones, analyze milestone intent and split into 1-3 executable TODO tasks.",
                         "",
@@ -707,7 +799,7 @@ export function registerTaskTools(server) {
                         "- Ensure each new task has stable TASK-xxxx ID and at least one roadmapRefs item.",
                     ]),
                     nextCallSection(preferredProject
-                        ? `projectContext(projectPath=\"${toProjectPath(preferredProject.governanceDir)}\")`
+                        ? `taskCreate(projectPath=\"${toProjectPath(preferredProject.governanceDir)}\", taskId=\"TASK-0001\", title=\"Create first executable slice\", roadmapRefs=[\"${preferredRoadmapRef}\"], summary=\"Derived from active roadmap milestone\")`
                         : "projectScan()"),
                 ],
             });
@@ -732,7 +824,7 @@ export function registerTaskTools(server) {
                     `- maxDepth: ${depth}`,
                     `- matchedProjects: ${projects.length}`,
                     `- actionableTasks: ${rankedCandidates.length}`,
-                    `- selectedProject: ${selected.governanceDir}`,
+                    `- selectedProject: ${toProjectPath(selected.governanceDir)}`,
                     `- selectedTaskId: ${selected.task.id}`,
                     `- selectedTaskStatus: ${selected.task.status}`,
                 ]),
@@ -748,7 +840,7 @@ export function registerTaskTools(server) {
                     "### Top Candidates",
                     ...rankedCandidates
                         .slice(0, candidateLimit)
-                        .map((item, index) => `${index + 1}. ${item.task.id} | ${item.task.status} | ${item.task.title} | project=${item.governanceDir} | projectScore=${item.projectScore} | latest=${item.projectLatestUpdatedAt}`),
+                        .map((item, index) => `${index + 1}. ${item.task.id} | ${item.task.status} | ${item.task.title} | projectPath=${toProjectPath(item.governanceDir)} | projectScore=${item.projectScore} | latest=${item.projectLatestUpdatedAt}`),
                     "",
                     "### Selection Reason",
                     "- Rank rule: projectScore DESC -> taskPriority DESC -> taskUpdatedAt DESC.",
@@ -791,6 +883,7 @@ export function registerTaskTools(server) {
             };
         }
         const governanceDir = await resolveGovernanceDir(projectPath);
+        const normalizedProjectPath = toProjectPath(governanceDir);
         const { markdownPath, tasks, markdown: tasksMarkdown } = await loadTasksDocument(governanceDir);
         const task = tasks.find((item) => item.id === taskId);
         if (!task) {
@@ -812,6 +905,7 @@ export function registerTaskTools(server) {
         const suggestedReadOrder = [markdownPath, ...relatedArtifacts.filter((item) => item !== markdownPath)];
         // Build summary with subState and blocker info (v1.1.0)
         const summaryLines = [
+            `- projectPath: ${normalizedProjectPath}`,
             `- governanceDir: ${governanceDir}`,
             `- taskId: ${task.id}`,
             `- title: ${task.title}`,
@@ -873,7 +967,7 @@ export function registerTaskTools(server) {
                     "",
                     "- Verify whether current status and evidence are consistent.",
                     ...taskStatusGuidance(task),
-                    "- If updates are needed, use tool writes for sqlite source (`taskUpdate` / `roadmapUpdate`) and keep TASK IDs unchanged.",
+                    "- If updates are needed, use tool writes for governance store (`taskUpdate` / `roadmapUpdate`) and keep TASK IDs unchanged.",
                     "- After editing, re-run `taskContext` to verify references and context consistency.",
                 ]),
                 lintSection(lintSuggestions),
@@ -917,6 +1011,7 @@ export function registerTaskTools(server) {
             };
         }
         const governanceDir = await resolveGovernanceDir(projectPath);
+        const normalizedProjectPath = toProjectPath(governanceDir);
         const { tasksPath, tasks } = await loadTasksDocument(governanceDir);
         const taskIndex = tasks.findIndex((item) => item.id === taskId);
         if (taskIndex === -1) {
@@ -971,6 +1066,7 @@ export function registerTaskTools(server) {
         const normalizedTask = normalizeTask(task);
         // Save task incrementally
         await upsertTaskInStore(tasksPath, normalizedTask);
+        await loadTasksDocumentWithOptions(governanceDir, true);
         task.status = normalizedTask.status;
         task.owner = normalizedTask.owner;
         task.summary = normalizedTask.summary;
@@ -981,6 +1077,8 @@ export function registerTaskTools(server) {
         task.blocker = normalizedTask.blocker;
         // Build response
         const updateSummary = [
+            `- projectPath: ${normalizedProjectPath}`,
+            `- governanceDir: ${governanceDir}`,
             `- taskId: ${taskId}`,
             `- originalStatus: ${originalStatus}`,
             `- newStatus: ${task.status}`,
@@ -1026,11 +1124,10 @@ export function registerTaskTools(server) {
                     ...(updates.blocker ? [`- blocker: ${JSON.stringify(updates.blocker)}`] : []),
                 ]),
                 guidanceSection([
-                    "Task updated successfully. Run `taskContext` to verify the changes.",
+                    "Task updated successfully and tasks.md has been synced. Run `taskContext` to verify the changes.",
                     "If status changed to DONE, ensure evidence links are added.",
                     "If subState or blocker were updated, verify the metadata is correct.",
-                    "SQLite is source of truth; tasks.md is a generated view and may be overwritten.",
-                    "Call `syncViews(projectPath=..., views=[\"tasks\"], force=true)` when immediate markdown materialization is required.",
+                    ".projitive governance store is source of truth; tasks.md is a generated view and may be overwritten.",
                 ]),
                 lintSection([]),
                 nextCallSection(`taskContext(projectPath=\"${toProjectPath(governanceDir)}\", taskId=\"${taskId}\")`),

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

@@ -149,7 +149,7 @@ describe("tasks module", () => {
         const guidanceB = await resolveNoTaskDiscoveryGuidance("/another/path");
         expect(guidanceA).toEqual(guidanceB);
     });
-    it("loads and saves tasks from sqlite and keeps newest-first order", async () => {
+    it("loads and saves tasks from governance store 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 });
@@ -163,7 +163,7 @@ describe("tasks module", () => {
         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");
+        expect(markdown).toContain("generated from .projitive governance store");
         await fs.rm(root, { recursive: true, force: true });
     });
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@projitive/mcp",
-  "version": "2.0.1",
+  "version": "2.0.3",
   "description": "Projitive MCP Server for project and task discovery/update",
   "license": "ISC",
   "author": "",
@@ -25,14 +25,11 @@
     "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",

package/output/source/common/migrations/runner.js

@@ -1,68 +0,0 @@
-import { MIGRATION_STEPS } from "./steps.js";
-function setStoreSchemaVersion(db, nextVersion) {
-    const statement = db.prepare(`
-    INSERT INTO meta (key, value)
-    VALUES (?, ?)
-    ON CONFLICT(key) DO UPDATE SET value=excluded.value
-  `);
-    statement.run(["store_schema_version", String(nextVersion)]);
-    statement.free();
-}
-function writeMigrationHistory(db, migrationId, fromVersion, toVersion, checksum, status, startedAt, finishedAt, errorMessage) {
-    const statement = db.prepare(`
-    INSERT INTO migration_history (
-      id,
-      from_version,
-      to_version,
-      checksum,
-      started_at,
-      finished_at,
-      status,
-      error_message
-    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)
-  `);
-    statement.run([
-        migrationId,
-        fromVersion,
-        toVersion,
-        checksum,
-        startedAt,
-        finishedAt,
-        status,
-        errorMessage,
-    ]);
-    statement.free();
-}
-export function runPendingMigrations(db, currentVersion, targetVersion) {
-    let versionCursor = currentVersion;
-    if (versionCursor >= targetVersion) {
-        return;
-    }
-    const steps = MIGRATION_STEPS
-        .filter((item) => item.fromVersion >= currentVersion && item.toVersion <= targetVersion)
-        .sort((a, b) => a.fromVersion - b.fromVersion);
-    for (const step of steps) {
-        if (step.fromVersion !== versionCursor) {
-            throw new Error(`Migration chain broken at version ${versionCursor}. Missing step ${versionCursor} -> ${step.toVersion}.`);
-        }
-        const startedAt = new Date().toISOString();
-        try {
-            db.exec("BEGIN TRANSACTION;");
-            step.up(db);
-            setStoreSchemaVersion(db, step.toVersion);
-            const finishedAt = new Date().toISOString();
-            writeMigrationHistory(db, step.id, step.fromVersion, step.toVersion, step.checksum, "SUCCESS", startedAt, finishedAt, null);
-            db.exec("COMMIT;");
-            versionCursor = step.toVersion;
-        }
-        catch (error) {
-            db.exec("ROLLBACK;");
-            const finishedAt = new Date().toISOString();
-            writeMigrationHistory(db, step.id, step.fromVersion, step.toVersion, step.checksum, "FAILED", startedAt, finishedAt, error instanceof Error ? error.message : String(error));
-            throw error;
-        }
-    }
-    if (versionCursor !== targetVersion) {
-        throw new Error(`Migration target not reached. expected=${targetVersion}, actual=${versionCursor}`);
-    }
-}

package/output/source/common/migrations/steps.js

@@ -1,55 +0,0 @@
-function hasColumn(db, tableName, columnName) {
-    const result = db.exec(`PRAGMA table_info(${tableName});`);
-    if (result.length === 0) {
-        return false;
-    }
-    const rows = result[0].values;
-    return rows.some((row) => String(row[1]) === columnName);
-}
-function ensureRecordVersionColumns(db) {
-    const tables = ["tasks", "roadmaps", "meta", "view_state"];
-    for (const tableName of tables) {
-        if (!hasColumn(db, tableName, "record_version")) {
-            db.exec(`ALTER TABLE ${tableName} ADD COLUMN record_version INTEGER NOT NULL DEFAULT 1;`);
-        }
-    }
-}
-function ensurePerformanceIndexes(db) {
-    db.exec(`
-    CREATE INDEX IF NOT EXISTS idx_tasks_status_updated
-      ON tasks(status, updated_at DESC);
-    CREATE INDEX IF NOT EXISTS idx_tasks_updated
-      ON tasks(updated_at DESC);
-    CREATE INDEX IF NOT EXISTS idx_roadmaps_updated
-      ON roadmaps(updated_at DESC);
-  `);
-}
-export const MIGRATION_STEPS = [
-    {
-        id: "20260313_baseline_v1",
-        fromVersion: 0,
-        toVersion: 1,
-        checksum: "baseline-v1",
-        up: () => {
-            // Baseline marker for pre-versioned stores.
-        },
-    },
-    {
-        id: "20260313_add_record_version_v2",
-        fromVersion: 1,
-        toVersion: 2,
-        checksum: "add-record-version-v2",
-        up: (db) => {
-            ensureRecordVersionColumns(db);
-        },
-    },
-    {
-        id: "20260313_add_indexes_v3",
-        fromVersion: 2,
-        toVersion: 3,
-        checksum: "add-indexes-v3",
-        up: (db) => {
-            ensurePerformanceIndexes(db);
-        },
-    },
-];

package/output/source/common/migrations/types.js

@@ -1 +0,0 @@
-export {};