@projitive/mcp 1.1.1 → 1.2.0

package/README.md

@@ -84,7 +84,7 @@ MCP client config example (`mcp.json`):
       "command": "npx",
       "args": ["-y", "@projitive/mcp"],
       "env": {
-        "PROJITIVE_SCAN_ROOT_PATH": "/absolute/path/to/your/workspace",
+        "PROJITIVE_SCAN_ROOT_PATHS": "/workspace/a:/workspace/b",
         "PROJITIVE_SCAN_MAX_DEPTH": "3"
       }
     }
@@ -94,7 +94,9 @@ MCP client config example (`mcp.json`):
 
 Environment variables (required):
 
-- `PROJITIVE_SCAN_ROOT_PATH`: required scan root for discovery methods.
+- `PROJITIVE_SCAN_ROOT_PATHS`: required scan roots for discovery methods.
+  - Use platform-delimiter string (`:` on Linux/macOS, `;` on Windows), e.g. `/workspace/a:/workspace/b`.
+  - Fallback: if not set, legacy `PROJITIVE_SCAN_ROOT_PATH` is used.
 - `PROJITIVE_SCAN_MAX_DEPTH`: required scan depth for discovery methods (integer `0-8`).
 
 Local path startup is not the recommended usage mode in this README.

package/output/package.json

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

package/output/source/common/index.js

@@ -4,7 +4,6 @@ export * from "./utils.js";
 export * from "./markdown.js";
 export * from "./files.js";
 export * from "./response.js";
-export * from "./confidence.js";
 export * from "./catch.js";
 export * from "./artifacts.js";
 export * from "./linter.js";

package/output/source/index.js

@@ -6,9 +6,8 @@ import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import packageJson from "../package.json" with { type: "json" };
 import { registerTools } from "./tools/index.js";
-import { registerResources } from "./resources/index.js";
 import { registerPrompts } from "./prompts/index.js";
-import { registerDesignContextResources, registerDesignContextPrompts } from "./design-context.js";
+import { registerResources } from "./resources/index.js";
 const PROJITIVE_SPEC_VERSION = "1.1.0";
 const currentFilePath = fileURLToPath(import.meta.url);
 const sourceDir = path.dirname(currentFilePath);
@@ -21,12 +20,10 @@ const server = new McpServer({
     version: MCP_RUNTIME_VERSION,
     description: "Semantic Projitive MCP for project/task discovery and agent guidance with markdown-first outputs",
 });
-// Register all modules
+// 注册所有模块
 registerTools(server);
-registerResources(server, repoRoot);
 registerPrompts(server);
-registerDesignContextResources(server);
-registerDesignContextPrompts(server);
+registerResources(server, repoRoot);
 async function main() {
     console.error(`[projitive-mcp] starting server`);
     console.error(`[projitive-mcp] version=${MCP_RUNTIME_VERSION} spec=${PROJITIVE_SPEC_VERSION} transport=stdio pid=${process.pid}`);

package/output/source/index.test.js

@@ -26,10 +26,6 @@ vi.mock("./tools/task.js", () => ({
 vi.mock("./tools/roadmap.js", () => ({
     registerRoadmapTools: vi.fn(),
 }));
-vi.mock("./design-context.js", () => ({
-    registerDesignContextResources: vi.fn(),
-    registerDesignContextPrompts: vi.fn(),
-}));
 vi.mock("./resources/governance.js", () => ({
     registerGovernanceResources: vi.fn(),
 }));
@@ -87,8 +83,6 @@ describe("index module", () => {
         expect(content).toContain("registerTools(server)");
         expect(content).toContain("registerResources(server, repoRoot)");
         expect(content).toContain("registerPrompts(server)");
-        expect(content).toContain("registerDesignContextResources(server)");
-        expect(content).toContain("registerDesignContextPrompts(server)");
     });
     it("should have proper error handling in main", async () => {
         const indexPath = path.join(sourceDir, "index.ts");

package/output/source/tools/project.js

@@ -46,9 +46,43 @@ function requireEnvVar(name) {
     }
     return value.trim();
 }
+function normalizeScanRoots(rootPaths) {
+    const normalized = rootPaths
+        .map((entry) => entry.trim())
+        .filter((entry) => entry.length > 0)
+        .map((entry) => normalizePath(entry));
+    return Array.from(new Set(normalized));
+}
+function parseScanRoots(rawValue) {
+    const trimmed = rawValue.trim();
+    if (trimmed.length === 0) {
+        return [];
+    }
+    return trimmed.split(path.delimiter);
+}
+export function resolveScanRoots(inputPaths) {
+    const normalizedInputPaths = normalizeScanRoots(inputPaths ?? []);
+    if (normalizedInputPaths.length > 0) {
+        return normalizedInputPaths;
+    }
+    const configuredRoots = process.env.PROJITIVE_SCAN_ROOT_PATHS;
+    const rootsFromMultiEnv = typeof configuredRoots === "string"
+        ? normalizeScanRoots(parseScanRoots(configuredRoots))
+        : [];
+    if (rootsFromMultiEnv.length > 0) {
+        return rootsFromMultiEnv;
+    }
+    const legacyRoot = process.env.PROJITIVE_SCAN_ROOT_PATH;
+    const rootsFromLegacyEnv = typeof legacyRoot === "string"
+        ? normalizeScanRoots([legacyRoot])
+        : [];
+    if (rootsFromLegacyEnv.length > 0) {
+        return rootsFromLegacyEnv;
+    }
+    throw new Error("Missing required environment variable: PROJITIVE_SCAN_ROOT_PATHS (or legacy PROJITIVE_SCAN_ROOT_PATH)");
+}
 export function resolveScanRoot(inputPath) {
-    const configuredRoot = requireEnvVar("PROJITIVE_SCAN_ROOT_PATH");
-    return normalizePath(inputPath ?? configuredRoot);
+    return resolveScanRoots(inputPath ? [inputPath] : undefined)[0];
 }
 export function resolveScanDepth(inputDepth) {
     const configuredDepthRaw = requireEnvVar("PROJITIVE_SCAN_MAX_DEPTH");
@@ -210,6 +244,10 @@ export async function discoverProjects(rootPath, maxDepth) {
     await walk(rootPath, 0);
     return Array.from(new Set(results)).sort();
 }
+export async function discoverProjectsAcrossRoots(rootPaths, maxDepth) {
+    const perRootResults = await Promise.all(rootPaths.map((rootPath) => discoverProjects(rootPath, maxDepth)));
+    return Array.from(new Set(perRootResults.flat())).sort();
+}
 async function pathExists(targetPath) {
     const accessResult = await catchIt(fs.access(targetPath));
     return !accessResult.isError();
@@ -362,14 +400,15 @@ export function registerProjectTools(server) {
         description: "Start here when project path is unknown; discover all governance roots",
         inputSchema: {},
     }, async () => {
-        const root = resolveScanRoot();
+        const roots = resolveScanRoots();
         const depth = resolveScanDepth();
-        const projects = await discoverProjects(root, depth);
+        const projects = await discoverProjectsAcrossRoots(roots, depth);
         const markdown = renderToolResponseMarkdown({
             toolName: "projectScan",
             sections: [
                 summarySection([
-                    `- rootPath: ${root}`,
+                    `- rootPaths: ${roots.join(", ")}`,
+                    `- rootCount: ${roots.length}`,
                     `- maxDepth: ${depth}`,
                     `- discoveredCount: ${projects.length}`,
                 ]),
@@ -398,9 +437,9 @@ export function registerProjectTools(server) {
             limit: z.number().int().min(1).max(50).optional(),
         },
     }, async ({ limit }) => {
-        const root = resolveScanRoot();
+        const roots = resolveScanRoots();
         const depth = resolveScanDepth();
-        const projects = await discoverProjects(root, depth);
+        const projects = await discoverProjectsAcrossRoots(roots, depth);
         const snapshots = await Promise.all(projects.map(async (governanceDir) => {
             const snapshot = await readTasksSnapshot(governanceDir);
             const inProgress = snapshot.tasks.filter((task) => task.status === "IN_PROGRESS").length;
@@ -435,7 +474,8 @@ export function registerProjectTools(server) {
             toolName: "projectNext",
             sections: [
                 summarySection([
-                    `- rootPath: ${root}`,
+                    `- rootPaths: ${roots.join(", ")}`,
+                    `- rootCount: ${roots.length}`,
                     `- maxDepth: ${depth}`,
                     `- matchedProjects: ${projects.length}`,
                     `- actionableProjects: ${ranked.length}`,

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

@@ -2,7 +2,7 @@ import fs from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 import { afterEach, describe, expect, it, vi } from "vitest";
-import { discoverProjects, hasProjectMarker, initializeProjectStructure, resolveGovernanceDir, resolveScanRoot, resolveScanDepth, toProjectPath, registerProjectTools } from "./project.js";
+import { discoverProjects, discoverProjectsAcrossRoots, hasProjectMarker, initializeProjectStructure, resolveGovernanceDir, resolveScanRoots, resolveScanDepth, toProjectPath, registerProjectTools } from "./project.js";
 const tempPaths = [];
 async function createTempDir() {
     const dir = await fs.mkdtemp(path.join(os.tmpdir(), "projitive-mcp-test-"));
@@ -186,6 +186,15 @@ describe("projitive module", () => {
             const projects = await discoverProjects(root, 3);
             expect(projects).toEqual([]);
         });
+        it("ignores non-existent roots when scanning across multiple roots", async () => {
+            const validRoot = await createTempDir();
+            const validProject = path.join(validRoot, "project-a");
+            const missingRoot = path.join(validRoot, "__missing_root__");
+            await fs.mkdir(validProject, { recursive: true });
+            await fs.writeFile(path.join(validProject, ".projitive"), "", "utf-8");
+            const projects = await discoverProjectsAcrossRoots([missingRoot, validRoot], 3);
+            expect(projects).toContain(validProject);
+        });
     });
     describe("initializeProjectStructure", () => {
         it("initializes governance structure under default .projitive directory", async () => {
@@ -267,20 +276,30 @@ describe("projitive module", () => {
                 expect(toProjectPath("/a/b/c")).toBe("/a/b");
             });
         });
-        describe("resolveScanRoot", () => {
-            it("uses environment variable when no input path", () => {
+        describe("resolveScanRoots", () => {
+            it("uses legacy environment variable when no multi-root env is provided", () => {
                 vi.stubEnv("PROJITIVE_SCAN_ROOT_PATH", "/test/root");
-                expect(resolveScanRoot()).toBe("/test/root");
+                expect(resolveScanRoots()).toEqual(["/test/root"]);
                 vi.unstubAllEnvs();
             });
-            it("uses input path when provided", () => {
+            it("uses input paths when provided", () => {
                 vi.stubEnv("PROJITIVE_SCAN_ROOT_PATH", "/test/root");
-                expect(resolveScanRoot("/custom/path")).toBe("/custom/path");
+                expect(resolveScanRoots(["/custom/path", " /custom/path ", "/second/path"])).toEqual(["/custom/path", "/second/path"]);
+                vi.unstubAllEnvs();
+            });
+            it("uses PROJITIVE_SCAN_ROOT_PATHS with platform delimiter", () => {
+                vi.stubEnv("PROJITIVE_SCAN_ROOT_PATHS", ["/root/a", "/root/b", "", " /root/c "].join(path.delimiter));
+                expect(resolveScanRoots()).toEqual(["/root/a", "/root/b", "/root/c"]);
+                vi.unstubAllEnvs();
+            });
+            it("treats JSON-like string as plain delimiter input", () => {
+                vi.stubEnv("PROJITIVE_SCAN_ROOT_PATHS", JSON.stringify(["/json/a", "/json/b"]));
+                expect(resolveScanRoots()).toHaveLength(1);
                 vi.unstubAllEnvs();
             });
-            it("throws error when required environment variable missing", () => {
+            it("throws error when no root environment variables are configured", () => {
                 vi.unstubAllEnvs();
-                expect(() => resolveScanRoot()).toThrow("Missing required environment variable: PROJITIVE_SCAN_ROOT_PATH");
+                expect(() => resolveScanRoots()).toThrow("Missing required environment variable: PROJITIVE_SCAN_ROOT_PATHS");
             });
         });
         describe("resolveScanDepth", () => {

package/output/source/tools/task.js

@@ -4,10 +4,9 @@ import { z } from "zod";
 import { candidateFilesFromArtifacts, discoverGovernanceArtifacts, findTextReferences } from "../common/index.js";
 import { asText, evidenceSection, guidanceSection, lintSection, nextCallSection, renderErrorMarkdown, renderToolResponseMarkdown, summarySection, } from "../common/index.js";
 import { catchIt, TASK_LINT_CODES, renderLintSuggestions } from "../common/index.js";
-import { resolveGovernanceDir, resolveScanDepth, resolveScanRoot, discoverProjects, toProjectPath } from "./project.js";
+import { resolveGovernanceDir, resolveScanDepth, resolveScanRoots, discoverProjectsAcrossRoots, toProjectPath } from "./project.js";
 import { isValidRoadmapId } from "./roadmap.js";
 import { SUB_STATE_PHASES, BLOCKER_TYPES } from "../types.js";
-import { calculateConfidenceScore, calculateContextCompleteness, calculateSimilarTaskHistory, calculateSpecificationClarity, getOrCreateTaskAutoCreateValidationHook, runPreCreationValidation, generateConfidenceReport } from "../common/index.js";
 export const TASKS_START = "<!-- PROJITIVE:TASKS:START -->";
 export const TASKS_END = "<!-- PROJITIVE:TASKS:END -->";
 export const ALLOWED_STATUS = ["TODO", "IN_PROGRESS", "BLOCKED", "DONE"];
@@ -51,7 +50,7 @@ const NO_TASK_DISCOVERY_HOOK_FILE = "task_no_actionable.md";
 const DEFAULT_NO_TASK_DISCOVERY_GUIDANCE = [
     "- Check whether current code violates project guide/spec conventions; create TODO tasks for each actionable gap.",
     "- Check unit/integration test coverage and identify high-value missing tests; create TODO tasks for meaningful coverage improvements.",
-    "- Check development/testing workflow for bottlenecks (slow feedback, fragile scripts, unclear runbooks); create TODO tasks to improve reliability.",
+    "- Check development/testing workflow for bottlenecks (slow feedback, fragile scripts, unclear runbooks); create tasks to improve reliability.",
     "- Scan for TODO/FIXME/HACK comments and convert feasible items into governed TODO tasks with evidence links.",
     "- Check dependency freshness and security advisories; create tasks for safe upgrades when needed.",
     "- Check repeated manual operations that can be automated (lint/test/release checks); create tasks to reduce operational toil.",
@@ -821,9 +820,9 @@ export function registerTaskTools(server) {
             limit: z.number().int().min(1).max(20).optional(),
         },
     }, async ({ limit }) => {
-        const root = resolveScanRoot();
+        const roots = resolveScanRoots();
         const depth = resolveScanDepth();
-        const projects = await discoverProjects(root, depth);
+        const projects = await discoverProjectsAcrossRoots(roots, depth);
         const rankedCandidates = rankActionableTaskCandidates(await readActionableTaskCandidates(projects));
         if (rankedCandidates.length === 0) {
             const projectSnapshots = await Promise.all(projects.map(async (governanceDir) => {
@@ -851,7 +850,8 @@ export function registerTaskTools(server) {
                 toolName: "taskNext",
                 sections: [
                     summarySection([
-                        `- rootPath: ${root}`,
+                        `- rootPaths: ${roots.join(", ")}`,
+                        `- rootCount: ${roots.length}`,
                         `- maxDepth: ${depth}`,
                         `- matchedProjects: ${projects.length}`,
                         "- actionableTasks: 0",
@@ -901,7 +901,8 @@ export function registerTaskTools(server) {
             toolName: "taskNext",
             sections: [
                 summarySection([
-                    `- rootPath: ${root}`,
+                    `- rootPaths: ${roots.join(", ")}`,
+                    `- rootCount: ${roots.length}`,
                     `- maxDepth: ${depth}`,
                     `- matchedProjects: ${projects.length}`,
                     `- actionableTasks: ${rankedCandidates.length}`,
@@ -1205,111 +1206,4 @@ export function registerTaskTools(server) {
         });
         return asText(markdown);
     });
-    // ============================================================================
-    // Spec v1.1.0 - Confidence Scoring Tools
-    // ============================================================================
-    server.registerTool("taskCalculateConfidence", {
-        title: "Calculate Task Confidence",
-        description: "Calculate confidence score for auto-creating a new task (Spec v1.1.0)",
-        inputSchema: {
-            projectPath: z.string(),
-            candidateTaskSummary: z.string(),
-            contextCompleteness: z.number().min(0).max(1).optional(),
-            similarTaskHistory: z.number().min(0).max(1).optional(),
-            specificationClarity: z.number().min(0).max(1).optional(),
-        },
-    }, async ({ projectPath, candidateTaskSummary, contextCompleteness, similarTaskHistory, specificationClarity }) => {
-        const governanceDir = await resolveGovernanceDir(projectPath);
-        const { tasks } = await loadTasks(governanceDir);
-        // Calculate factors if not provided
-        const calculatedContextCompleteness = contextCompleteness ?? await calculateContextCompleteness(governanceDir);
-        const calculatedSimilarTaskHistory = similarTaskHistory ?? calculateSimilarTaskHistory(tasks, candidateTaskSummary);
-        const calculatedSpecificationClarity = specificationClarity ?? calculateSpecificationClarity({
-            hasRoadmap: true, // Assume roadmap exists for simplicity
-            hasDesignDocs: true,
-            hasClearAcceptanceCriteria: candidateTaskSummary.length > 50,
-        });
-        const factors = {
-            contextCompleteness: calculatedContextCompleteness,
-            similarTaskHistory: calculatedSimilarTaskHistory,
-            specificationClarity: calculatedSpecificationClarity,
-        };
-        const confidenceScore = calculateConfidenceScore(factors);
-        const validationResult = await runPreCreationValidation(governanceDir, confidenceScore);
-        const hookContent = await getOrCreateTaskAutoCreateValidationHook(governanceDir);
-        const markdown = renderToolResponseMarkdown({
-            toolName: "taskCalculateConfidence",
-            sections: [
-                summarySection([
-                    `- governanceDir: ${governanceDir}`,
-                    `- confidenceScore: ${(confidenceScore.score * 100).toFixed(0)}%`,
-                    `- recommendation: ${confidenceScore.recommendation}`,
-                    `- validationPassed: ${validationResult.passed}`,
-                ]),
-                evidenceSection([
-                    "### Confidence Report",
-                    ...generateConfidenceReport(confidenceScore).split("\n"),
-                    "",
-                    "### Validation Issues",
-                    ...(validationResult.issues.length > 0
-                        ? validationResult.issues.map(issue => `- ${issue}`)
-                        : ["- (none)"]),
-                    "",
-                    "### Validation Hook",
-                    "- hook created/verified at: hooks/task_auto_create_validation.md",
-                ]),
-                guidanceSection([
-                    confidenceScore.recommendation === "auto_create"
-                        ? "✅ Confidence is high - you can auto-create this task."
-                        : confidenceScore.recommendation === "review_required"
-                            ? "⚠️ Confidence is medium - review recommended before creating."
-                            : "❌ Confidence is low - do not auto-create this task.",
-                    "",
-                    "### Next Steps",
-                    "- If recommendation is auto_create: use taskUpdate or manually add the task",
-                    "- If review_required: review the factors and improve context before creating",
-                    "- If do_not_create: gather more requirements or context before attempting",
-                ]),
-                lintSection([]),
-                nextCallSection(confidenceScore.recommendation !== "do_not_create"
-                    ? `projectContext(projectPath=\"${toProjectPath(governanceDir)}\")`
-                    : undefined),
-            ],
-        });
-        return asText(markdown);
-    });
-    server.registerTool("taskCreateValidationHook", {
-        title: "Create Validation Hook",
-        description: "Create or update the task auto-create validation hook (Spec v1.1.0)",
-        inputSchema: {
-            projectPath: z.string(),
-        },
-    }, async ({ projectPath }) => {
-        const governanceDir = await resolveGovernanceDir(projectPath);
-        const hookContent = await getOrCreateTaskAutoCreateValidationHook(governanceDir);
-        const markdown = renderToolResponseMarkdown({
-            toolName: "taskCreateValidationHook",
-            sections: [
-                summarySection([
-                    `- governanceDir: ${governanceDir}`,
-                    `- hookPath: ${governanceDir}/hooks/task_auto_create_validation.md`,
-                    `- status: created/verified`,
-                ]),
-                evidenceSection([
-                    "### Hook Content",
-                    "```markdown",
-                    ...hookContent.split("\n"),
-                    "```",
-                ]),
-                guidanceSection([
-                    "Validation hook created successfully.",
-                    "Edit the hook file to customize pre-creation and post-creation actions.",
-                    "The hook will be used by taskCalculateConfidence for validation.",
-                ]),
-                lintSection([]),
-                nextCallSection(`taskCalculateConfidence(projectPath=\"${toProjectPath(governanceDir)}\", candidateTaskSummary=\"Your task summary here\")`),
-            ],
-        });
-        return asText(markdown);
-    });
 }

package/output/source/types.js

@@ -26,17 +26,6 @@ export const BLOCKER_TYPES = [
     "resource",
     "approval"
 ];
-// Weight factors for confidence calculation
-export const CONFIDENCE_WEIGHTS = {
-    contextCompleteness: 0.4,
-    similarTaskHistory: 0.3,
-    specificationClarity: 0.3,
-};
-// Confidence thresholds
-export const CONFIDENCE_THRESHOLDS = {
-    autoCreate: 0.85,
-    reviewRequired: 0.6,
-};
 // ============================================================================
 // Parser Constants
 // ============================================================================

package/package.json

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

package/output/source/common/confidence.js

@@ -1,231 +0,0 @@
-/**
- * Projitive MCP - Confidence Scoring for Spec v1.1.0
- *
- * This module implements the confidence scoring algorithm for auto-discovery
- * and task creation, along with validation hooks integration.
- */
-import fs from "node:fs/promises";
-import path from "node:path";
-import { CONFIDENCE_WEIGHTS, CONFIDENCE_THRESHOLDS } from "../types.js";
-// ============================================================================
-// Confidence Scoring Algorithm
-// ============================================================================
-/**
- * Calculate confidence score based on the three factors
- * Formula: context_completeness * 0.4 + similar_task_history * 0.3 + specification_clarity * 0.3
- */
-export function calculateConfidenceScore(factors) {
-    // Validate input ranges
-    const validateFactor = (value, name) => {
-        if (value < 0 || value > 1) {
-            console.warn(`[Confidence] ${name} value ${value} is outside [0, 1] range, clamping`);
-            return Math.max(0, Math.min(1, value));
-        }
-        return value;
-    };
-    const contextCompleteness = validateFactor(factors.contextCompleteness, "contextCompleteness");
-    const similarTaskHistory = validateFactor(factors.similarTaskHistory, "similarTaskHistory");
-    const specificationClarity = validateFactor(factors.specificationClarity, "specificationClarity");
-    // Calculate weighted score
-    const score = contextCompleteness * CONFIDENCE_WEIGHTS.contextCompleteness +
-        similarTaskHistory * CONFIDENCE_WEIGHTS.similarTaskHistory +
-        specificationClarity * CONFIDENCE_WEIGHTS.specificationClarity;
-    // Determine recommendation
-    let recommendation;
-    if (score >= CONFIDENCE_THRESHOLDS.autoCreate) {
-        recommendation = "auto_create";
-    }
-    else if (score >= CONFIDENCE_THRESHOLDS.reviewRequired) {
-        recommendation = "review_required";
-    }
-    else {
-        recommendation = "do_not_create";
-    }
-    return {
-        score,
-        factors: {
-            contextCompleteness,
-            similarTaskHistory,
-            specificationClarity,
-        },
-        recommendation,
-    };
-}
-// ============================================================================
-// Factor Calculation Helpers
-// ============================================================================
-/**
- * Calculate context completeness factor by checking available governance artifacts
- */
-export async function calculateContextCompleteness(governanceDir) {
-    const requiredFiles = [
-        "tasks.md",
-        "roadmap.md",
-        "README.md"
-    ];
-    const optionalFiles = [
-        "hooks/task_no_actionable.md",
-        "hooks/task_auto_create_validation.md"
-    ];
-    let availableCount = 0;
-    const totalFiles = requiredFiles.length + optionalFiles.length;
-    // Check required files
-    for (const file of requiredFiles) {
-        const filePath = path.join(governanceDir, file);
-        try {
-            await fs.access(filePath);
-            availableCount++;
-        }
-        catch {
-            // File doesn't exist
-        }
-    }
-    // Check optional files (weighted 0.5 each)
-    for (const file of optionalFiles) {
-        const filePath = path.join(governanceDir, file);
-        try {
-            await fs.access(filePath);
-            availableCount += 0.5;
-        }
-        catch {
-            // File doesn't exist
-        }
-    }
-    return Math.min(1, availableCount / totalFiles);
-}
-/**
- * Calculate similar task history success rate
- */
-export function calculateSimilarTaskHistory(tasks, candidateTaskSummary) {
-    // Filter similar tasks based on keyword matching
-    const keywords = candidateTaskSummary.toLowerCase().split(/\s+/).filter(w => w.length > 3);
-    const similarTasks = tasks.filter(task => {
-        const taskText = `${task.title} ${task.summary}`.toLowerCase();
-        return keywords.some(keyword => taskText.includes(keyword));
-    });
-    if (similarTasks.length === 0) {
-        return 0.5; // Neutral score when no history
-    }
-    // Calculate success rate
-    const completedTasks = similarTasks.filter(task => task.status === "DONE");
-    return completedTasks.length / similarTasks.length;
-}
-/**
- * Calculate specification clarity factor
- */
-export function calculateSpecificationClarity(projectContext) {
-    let clarity = 0.3; // Base clarity
-    if (projectContext.hasRoadmap)
-        clarity += 0.2;
-    if (projectContext.hasDesignDocs)
-        clarity += 0.2;
-    if (projectContext.hasClearAcceptanceCriteria)
-        clarity += 0.3;
-    return Math.min(1, clarity);
-}
-// ============================================================================
-// Validation Hooks Integration
-// ============================================================================
-const TASK_AUTO_CREATE_VALIDATION_HOOK = "task_auto_create_validation.md";
-const DEFAULT_TASK_AUTO_CREATE_VALIDATION_HOOK = `# Task Auto-Create Validation Hook
-
-## Pre-Creation Checklist
-- [ ] Context files exist and are readable
-- [ ] Similar tasks have been completed successfully
-- [ ] Acceptance criteria are clear and testable
-- [ ] Dependencies are identified and available
-
-## Post-Creation Actions
-- [ ] Add evidence link to analysis document
-- [ ] Notify relevant stakeholders (if configured)
-- [ ] Schedule validation review (24h for high-confidence)
-`;
-/**
- * Check if task auto-create validation hook exists
- */
-export async function hasTaskAutoCreateValidationHook(governanceDir) {
-    const hookPath = path.join(governanceDir, "hooks", TASK_AUTO_CREATE_VALIDATION_HOOK);
-    try {
-        await fs.access(hookPath);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-/**
- * Get or create task auto-create validation hook
- */
-export async function getOrCreateTaskAutoCreateValidationHook(governanceDir) {
-    const hooksDir = path.join(governanceDir, "hooks");
-    const hookPath = path.join(hooksDir, TASK_AUTO_CREATE_VALIDATION_HOOK);
-    try {
-        // Try to read existing hook
-        const content = await fs.readFile(hookPath, "utf-8");
-        return content;
-    }
-    catch {
-        // Create hooks directory if it doesn't exist
-        try {
-            await fs.mkdir(hooksDir, { recursive: true });
-        }
-        catch {
-            // Directory already exists or creation failed silently
-        }
-        // Create default hook
-        await fs.writeFile(hookPath, DEFAULT_TASK_AUTO_CREATE_VALIDATION_HOOK, "utf-8");
-        return DEFAULT_TASK_AUTO_CREATE_VALIDATION_HOOK;
-    }
-}
-/**
- * Run pre-creation validation checklist
- */
-export async function runPreCreationValidation(governanceDir, confidenceScore) {
-    const issues = [];
-    // Check confidence score first
-    if (confidenceScore.recommendation === "do_not_create") {
-        issues.push(`Confidence score ${confidenceScore.score.toFixed(2)} is below threshold (${CONFIDENCE_THRESHOLDS.reviewRequired})`);
-    }
-    // Check context completeness
-    if (confidenceScore.factors.contextCompleteness < 0.6) {
-        issues.push(`Context completeness (${confidenceScore.factors.contextCompleteness.toFixed(2)}) is low - more governance artifacts recommended`);
-    }
-    // Check for validation hook
-    const hasHook = await hasTaskAutoCreateValidationHook(governanceDir);
-    if (!hasHook) {
-        issues.push("Task auto-create validation hook not found - will create default hook");
-    }
-    return {
-        passed: issues.length === 0 || confidenceScore.recommendation === "auto_create",
-        issues,
-    };
-}
-// ============================================================================
-// Confidence Report Generation
-// ============================================================================
-/**
- * Generate a human-readable confidence report
- */
-export function generateConfidenceReport(confidenceScore) {
-    const lines = [
-        "# Confidence Score Report",
-        "",
-        `## Final Score: ${(confidenceScore.score * 100).toFixed(0)}%`,
-        `**Recommendation**: ${confidenceScore.recommendation.replace(/_/g, " ")}`,
-        "",
-        "## Factor Breakdown",
-        "",
-        `| Factor | Score | Weight | Contribution |`,
-        `|--------|-------|--------|--------------|`,
-        `| Context Completeness | ${(confidenceScore.factors.contextCompleteness * 100).toFixed(0)}% | ${(CONFIDENCE_WEIGHTS.contextCompleteness * 100).toFixed(0)}% | ${(confidenceScore.factors.contextCompleteness * CONFIDENCE_WEIGHTS.contextCompleteness * 100).toFixed(0)}% |`,
-        `| Similar Task History | ${(confidenceScore.factors.similarTaskHistory * 100).toFixed(0)}% | ${(CONFIDENCE_WEIGHTS.similarTaskHistory * 100).toFixed(0)}% | ${(confidenceScore.factors.similarTaskHistory * CONFIDENCE_WEIGHTS.similarTaskHistory * 100).toFixed(0)}% |`,
-        `| Specification Clarity | ${(confidenceScore.factors.specificationClarity * 100).toFixed(0)}% | ${(CONFIDENCE_WEIGHTS.specificationClarity * 100).toFixed(0)}% | ${(confidenceScore.factors.specificationClarity * CONFIDENCE_WEIGHTS.specificationClarity * 100).toFixed(0)}% |`,
-        "",
-        "## Thresholds",
-        "",
-        `- Auto-create: >= ${(CONFIDENCE_THRESHOLDS.autoCreate * 100).toFixed(0)}%`,
-        `- Review required: ${(CONFIDENCE_THRESHOLDS.reviewRequired * 100).toFixed(0)}% - ${(CONFIDENCE_THRESHOLDS.autoCreate * 100).toFixed(0)}%`,
-        `- Do not create: < ${(CONFIDENCE_THRESHOLDS.reviewRequired * 100).toFixed(0)}%`,
-    ];
-    return lines.join("\n");
-}

package/output/source/common/confidence.test.js

@@ -1,205 +0,0 @@
-import fs from "node:fs/promises";
-import os from "node:os";
-import path from "node:path";
-import { afterEach, describe, expect, it } from "vitest";
-import { calculateConfidenceScore, calculateContextCompleteness, calculateSimilarTaskHistory, calculateSpecificationClarity, hasTaskAutoCreateValidationHook, getOrCreateTaskAutoCreateValidationHook, runPreCreationValidation, generateConfidenceReport, } from "./confidence.js";
-const tempPaths = [];
-async function createTempDir() {
-    const dir = await fs.mkdtemp(path.join(os.tmpdir(), "projitive-confidence-test-"));
-    tempPaths.push(dir);
-    return dir;
-}
-afterEach(async () => {
-    await Promise.all(tempPaths.splice(0).map(async (dir) => {
-        await fs.rm(dir, { recursive: true, force: true });
-    }));
-});
-describe("confidence module", () => {
-    describe("calculateConfidenceScore", () => {
-        it("calculates confidence score with valid inputs", () => {
-            const result = calculateConfidenceScore({
-                contextCompleteness: 0.8,
-                similarTaskHistory: 0.7,
-                specificationClarity: 0.9,
-            });
-            expect(result.score).toBeGreaterThan(0);
-            expect(result.score).toBeLessThanOrEqual(1);
-            expect(result.recommendation).toBeDefined();
-        });
-        it("recommends auto_create for high confidence scores", () => {
-            const result = calculateConfidenceScore({
-                contextCompleteness: 1.0,
-                similarTaskHistory: 1.0,
-                specificationClarity: 1.0,
-            });
-            expect(result.recommendation).toBe("auto_create");
-        });
-        it("recommends review_required for medium confidence scores", () => {
-            const result = calculateConfidenceScore({
-                contextCompleteness: 0.7,
-                similarTaskHistory: 0.7,
-                specificationClarity: 0.7,
-            });
-            expect(result.recommendation).toBe("review_required");
-        });
-        it("recommends do_not_create for low confidence scores", () => {
-            const result = calculateConfidenceScore({
-                contextCompleteness: 0.0,
-                similarTaskHistory: 0.0,
-                specificationClarity: 0.0,
-            });
-            expect(result.recommendation).toBe("do_not_create");
-        });
-        it("clamps values outside [0, 1] range", () => {
-            const result = calculateConfidenceScore({
-                contextCompleteness: 1.5,
-                similarTaskHistory: -0.5,
-                specificationClarity: 2.0,
-            });
-            expect(result.factors.contextCompleteness).toBe(1);
-            expect(result.factors.similarTaskHistory).toBe(0);
-            expect(result.factors.specificationClarity).toBe(1);
-        });
-    });
-    describe("calculateContextCompleteness", () => {
-        it("returns 0 for empty directory", async () => {
-            const root = await createTempDir();
-            const completeness = await calculateContextCompleteness(root);
-            expect(completeness).toBe(0);
-        });
-        it("returns higher score for more complete context", async () => {
-            const root = await createTempDir();
-            await fs.writeFile(path.join(root, "tasks.md"), "", "utf-8");
-            await fs.writeFile(path.join(root, "roadmap.md"), "", "utf-8");
-            await fs.writeFile(path.join(root, "README.md"), "", "utf-8");
-            const completeness = await calculateContextCompleteness(root);
-            expect(completeness).toBeGreaterThan(0.5);
-        });
-    });
-    describe("calculateSimilarTaskHistory", () => {
-        const sampleTasks = [
-            {
-                id: "TASK-0001",
-                title: "Implement feature X",
-                status: "DONE",
-                summary: "Build core functionality for feature X",
-                owner: "ai-copilot",
-                updatedAt: "2026-02-22T00:00:00.000Z",
-                links: [],
-                roadmapRefs: [],
-            },
-            {
-                id: "TASK-0002",
-                title: "Test feature Y",
-                status: "TODO",
-                summary: "Write tests for feature Y",
-                owner: "ai-copilot",
-                updatedAt: "2026-02-22T00:00:00.000Z",
-                links: [],
-                roadmapRefs: [],
-            },
-            {
-                id: "TASK-0003",
-                title: "Implement feature Z",
-                status: "DONE",
-                summary: "Build core functionality for feature Z",
-                owner: "ai-copilot",
-                updatedAt: "2026-02-22T00:00:00.000Z",
-                links: [],
-                roadmapRefs: [],
-            },
-        ];
-        it("returns 0.5 when no similar tasks", () => {
-            const result = calculateSimilarTaskHistory([], "Build something new");
-            expect(result).toBe(0.5);
-        });
-        it("calculates success rate for similar tasks", () => {
-            const result = calculateSimilarTaskHistory(sampleTasks, "Implement feature A with core functionality");
-            expect(result).toBeGreaterThan(0);
-            expect(result).toBeLessThanOrEqual(1);
-        });
-        it("handles tasks with no matching keywords", () => {
-            const result = calculateSimilarTaskHistory(sampleTasks, "Something completely different unrelated");
-            expect(result).toBe(0.5);
-        });
-    });
-    describe("calculateSpecificationClarity", () => {
-        it("returns base clarity with no context", () => {
-            const result = calculateSpecificationClarity({});
-            expect(result).toBe(0.3);
-        });
-        it("increases clarity with roadmap", () => {
-            const result = calculateSpecificationClarity({ hasRoadmap: true });
-            expect(result).toBeGreaterThan(0.3);
-        });
-        it("increases clarity with design docs", () => {
-            const result = calculateSpecificationClarity({ hasDesignDocs: true });
-            expect(result).toBeGreaterThan(0.3);
-        });
-        it("reaches maximum clarity with all factors", () => {
-            const result = calculateSpecificationClarity({
-                hasRoadmap: true,
-                hasDesignDocs: true,
-                hasClearAcceptanceCriteria: true,
-            });
-            expect(result).toBe(1);
-        });
-    });
-    describe("validation hooks", () => {
-        it("detects missing validation hook", async () => {
-            const root = await createTempDir();
-            const hasHook = await hasTaskAutoCreateValidationHook(root);
-            expect(hasHook).toBe(false);
-        });
-        it("creates default validation hook", async () => {
-            const root = await createTempDir();
-            const hookContent = await getOrCreateTaskAutoCreateValidationHook(root);
-            expect(hookContent).toContain("Task Auto-Create Validation Hook");
-        });
-        it("reads existing validation hook", async () => {
-            const root = await createTempDir();
-            const hooksDir = path.join(root, "hooks");
-            await fs.mkdir(hooksDir, { recursive: true });
-            const hookPath = path.join(hooksDir, "task_auto_create_validation.md");
-            await fs.writeFile(hookPath, "custom hook content", "utf-8");
-            const hookContent = await getOrCreateTaskAutoCreateValidationHook(root);
-            expect(hookContent).toBe("custom hook content");
-        });
-    });
-    describe("runPreCreationValidation", () => {
-        it("validates confidence score", async () => {
-            const root = await createTempDir();
-            const confidenceScore = calculateConfidenceScore({
-                contextCompleteness: 0.9,
-                similarTaskHistory: 0.9,
-                specificationClarity: 0.9,
-            });
-            const result = await runPreCreationValidation(root, confidenceScore);
-            expect(result.passed).toBeDefined();
-            expect(result.issues).toBeInstanceOf(Array);
-        });
-    });
-    describe("generateConfidenceReport", () => {
-        it("generates human-readable report", () => {
-            const confidenceScore = calculateConfidenceScore({
-                contextCompleteness: 0.8,
-                similarTaskHistory: 0.7,
-                specificationClarity: 0.9,
-            });
-            const report = generateConfidenceReport(confidenceScore);
-            expect(report).toContain("Confidence Score Report");
-            expect(report).toContain("Final Score");
-            expect(report).toContain("Factor Breakdown");
-            expect(report).toContain("Thresholds");
-        });
-        it("includes recommendation in report", () => {
-            const confidenceScore = calculateConfidenceScore({
-                contextCompleteness: 1.0,
-                similarTaskHistory: 1.0,
-                specificationClarity: 1.0,
-            });
-            const report = generateConfidenceReport(confidenceScore);
-            expect(report).toContain("auto create");
-        });
-    });
-});

package/output/source/design-context.js

@@ -1,66 +0,0 @@
-import { z } from "zod";
-function asUserPrompt(text) {
-    return {
-        messages: [
-            {
-                role: "user",
-                content: {
-                    type: "text",
-                    text,
-                },
-            },
-        ],
-    };
-}
-export function registerDesignContextResources(server) {
-    // Register design context resources
-    server.registerResource("designContext", "projitive://design-context/designs", {
-        title: "Design Context",
-        description: "Design context and resources for the project",
-        mimeType: "text/markdown",
-    }, async () => ({
-        contents: [
-            {
-                uri: "projitive://design-context/designs",
-                text: `# Design Context\n\nThis is the design context for the project.`,
-            },
-        ],
-    }));
-}
-export function registerDesignContextPrompts(server) {
-    // Register design context prompts
-    server.registerPrompt("designContext", {
-        title: "Design Context",
-        description: "Get design context for the project",
-        argsSchema: {
-            projectPath: z.string().optional(),
-        },
-    }, async ({ projectPath }) => {
-        const text = [
-            "You are exploring the design context for the project.",
-            "",
-            projectPath
-                ? [
-                    `1) Project path is known: "${projectPath}"`,
-                    "2) Review the design context resources.",
-                    "3) Identify design patterns and guidelines.",
-                ].join("\n")
-                : [
-                    "1) Project path is unknown: Run projectScan() to discover all governance roots.",
-                    "2) Select a project to work on.",
-                    "3) Run projectContext() to load project summary.",
-                    "4) Review the design context resources.",
-                ].join("\n"),
-            "",
-            "Key resources to read:",
-            "- projitive://design-context/designs - Design context and resources",
-            "- projitive://governance/workspace - Project overview",
-            "- projitive://governance/roadmap - Project roadmap",
-            "",
-            "Hard rules:",
-            "- Follow the design patterns and guidelines.",
-            "- Keep design documents in the .projitive/designs/ directory.",
-        ].join("\n");
-        return asUserPrompt(text);
-    });
-}