knowns 0.2.1 → 0.3.1

package/dist/mcp/server.js

@@ -10073,10 +10073,10 @@ var require_stringify = __commonJS({
       data = Object.assign({}, file3.data, data);
       const open = opts.delimiters[0];
       const close = opts.delimiters[1];
-      const matter3 = engine.stringify(data, options2).trim();
+      const matter5 = engine.stringify(data, options2).trim();
       let buf = "";
-      if (matter3 !== "{}") {
-        buf = newline(open) + newline(matter3) + newline(close);
+      if (matter5 !== "{}") {
+        buf = newline(open) + newline(matter5) + newline(close);
       }
       if (typeof file3.excerpt === "string" && file3.excerpt !== "") {
         if (str2.indexOf(file3.excerpt.trim()) === -1) {
@@ -10182,19 +10182,19 @@ var require_gray_matter = __commonJS({
     var toFile = require_to_file();
     var parse4 = require_parse();
     var utils = require_utils2();
-    function matter3(input, options2) {
+    function matter5(input, options2) {
       if (input === "") {
         return { data: {}, content: input, excerpt: "", orig: input };
       }
       let file3 = toFile(input);
-      const cached2 = matter3.cache[file3.content];
+      const cached2 = matter5.cache[file3.content];
       if (!options2) {
         if (cached2) {
           file3 = Object.assign({}, cached2);
           file3.orig = cached2.orig;
           return file3;
         }
-        matter3.cache[file3.content] = file3;
+        matter5.cache[file3.content] = file3;
       }
       return parseMatter(file3, options2);
     }
@@ -10216,7 +10216,7 @@ var require_gray_matter = __commonJS({
       }
       str2 = str2.slice(openLen);
       const len = str2.length;
-      const language = matter3.language(str2, opts);
+      const language = matter5.language(str2, opts);
       if (language.name) {
         file3.language = language.name;
         str2 = str2.slice(language.raw.length);
@@ -10251,24 +10251,24 @@ var require_gray_matter = __commonJS({
       }
       return file3;
     }
-    matter3.engines = engines2;
-    matter3.stringify = function(file3, data, options2) {
-      if (typeof file3 === "string") file3 = matter3(file3, options2);
+    matter5.engines = engines2;
+    matter5.stringify = function(file3, data, options2) {
+      if (typeof file3 === "string") file3 = matter5(file3, options2);
       return stringify(file3, data, options2);
     };
-    matter3.read = function(filepath, options2) {
+    matter5.read = function(filepath, options2) {
       const str2 = fs.readFileSync(filepath, "utf8");
-      const file3 = matter3(str2, options2);
+      const file3 = matter5(str2, options2);
       file3.path = filepath;
       return file3;
     };
-    matter3.test = function(str2, options2) {
+    matter5.test = function(str2, options2) {
       return utils.startsWith(str2, defaults(options2).delimiters[0]);
     };
-    matter3.language = function(str2, options2) {
+    matter5.language = function(str2, options2) {
       const opts = defaults(options2);
       const open = opts.delimiters[0];
-      if (matter3.test(str2)) {
+      if (matter5.test(str2)) {
         str2 = str2.slice(open.length);
       }
       const language = str2.slice(0, str2.search(/\r?\n/));
@@ -10277,17 +10277,18 @@ var require_gray_matter = __commonJS({
         name: language ? language.trim() : ""
       };
     };
-    matter3.cache = {};
-    matter3.clearCache = function() {
-      matter3.cache = {};
+    matter5.cache = {};
+    matter5.clearCache = function() {
+      matter5.cache = {};
     };
-    module2.exports = matter3;
+    module2.exports = matter5;
   }
 });
 
 // src/mcp/server.ts
-import { readFile as readFile2 } from "node:fs/promises";
-import { join as join4 } from "node:path";
+import { existsSync as existsSync5 } from "node:fs";
+import { readFile as readFile4 } from "node:fs/promises";
+import { join as join8 } from "node:path";
 
 // node_modules/zod/v3/helpers/util.js
 var util;
@@ -29521,7 +29522,7 @@ var Protocol = class {
     const capturedTransport = this._transport;
     const relatedTaskId = request.params?._meta?.[RELATED_TASK_META_KEY]?.taskId;
     if (handler === void 0) {
-      const errorResponse = {
+      const errorResponse2 = {
         jsonrpc: "2.0",
         id: request.id,
         error: {
@@ -29532,11 +29533,11 @@ var Protocol = class {
       if (relatedTaskId && this._taskMessageQueue) {
         this._enqueueTaskMessage(relatedTaskId, {
           type: "error",
-          message: errorResponse,
+          message: errorResponse2,
           timestamp: Date.now()
         }, capturedTransport?.sessionId).catch((error46) => this._onerror(new Error(`Failed to enqueue error response: ${error46}`)));
       } else {
-        capturedTransport?.send(errorResponse).catch((error46) => this._onerror(new Error(`Failed to send an error response: ${error46}`)));
+        capturedTransport?.send(errorResponse2).catch((error46) => this._onerror(new Error(`Failed to send an error response: ${error46}`)));
       }
       return;
     }
@@ -29601,7 +29602,7 @@ var Protocol = class {
       if (abortController.signal.aborted) {
         return;
       }
-      const errorResponse = {
+      const errorResponse2 = {
         jsonrpc: "2.0",
         id: request.id,
         error: {
@@ -29613,11 +29614,11 @@ var Protocol = class {
       if (relatedTaskId && this._taskMessageQueue) {
         await this._enqueueTaskMessage(relatedTaskId, {
           type: "error",
-          message: errorResponse,
+          message: errorResponse2,
           timestamp: Date.now()
         }, capturedTransport?.sessionId);
       } else {
-        await capturedTransport?.send(errorResponse);
+        await capturedTransport?.send(errorResponse2);
       }
     }).catch((error46) => this._onerror(new Error(`Failed to send response: ${error46}`))).finally(() => {
       this._requestHandlerAbortControllers.delete(request.id);
@@ -30874,7 +30875,7 @@ var StdioServerTransport = class {
 };
 
 // src/storage/file-store.ts
-import { mkdir as mkdir2, readdir, unlink as unlink2 } from "node:fs/promises";
+import { mkdir as mkdir2, readdir, rename, unlink as unlink2 } from "node:fs/promises";
 import { join as join2 } from "node:path";
 
 // src/models/project.ts
@@ -31352,6 +31353,8 @@ var FileStore = class {
   // .knowns/
   tasksPath;
   // .knowns/tasks/
+  archivePath;
+  // .knowns/archive/
   projectPath;
   // .knowns/config.json
   timeEntriesPath;
@@ -31361,6 +31364,7 @@ var FileStore = class {
     this.projectRoot = projectRoot;
     this.basePath = join2(projectRoot, ".knowns");
     this.tasksPath = join2(this.basePath, "tasks");
+    this.archivePath = join2(this.basePath, "archive");
     this.projectPath = join2(this.basePath, "config.json");
     this.timeEntriesPath = join2(this.basePath, "time-entries.json");
     this.versionStore = new VersionStore(projectRoot);
@@ -31535,6 +31539,7 @@ var FileStore = class {
         await this.addSubtask(newParent, id);
       }
     }
+    const oldFileName = updates.title && updates.title !== task.title ? await this.findTaskFile(id) : null;
     const updatedTask = {
       ...task,
       ...updates,
@@ -31543,6 +31548,10 @@ var FileStore = class {
       updatedAt: /* @__PURE__ */ new Date()
     };
     await this.versionStore.recordVersion(id, task, updatedTask, author);
+    if (oldFileName) {
+      const oldFilePath = join2(this.tasksPath, oldFileName);
+      await unlink2(oldFilePath);
+    }
     await this.saveTask(updatedTask);
     if (updates.timeEntries !== void 0) {
       const allTimeEntries = await this.loadTimeEntries();
@@ -31562,6 +31571,66 @@ var FileStore = class {
     const filePath = join2(this.tasksPath, fileName);
     await unlink2(filePath);
   }
+  /**
+   * Archive task - move to archive folder
+   */
+  async archiveTask(id) {
+    const task = await this.getTask(id);
+    if (!task) {
+      throw new Error(`Task ${id} not found`);
+    }
+    const fileName = await this.findTaskFile(id);
+    if (!fileName) {
+      throw new Error(`Task file for ${id} not found`);
+    }
+    await mkdir2(this.archivePath, { recursive: true });
+    const oldPath = join2(this.tasksPath, fileName);
+    const newPath = join2(this.archivePath, fileName);
+    await rename(oldPath, newPath);
+    return task;
+  }
+  /**
+   * Unarchive task - restore from archive folder
+   */
+  async unarchiveTask(id) {
+    try {
+      const files = await readdir(this.archivePath);
+      const taskFile = files.find((f) => f.startsWith(`task-${id} -`));
+      if (!taskFile) {
+        throw new Error(`Archived task ${id} not found`);
+      }
+      const archiveFilePath = join2(this.archivePath, taskFile);
+      const tasksFilePath = join2(this.tasksPath, taskFile);
+      await rename(archiveFilePath, tasksFilePath);
+      return await this.getTask(id);
+    } catch (error46) {
+      console.error(`Failed to unarchive task ${id}:`, error46);
+      throw error46;
+    }
+  }
+  /**
+   * Batch archive tasks - archive all done tasks older than specified duration
+   * @param olderThanMs - Duration in milliseconds (tasks done before now - olderThanMs will be archived)
+   * @returns Array of archived tasks
+   */
+  async batchArchiveTasks(olderThanMs) {
+    const allTasks = await this.getAllTasks();
+    const now = Date.now();
+    const cutoffTime = now - olderThanMs;
+    const tasksToArchive = allTasks.filter(
+      (task) => task.status === "done" && new Date(task.updatedAt).getTime() < cutoffTime
+    );
+    const archivedTasks = [];
+    for (const task of tasksToArchive) {
+      try {
+        await this.archiveTask(task.id);
+        archivedTasks.push(task);
+      } catch (error46) {
+        console.error(`Failed to archive task ${task.id}:`, error46);
+      }
+    }
+    return archivedTasks;
+  }
   /**
    * Save task to file
    */
@@ -31580,11 +31649,18 @@ var FileStore = class {
   }
   /**
    * Find task file by ID
+   * Warns if multiple files with same ID are found (indicates a bug)
    */
   async findTaskFile(id) {
     try {
       const files = await readdir(this.tasksPath);
-      return files.find((f) => f.startsWith(`task-${id} -`)) || null;
+      const matchingFiles = files.filter((f) => f.startsWith(`task-${id} -`));
+      if (matchingFiles.length > 1) {
+        console.warn(
+          `Warning: Found ${matchingFiles.length} files for task-${id}. This may cause data inconsistency. Files: ${matchingFiles.join(", ")}`
+        );
+      }
+      return matchingFiles[0] || null;
     } catch (_error) {
       return null;
     }
@@ -31675,9 +31751,95 @@ var FileStore = class {
   }
 };
 
-// src/utils/doc-links.ts
+// src/mcp/server.ts
+var import_gray_matter4 = __toESM(require_gray_matter(), 1);
+
+// src/utils/notify-server.ts
+import { existsSync as existsSync2, readFileSync } from "node:fs";
+import { join as join4 } from "node:path";
+
+// src/utils/find-project-root.ts
 import { existsSync } from "node:fs";
-import { join as join3 } from "node:path";
+import { dirname, join as join3 } from "node:path";
+function findProjectRoot(startPath = process.cwd()) {
+  let currentPath = startPath;
+  for (let i = 0; i < 20; i++) {
+    const knownsPath = join3(currentPath, ".knowns");
+    if (existsSync(knownsPath)) {
+      return currentPath;
+    }
+    const parentPath = dirname(currentPath);
+    if (parentPath === currentPath) {
+      return null;
+    }
+    currentPath = parentPath;
+  }
+  return null;
+}
+
+// src/utils/notify-server.ts
+var DEFAULT_PORT = 6420;
+function getServerPort() {
+  try {
+    const projectRoot = findProjectRoot();
+    if (!projectRoot) return DEFAULT_PORT;
+    const configPath = join4(projectRoot, ".knowns/config.json");
+    if (!existsSync2(configPath)) return DEFAULT_PORT;
+    const content = readFileSync(configPath, "utf-8");
+    const config2 = JSON.parse(content);
+    const port = config2.settings?.serverPort;
+    return typeof port === "number" ? port : DEFAULT_PORT;
+  } catch {
+    return DEFAULT_PORT;
+  }
+}
+async function notifyTaskUpdate(taskId) {
+  try {
+    const port = getServerPort();
+    const response = await fetch(`http://localhost:${port}/api/notify`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ taskId }),
+      signal: AbortSignal.timeout(1e3)
+      // 1 second timeout
+    });
+    if (response.ok) {
+    }
+  } catch {
+  }
+}
+async function notifyDocUpdate(docPath) {
+  try {
+    const port = getServerPort();
+    await fetch(`http://localhost:${port}/api/notify`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ type: "docs:updated", docPath }),
+      signal: AbortSignal.timeout(1e3)
+    });
+  } catch {
+  }
+}
+async function notifyTimeUpdate(active) {
+  try {
+    const port = getServerPort();
+    await fetch(`http://localhost:${port}/api/notify`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ type: "time:updated", active }),
+      signal: AbortSignal.timeout(1e3)
+    });
+  } catch {
+  }
+}
+
+// src/mcp/utils.ts
+import { readFile as readFile2 } from "node:fs/promises";
+import { join as join6 } from "node:path";
+
+// src/utils/doc-links.ts
+import { existsSync as existsSync3 } from "node:fs";
+import { join as join5 } from "node:path";
 function parseMarkdownLinks(text) {
   const linkPattern = /\[([^\]]+)\]\(([^)]+)\)/g;
   const links = [];
@@ -31693,7 +31855,7 @@ function parseMarkdownLinks(text) {
 function resolveDocReferences(content, projectRoot) {
   const links = parseMarkdownLinks(content);
   const docReferences = [];
-  const docsDir = join3(projectRoot, ".knowns", "docs");
+  const docsDir = join5(projectRoot, ".knowns", "docs");
   for (const link of links) {
     if (link.target.startsWith("http://") || link.target.startsWith("https://")) {
       continue;
@@ -31709,8 +31871,8 @@ function resolveDocReferences(content, projectRoot) {
     if (!filename.endsWith(".md")) {
       filename = `${filename}.md`;
     }
-    const resolvedPath = join3(docsDir, filename);
-    const exists = existsSync(resolvedPath);
+    const resolvedPath = join5(docsDir, filename);
+    const exists = existsSync3(resolvedPath);
     docReferences.push({
       text: link.text,
       filename: link.target,
@@ -31721,9 +31883,8 @@ function resolveDocReferences(content, projectRoot) {
   return docReferences;
 }
 
-// src/mcp/server.ts
+// src/mcp/utils.ts
 var import_gray_matter2 = __toESM(require_gray_matter(), 1);
-var fileStore = new FileStore(process.cwd());
 function parseDuration(durationStr) {
   let totalSeconds = 0;
   const hoursMatch = durationStr.match(/(\d+)h/);
@@ -31755,7 +31916,7 @@ function formatDuration(seconds) {
 }
 async function fetchLinkedDocs(task) {
   const projectRoot = process.cwd();
-  const docsDir = join4(projectRoot, ".knowns", "docs");
+  const docsDir = join6(projectRoot, ".knowns", "docs");
   const allContent = [task.description || "", task.implementationPlan || "", task.implementationNotes || ""].join("\n");
   const docRefs = resolveDocReferences(allContent, projectRoot);
   const linkedDocs = [];
@@ -31763,7 +31924,7 @@ async function fetchLinkedDocs(task) {
     if (!ref.exists) continue;
     try {
       const filename = ref.resolvedPath.replace("@.knowns/docs/", "");
-      const filepath = join4(docsDir, filename);
+      const filepath = join6(docsDir, filename);
       const fileContent = await readFile2(filepath, "utf-8");
       const { data, content } = (0, import_gray_matter2.default)(fileContent);
       linkedDocs.push({
@@ -31776,6 +31937,28 @@ async function fetchLinkedDocs(task) {
   }
   return linkedDocs;
 }
+function successResponse(data) {
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify({ success: true, ...data }, null, 2)
+      }
+    ]
+  };
+}
+function errorResponse(error46) {
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify({ success: false, error: error46 }, null, 2)
+      }
+    ]
+  };
+}
+
+// src/mcp/handlers/task.ts
 var createTaskSchema = external_exports3.object({
   title: external_exports3.string(),
   description: external_exports3.string().optional(),
@@ -31806,40 +31989,7 @@ var listTasksSchema = external_exports3.object({
 var searchTasksSchema = external_exports3.object({
   query: external_exports3.string()
 });
-var startTimeSchema = external_exports3.object({
-  taskId: external_exports3.string()
-});
-var stopTimeSchema = external_exports3.object({
-  taskId: external_exports3.string()
-});
-var addTimeSchema = external_exports3.object({
-  taskId: external_exports3.string(),
-  duration: external_exports3.string(),
-  // e.g., "2h", "30m", "1h30m"
-  note: external_exports3.string().optional(),
-  date: external_exports3.string().optional()
-  // ISO date string
-});
-var getTimeReportSchema = external_exports3.object({
-  from: external_exports3.string().optional(),
-  // YYYY-MM-DD
-  to: external_exports3.string().optional(),
-  // YYYY-MM-DD
-  groupBy: external_exports3.enum(["task", "label", "status"]).optional()
-});
-var server = new Server(
-  {
-    name: "knowns-mcp-server",
-    version: "1.0.0"
-  },
-  {
-    capabilities: {
-      tools: {},
-      resources: {}
-    }
-  }
-);
-var tools = [
+var taskTools = [
   {
     name: "create_task",
     description: "Create a new task with title and optional description, status, priority, labels, and assignee",
@@ -31932,7 +32082,144 @@ var tools = [
       },
       required: ["query"]
     }
-  },
+  }
+];
+async function handleCreateTask(args, fileStore2) {
+  const input = createTaskSchema.parse(args);
+  const task = await fileStore2.createTask({
+    title: input.title,
+    description: input.description,
+    status: input.status || "todo",
+    priority: input.priority || "medium",
+    assignee: input.assignee,
+    labels: input.labels || [],
+    parent: input.parent,
+    subtasks: [],
+    acceptanceCriteria: [],
+    timeSpent: 0,
+    timeEntries: []
+  });
+  await notifyTaskUpdate(task.id);
+  return successResponse({
+    task: {
+      id: task.id,
+      title: task.title,
+      status: task.status,
+      priority: task.priority
+    }
+  });
+}
+async function handleGetTask(args, fileStore2) {
+  const input = getTaskSchema.parse(args);
+  const task = await fileStore2.getTask(input.taskId);
+  if (!task) {
+    return errorResponse(`Task ${input.taskId} not found`);
+  }
+  const linkedDocs = await fetchLinkedDocs(task);
+  return successResponse({
+    task: {
+      id: task.id,
+      title: task.title,
+      description: task.description,
+      status: task.status,
+      priority: task.priority,
+      assignee: task.assignee,
+      labels: task.labels,
+      acceptanceCriteria: task.acceptanceCriteria,
+      createdAt: task.createdAt,
+      updatedAt: task.updatedAt,
+      linkedDocumentation: linkedDocs
+    }
+  });
+}
+async function handleUpdateTask(args, fileStore2) {
+  const input = updateTaskSchema.parse(args);
+  const updates = {};
+  if (input.title) updates.title = input.title;
+  if (input.description) updates.description = input.description;
+  if (input.status) updates.status = input.status;
+  if (input.priority) updates.priority = input.priority;
+  if (input.assignee) updates.assignee = input.assignee;
+  if (input.labels) updates.labels = input.labels;
+  const task = await fileStore2.updateTask(input.taskId, updates);
+  await notifyTaskUpdate(task.id);
+  return successResponse({
+    task: {
+      id: task.id,
+      title: task.title,
+      status: task.status,
+      priority: task.priority
+    }
+  });
+}
+async function handleListTasks(args, fileStore2) {
+  const input = listTasksSchema.parse(args);
+  let tasks = await fileStore2.getAllTasks();
+  if (input.status) {
+    tasks = tasks.filter((t) => t.status === input.status);
+  }
+  if (input.priority) {
+    tasks = tasks.filter((t) => t.priority === input.priority);
+  }
+  if (input.assignee) {
+    tasks = tasks.filter((t) => t.assignee === input.assignee);
+  }
+  if (input.label) {
+    tasks = tasks.filter((t) => t.labels.includes(input.label));
+  }
+  return successResponse({
+    count: tasks.length,
+    tasks: tasks.map((t) => ({
+      id: t.id,
+      title: t.title,
+      status: t.status,
+      priority: t.priority,
+      assignee: t.assignee,
+      labels: t.labels
+    }))
+  });
+}
+async function handleSearchTasks(args, fileStore2) {
+  const input = searchTasksSchema.parse(args);
+  const tasks = await fileStore2.getAllTasks();
+  const query = input.query.toLowerCase();
+  const results = tasks.filter(
+    (t) => t.title.toLowerCase().includes(query) || t.description?.toLowerCase().includes(query) || t.labels.some((l) => l.toLowerCase().includes(query))
+  );
+  return successResponse({
+    count: results.length,
+    tasks: results.map((t) => ({
+      id: t.id,
+      title: t.title,
+      status: t.status,
+      priority: t.priority
+    }))
+  });
+}
+
+// src/mcp/handlers/time.ts
+var startTimeSchema = external_exports3.object({
+  taskId: external_exports3.string()
+});
+var stopTimeSchema = external_exports3.object({
+  taskId: external_exports3.string()
+});
+var addTimeSchema = external_exports3.object({
+  taskId: external_exports3.string(),
+  duration: external_exports3.string(),
+  // e.g., "2h", "30m", "1h30m"
+  note: external_exports3.string().optional(),
+  date: external_exports3.string().optional()
+  // ISO date string
+});
+var getTimeReportSchema = external_exports3.object({
+  from: external_exports3.string().optional(),
+  // YYYY-MM-DD
+  to: external_exports3.string().optional(),
+  // YYYY-MM-DD
+  groupBy: external_exports3.enum(["task", "label", "status"]).optional()
+});
+var timeTools = [
   {
     name: "start_time",
     description: "Start time tracking for a task",
@@ -31990,7 +32277,173 @@ var tools = [
         }
       }
     }
-  },
+  }
+];
+async function handleStartTime(args, fileStore2) {
+  const input = startTimeSchema.parse(args);
+  const task = await fileStore2.getTask(input.taskId);
+  if (!task) {
+    return errorResponse(`Task ${input.taskId} not found`);
+  }
+  const activeEntry = task.timeEntries.find((e) => !e.endedAt);
+  if (activeEntry) {
+    return errorResponse("Time tracking already active for this task");
+  }
+  const newEntry = {
+    id: `entry-${Date.now()}`,
+    startedAt: /* @__PURE__ */ new Date(),
+    duration: 0,
+    note: "Started via MCP"
+  };
+  await fileStore2.updateTask(input.taskId, {
+    timeEntries: [...task.timeEntries, newEntry]
+  });
+  await notifyTaskUpdate(input.taskId);
+  await notifyTimeUpdate({
+    taskId: input.taskId,
+    taskTitle: task.title,
+    startedAt: newEntry.startedAt.toISOString(),
+    pausedAt: null,
+    totalPausedMs: 0
+  });
+  return successResponse({
+    message: `Started tracking time for task ${input.taskId}`,
+    startedAt: newEntry.startedAt
+  });
+}
+async function handleStopTime(args, fileStore2) {
+  const input = stopTimeSchema.parse(args);
+  const task = await fileStore2.getTask(input.taskId);
+  if (!task) {
+    return errorResponse(`Task ${input.taskId} not found`);
+  }
+  const activeIndex = task.timeEntries.findIndex((e) => !e.endedAt);
+  if (activeIndex === -1) {
+    return errorResponse("No active time tracking for this task");
+  }
+  const endTime = /* @__PURE__ */ new Date();
+  const startTime = task.timeEntries[activeIndex].startedAt;
+  const duration3 = Math.floor((endTime.getTime() - new Date(startTime).getTime()) / 1e3);
+  const updatedEntries = [...task.timeEntries];
+  updatedEntries[activeIndex] = {
+    ...updatedEntries[activeIndex],
+    endedAt: endTime,
+    duration: duration3
+  };
+  const newTimeSpent = task.timeSpent + duration3;
+  await fileStore2.updateTask(input.taskId, {
+    timeEntries: updatedEntries,
+    timeSpent: newTimeSpent
+  });
+  await notifyTaskUpdate(input.taskId);
+  await notifyTimeUpdate(null);
+  return successResponse({
+    message: `Stopped tracking time for task ${input.taskId}`,
+    duration: formatDuration(duration3),
+    totalTime: formatDuration(newTimeSpent)
+  });
+}
+async function handleAddTime(args, fileStore2) {
+  const input = addTimeSchema.parse(args);
+  const task = await fileStore2.getTask(input.taskId);
+  if (!task) {
+    return errorResponse(`Task ${input.taskId} not found`);
+  }
+  const duration3 = parseDuration(input.duration);
+  const startDate = input.date ? new Date(input.date) : /* @__PURE__ */ new Date();
+  const newEntry = {
+    id: `entry-${Date.now()}`,
+    startedAt: startDate,
+    endedAt: new Date(startDate.getTime() + duration3 * 1e3),
+    duration: duration3,
+    note: input.note || "Added via MCP"
+  };
+  const newTimeSpent = task.timeSpent + duration3;
+  await fileStore2.updateTask(input.taskId, {
+    timeEntries: [...task.timeEntries, newEntry],
+    timeSpent: newTimeSpent
+  });
+  await notifyTaskUpdate(input.taskId);
+  return successResponse({
+    message: `Added ${formatDuration(duration3)} to task ${input.taskId}`,
+    totalTime: formatDuration(newTimeSpent)
+  });
+}
+async function handleGetTimeReport(args, fileStore2) {
+  const input = getTimeReportSchema.parse(args);
+  const tasks = await fileStore2.getAllTasks();
+  let fromDate;
+  let toDate;
+  if (input.from) fromDate = new Date(input.from);
+  if (input.to) toDate = new Date(input.to);
+  const taskTimeData = tasks.map((task) => {
+    let totalSeconds = 0;
+    for (const entry of task.timeEntries) {
+      if (entry.endedAt) {
+        const entryDate = new Date(entry.startedAt);
+        if (fromDate && entryDate < fromDate) continue;
+        if (toDate && entryDate > toDate) continue;
+        totalSeconds += entry.duration;
+      }
+    }
+    return {
+      taskId: task.id,
+      title: task.title,
+      status: task.status,
+      labels: task.labels,
+      totalSeconds
+    };
+  }).filter((data) => data.totalSeconds > 0);
+  if (input.groupBy === "label") {
+    const grouped = {};
+    for (const data of taskTimeData) {
+      for (const label of data.labels) {
+        grouped[label] = (grouped[label] || 0) + data.totalSeconds;
+      }
+      if (data.labels.length === 0) {
+        grouped["(no label)"] = (grouped["(no label)"] || 0) + data.totalSeconds;
+      }
+    }
+    return successResponse({
+      groupBy: "label",
+      data: Object.entries(grouped).map(([label, seconds]) => ({
+        label,
+        time: formatDuration(seconds),
+        seconds
+      })),
+      totalSeconds: Object.values(grouped).reduce((a, b) => a + b, 0)
+    });
+  }
+  if (input.groupBy === "status") {
+    const grouped = {};
+    for (const data of taskTimeData) {
+      grouped[data.status] = (grouped[data.status] || 0) + data.totalSeconds;
+    }
+    return successResponse({
+      groupBy: "status",
+      data: Object.entries(grouped).map(([status, seconds]) => ({
+        status,
+        time: formatDuration(seconds),
+        seconds
+      })),
+      totalSeconds: Object.values(grouped).reduce((a, b) => a + b, 0)
+    });
+  }
+  return successResponse({
+    groupBy: "task",
+    data: taskTimeData.map((data) => ({
+      taskId: data.taskId,
+      title: data.title,
+      status: data.status,
+      time: formatDuration(data.totalSeconds),
+      seconds: data.totalSeconds
+    })),
+    totalSeconds: taskTimeData.reduce((sum, data) => sum + data.totalSeconds, 0)
+  });
+}
+
+// src/mcp/handlers/board.ts
+var boardTools = [
   {
     name: "get_board",
     description: "Get current board state with tasks grouped by status",
@@ -32000,6 +32453,404 @@ var tools = [
     }
   }
 ];
+async function handleGetBoard(fileStore2) {
+  const tasks = await fileStore2.getAllTasks();
+  const board = {
+    todo: [],
+    "in-progress": [],
+    "in-review": [],
+    done: [],
+    blocked: []
+  };
+  for (const task of tasks) {
+    if (board[task.status]) {
+      board[task.status].push(task);
+    }
+  }
+  const mapTask = (t) => ({
+    id: t.id,
+    title: t.title,
+    priority: t.priority,
+    assignee: t.assignee,
+    labels: t.labels
+  });
+  return successResponse({
+    board: {
+      todo: board.todo.map(mapTask),
+      "in-progress": board["in-progress"].map(mapTask),
+      "in-review": board["in-review"].map(mapTask),
+      done: board.done.map(mapTask),
+      blocked: board.blocked.map(mapTask)
+    },
+    totalTasks: tasks.length
+  });
+}
+
+// src/mcp/handlers/doc.ts
+import { existsSync as existsSync4 } from "node:fs";
+import { mkdir as mkdir3, readFile as readFile3, readdir as readdir2, writeFile as writeFile2 } from "node:fs/promises";
+import { join as join7 } from "node:path";
+var import_gray_matter3 = __toESM(require_gray_matter(), 1);
+var DOCS_DIR = join7(process.cwd(), ".knowns", "docs");
+var listDocsSchema = external_exports3.object({
+  tag: external_exports3.string().optional()
+});
+var getDocSchema = external_exports3.object({
+  path: external_exports3.string()
+  // Document path (filename or folder/filename)
+});
+var createDocSchema = external_exports3.object({
+  title: external_exports3.string(),
+  description: external_exports3.string().optional(),
+  content: external_exports3.string().optional(),
+  tags: external_exports3.array(external_exports3.string()).optional(),
+  folder: external_exports3.string().optional()
+  // Optional folder path
+});
+var updateDocSchema = external_exports3.object({
+  path: external_exports3.string(),
+  // Document path
+  title: external_exports3.string().optional(),
+  description: external_exports3.string().optional(),
+  content: external_exports3.string().optional(),
+  tags: external_exports3.array(external_exports3.string()).optional(),
+  appendContent: external_exports3.string().optional()
+  // Append to existing content
+});
+var searchDocsSchema = external_exports3.object({
+  query: external_exports3.string(),
+  tag: external_exports3.string().optional()
+});
+var docTools = [
+  {
+    name: "list_docs",
+    description: "List all documentation files with optional tag filter",
+    inputSchema: {
+      type: "object",
+      properties: {
+        tag: { type: "string", description: "Filter by tag" }
+      }
+    }
+  },
+  {
+    name: "get_doc",
+    description: "Get a documentation file by path (filename or folder/filename)",
+    inputSchema: {
+      type: "object",
+      properties: {
+        path: {
+          type: "string",
+          description: "Document path (e.g., 'readme', 'guides/setup', 'conventions/naming.md')"
+        }
+      },
+      required: ["path"]
+    }
+  },
+  {
+    name: "create_doc",
+    description: "Create a new documentation file",
+    inputSchema: {
+      type: "object",
+      properties: {
+        title: { type: "string", description: "Document title" },
+        description: { type: "string", description: "Document description" },
+        content: { type: "string", description: "Initial content (markdown)" },
+        tags: {
+          type: "array",
+          items: { type: "string" },
+          description: "Document tags"
+        },
+        folder: {
+          type: "string",
+          description: "Folder path (e.g., 'guides', 'patterns/auth')"
+        }
+      },
+      required: ["title"]
+    }
+  },
+  {
+    name: "update_doc",
+    description: "Update an existing documentation file",
+    inputSchema: {
+      type: "object",
+      properties: {
+        path: {
+          type: "string",
+          description: "Document path (e.g., 'readme', 'guides/setup')"
+        },
+        title: { type: "string", description: "New title" },
+        description: { type: "string", description: "New description" },
+        content: { type: "string", description: "Replace content" },
+        tags: {
+          type: "array",
+          items: { type: "string" },
+          description: "New tags"
+        },
+        appendContent: {
+          type: "string",
+          description: "Append to existing content"
+        }
+      },
+      required: ["path"]
+    }
+  },
+  {
+    name: "search_docs",
+    description: "Search documentation by query string",
+    inputSchema: {
+      type: "object",
+      properties: {
+        query: { type: "string", description: "Search query" },
+        tag: { type: "string", description: "Filter by tag" }
+      },
+      required: ["query"]
+    }
+  }
+];
+async function ensureDocsDir() {
+  if (!existsSync4(DOCS_DIR)) {
+    await mkdir3(DOCS_DIR, { recursive: true });
+  }
+}
+function titleToFilename(title) {
+  return title.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+}
+async function getAllMdFiles(dir, basePath = "") {
+  const files = [];
+  if (!existsSync4(dir)) {
+    return files;
+  }
+  const entries = await readdir2(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = join7(dir, entry.name);
+    const relativePath = basePath ? join7(basePath, entry.name) : entry.name;
+    if (entry.isDirectory()) {
+      const subFiles = await getAllMdFiles(fullPath, relativePath);
+      files.push(...subFiles);
+    } else if (entry.isFile() && entry.name.endsWith(".md")) {
+      files.push(relativePath);
+    }
+  }
+  return files;
+}
+async function resolveDocPath(name) {
+  await ensureDocsDir();
+  let filename = name.endsWith(".md") ? name : `${name}.md`;
+  let filepath = join7(DOCS_DIR, filename);
+  if (existsSync4(filepath)) {
+    return { filepath, filename };
+  }
+  filename = `${titleToFilename(name)}.md`;
+  filepath = join7(DOCS_DIR, filename);
+  if (existsSync4(filepath)) {
+    return { filepath, filename };
+  }
+  const allFiles = await getAllMdFiles(DOCS_DIR);
+  const searchName = name.toLowerCase().replace(/\.md$/, "");
+  const matchingFile = allFiles.find((file3) => {
+    const fileNameOnly = file3.toLowerCase().replace(/\.md$/, "");
+    const fileBaseName = file3.split("/").pop()?.toLowerCase().replace(/\.md$/, "");
+    return fileNameOnly === searchName || fileBaseName === searchName || file3 === name;
+  });
+  if (matchingFile) {
+    return {
+      filepath: join7(DOCS_DIR, matchingFile),
+      filename: matchingFile
+    };
+  }
+  return null;
+}
+async function handleListDocs(args) {
+  const input = listDocsSchema.parse(args);
+  await ensureDocsDir();
+  const mdFiles = await getAllMdFiles(DOCS_DIR);
+  if (mdFiles.length === 0) {
+    return successResponse({
+      count: 0,
+      docs: [],
+      message: "No documentation files found"
+    });
+  }
+  const docs = [];
+  for (const file3 of mdFiles) {
+    const content = await readFile3(join7(DOCS_DIR, file3), "utf-8");
+    const { data } = (0, import_gray_matter3.default)(content);
+    const metadata = data;
+    if (input.tag && !metadata.tags?.includes(input.tag)) {
+      continue;
+    }
+    docs.push({
+      path: file3.replace(/\.md$/, ""),
+      title: metadata.title || file3.replace(/\.md$/, ""),
+      description: metadata.description,
+      tags: metadata.tags,
+      updatedAt: metadata.updatedAt
+    });
+  }
+  return successResponse({
+    count: docs.length,
+    docs
+  });
+}
+async function handleGetDoc(args) {
+  const input = getDocSchema.parse(args);
+  const resolved = await resolveDocPath(input.path);
+  if (!resolved) {
+    return errorResponse(`Documentation not found: ${input.path}`);
+  }
+  const fileContent = await readFile3(resolved.filepath, "utf-8");
+  const { data, content } = (0, import_gray_matter3.default)(fileContent);
+  const metadata = data;
+  return successResponse({
+    doc: {
+      path: resolved.filename.replace(/\.md$/, ""),
+      title: metadata.title,
+      description: metadata.description,
+      tags: metadata.tags,
+      createdAt: metadata.createdAt,
+      updatedAt: metadata.updatedAt,
+      content: content.trim()
+    }
+  });
+}
+async function handleCreateDoc(args) {
+  const input = createDocSchema.parse(args);
+  await ensureDocsDir();
+  const filename = `${titleToFilename(input.title)}.md`;
+  let targetDir = DOCS_DIR;
+  let relativePath = filename;
+  if (input.folder) {
+    const folderPath = input.folder.replace(/^\/|\/$/g, "");
+    targetDir = join7(DOCS_DIR, folderPath);
+    relativePath = join7(folderPath, filename);
+    if (!existsSync4(targetDir)) {
+      await mkdir3(targetDir, { recursive: true });
+    }
+  }
+  const filepath = join7(targetDir, filename);
+  if (existsSync4(filepath)) {
+    return errorResponse(`Document already exists: ${relativePath}`);
+  }
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const metadata = {
+    title: input.title,
+    createdAt: now,
+    updatedAt: now
+  };
+  if (input.description) {
+    metadata.description = input.description;
+  }
+  if (input.tags) {
+    metadata.tags = input.tags;
+  }
+  const initialContent = input.content || "# Content\n\nWrite your documentation here.";
+  const fileContent = import_gray_matter3.default.stringify(initialContent, metadata);
+  await writeFile2(filepath, fileContent, "utf-8");
+  await notifyDocUpdate(relativePath);
+  return successResponse({
+    message: `Created documentation: ${relativePath}`,
+    doc: {
+      path: relativePath.replace(/\.md$/, ""),
+      title: metadata.title,
+      description: metadata.description,
+      tags: metadata.tags
+    }
+  });
+}
+async function handleUpdateDoc(args) {
+  const input = updateDocSchema.parse(args);
+  const resolved = await resolveDocPath(input.path);
+  if (!resolved) {
+    return errorResponse(`Documentation not found: ${input.path}`);
+  }
+  const fileContent = await readFile3(resolved.filepath, "utf-8");
+  const { data, content } = (0, import_gray_matter3.default)(fileContent);
+  const metadata = data;
+  if (input.title) metadata.title = input.title;
+  if (input.description) metadata.description = input.description;
+  if (input.tags) metadata.tags = input.tags;
+  metadata.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  let updatedContent = content;
+  if (input.content) {
+    updatedContent = input.content;
+  }
+  if (input.appendContent) {
+    updatedContent = `${content.trimEnd()}
+
+${input.appendContent}`;
+  }
+  const newFileContent = import_gray_matter3.default.stringify(updatedContent, metadata);
+  await writeFile2(resolved.filepath, newFileContent, "utf-8");
+  await notifyDocUpdate(resolved.filename);
+  return successResponse({
+    message: `Updated documentation: ${resolved.filename}`,
+    doc: {
+      path: resolved.filename.replace(/\.md$/, ""),
+      title: metadata.title,
+      description: metadata.description,
+      tags: metadata.tags,
+      updatedAt: metadata.updatedAt
+    }
+  });
+}
+async function handleSearchDocs(args) {
+  const input = searchDocsSchema.parse(args);
+  await ensureDocsDir();
+  const mdFiles = await getAllMdFiles(DOCS_DIR);
+  const query = input.query.toLowerCase();
+  const results = [];
+  for (const file3 of mdFiles) {
+    const fileContent = await readFile3(join7(DOCS_DIR, file3), "utf-8");
+    const { data, content } = (0, import_gray_matter3.default)(fileContent);
+    const metadata = data;
+    if (input.tag && !metadata.tags?.includes(input.tag)) {
+      continue;
+    }
+    const titleMatch = metadata.title?.toLowerCase().includes(query);
+    const descMatch = metadata.description?.toLowerCase().includes(query);
+    const tagMatch = metadata.tags?.some((t) => t.toLowerCase().includes(query));
+    const contentMatch = content.toLowerCase().includes(query);
+    if (titleMatch || descMatch || tagMatch || contentMatch) {
+      let matchContext;
+      if (contentMatch) {
+        const contentLower = content.toLowerCase();
+        const matchIndex = contentLower.indexOf(query);
+        if (matchIndex !== -1) {
+          const start = Math.max(0, matchIndex - 50);
+          const end = Math.min(content.length, matchIndex + query.length + 50);
+          matchContext = `...${content.slice(start, end).replace(/\n/g, " ")}...`;
+        }
+      }
+      results.push({
+        path: file3.replace(/\.md$/, ""),
+        title: metadata.title || file3.replace(/\.md$/, ""),
+        description: metadata.description,
+        tags: metadata.tags,
+        matchContext
+      });
+    }
+  }
+  return successResponse({
+    count: results.length,
+    docs: results
+  });
+}
+
+// src/mcp/server.ts
+var fileStore = new FileStore(process.cwd());
+var server = new Server(
+  {
+    name: "knowns-mcp-server",
+    version: "1.0.0"
+  },
+  {
+    capabilities: {
+      tools: {},
+      resources: {}
+    }
+  }
+);
+var tools = [...taskTools, ...timeTools, ...boardTools, ...docTools];
 server.setRequestHandler(ListToolsRequestSchema, async () => {
   return { tools };
 });
@@ -32007,540 +32858,129 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
   const { name, arguments: args } = request.params;
   try {
     switch (name) {
-      case "create_task": {
-        const input = createTaskSchema.parse(args);
-        const task = await fileStore.createTask({
-          title: input.title,
-          description: input.description,
-          status: input.status || "todo",
-          priority: input.priority || "medium",
-          assignee: input.assignee,
-          labels: input.labels || [],
-          parent: input.parent,
-          subtasks: [],
-          acceptanceCriteria: [],
-          timeSpent: 0,
-          timeEntries: []
-        });
-        return {
-          content: [
-            {
-              type: "text",
-              text: JSON.stringify(
-                {
-                  success: true,
-                  task: {
-                    id: task.id,
-                    title: task.title,
-                    status: task.status,
-                    priority: task.priority
-                  }
-                },
-                null,
-                2
-              )
-            }
-          ]
-        };
-      }
-      case "get_task": {
-        const input = getTaskSchema.parse(args);
-        const task = await fileStore.getTask(input.taskId);
-        if (!task) {
-          return {
-            content: [
-              {
-                type: "text",
-                text: JSON.stringify(
-                  {
-                    success: false,
-                    error: `Task ${input.taskId} not found`
-                  },
-                  null,
-                  2
-                )
-              }
-            ]
-          };
-        }
-        const linkedDocs = await fetchLinkedDocs(task);
-        return {
-          content: [
-            {
-              type: "text",
-              text: JSON.stringify(
-                {
-                  success: true,
-                  task: {
-                    id: task.id,
-                    title: task.title,
-                    description: task.description,
-                    status: task.status,
-                    priority: task.priority,
-                    assignee: task.assignee,
-                    labels: task.labels,
-                    acceptanceCriteria: task.acceptanceCriteria,
-                    createdAt: task.createdAt,
-                    updatedAt: task.updatedAt,
-                    linkedDocumentation: linkedDocs
-                  }
-                },
-                null,
-                2
-              )
-            }
-          ]
-        };
-      }
-      case "update_task": {
-        const input = updateTaskSchema.parse(args);
-        const updates = {};
-        if (input.title) updates.title = input.title;
-        if (input.description) updates.description = input.description;
-        if (input.status) updates.status = input.status;
-        if (input.priority) updates.priority = input.priority;
-        if (input.assignee) updates.assignee = input.assignee;
-        if (input.labels) updates.labels = input.labels;
-        const task = await fileStore.updateTask(input.taskId, updates);
-        return {
-          content: [
-            {
-              type: "text",
-              text: JSON.stringify(
-                {
-                  success: true,
-                  task: {
-                    id: task.id,
-                    title: task.title,
-                    status: task.status,
-                    priority: task.priority
-                  }
-                },
-                null,
-                2
-              )
-            }
-          ]
-        };
-      }
-      case "list_tasks": {
-        const input = listTasksSchema.parse(args);
-        let tasks = await fileStore.getAllTasks();
-        if (input.status) {
-          tasks = tasks.filter((t) => t.status === input.status);
-        }
-        if (input.priority) {
-          tasks = tasks.filter((t) => t.priority === input.priority);
-        }
-        if (input.assignee) {
-          tasks = tasks.filter((t) => t.assignee === input.assignee);
-        }
-        if (input.label) {
-          tasks = tasks.filter((t) => t.labels.includes(input.label));
-        }
-        return {
-          content: [
-            {
-              type: "text",
-              text: JSON.stringify(
-                {
-                  success: true,
-                  count: tasks.length,
-                  tasks: tasks.map((t) => ({
-                    id: t.id,
-                    title: t.title,
-                    status: t.status,
-                    priority: t.priority,
-                    assignee: t.assignee,
-                    labels: t.labels
-                  }))
-                },
-                null,
-                2
-              )
-            }
-          ]
-        };
-      }
-      case "search_tasks": {
-        const input = searchTasksSchema.parse(args);
-        const tasks = await fileStore.getAllTasks();
-        const query = input.query.toLowerCase();
-        const results = tasks.filter(
-          (t) => t.title.toLowerCase().includes(query) || t.description?.toLowerCase().includes(query) || t.labels.some((l) => l.toLowerCase().includes(query))
-        );
-        return {
-          content: [
-            {
-              type: "text",
-              text: JSON.stringify(
-                {
-                  success: true,
-                  count: results.length,
-                  tasks: results.map((t) => ({
-                    id: t.id,
-                    title: t.title,
-                    status: t.status,
-                    priority: t.priority
-                  }))
-                },
-                null,
-                2
-              )
-            }
-          ]
-        };
-      }
-      case "start_time": {
-        const input = startTimeSchema.parse(args);
-        const task = await fileStore.getTask(input.taskId);
-        if (!task) {
-          return {
-            content: [
-              {
-                type: "text",
-                text: JSON.stringify({
-                  success: false,
-                  error: `Task ${input.taskId} not found`
-                })
-              }
-            ]
-          };
-        }
-        const activeEntry = task.timeEntries.find((e) => !e.endedAt);
-        if (activeEntry) {
-          return {
-            content: [
-              {
-                type: "text",
-                text: JSON.stringify({
-                  success: false,
-                  error: "Time tracking already active for this task"
-                })
-              }
-            ]
-          };
-        }
-        const newEntry = {
-          id: `entry-${Date.now()}`,
-          startedAt: /* @__PURE__ */ new Date(),
-          duration: 0,
-          note: "Started via MCP"
-        };
-        await fileStore.updateTask(input.taskId, {
-          timeEntries: [...task.timeEntries, newEntry]
-        });
-        return {
-          content: [
-            {
-              type: "text",
-              text: JSON.stringify({
-                success: true,
-                message: `Started tracking time for task ${input.taskId}`,
-                startedAt: newEntry.startedAt
-              })
-            }
-          ]
-        };
-      }
-      case "stop_time": {
-        const input = stopTimeSchema.parse(args);
-        const task = await fileStore.getTask(input.taskId);
-        if (!task) {
-          return {
-            content: [
-              {
-                type: "text",
-                text: JSON.stringify({
-                  success: false,
-                  error: `Task ${input.taskId} not found`
-                })
-              }
-            ]
-          };
-        }
-        const activeIndex = task.timeEntries.findIndex((e) => !e.endedAt);
-        if (activeIndex === -1) {
-          return {
-            content: [
-              {
-                type: "text",
-                text: JSON.stringify({
-                  success: false,
-                  error: "No active time tracking for this task"
-                })
-              }
-            ]
-          };
-        }
-        const endTime = /* @__PURE__ */ new Date();
-        const startTime = task.timeEntries[activeIndex].startedAt;
-        const duration3 = Math.floor((endTime.getTime() - startTime.getTime()) / 1e3);
-        const updatedEntries = [...task.timeEntries];
-        updatedEntries[activeIndex] = {
-          ...updatedEntries[activeIndex],
-          endedAt: endTime,
-          duration: duration3
-        };
-        const newTimeSpent = task.timeSpent + duration3;
-        await fileStore.updateTask(input.taskId, {
-          timeEntries: updatedEntries,
-          timeSpent: newTimeSpent
-        });
-        return {
-          content: [
-            {
-              type: "text",
-              text: JSON.stringify({
-                success: true,
-                message: `Stopped tracking time for task ${input.taskId}`,
-                duration: formatDuration(duration3),
-                totalTime: formatDuration(newTimeSpent)
-              })
-            }
-          ]
-        };
-      }
-      case "add_time": {
-        const input = addTimeSchema.parse(args);
-        const task = await fileStore.getTask(input.taskId);
-        if (!task) {
-          return {
-            content: [
-              {
-                type: "text",
-                text: JSON.stringify({
-                  success: false,
-                  error: `Task ${input.taskId} not found`
-                })
-              }
-            ]
-          };
-        }
-        const duration3 = parseDuration(input.duration);
-        const startDate = input.date ? new Date(input.date) : /* @__PURE__ */ new Date();
-        const newEntry = {
-          id: `entry-${Date.now()}`,
-          startedAt: startDate,
-          endedAt: new Date(startDate.getTime() + duration3 * 1e3),
-          duration: duration3,
-          note: input.note || "Added via MCP"
-        };
-        const newTimeSpent = task.timeSpent + duration3;
-        await fileStore.updateTask(input.taskId, {
-          timeEntries: [...task.timeEntries, newEntry],
-          timeSpent: newTimeSpent
-        });
-        return {
-          content: [
-            {
-              type: "text",
-              text: JSON.stringify({
-                success: true,
-                message: `Added ${formatDuration(duration3)} to task ${input.taskId}`,
-                totalTime: formatDuration(newTimeSpent)
-              })
-            }
-          ]
-        };
-      }
-      case "get_time_report": {
-        const input = getTimeReportSchema.parse(args);
-        const tasks = await fileStore.getAllTasks();
-        let fromDate;
-        let toDate;
-        if (input.from) fromDate = new Date(input.from);
-        if (input.to) toDate = new Date(input.to);
-        const taskTimeData = tasks.map((task) => {
-          let totalSeconds = 0;
-          for (const entry of task.timeEntries) {
-            if (entry.endedAt) {
-              const entryDate = new Date(entry.startedAt);
-              if (fromDate && entryDate < fromDate) continue;
-              if (toDate && entryDate > toDate) continue;
-              totalSeconds += entry.duration;
-            }
-          }
-          return {
-            taskId: task.id,
-            title: task.title,
-            status: task.status,
-            labels: task.labels,
-            totalSeconds
-          };
-        }).filter((data) => data.totalSeconds > 0);
-        if (input.groupBy === "label") {
-          const grouped = {};
-          for (const data of taskTimeData) {
-            for (const label of data.labels) {
-              grouped[label] = (grouped[label] || 0) + data.totalSeconds;
-            }
-            if (data.labels.length === 0) {
-              grouped["(no label)"] = (grouped["(no label)"] || 0) + data.totalSeconds;
-            }
-          }
-          return {
-            content: [
-              {
-                type: "text",
-                text: JSON.stringify(
-                  {
-                    success: true,
-                    groupBy: "label",
-                    data: Object.entries(grouped).map(([label, seconds]) => ({
-                      label,
-                      time: formatDuration(seconds),
-                      seconds
-                    })),
-                    totalSeconds: Object.values(grouped).reduce((a, b) => a + b, 0)
-                  },
-                  null,
-                  2
-                )
-              }
-            ]
-          };
-        }
-        if (input.groupBy === "status") {
-          const grouped = {};
-          for (const data of taskTimeData) {
-            grouped[data.status] = (grouped[data.status] || 0) + data.totalSeconds;
-          }
-          return {
-            content: [
-              {
-                type: "text",
-                text: JSON.stringify(
-                  {
-                    success: true,
-                    groupBy: "status",
-                    data: Object.entries(grouped).map(([status, seconds]) => ({
-                      status,
-                      time: formatDuration(seconds),
-                      seconds
-                    })),
-                    totalSeconds: Object.values(grouped).reduce((a, b) => a + b, 0)
-                  },
-                  null,
-                  2
-                )
-              }
-            ]
-          };
-        }
-        return {
-          content: [
-            {
-              type: "text",
-              text: JSON.stringify(
-                {
-                  success: true,
-                  groupBy: "task",
-                  data: taskTimeData.map((data) => ({
-                    taskId: data.taskId,
-                    title: data.title,
-                    status: data.status,
-                    time: formatDuration(data.totalSeconds),
-                    seconds: data.totalSeconds
-                  })),
-                  totalSeconds: taskTimeData.reduce((sum, data) => sum + data.totalSeconds, 0)
-                },
-                null,
-                2
-              )
-            }
-          ]
-        };
-      }
-      case "get_board": {
-        const tasks = await fileStore.getAllTasks();
-        const board = {
-          todo: [],
-          "in-progress": [],
-          "in-review": [],
-          done: [],
-          blocked: []
-        };
-        for (const task of tasks) {
-          if (board[task.status]) {
-            board[task.status].push(task);
-          }
-        }
-        return {
-          content: [
-            {
-              type: "text",
-              text: JSON.stringify(
-                {
-                  success: true,
-                  board: {
-                    todo: board.todo.map((t) => ({
-                      id: t.id,
-                      title: t.title,
-                      priority: t.priority,
-                      assignee: t.assignee,
-                      labels: t.labels
-                    })),
-                    "in-progress": board["in-progress"].map((t) => ({
-                      id: t.id,
-                      title: t.title,
-                      priority: t.priority,
-                      assignee: t.assignee,
-                      labels: t.labels
-                    })),
-                    "in-review": board["in-review"].map((t) => ({
-                      id: t.id,
-                      title: t.title,
-                      priority: t.priority,
-                      assignee: t.assignee,
-                      labels: t.labels
-                    })),
-                    done: board.done.map((t) => ({
-                      id: t.id,
-                      title: t.title,
-                      priority: t.priority,
-                      assignee: t.assignee,
-                      labels: t.labels
-                    })),
-                    blocked: board.blocked.map((t) => ({
-                      id: t.id,
-                      title: t.title,
-                      priority: t.priority,
-                      assignee: t.assignee,
-                      labels: t.labels
-                    }))
-                  },
-                  totalTasks: tasks.length
-                },
-                null,
-                2
-              )
-            }
-          ]
-        };
-      }
+      // Task handlers
+      case "create_task":
+        return await handleCreateTask(args, fileStore);
+      case "get_task":
+        return await handleGetTask(args, fileStore);
+      case "update_task":
+        return await handleUpdateTask(args, fileStore);
+      case "list_tasks":
+        return await handleListTasks(args, fileStore);
+      case "search_tasks":
+        return await handleSearchTasks(args, fileStore);
+      // Time handlers
+      case "start_time":
+        return await handleStartTime(args, fileStore);
+      case "stop_time":
+        return await handleStopTime(args, fileStore);
+      case "add_time":
+        return await handleAddTime(args, fileStore);
+      case "get_time_report":
+        return await handleGetTimeReport(args, fileStore);
+      // Board handlers
+      case "get_board":
+        return await handleGetBoard(fileStore);
+      // Doc handlers
+      case "list_docs":
+        return await handleListDocs(args);
+      case "get_doc":
+        return await handleGetDoc(args);
+      case "create_doc":
+        return await handleCreateDoc(args);
+      case "update_doc":
+        return await handleUpdateDoc(args);
+      case "search_docs":
+        return await handleSearchDocs(args);
       default:
-        return {
-          content: [
-            {
-              type: "text",
-              text: JSON.stringify({
-                success: false,
-                error: `Unknown tool: ${name}`
-              })
-            }
-          ]
-        };
+        return errorResponse(`Unknown tool: ${name}`);
     }
   } catch (error46) {
+    return errorResponse(error46 instanceof Error ? error46.message : String(error46));
+  }
+});
+server.setRequestHandler(ListResourcesRequestSchema, async () => {
+  const tasks = await fileStore.getAllTasks();
+  const docsDir = join8(process.cwd(), ".knowns", "docs");
+  const taskResources = tasks.map((task) => ({
+    uri: `knowns://task/${task.id}`,
+    name: task.title,
+    mimeType: "application/json",
+    description: `Task #${task.id}: ${task.title}`
+  }));
+  const docResources = [];
+  if (existsSync5(docsDir)) {
+    const { readdir: readdir3 } = await import("node:fs/promises");
+    async function getAllMdFiles2(dir, basePath = "") {
+      const files = [];
+      const entries = await readdir3(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        const fullPath = join8(dir, entry.name);
+        const relativePath = basePath ? join8(basePath, entry.name) : entry.name;
+        if (entry.isDirectory()) {
+          const subFiles = await getAllMdFiles2(fullPath, relativePath);
+          files.push(...subFiles);
+        } else if (entry.isFile() && entry.name.endsWith(".md")) {
+          files.push(relativePath);
+        }
+      }
+      return files;
+    }
+    const mdFiles = await getAllMdFiles2(docsDir);
+    for (const file3 of mdFiles) {
+      const filepath = join8(docsDir, file3);
+      const content = await readFile4(filepath, "utf-8");
+      const { data } = (0, import_gray_matter4.default)(content);
+      docResources.push({
+        uri: `knowns://doc/${file3.replace(/\.md$/, "")}`,
+        name: data.title || file3.replace(/\.md$/, ""),
+        mimeType: "text/markdown",
+        description: data.description || `Documentation: ${file3}`
+      });
+    }
+  }
+  return {
+    resources: [...taskResources, ...docResources]
+  };
+});
+server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
+  const uri = request.params.uri;
+  const taskMatch = uri.match(/^knowns:\/\/task\/(.+)$/);
+  if (taskMatch) {
+    const taskId = taskMatch[1];
+    const task = await fileStore.getTask(taskId);
+    if (!task) {
+      throw new Error(`Task ${taskId} not found`);
+    }
+    return {
+      contents: [
+        {
+          uri,
+          mimeType: "application/json",
+          text: JSON.stringify(task, null, 2)
+        }
+      ]
+    };
+  }
+  const docMatch = uri.match(/^knowns:\/\/doc\/(.+)$/);
+  if (docMatch) {
+    const docPath = docMatch[1];
+    const docsDir = join8(process.cwd(), ".knowns", "docs");
+    const filepath = join8(docsDir, `${docPath}.md`);
+    if (!existsSync5(filepath)) {
+      throw new Error(`Documentation ${docPath} not found`);
+    }
+    const content = await readFile4(filepath, "utf-8");
+    const { data, content: docContent } = (0, import_gray_matter4.default)(content);
     return {
-      content: [
+      contents: [
         {
-          type: "text",
+          uri,
+          mimeType: "text/markdown",
           text: JSON.stringify(
             {
-              success: false,
-              error: error46 instanceof Error ? error46.message : String(error46)
+              metadata: data,
+              content: docContent.trim()
             },
             null,
             2
@@ -32549,48 +32989,28 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
       ]
     };
   }
+  throw new Error(`Invalid resource URI: ${uri}`);
 });
-server.setRequestHandler(ListResourcesRequestSchema, async () => {
-  const tasks = await fileStore.getAllTasks();
-  return {
-    resources: tasks.map((task) => ({
-      uri: `knowns://task/${task.id}`,
-      name: task.title,
-      mimeType: "application/json",
-      description: `Task #${task.id}: ${task.title}`
-    }))
-  };
-});
-server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
-  const uri = request.params.uri;
-  const match = uri.match(/^knowns:\/\/task\/(.+)$/);
-  if (!match) {
-    throw new Error(`Invalid resource URI: ${uri}`);
-  }
-  const taskId = match[1];
-  const task = await fileStore.getTask(taskId);
-  if (!task) {
-    throw new Error(`Task ${taskId} not found`);
+async function startMcpServer(options2 = {}) {
+  if (options2.verbose) {
+    console.error("Knowns MCP Server starting...");
   }
-  return {
-    contents: [
-      {
-        uri,
-        mimeType: "application/json",
-        text: JSON.stringify(task, null, 2)
-      }
-    ]
-  };
-});
-async function main() {
   const transport = new StdioServerTransport();
   await server.connect(transport);
-  console.error("Knowns MCP Server running on stdio");
+  if (options2.verbose) {
+    console.error("Knowns MCP Server running on stdio");
+  }
 }
-main().catch((error46) => {
-  console.error("Fatal error:", error46);
-  process.exit(1);
-});
+var isStandaloneServer = process.argv[1]?.includes("mcp/server") || process.argv[1]?.includes("mcp\\server");
+if (isStandaloneServer) {
+  startMcpServer({ verbose: true }).catch((error46) => {
+    console.error("Fatal error:", error46);
+    process.exit(1);
+  });
+}
+export {
+  startMcpServer
+};
 /*! Bundled license information:
 
 is-extendable/index.js: