@projitive/mcp 2.0.2 → 2.0.4

package/output/source/tools/task.js

@@ -1,60 +1,61 @@
-import fs from "node:fs/promises";
-import path from "node:path";
-import { z } from "zod";
-import { candidateFilesFromArtifacts, discoverGovernanceArtifacts, findTextReferences, ensureStore, loadActionableTasksFromStore, loadRoadmapsFromStore, loadTaskStatusStatsFromStore, loadTasksFromStore, replaceTasksInStore, upsertTaskInStore, getStoreVersion, getMarkdownViewState, markMarkdownViewBuilt, } from "../common/index.js";
-import { asText, evidenceSection, guidanceSection, lintSection, nextCallSection, renderErrorMarkdown, renderToolResponseMarkdown, summarySection, } from "../common/index.js";
-import { TASK_LINT_CODES, renderLintSuggestions } from "../common/index.js";
-import { resolveGovernanceDir, resolveScanDepth, resolveScanRoots, discoverProjectsAcrossRoots, toProjectPath } from "./project.js";
-import { isValidRoadmapId } from "./roadmap.js";
-import { SUB_STATE_PHASES, BLOCKER_TYPES } from "../types.js";
-export const ALLOWED_STATUS = ["TODO", "IN_PROGRESS", "BLOCKED", "DONE"];
-export const TASK_ID_REGEX = /^TASK-\d{4}$/;
-export const TASKS_MARKDOWN_FILE = "tasks.md";
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { z } from 'zod';
+import { candidateFilesFromArtifacts, discoverGovernanceArtifacts, findTextReferences, ensureStore, loadActionableTasksFromStore, loadRoadmapsFromStore, loadTaskStatusStatsFromStore, loadTasksFromStore, replaceTasksInStore, upsertTaskInStore, getStoreVersion, getMarkdownViewState, markMarkdownViewBuilt, } from '../common/index.js';
+import { asText, evidenceSection, guidanceSection, lintSection, nextCallSection, renderErrorMarkdown, renderToolResponseMarkdown, summarySection, } from '../common/index.js';
+import { TASK_LINT_CODES, renderLintSuggestions } from '../common/index.js';
+import { resolveGovernanceDir, resolveScanDepth, resolveScanRoots, discoverProjectsAcrossRoots, toProjectPath } from './project.js';
+import { isValidRoadmapId } from './roadmap.js';
+import { SUB_STATE_PHASES, BLOCKER_TYPES } from '../types.js';
+export const ALLOWED_STATUS = ['TODO', 'IN_PROGRESS', 'BLOCKED', 'DONE'];
+export const TASK_ID_REGEX = /^TASK-(\d+)$/;
+export const TASKS_MARKDOWN_FILE = 'tasks.md';
 function appendLintSuggestions(target, suggestions) {
     target.push(...renderLintSuggestions(suggestions));
 }
 function taskStatusGuidance(task) {
-    if (task.status === "TODO") {
+    if (task.status === 'TODO') {
         return [
-            "- This task is TODO: confirm scope and set execution plan before edits.",
-            "- Move to IN_PROGRESS only after owner and initial evidence are ready.",
+            '- This task is TODO: confirm scope and set execution plan before edits.',
+            '- Move to IN_PROGRESS only after owner and initial evidence are ready.',
         ];
     }
-    if (task.status === "IN_PROGRESS") {
+    if (task.status === 'IN_PROGRESS') {
         return [
-            "- This task is IN_PROGRESS: prioritize finishing with report/design evidence updates.",
-            "- Verify references stay consistent before marking DONE.",
+            '- This task is IN_PROGRESS: prioritize finishing with report/design evidence updates.',
+            '- Verify references stay consistent before marking DONE.',
         ];
     }
-    if (task.status === "BLOCKED") {
+    if (task.status === 'BLOCKED') {
         return [
-            "- This task is BLOCKED: identify blocker and required unblock condition first.",
-            "- Reopen only after blocker evidence is documented.",
+            '- This task is BLOCKED: identify blocker and required unblock condition first.',
+            '- Reopen only after blocker evidence is documented.',
         ];
     }
     return [
-        "- This task is DONE: only reopen when new requirement changes scope.",
-        "- Keep report evidence immutable unless correction is required.",
+        '- This task is DONE: only reopen when new requirement changes scope.',
+        '- Keep report evidence immutable unless correction is required.',
     ];
 }
 const DEFAULT_NO_TASK_DISCOVERY_GUIDANCE = [
-    "- Recheck project state first: run projectContext and confirm there is truly no TODO/IN_PROGRESS task to execute.",
-    "- 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.",
-    "- Create TODO tasks only when evidence is clear: each new task must produce at least one report/designs/readme artifact update.",
-    "- Skip duplicate scope: do not create tasks that overlap existing TODO/IN_PROGRESS/BLOCKED task intent.",
-    "- Use quality gates for discovery candidates: user value, delivery risk reduction, or measurable throughput improvement.",
-    "- Keep each discovery round small (1-3 tasks), then rerun taskNext immediately for re-ranking and execution.",
+    '- 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.',
+    '- Create TODO tasks only when evidence is clear: each new task must produce at least one report/designs/readme artifact update.',
+    '- Skip duplicate scope: do not create tasks that overlap existing TODO/IN_PROGRESS/BLOCKED task intent.',
+    '- Use quality gates for discovery candidates: user value, delivery risk reduction, or measurable throughput improvement.',
+    '- Keep each discovery round small (1-3 tasks), then rerun taskNext immediately for re-ranking and execution.',
 ];
 const DEFAULT_TASK_CONTEXT_READING_GUIDANCE = [
-    "- Read governance workspace overview first (README.md / projitive://governance/workspace).",
-    "- Read roadmap and active milestones (roadmap.md / projitive://governance/roadmap).",
-    "- Read task view and related task cards (tasks.md / projitive://governance/tasks).",
-    "- Read design specs and technical decisions under designs/ (architecture, API contracts, constraints).",
-    "- Read reports/ for latest execution evidence, regressions, and unresolved risks.",
-    "- Read process guides under templates/docs/project guidelines to align with local governance rules.",
-    "- If available, read docs/ architecture or migration guides before major structural changes.",
+    '- Read governance workspace overview first (README.md / projitive://governance/workspace).',
+    '- Read roadmap and active milestones (roadmap.md / projitive://governance/roadmap).',
+    '- Read task view and related task cards (tasks.md / projitive://governance/tasks).',
+    '- Read design specs and technical decisions under designs/ (architecture, API contracts, constraints).',
+    '- Read reports/ for latest execution evidence, regressions, and unresolved risks.',
+    '- Read process guides under templates/docs/project guidelines to align with local governance rules.',
+    '- If available, read docs/ architecture or migration guides before major structural changes.',
 ];
 export async function resolveNoTaskDiscoveryGuidance(governanceDir) {
     void governanceDir;
@@ -65,7 +66,7 @@ export async function resolveTaskContextReadingGuidance(governanceDir) {
     return DEFAULT_TASK_CONTEXT_READING_GUIDANCE;
 }
 async function readRoadmapIds(governanceDir) {
-    const dbPath = path.join(governanceDir, ".projitive");
+    const dbPath = path.join(governanceDir, '.projitive');
     try {
         await ensureStore(dbPath);
         const milestones = await loadRoadmapsFromStore(dbPath);
@@ -78,16 +79,16 @@ async function readRoadmapIds(governanceDir) {
 }
 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",
+        '```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",
-        "  - .projitive/roadmap.md",
-        "```",
+        '- links:',
+        '  - README.md',
+        '  - .projitive/roadmap.md',
+        '```',
     ];
 }
 function isHttpUrl(value) {
@@ -95,9 +96,9 @@ function isHttpUrl(value) {
 }
 function isProjectRootRelativePath(value) {
     return value.length > 0
-        && !value.startsWith("/")
-        && !value.startsWith("./")
-        && !value.startsWith("../")
+        && !value.startsWith('/')
+        && !value.startsWith('./')
+        && !value.startsWith('../')
         && !/^[A-Za-z]:\//.test(value);
 }
 function normalizeTaskLink(link) {
@@ -105,16 +106,16 @@ function normalizeTaskLink(link) {
     if (trimmed.length === 0 || isHttpUrl(trimmed)) {
         return trimmed;
     }
-    const slashNormalized = trimmed.replace(/\\/g, "/");
-    const withoutDotPrefix = slashNormalized.replace(/^\.\//, "");
-    return withoutDotPrefix.replace(/^\/+/, "");
+    const slashNormalized = trimmed.replace(/\\/g, '/');
+    const withoutDotPrefix = slashNormalized.replace(/^\.\//, '');
+    return withoutDotPrefix.replace(/^\/+/, '');
 }
 function resolveTaskLinkPath(projectPath, link) {
     return path.join(projectPath, link);
 }
 async function readActionableTaskCandidates(governanceDirs) {
     const snapshots = await Promise.all(governanceDirs.map(async (governanceDir) => {
-        const tasksPath = path.join(governanceDir, ".projitive");
+        const tasksPath = path.join(governanceDir, '.projitive');
         await ensureStore(tasksPath);
         const [stats, actionableTasks] = await Promise.all([
             loadTaskStatusStatsFromStore(tasksPath),
@@ -124,11 +125,11 @@ async function readActionableTaskCandidates(governanceDirs) {
             governanceDir,
             tasks: actionableTasks,
             projectScore: stats.inProgress * 2 + stats.todo,
-            projectLatestUpdatedAt: stats.latestUpdatedAt || "(unknown)",
+            projectLatestUpdatedAt: stats.latestUpdatedAt || '(unknown)',
         };
     }));
     return snapshots.flatMap((item) => item.tasks
-        .filter((task) => task.status === "IN_PROGRESS" || task.status === "TODO")
+        .filter((task) => task.status === 'IN_PROGRESS' || task.status === 'TODO')
         .map((task) => ({
         governanceDir: item.governanceDir,
         task,
@@ -142,13 +143,13 @@ export function nowIso() {
     return new Date().toISOString();
 }
 export function isValidTaskId(id) {
-    return TASK_ID_REGEX.test(id);
+    return toTaskIdNumericSuffix(id) > 0;
 }
 export function taskPriority(status) {
-    if (status === "IN_PROGRESS") {
+    if (status === 'IN_PROGRESS') {
         return 2;
     }
-    if (status === "TODO") {
+    if (status === 'TODO') {
         return 1;
     }
     return 0;
@@ -158,11 +159,21 @@ export function toTaskUpdatedAtMs(updatedAt) {
     return Number.isFinite(timestamp) ? timestamp : 0;
 }
 function toTaskIdNumericSuffix(taskId) {
-    const match = taskId.match(/^(?:TASK-)(\d{4})$/);
+    const match = taskId.match(TASK_ID_REGEX);
     if (!match) {
         return -1;
     }
-    return Number.parseInt(match[1], 10);
+    const suffix = Number.parseInt(match[1], 10);
+    return Number.isFinite(suffix) ? suffix : -1;
+}
+function nextTaskId(tasks) {
+    const maxSuffix = tasks
+        .map((item) => toTaskIdNumericSuffix(item.id))
+        .filter((value) => value > 0)
+        .reduce((max, value) => Math.max(max, value), 0);
+    const next = maxSuffix + 1;
+    const minWidth = Math.max(4, String(next).length);
+    return `TASK-${String(next).padStart(minWidth, '0')}`;
 }
 export function sortTasksNewestFirst(tasks) {
     return [...tasks].sort((a, b) => {
@@ -182,13 +193,13 @@ function normalizeAndSortTasks(tasks) {
 }
 function resolveTaskArtifactPaths(governanceDir) {
     return {
-        tasksPath: path.join(governanceDir, ".projitive"),
+        tasksPath: path.join(governanceDir, '.projitive'),
         markdownPath: path.join(governanceDir, TASKS_MARKDOWN_FILE),
     };
 }
 async function syncTasksMarkdownView(tasksPath, markdownPath, markdown, force = false) {
-    const sourceVersion = await getStoreVersion(tasksPath, "tasks");
-    const viewState = await getMarkdownViewState(tasksPath, "tasks_markdown");
+    const sourceVersion = await getStoreVersion(tasksPath, 'tasks');
+    const viewState = await getMarkdownViewState(tasksPath, 'tasks_markdown');
     const markdownExists = await fs.access(markdownPath).then(() => true).catch(() => false);
     const shouldWrite = force
         || !markdownExists
@@ -197,8 +208,8 @@ async function syncTasksMarkdownView(tasksPath, markdownPath, markdown, force =
     if (!shouldWrite) {
         return;
     }
-    await fs.writeFile(markdownPath, markdown, "utf-8");
-    await markMarkdownViewBuilt(tasksPath, "tasks_markdown", sourceVersion);
+    await fs.writeFile(markdownPath, markdown, 'utf-8');
+    await markMarkdownViewBuilt(tasksPath, 'tasks_markdown', sourceVersion);
 }
 export function rankActionableTaskCandidates(candidates) {
     return [...candidates].sort((a, b) => {
@@ -224,9 +235,9 @@ export function normalizeTask(task) {
     const normalized = {
         id: String(task.id),
         title: String(task.title),
-        status: ALLOWED_STATUS.includes(task.status) ? task.status : "TODO",
-        owner: task.owner ? String(task.owner) : "",
-        summary: task.summary ? String(task.summary) : "",
+        status: ALLOWED_STATUS.includes(task.status) ? task.status : 'TODO',
+        owner: task.owner ? String(task.owner) : '',
+        summary: task.summary ? String(task.summary) : '',
         updatedAt: task.updatedAt ? String(task.updatedAt) : nowIso(),
         links: Array.isArray(task.links)
             ? Array.from(new Set(task.links
@@ -257,32 +268,32 @@ function collectTaskLintSuggestionItems(tasks) {
     if (duplicateIds.length > 0) {
         suggestions.push({
             code: TASK_LINT_CODES.DUPLICATE_ID,
-            message: `Duplicate task IDs detected: ${duplicateIds.join(", ")}.`,
-            fixHint: "Keep task IDs unique in marker block.",
+            message: `Duplicate task IDs detected: ${duplicateIds.join(', ')}.`,
+            fixHint: 'Keep task IDs unique in marker block.',
         });
     }
-    const inProgressWithoutOwner = tasks.filter((task) => task.status === "IN_PROGRESS" && task.owner.trim().length === 0);
+    const inProgressWithoutOwner = tasks.filter((task) => task.status === 'IN_PROGRESS' && task.owner.trim().length === 0);
     if (inProgressWithoutOwner.length > 0) {
         suggestions.push({
             code: TASK_LINT_CODES.IN_PROGRESS_OWNER_EMPTY,
             message: `${inProgressWithoutOwner.length} IN_PROGRESS task(s) have empty owner.`,
-            fixHint: "Set owner before continuing execution.",
+            fixHint: 'Set owner before continuing execution.',
         });
     }
-    const doneWithoutLinks = tasks.filter((task) => task.status === "DONE" && task.links.length === 0);
+    const doneWithoutLinks = tasks.filter((task) => task.status === 'DONE' && task.links.length === 0);
     if (doneWithoutLinks.length > 0) {
         suggestions.push({
             code: TASK_LINT_CODES.DONE_LINKS_MISSING,
             message: `${doneWithoutLinks.length} DONE task(s) have no links evidence.`,
-            fixHint: "Add at least one evidence link before keeping DONE.",
+            fixHint: 'Add at least one evidence link before keeping DONE.',
         });
     }
-    const blockedWithoutReason = tasks.filter((task) => task.status === "BLOCKED" && task.summary.trim().length === 0);
+    const blockedWithoutReason = tasks.filter((task) => task.status === 'BLOCKED' && task.summary.trim().length === 0);
     if (blockedWithoutReason.length > 0) {
         suggestions.push({
             code: TASK_LINT_CODES.BLOCKED_SUMMARY_EMPTY,
             message: `${blockedWithoutReason.length} BLOCKED task(s) have empty summary.`,
-            fixHint: "Add blocker reason and unblock condition.",
+            fixHint: 'Add blocker reason and unblock condition.',
         });
     }
     const invalidUpdatedAt = tasks.filter((task) => !Number.isFinite(new Date(task.updatedAt).getTime()));
@@ -290,7 +301,7 @@ function collectTaskLintSuggestionItems(tasks) {
         suggestions.push({
             code: TASK_LINT_CODES.UPDATED_AT_INVALID,
             message: `${invalidUpdatedAt.length} task(s) have invalid updatedAt format.`,
-            fixHint: "Use ISO8601 UTC timestamp.",
+            fixHint: 'Use ISO8601 UTC timestamp.',
         });
     }
     const missingRoadmapRefs = tasks.filter((task) => task.roadmapRefs.length === 0);
@@ -298,7 +309,7 @@ function collectTaskLintSuggestionItems(tasks) {
         suggestions.push({
             code: TASK_LINT_CODES.ROADMAP_REFS_EMPTY,
             message: `${missingRoadmapRefs.length} task(s) have empty roadmapRefs.`,
-            fixHint: "Bind at least one ROADMAP-xxxx when applicable.",
+            fixHint: 'Bind at least one ROADMAP-xxxx when applicable.',
         });
     }
     const invalidLinkPathFormat = tasks.filter((task) => task.links.some((link) => {
@@ -309,18 +320,18 @@ function collectTaskLintSuggestionItems(tasks) {
         suggestions.push({
             code: TASK_LINT_CODES.LINK_PATH_FORMAT_INVALID,
             message: `${invalidLinkPathFormat.length} task(s) contain invalid links path format.`,
-            fixHint: "Use project-root-relative paths without leading slash (for example reports/task-0001.md) or http(s) URL.",
+            fixHint: 'Use project-root-relative paths without leading slash (for example reports/task-0001.md) or http(s) URL.',
         });
     }
     // ============================================================================
     // Spec v1.1.0 - Blocker Categorization Validation
     // ============================================================================
-    const blockedWithoutBlocker = tasks.filter((task) => task.status === "BLOCKED" && !task.blocker);
+    const blockedWithoutBlocker = tasks.filter((task) => task.status === 'BLOCKED' && !task.blocker);
     if (blockedWithoutBlocker.length > 0) {
         suggestions.push({
             code: TASK_LINT_CODES.BLOCKED_WITHOUT_BLOCKER,
             message: `${blockedWithoutBlocker.length} BLOCKED task(s) have no blocker metadata.`,
-            fixHint: "Add structured blocker metadata with type and description.",
+            fixHint: 'Add structured blocker metadata with type and description.',
         });
     }
     const blockerTypeInvalid = tasks.filter((task) => task.blocker && !BLOCKER_TYPES.includes(task.blocker.type));
@@ -328,7 +339,7 @@ function collectTaskLintSuggestionItems(tasks) {
         suggestions.push({
             code: TASK_LINT_CODES.BLOCKER_TYPE_INVALID,
             message: `${blockerTypeInvalid.length} task(s) have invalid blocker type.`,
-            fixHint: `Use one of: ${BLOCKER_TYPES.join(", ")}.`,
+            fixHint: `Use one of: ${BLOCKER_TYPES.join(', ')}.`,
         });
     }
     const blockerDescriptionEmpty = tasks.filter((task) => task.blocker && !task.blocker.description?.trim());
@@ -336,18 +347,18 @@ function collectTaskLintSuggestionItems(tasks) {
         suggestions.push({
             code: TASK_LINT_CODES.BLOCKER_DESCRIPTION_EMPTY,
             message: `${blockerDescriptionEmpty.length} task(s) have empty blocker description.`,
-            fixHint: "Provide a clear description of why the task is blocked.",
+            fixHint: 'Provide a clear description of why the task is blocked.',
         });
     }
     // ============================================================================
     // Spec v1.1.0 - Sub-state Metadata Validation (Optional but Recommended)
     // ============================================================================
-    const inProgressWithoutSubState = tasks.filter((task) => task.status === "IN_PROGRESS" && !task.subState);
+    const inProgressWithoutSubState = tasks.filter((task) => task.status === 'IN_PROGRESS' && !task.subState);
     if (inProgressWithoutSubState.length > 0) {
         suggestions.push({
             code: TASK_LINT_CODES.IN_PROGRESS_WITHOUT_SUBSTATE,
             message: `${inProgressWithoutSubState.length} IN_PROGRESS task(s) have no subState metadata.`,
-            fixHint: "Add optional subState metadata for better progress tracking.",
+            fixHint: 'Add optional subState metadata for better progress tracking.',
         });
     }
     const subStatePhaseInvalid = tasks.filter((task) => task.subState?.phase && !SUB_STATE_PHASES.includes(task.subState.phase));
@@ -355,15 +366,15 @@ function collectTaskLintSuggestionItems(tasks) {
         suggestions.push({
             code: TASK_LINT_CODES.SUBSTATE_PHASE_INVALID,
             message: `${subStatePhaseInvalid.length} task(s) have invalid subState phase.`,
-            fixHint: `Use one of: ${SUB_STATE_PHASES.join(", ")}.`,
+            fixHint: `Use one of: ${SUB_STATE_PHASES.join(', ')}.`,
         });
     }
-    const subStateConfidenceInvalid = tasks.filter((task) => typeof task.subState?.confidence === "number" && (task.subState.confidence < 0 || task.subState.confidence > 1));
+    const subStateConfidenceInvalid = tasks.filter((task) => typeof task.subState?.confidence === 'number' && (task.subState.confidence < 0 || task.subState.confidence > 1));
     if (subStateConfidenceInvalid.length > 0) {
         suggestions.push({
             code: TASK_LINT_CODES.SUBSTATE_CONFIDENCE_INVALID,
             message: `${subStateConfidenceInvalid.length} task(s) have invalid confidence score.`,
-            fixHint: "Confidence must be between 0.0 and 1.0.",
+            fixHint: 'Confidence must be between 0.0 and 1.0.',
         });
     }
     return suggestions;
@@ -373,18 +384,18 @@ export function collectTaskLintSuggestions(tasks) {
 }
 function collectSingleTaskLintSuggestions(task) {
     const suggestions = [];
-    if (task.status === "IN_PROGRESS" && task.owner.trim().length === 0) {
+    if (task.status === 'IN_PROGRESS' && task.owner.trim().length === 0) {
         suggestions.push({
             code: TASK_LINT_CODES.IN_PROGRESS_OWNER_EMPTY,
-            message: "Current task is IN_PROGRESS but owner is empty.",
-            fixHint: "Set owner before continuing execution.",
+            message: 'Current task is IN_PROGRESS but owner is empty.',
+            fixHint: 'Set owner before continuing execution.',
         });
     }
-    if (task.status === "DONE" && task.links.length === 0) {
+    if (task.status === 'DONE' && task.links.length === 0) {
         suggestions.push({
             code: TASK_LINT_CODES.DONE_LINKS_MISSING,
-            message: "Current task is DONE but has no links evidence.",
-            fixHint: "Add at least one evidence link.",
+            message: 'Current task is DONE but has no links evidence.',
+            fixHint: 'Add at least one evidence link.',
         });
     }
     const invalidLinkPathFormat = task.links.some((link) => {
@@ -394,77 +405,77 @@ function collectSingleTaskLintSuggestions(task) {
     if (invalidLinkPathFormat) {
         suggestions.push({
             code: TASK_LINT_CODES.LINK_PATH_FORMAT_INVALID,
-            message: "Current task has invalid links path format.",
-            fixHint: "Use project-root-relative paths without leading slash (for example reports/task-0001.md) or http(s) URL.",
+            message: 'Current task has invalid links path format.',
+            fixHint: 'Use project-root-relative paths without leading slash (for example reports/task-0001.md) or http(s) URL.',
         });
     }
-    if (task.status === "BLOCKED" && task.summary.trim().length === 0) {
+    if (task.status === 'BLOCKED' && task.summary.trim().length === 0) {
         suggestions.push({
             code: TASK_LINT_CODES.BLOCKED_SUMMARY_EMPTY,
-            message: "Current task is BLOCKED but summary is empty.",
-            fixHint: "Add blocker reason and unblock condition.",
+            message: 'Current task is BLOCKED but summary is empty.',
+            fixHint: 'Add blocker reason and unblock condition.',
         });
     }
     if (!Number.isFinite(new Date(task.updatedAt).getTime())) {
         suggestions.push({
             code: TASK_LINT_CODES.UPDATED_AT_INVALID,
-            message: "Current task updatedAt is invalid.",
-            fixHint: "Use ISO8601 UTC timestamp.",
+            message: 'Current task updatedAt is invalid.',
+            fixHint: 'Use ISO8601 UTC timestamp.',
         });
     }
     if (task.roadmapRefs.length === 0) {
         suggestions.push({
             code: TASK_LINT_CODES.ROADMAP_REFS_EMPTY,
-            message: "Current task has empty roadmapRefs.",
-            fixHint: "Bind ROADMAP-xxxx where applicable.",
+            message: 'Current task has empty roadmapRefs.',
+            fixHint: 'Bind ROADMAP-xxxx where applicable.',
         });
     }
     // ============================================================================
     // Spec v1.1.0 - Blocker Categorization Validation (Single Task)
     // ============================================================================
-    if (task.status === "BLOCKED" && !task.blocker) {
+    if (task.status === 'BLOCKED' && !task.blocker) {
         suggestions.push({
             code: TASK_LINT_CODES.BLOCKED_WITHOUT_BLOCKER,
-            message: "Current task is BLOCKED but has no blocker metadata.",
-            fixHint: "Add structured blocker metadata with type and description.",
+            message: 'Current task is BLOCKED but has no blocker metadata.',
+            fixHint: 'Add structured blocker metadata with type and description.',
         });
     }
     if (task.blocker && !BLOCKER_TYPES.includes(task.blocker.type)) {
         suggestions.push({
             code: TASK_LINT_CODES.BLOCKER_TYPE_INVALID,
             message: `Current task has invalid blocker type: ${task.blocker.type}.`,
-            fixHint: `Use one of: ${BLOCKER_TYPES.join(", ")}.`,
+            fixHint: `Use one of: ${BLOCKER_TYPES.join(', ')}.`,
         });
     }
     if (task.blocker && !task.blocker.description?.trim()) {
         suggestions.push({
             code: TASK_LINT_CODES.BLOCKER_DESCRIPTION_EMPTY,
-            message: "Current task has empty blocker description.",
-            fixHint: "Provide a clear description of why the task is blocked.",
+            message: 'Current task has empty blocker description.',
+            fixHint: 'Provide a clear description of why the task is blocked.',
         });
     }
     // ============================================================================
     // Spec v1.1.0 - Sub-state Metadata Validation (Single Task, Optional)
     // ============================================================================
-    if (task.status === "IN_PROGRESS" && !task.subState) {
+    if (task.status === 'IN_PROGRESS' && !task.subState) {
         suggestions.push({
             code: TASK_LINT_CODES.IN_PROGRESS_WITHOUT_SUBSTATE,
-            message: "Current task is IN_PROGRESS but has no subState metadata.",
-            fixHint: "Add optional subState metadata for better progress tracking.",
+            message: 'Current task is IN_PROGRESS but has no subState metadata.',
+            fixHint: 'Add optional subState metadata for better progress tracking.',
         });
     }
     if (task.subState?.phase && !SUB_STATE_PHASES.includes(task.subState.phase)) {
         suggestions.push({
             code: TASK_LINT_CODES.SUBSTATE_PHASE_INVALID,
             message: `Current task has invalid subState phase: ${task.subState.phase}.`,
-            fixHint: `Use one of: ${SUB_STATE_PHASES.join(", ")}.`,
+            fixHint: `Use one of: ${SUB_STATE_PHASES.join(', ')}.`,
         });
     }
-    if (typeof task.subState?.confidence === "number" && (task.subState.confidence < 0 || task.subState.confidence > 1)) {
+    if (typeof task.subState?.confidence === 'number' && (task.subState.confidence < 0 || task.subState.confidence > 1)) {
         suggestions.push({
             code: TASK_LINT_CODES.SUBSTATE_CONFIDENCE_INVALID,
             message: `Current task has invalid confidence score: ${task.subState.confidence}.`,
-            fixHint: "Confidence must be between 0.0 and 1.0.",
+            fixHint: 'Confidence must be between 0.0 and 1.0.',
         });
     }
     return renderLintSuggestions(suggestions);
@@ -484,7 +495,7 @@ async function collectTaskFileLintSuggestions(governanceDir, task) {
             suggestions.push({
                 code: TASK_LINT_CODES.LINK_PATH_FORMAT_INVALID,
                 message: `Link path should be project-root-relative without leading slash: ${normalized}.`,
-                fixHint: "Use path/from/project/root format.",
+                fixHint: 'Use path/from/project/root format.',
             });
             continue;
         }
@@ -501,25 +512,25 @@ async function collectTaskFileLintSuggestions(governanceDir, task) {
 }
 export function renderTasksMarkdown(tasks) {
     const sections = sortTasksNewestFirst(tasks).map((task) => {
-        const roadmapRefs = task.roadmapRefs.length > 0 ? task.roadmapRefs.join(", ") : "(none)";
+        const roadmapRefs = task.roadmapRefs.length > 0 ? task.roadmapRefs.join(', ') : '(none)';
         const links = task.links.length > 0
-            ? ["- links:", ...task.links.map((link) => `  - ${link}`)]
-            : ["- links:", "  - (none)"];
+            ? ['- links:', ...task.links.map((link) => `  - ${link}`)]
+            : ['- links:', '  - (none)'];
         const lines = [
             `## ${task.id} | ${task.status} | ${task.title}`,
-            `- owner: ${task.owner || "(none)"}`,
-            `- summary: ${task.summary || "(none)"}`,
+            `- owner: ${task.owner || '(none)'}`,
+            `- summary: ${task.summary || '(none)'}`,
             `- updatedAt: ${task.updatedAt}`,
             `- roadmapRefs: ${roadmapRefs}`,
             ...links,
         ];
         // Add subState for IN_PROGRESS tasks (Spec v1.1.0)
-        if (task.subState && task.status === "IN_PROGRESS") {
-            lines.push(`- subState:`);
+        if (task.subState && task.status === 'IN_PROGRESS') {
+            lines.push('- subState:');
             if (task.subState.phase) {
                 lines.push(`  - phase: ${task.subState.phase}`);
             }
-            if (typeof task.subState.confidence === "number") {
+            if (typeof task.subState.confidence === 'number') {
                 lines.push(`  - confidence: ${task.subState.confidence}`);
             }
             if (task.subState.estimatedCompletion) {
@@ -527,8 +538,8 @@ export function renderTasksMarkdown(tasks) {
             }
         }
         // Add blocker for BLOCKED tasks (Spec v1.1.0)
-        if (task.blocker && task.status === "BLOCKED") {
-            lines.push(`- blocker:`);
+        if (task.blocker && task.status === 'BLOCKED') {
+            lines.push('- blocker:');
             lines.push(`  - type: ${task.blocker.type}`);
             lines.push(`  - description: ${task.blocker.description}`);
             if (task.blocker.blockingEntity) {
@@ -541,16 +552,20 @@ export function renderTasksMarkdown(tasks) {
                 lines.push(`  - escalationPath: ${task.blocker.escalationPath}`);
             }
         }
-        return lines.join("\n");
+        return lines.join('\n');
     });
     return [
-        "# Tasks",
-        "",
-        "This file is generated from .projitive sqlite tables by Projitive MCP. Manual edits will be overwritten.",
-        "",
-        ...(sections.length > 0 ? sections : ["(no tasks)"]),
-        "",
-    ].join("\n");
+        '# Tasks',
+        '',
+        'Projitive is an AI-first project governance framework for tasks, roadmaps, reports, and designs.',
+        'Author: yinxulai',
+        'Repository: https://github.com/yinxulai/projitive',
+        'Do not edit this file manually. This file is automatically generated by Projitive.',
+        'This file is generated from .projitive governance store by Projitive MCP. Manual edits will be overwritten.',
+        '',
+        ...(sections.length > 0 ? sections : ['(no tasks)']),
+        '',
+    ].join('\n');
 }
 export async function ensureTasksFile(inputPath) {
     const governanceDir = await resolveGovernanceDir(inputPath);
@@ -587,25 +602,27 @@ export function validateTransition(from, to) {
         return true;
     }
     const allowed = {
-        TODO: new Set(["IN_PROGRESS", "BLOCKED"]),
-        IN_PROGRESS: new Set(["BLOCKED", "DONE"]),
-        BLOCKED: new Set(["IN_PROGRESS", "TODO"]),
+        TODO: new Set(['IN_PROGRESS', 'BLOCKED']),
+        IN_PROGRESS: new Set(['BLOCKED', 'DONE']),
+        BLOCKED: new Set(['IN_PROGRESS', 'TODO']),
         DONE: new Set(),
     };
     return allowed[from].has(to);
 }
 export function registerTaskTools(server) {
-    server.registerTool("taskList", {
-        title: "Task List",
-        description: "List tasks for a known project and optionally filter by status",
+    server.registerTool('taskList', {
+        title: 'Task List',
+        description: 'List tasks for a known project and optionally filter by status',
         inputSchema: {
             projectPath: z.string(),
-            status: z.enum(["TODO", "IN_PROGRESS", "BLOCKED", "DONE"]).optional(),
+            status: z.enum(['TODO', 'IN_PROGRESS', 'BLOCKED', 'DONE']).optional(),
             limit: z.number().int().min(1).max(200).optional(),
         },
     }, async ({ projectPath, status, limit }) => {
         const governanceDir = await resolveGovernanceDir(projectPath);
-        const { tasks } = await loadTasksDocument(governanceDir);
+        const normalizedProjectPath = toProjectPath(governanceDir);
+        const { tasks, markdownPath: tasksViewPath } = await loadTasksDocument(governanceDir);
+        const roadmapViewPath = path.join(governanceDir, 'roadmap.md');
         const filtered = tasks
             .filter((task) => (status ? task.status === status : true))
             .slice(0, limit ?? 100);
@@ -615,35 +632,130 @@ export function registerTaskTools(server) {
                 {
                     code: TASK_LINT_CODES.FILTER_EMPTY,
                     message: `No tasks matched status=${status}.`,
-                    fixHint: "Confirm status values or update task states.",
+                    fixHint: 'Confirm status values or update task states.',
                 },
             ]);
         }
         const nextTaskId = filtered[0]?.id;
         const markdown = renderToolResponseMarkdown({
-            toolName: "taskList",
+            toolName: 'taskList',
             sections: [
                 summarySection([
+                    `- projectPath: ${normalizedProjectPath}`,
                     `- governanceDir: ${governanceDir}`,
-                    `- filter.status: ${status ?? "(none)"}`,
+                    `- tasksView: ${tasksViewPath}`,
+                    `- roadmapView: ${roadmapViewPath}`,
+                    `- filter.status: ${status ?? '(none)'}`,
                     `- returned: ${filtered.length}`,
                 ]),
                 evidenceSection([
-                    "- tasks:",
-                    ...filtered.map((task) => `- ${task.id} | ${task.status} | ${task.title} | owner=${task.owner || ""} | updatedAt=${task.updatedAt}`),
+                    '- tasks:',
+                    ...filtered.map((task) => `- ${task.id} | ${task.status} | ${task.title} | owner=${task.owner || ''} | updatedAt=${task.updatedAt}`),
                 ]),
-                guidanceSection(["- Pick one task ID and call `taskContext`."]),
+                guidanceSection(['- Pick one task ID and call `taskContext`.']),
                 lintSection(lintSuggestions),
                 nextCallSection(nextTaskId
-                    ? `taskContext(projectPath=\"${toProjectPath(governanceDir)}\", taskId=\"${nextTaskId}\")`
+                    ? `taskContext(projectPath="${toProjectPath(governanceDir)}", taskId="${nextTaskId}")`
                     : undefined),
             ],
         });
         return asText(markdown);
     });
-    server.registerTool("taskNext", {
-        title: "Task Next",
-        description: "Start here to auto-select the highest-priority actionable task",
+    server.registerTool('taskCreate', {
+        title: 'Task Create',
+        description: 'Create a new task in governance store with stable TASK-<number> ID',
+        inputSchema: {
+            projectPath: z.string(),
+            taskId: z.string().optional(),
+            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 (taskId && !isValidTaskId(taskId)) {
+            return {
+                ...asText(renderErrorMarkdown('taskCreate', `Invalid task ID format: ${taskId}`, ['expected format: TASK-1 or TASK-0001', 'omit taskId to auto-generate next ID'], `taskCreate(projectPath="${projectPath}", title="Define executable objective")`)),
+                isError: true,
+            };
+        }
+        const governanceDir = await resolveGovernanceDir(projectPath);
+        const normalizedProjectPath = toProjectPath(governanceDir);
+        const { tasksPath, tasks, markdownPath: tasksViewPath } = await loadTasksDocument(governanceDir);
+        const roadmapViewPath = path.join(governanceDir, 'roadmap.md');
+        const finalTaskId = taskId ?? nextTaskId(tasks);
+        const duplicated = tasks.some((item) => item.id === finalTaskId);
+        if (duplicated) {
+            return {
+                ...asText(renderErrorMarkdown('taskCreate', `Task already exists: ${finalTaskId}`, ['task IDs must be unique', 'use taskUpdate for existing tasks'], `taskUpdate(projectPath="${normalizedProjectPath}", taskId="${finalTaskId}", updates={...})`)),
+                isError: true,
+            };
+        }
+        const createdTask = normalizeTask({
+            id: finalTaskId,
+            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}`,
+                    `- tasksView: ${tasksViewPath}`,
+                    `- roadmapView: ${roadmapViewPath}`,
+                    `- 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',
         inputSchema: {
             limit: z.number().int().min(1).max(20).optional(),
         },
@@ -654,7 +766,7 @@ export function registerTaskTools(server) {
         const rankedCandidates = rankActionableTaskCandidates(await readActionableTaskCandidates(projects));
         if (rankedCandidates.length === 0) {
             const projectSnapshots = await Promise.all(projects.map(async (governanceDir) => {
-                const tasksPath = path.join(governanceDir, ".projitive");
+                const tasksPath = path.join(governanceDir, '.projitive');
                 await ensureStore(tasksPath);
                 const stats = await loadTaskStatusStatsFromStore(tasksPath);
                 const roadmapIds = await readRoadmapIds(governanceDir);
@@ -669,46 +781,47 @@ export function registerTaskTools(server) {
                 };
             }));
             const preferredProject = projectSnapshots[0];
-            const preferredRoadmapRef = preferredProject?.roadmapIds[0] ?? "ROADMAP-0001";
+            const preferredRoadmapRef = preferredProject?.roadmapIds[0] ?? 'ROADMAP-0001';
             const noTaskDiscoveryGuidance = await resolveNoTaskDiscoveryGuidance(preferredProject?.governanceDir);
             const markdown = renderToolResponseMarkdown({
-                toolName: "taskNext",
+                toolName: 'taskNext',
                 sections: [
                     summarySection([
-                        `- rootPaths: ${roots.join(", ")}`,
+                        `- rootPaths: ${roots.join(', ')}`,
                         `- rootCount: ${roots.length}`,
                         `- maxDepth: ${depth}`,
                         `- matchedProjects: ${projects.length}`,
-                        "- actionableTasks: 0",
+                        '- actionableTasks: 0',
                     ]),
                     evidenceSection([
-                        "### Project Snapshots",
+                        '### 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)"}`)
-                            : ["- (none)"]),
-                        "",
-                        "### Seed Task Template",
+                            ? 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',
                         ...renderTaskSeedTemplate(preferredRoadmapRef),
                     ]),
                     guidanceSection([
-                        "- No TODO/IN_PROGRESS task is available.",
-                        "- 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.",
-                        "",
-                        "### No-Task Discovery Checklist",
+                        '- 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.',
+                        '',
+                        '### 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 creating tasks, rerun `taskNext` to re-rank actionable work.",
+                        '',
+                        '- 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 creating tasks, rerun `taskNext` to re-rank actionable work.',
                     ]),
                     lintSection([
-                        "- No actionable tasks found. Verify task statuses and required fields in .projitive task table.",
-                        "- Ensure each new task has stable TASK-xxxx ID and at least one roadmapRefs item.",
+                        '- No actionable tasks found. Verify task statuses and required fields in .projitive task table.',
+                        '- Ensure each new task has stable TASK-<number> ID and at least one roadmapRefs item.',
                     ]),
                     nextCallSection(preferredProject
-                        ? `projectContext(projectPath=\"${toProjectPath(preferredProject.governanceDir)}\")`
-                        : "projectScan()"),
+                        ? `taskCreate(projectPath="${toProjectPath(preferredProject.governanceDir)}", title="Create first executable slice", roadmapRefs=["${preferredRoadmapRef}"], summary="Derived from active roadmap milestone")`
+                        : 'projectScan()'),
                 ],
             });
             return asText(markdown);
@@ -724,61 +837,61 @@ export function registerTaskTools(server) {
         const suggestedReadOrder = [selectedTaskDocument.markdownPath, ...relatedArtifacts.filter((item) => item !== selectedTaskDocument.markdownPath)];
         const candidateLimit = limit ?? 5;
         const markdown = renderToolResponseMarkdown({
-            toolName: "taskNext",
+            toolName: 'taskNext',
             sections: [
                 summarySection([
-                    `- rootPaths: ${roots.join(", ")}`,
+                    `- rootPaths: ${roots.join(', ')}`,
                     `- rootCount: ${roots.length}`,
                     `- maxDepth: ${depth}`,
                     `- matchedProjects: ${projects.length}`,
                     `- actionableTasks: ${rankedCandidates.length}`,
-                    `- selectedProject: ${selected.governanceDir}`,
+                    `- selectedProject: ${toProjectPath(selected.governanceDir)}`,
                     `- selectedTaskId: ${selected.task.id}`,
                     `- selectedTaskStatus: ${selected.task.status}`,
                 ]),
                 evidenceSection([
-                    "### Selected Task",
+                    '### Selected Task',
                     `- id: ${selected.task.id}`,
                     `- title: ${selected.task.title}`,
-                    `- owner: ${selected.task.owner || "(none)"}`,
+                    `- owner: ${selected.task.owner || '(none)'}`,
                     `- updatedAt: ${selected.task.updatedAt}`,
-                    `- roadmapRefs: ${selected.task.roadmapRefs.join(", ") || "(none)"}`,
+                    `- roadmapRefs: ${selected.task.roadmapRefs.join(', ') || '(none)'}`,
                     `- taskLocation: ${taskLocation ? `${taskLocation.filePath}#L${taskLocation.line}` : selectedTaskDocument.markdownPath}`,
-                    "",
-                    "### Top Candidates",
+                    '',
+                    '### 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}`),
-                    "",
-                    "### Selection Reason",
-                    "- Rank rule: projectScore DESC -> taskPriority DESC -> taskUpdatedAt DESC.",
+                        .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.',
                     `- Selected candidate scores: projectScore=${selected.projectScore}, taskPriority=${selected.taskPriority}, taskUpdatedAtMs=${selected.taskUpdatedAtMs}.`,
-                    "",
-                    "### Related Artifacts",
-                    ...(relatedArtifacts.length > 0 ? relatedArtifacts.map((file) => `- ${file}`) : ["- (none)"]),
-                    "",
-                    "### Reference Locations",
+                    '',
+                    '### Related Artifacts',
+                    ...(relatedArtifacts.length > 0 ? relatedArtifacts.map((file) => `- ${file}`) : ['- (none)']),
+                    '',
+                    '### Reference Locations',
                     ...(referenceLocations.length > 0
                         ? referenceLocations.map((item) => `- ${item.filePath}#L${item.line}: ${item.text}`)
-                        : ["- (none)"]),
-                    "",
-                    "### Suggested Read Order",
+                        : ['- (none)']),
+                    '',
+                    '### Suggested Read Order',
                     ...suggestedReadOrder.map((item, index) => `${index + 1}. ${item}`),
                 ]),
                 guidanceSection([
-                    "- Start immediately with Suggested Read Order and execute the selected task.",
-                    "- Update markdown artifacts directly while keeping TASK/ROADMAP IDs unchanged.",
-                    "- Re-run `taskContext` for the selectedTaskId after edits to verify evidence consistency.",
+                    '- Start immediately with Suggested Read Order and execute the selected task.',
+                    '- Update markdown artifacts directly while keeping TASK/ROADMAP IDs unchanged.',
+                    '- Re-run `taskContext` for the selectedTaskId after edits to verify evidence consistency.',
                 ]),
                 lintSection(lintSuggestions),
-                nextCallSection(`taskContext(projectPath=\"${toProjectPath(selected.governanceDir)}\", taskId=\"${selected.task.id}\")`),
+                nextCallSection(`taskContext(projectPath="${toProjectPath(selected.governanceDir)}", taskId="${selected.task.id}")`),
             ],
         });
         return asText(markdown);
     });
-    server.registerTool("taskContext", {
-        title: "Task Context",
-        description: "Get deep context, evidence links, and read order for one task",
+    server.registerTool('taskContext', {
+        title: 'Task Context',
+        description: 'Get deep context, evidence links, and read order for one task',
         inputSchema: {
             projectPath: z.string(),
             taskId: z.string(),
@@ -786,16 +899,18 @@ export function registerTaskTools(server) {
     }, async ({ projectPath, taskId }) => {
         if (!isValidTaskId(taskId)) {
             return {
-                ...asText(renderErrorMarkdown("taskContext", `Invalid task ID format: ${taskId}`, ["expected format: TASK-0001", "retry with a valid task ID"], `taskContext(projectPath=\"${projectPath}\", taskId=\"TASK-0001\")`)),
+                ...asText(renderErrorMarkdown('taskContext', `Invalid task ID format: ${taskId}`, ['expected format: TASK-1 or TASK-0001', 'retry with a valid task ID'], `taskContext(projectPath="${projectPath}", taskId="TASK-0001")`)),
                 isError: true,
             };
         }
         const governanceDir = await resolveGovernanceDir(projectPath);
-        const { markdownPath, tasks, markdown: tasksMarkdown } = await loadTasksDocument(governanceDir);
+        const normalizedProjectPath = toProjectPath(governanceDir);
+        const { markdownPath, tasks } = await loadTasksDocument(governanceDir);
+        const roadmapViewPath = path.join(governanceDir, 'roadmap.md');
         const task = tasks.find((item) => item.id === taskId);
         if (!task) {
             return {
-                ...asText(renderErrorMarkdown("taskContext", `Task not found: ${taskId}`, ["run `taskList` to discover available IDs", "retry with an existing task ID"], `taskList(projectPath=\"${toProjectPath(governanceDir)}\")`)),
+                ...asText(renderErrorMarkdown('taskContext', `Task not found: ${taskId}`, ['run `taskList` to discover available IDs', 'retry with an existing task ID'], `taskList(projectPath="${toProjectPath(governanceDir)}")`)),
                 isError: true,
             };
         }
@@ -812,22 +927,25 @@ 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}`,
+            `- tasksView: ${markdownPath}`,
+            `- roadmapView: ${roadmapViewPath}`,
             `- taskId: ${task.id}`,
             `- title: ${task.title}`,
             `- status: ${task.status}`,
             `- owner: ${task.owner}`,
             `- updatedAt: ${task.updatedAt}`,
-            `- roadmapRefs: ${task.roadmapRefs.join(", ") || "(none)"}`,
+            `- roadmapRefs: ${task.roadmapRefs.join(', ') || '(none)'}`,
             `- taskLocation: ${taskLocation ? `${taskLocation.filePath}#L${taskLocation.line}` : markdownPath}`,
         ];
         // Add subState info for IN_PROGRESS tasks (v1.1.0)
-        if (task.subState && task.status === "IN_PROGRESS") {
-            summaryLines.push(`- subState:`);
+        if (task.subState && task.status === 'IN_PROGRESS') {
+            summaryLines.push('- subState:');
             if (task.subState.phase) {
                 summaryLines.push(`  - phase: ${task.subState.phase}`);
             }
-            if (typeof task.subState.confidence === "number") {
+            if (typeof task.subState.confidence === 'number') {
                 summaryLines.push(`  - confidence: ${task.subState.confidence}`);
             }
             if (task.subState.estimatedCompletion) {
@@ -835,8 +953,8 @@ export function registerTaskTools(server) {
             }
         }
         // Add blocker info for BLOCKED tasks (v1.1.0)
-        if (task.blocker && task.status === "BLOCKED") {
-            summaryLines.push(`- blocker:`);
+        if (task.blocker && task.status === 'BLOCKED') {
+            summaryLines.push('- blocker:');
             summaryLines.push(`  - type: ${task.blocker.type}`);
             summaryLines.push(`  - description: ${task.blocker.description}`);
             if (task.blocker.blockingEntity) {
@@ -850,58 +968,58 @@ export function registerTaskTools(server) {
             }
         }
         const coreMarkdown = renderToolResponseMarkdown({
-            toolName: "taskContext",
+            toolName: 'taskContext',
             sections: [
                 summarySection(summaryLines),
                 evidenceSection([
-                    "### Related Artifacts",
-                    ...(relatedArtifacts.length > 0 ? relatedArtifacts.map((file) => `- ${file}`) : ["- (none)"]),
-                    "",
-                    "### Reference Locations",
+                    '### Related Artifacts',
+                    ...(relatedArtifacts.length > 0 ? relatedArtifacts.map((file) => `- ${file}`) : ['- (none)']),
+                    '',
+                    '### Reference Locations',
                     ...(referenceLocations.length > 0
                         ? referenceLocations.map((item) => `- ${item.filePath}#L${item.line}: ${item.text}`)
-                        : ["- (none)"]),
-                    "",
-                    "### Suggested Read Order",
+                        : ['- (none)']),
+                    '',
+                    '### Suggested Read Order',
                     ...suggestedReadOrder.map((item, index) => `${index + 1}. ${item}`),
                 ]),
                 guidanceSection([
-                    "- Read the files in Suggested Read Order.",
-                    "",
-                    "### Recommended Context Reading",
+                    '- Read the files in Suggested Read Order.',
+                    '',
+                    '### Recommended Context Reading',
                     ...contextReadingGuidance,
-                    "",
-                    "- Verify whether current status and evidence are consistent.",
+                    '',
+                    '- 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.",
-                    "- After editing, re-run `taskContext` to verify references and context consistency.",
+                    '- 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),
-                nextCallSection(`taskContext(projectPath=\"${toProjectPath(governanceDir)}\", taskId=\"${task.id}\")`),
+                nextCallSection(`taskContext(projectPath="${toProjectPath(governanceDir)}", taskId="${task.id}")`),
             ],
         });
         return asText(coreMarkdown);
     });
     // taskUpdate tool - Update task fields including subState and blocker (Spec v1.1.0)
-    server.registerTool("taskUpdate", {
-        title: "Task Update",
-        description: "Update task fields including status, owner, summary, subState, and blocker metadata",
+    server.registerTool('taskUpdate', {
+        title: 'Task Update',
+        description: 'Update task fields including status, owner, summary, subState, and blocker metadata',
         inputSchema: {
             projectPath: z.string(),
             taskId: z.string(),
             updates: z.object({
-                status: z.enum(["TODO", "IN_PROGRESS", "BLOCKED", "DONE"]).optional(),
+                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(),
+                    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"]),
+                    type: z.enum(['internal_dependency', 'external_dependency', 'resource', 'approval']),
                     description: z.string(),
                     blockingEntity: z.string().optional(),
                     unblockCondition: z.string().optional(),
@@ -912,16 +1030,19 @@ export function registerTaskTools(server) {
     }, async ({ projectPath, taskId, updates }) => {
         if (!isValidTaskId(taskId)) {
             return {
-                ...asText(renderErrorMarkdown("taskUpdate", `Invalid task ID format: ${taskId}`, ["expected format: TASK-0001", "retry with a valid task ID"], `taskUpdate(projectPath=\"${projectPath}\", taskId=\"TASK-0001\", updates={...})`)),
+                ...asText(renderErrorMarkdown('taskUpdate', `Invalid task ID format: ${taskId}`, ['expected format: TASK-1 or TASK-0001', 'retry with a valid task ID'], `taskUpdate(projectPath="${projectPath}", taskId="TASK-0001", updates={...})`)),
                 isError: true,
             };
         }
         const governanceDir = await resolveGovernanceDir(projectPath);
+        const normalizedProjectPath = toProjectPath(governanceDir);
         const { tasksPath, tasks } = await loadTasksDocument(governanceDir);
+        const tasksViewPath = path.join(governanceDir, TASKS_MARKDOWN_FILE);
+        const roadmapViewPath = path.join(governanceDir, 'roadmap.md');
         const taskIndex = tasks.findIndex((item) => item.id === taskId);
         if (taskIndex === -1) {
             return {
-                ...asText(renderErrorMarkdown("taskUpdate", `Task not found: ${taskId}`, ["run `taskList` to discover available IDs", "retry with an existing task ID"], `taskList(projectPath=\"${toProjectPath(governanceDir)}\")`)),
+                ...asText(renderErrorMarkdown('taskUpdate', `Task not found: ${taskId}`, ['run `taskList` to discover available IDs', 'retry with an existing task ID'], `taskList(projectPath="${toProjectPath(governanceDir)}")`)),
                 isError: true,
             };
         }
@@ -930,7 +1051,7 @@ export function registerTaskTools(server) {
         // Validate status transition
         if (updates.status && !validateTransition(originalStatus, updates.status)) {
             return {
-                ...asText(renderErrorMarkdown("taskUpdate", `Invalid status transition: ${originalStatus} -> ${updates.status}`, ["use `validateTransition` to check allowed transitions", "provide evidence when transitioning to DONE"], `taskContext(projectPath=\"${toProjectPath(governanceDir)}\", taskId=\"${taskId}\")`)),
+                ...asText(renderErrorMarkdown('taskUpdate', `Invalid status transition: ${originalStatus} -> ${updates.status}`, ['use `validateTransition` to check allowed transitions', 'provide evidence when transitioning to DONE'], `taskContext(projectPath="${toProjectPath(governanceDir)}", taskId="${taskId}")`)),
                 isError: true,
             };
         }
@@ -971,6 +1092,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,22 +1103,26 @@ export function registerTaskTools(server) {
         task.blocker = normalizedTask.blocker;
         // Build response
         const updateSummary = [
+            `- projectPath: ${normalizedProjectPath}`,
+            `- governanceDir: ${governanceDir}`,
+            `- tasksView: ${tasksViewPath}`,
+            `- roadmapView: ${roadmapViewPath}`,
             `- taskId: ${taskId}`,
             `- originalStatus: ${originalStatus}`,
             `- newStatus: ${task.status}`,
             `- updatedAt: ${task.updatedAt}`,
         ];
         if (task.subState) {
-            updateSummary.push(`- subState:`);
+            updateSummary.push('- subState:');
             if (task.subState.phase)
                 updateSummary.push(`  - phase: ${task.subState.phase}`);
-            if (typeof task.subState.confidence === "number")
+            if (typeof task.subState.confidence === 'number')
                 updateSummary.push(`  - confidence: ${task.subState.confidence}`);
             if (task.subState.estimatedCompletion)
                 updateSummary.push(`  - estimatedCompletion: ${task.subState.estimatedCompletion}`);
         }
         if (task.blocker) {
-            updateSummary.push(`- blocker:`);
+            updateSummary.push('- blocker:');
             updateSummary.push(`  - type: ${task.blocker.type}`);
             updateSummary.push(`  - description: ${task.blocker.description}`);
             if (task.blocker.blockingEntity)
@@ -1007,33 +1133,32 @@ export function registerTaskTools(server) {
                 updateSummary.push(`  - escalationPath: ${task.blocker.escalationPath}`);
         }
         const markdown = renderToolResponseMarkdown({
-            toolName: "taskUpdate",
+            toolName: 'taskUpdate',
             sections: [
                 summarySection(updateSummary),
                 evidenceSection([
-                    "### Updated Task",
+                    '### Updated Task',
                     `- ${task.id} | ${task.status} | ${task.title}`,
-                    `- owner: ${task.owner || "(none)"}`,
-                    `- summary: ${task.summary || "(none)"}`,
-                    "",
-                    "### Update Details",
+                    `- owner: ${task.owner || '(none)'}`,
+                    `- summary: ${task.summary || '(none)'}`,
+                    '',
+                    '### Update Details',
                     ...(updates.status ? [`- status: ${originalStatus} → ${updates.status}`] : []),
                     ...(updates.owner !== undefined ? [`- owner: ${updates.owner}`] : []),
                     ...(updates.summary !== undefined ? [`- summary: ${updates.summary}`] : []),
-                    ...(updates.roadmapRefs ? [`- roadmapRefs: ${updates.roadmapRefs.join(", ")}`] : []),
-                    ...(updates.links ? [`- links: ${updates.links.join(", ")}`] : []),
+                    ...(updates.roadmapRefs ? [`- roadmapRefs: ${updates.roadmapRefs.join(', ')}`] : []),
+                    ...(updates.links ? [`- links: ${updates.links.join(', ')}`] : []),
                     ...(updates.subState ? [`- subState: ${JSON.stringify(updates.subState)}`] : []),
                     ...(updates.blocker ? [`- blocker: ${JSON.stringify(updates.blocker)}`] : []),
                 ]),
                 guidanceSection([
-                    "Task updated successfully. 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.",
+                    '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.',
+                    '.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}\")`),
+                nextCallSection(`taskContext(projectPath="${toProjectPath(governanceDir)}", taskId="${taskId}")`),
             ],
         });
         return asText(markdown);