@docyrus/docyrus 0.0.43 → 0.0.45

package/server-loader.js

@@ -22018,6 +22018,23 @@ function normalizeDeploymentName(params) {
   return params.defaultModel;
 }
 async function resolveKnowledgeProviderFromAgentRuntime(params) {
+  if (params.docyrusApi) {
+    const { apiBaseUrl, accessToken } = params.docyrusApi;
+    const gatewayBase = apiBaseUrl.replace(/\/+$/u, "") + "/ai/gateway";
+    return {
+      provider: {
+        providerId: "docyrus-api",
+        apiBase: gatewayBase,
+        model: DEFAULT_EMBEDDING_MODEL,
+        dimensions: DEFAULT_DIMENSIONS,
+        key: accessToken,
+        headers: (key) => ({
+          Authorization: `Bearer ${key}`,
+          "Content-Type": "application/json"
+        })
+      }
+    };
+  }
   const agentRootPath = resolveDocyrusPiAgentRootPath(params.settingsRootPath);
   const authState = readJsonFile((0, import_node_path10.join)(agentRootPath, "auth.json")) || {};
   const envStore = new AgentEnvStore((0, import_node_path10.join)(agentRootPath, "env.json"));
@@ -22560,9 +22577,9 @@ async function checkKnowledgeSections(knowledgeDir) {
 }
 
 // src/knowledge/init.ts
-var import_node_fs9 = require("node:fs");
-var import_promises11 = require("node:fs/promises");
-var import_node_path15 = require("node:path");
+var import_node_fs7 = require("node:fs");
+var import_promises9 = require("node:fs/promises");
+var import_node_path13 = require("node:path");
 init_graph();
 
 // src/knowledge/bootstrap.ts
@@ -22974,29 +22991,265 @@ async function generateInitialKnowledge(params) {
   };
 }
 
+// src/knowledge/init.ts
+var MARKER_BEGIN = "%% docyrus-knowledge:begin %%";
+var MARKER_END = "%% docyrus-knowledge:end %%";
+var HOOK_MARKER_BEGIN = "# docyrus-knowledge:begin";
+var HOOK_MARKER_END = "# docyrus-knowledge:end";
+function wrapManagedBlock(content3) {
+  return `${MARKER_BEGIN}
+${content3}${content3.endsWith("\n") ? "" : "\n"}${MARKER_END}
+`;
+}
+async function ensureDirectory(pathValue) {
+  await (0, import_promises9.mkdir)(pathValue, {
+    recursive: true,
+    mode: 493
+  });
+}
+async function writeIfMissing(filePath, content3) {
+  if ((0, import_node_fs7.existsSync)(filePath)) {
+    return "kept";
+  }
+  await ensureDirectory((0, import_node_path13.dirname)(filePath));
+  await (0, import_promises9.writeFile)(filePath, content3, "utf8");
+  return "created";
+}
+async function writeOrUpdate(filePath, content3) {
+  if (!(0, import_node_fs7.existsSync)(filePath)) {
+    await ensureDirectory((0, import_node_path13.dirname)(filePath));
+    await (0, import_promises9.writeFile)(filePath, content3, "utf8");
+    return "created";
+  }
+  const current = await (0, import_promises9.readFile)(filePath, "utf8");
+  if (current === content3) {
+    return "kept";
+  }
+  await ensureDirectory((0, import_node_path13.dirname)(filePath));
+  await (0, import_promises9.writeFile)(filePath, content3, "utf8");
+  return "updated";
+}
+async function upsertManagedBlock(filePath, content3) {
+  const wrapped = wrapManagedBlock(content3);
+  if (!(0, import_node_fs7.existsSync)(filePath)) {
+    await ensureDirectory((0, import_node_path13.dirname)(filePath));
+    await (0, import_promises9.writeFile)(filePath, wrapped, "utf8");
+    return "created";
+  }
+  const current = await (0, import_promises9.readFile)(filePath, "utf8");
+  const beginIndex = current.indexOf(MARKER_BEGIN);
+  const endIndex = current.indexOf(MARKER_END);
+  if (beginIndex !== -1 && endIndex !== -1 && endIndex > beginIndex) {
+    const replaceEnd = current[endIndex + MARKER_END.length] === "\n" ? endIndex + MARKER_END.length + 1 : endIndex + MARKER_END.length;
+    const updated = `${current.slice(0, beginIndex)}${wrapped}${current.slice(replaceEnd)}`;
+    await (0, import_promises9.writeFile)(filePath, updated, "utf8");
+    return "updated";
+  }
+  const separator = current.endsWith("\n") ? "\n" : "\n\n";
+  await (0, import_promises9.writeFile)(filePath, `${current}${separator}${wrapped}`, "utf8");
+  return "appended";
+}
+function normalizeObject(value2) {
+  return typeof value2 === "object" && value2 !== null && !Array.isArray(value2) ? { ...value2 } : {};
+}
+async function updateJsonFile(filePath, updater) {
+  const current = (0, import_node_fs7.existsSync)(filePath) ? normalizeObject(JSON.parse((0, import_node_fs7.readFileSync)(filePath, "utf8"))) : {};
+  await ensureDirectory((0, import_node_path13.dirname)(filePath));
+  await (0, import_promises9.writeFile)(filePath, `${JSON.stringify(updater(current), null, 2)}
+`, "utf8");
+}
+function wrapHookBlock(content3) {
+  return `${HOOK_MARKER_BEGIN}
+${content3}${content3.endsWith("\n") ? "" : "\n"}${HOOK_MARKER_END}
+`;
+}
+async function upsertShellHook(filePath, content3, shellHeader) {
+  const wrapped = wrapHookBlock(content3);
+  if (!(0, import_node_fs7.existsSync)(filePath)) {
+    await ensureDirectory((0, import_node_path13.dirname)(filePath));
+    const initial = `${shellHeader || ""}${wrapped}`;
+    await (0, import_promises9.writeFile)(filePath, initial, {
+      encoding: "utf8",
+      mode: 493
+    });
+    await (0, import_promises9.chmod)(filePath, 493);
+    return "created";
+  }
+  const current = await (0, import_promises9.readFile)(filePath, "utf8");
+  const beginIndex = current.indexOf(HOOK_MARKER_BEGIN);
+  const endIndex = current.indexOf(HOOK_MARKER_END);
+  if (beginIndex !== -1 && endIndex !== -1 && endIndex > beginIndex) {
+    const replaceEnd = current[endIndex + HOOK_MARKER_END.length] === "\n" ? endIndex + HOOK_MARKER_END.length + 1 : endIndex + HOOK_MARKER_END.length;
+    const nextContent = `${current.slice(0, beginIndex)}${wrapped}${current.slice(replaceEnd)}`;
+    if (nextContent === current) {
+      return "kept";
+    }
+    await (0, import_promises9.writeFile)(filePath, nextContent, "utf8");
+    await (0, import_promises9.chmod)(filePath, 493);
+    return "updated";
+  }
+  const separator = current.endsWith("\n") ? "\n" : "\n\n";
+  await (0, import_promises9.writeFile)(filePath, `${current}${separator}${wrapped}`, "utf8");
+  await (0, import_promises9.chmod)(filePath, 493);
+  return "appended";
+}
+function buildKnowledgeDocumentTemplate() {
+  return [
+    "# Knowledge",
+    "",
+    "This directory captures the architecture, constraints, workflows, and test expectations that coding agents should read before changing the repo.",
+    "",
+    "## Working Agreement",
+    "",
+    "Search this knowledge graph before coding, keep it updated when behavior changes, and use \\[\\[wiki links\\]\\] plus `@docyrus` backlinks to connect decisions to implementation.",
+    "",
+    "## Backlinks",
+    "",
+    "Use `// @docyrus: \\[\\[knowledge#Section Name\\]\\]` or `# @docyrus: \\[\\[knowledge#Section Name\\]\\]` near the code or tests that implement a documented behavior.",
+    ""
+  ].join("\n");
+}
+function buildAgentsTemplate(commandPrefix) {
+  return [
+    "# Knowledge Graph Workflow",
+    "",
+    `- If \`docyrus/knowledge/\` exists, run \`${commandPrefix} knowledge search\` before coding so you start from documented intent instead of rediscovering it from source files.`,
+    `- Use \`${commandPrefix} knowledge expand\` when prompts contain \`[[refs]]\` so section names resolve to real file locations and summaries.`,
+    "- Keep `docyrus/knowledge/` in sync whenever you change functionality, architecture, tests, or behavior.",
+    `- Before finishing, run \`${commandPrefix} knowledge check\` and fix any broken links, stale references, or missing \`@docyrus\` backlinks.`,
+    ""
+  ].join("\n");
+}
+function buildCursorRulesTemplate(commandPrefix) {
+  return [
+    "# Knowledge Graph Workflow",
+    "",
+    `- Use \`${commandPrefix} knowledge search\` to find relevant documentation before reading or editing code.`,
+    `- Use \`${commandPrefix} knowledge section\` to read the full section once you have a relevant section id.`,
+    `- Use \`${commandPrefix} knowledge expand\` whenever the prompt includes \`[[refs]]\`.`,
+    `- Keep \`docyrus/knowledge/\` updated and finish with \`${commandPrefix} knowledge check\`.`,
+    ""
+  ].join("\n");
+}
+function buildClaudeHookCommand(commandPrefix, event) {
+  return `${commandPrefix} knowledge hook claude ${event}`;
+}
+function syncClaudeHooks(settings, commandPrefix) {
+  const hooks = normalizeObject(settings.hooks);
+  const nextHooks = { ...hooks };
+  for (const [eventName, entries] of Object.entries(nextHooks)) {
+    if (!Array.isArray(entries)) {
+      continue;
+    }
+    nextHooks[eventName] = entries.filter((entry) => {
+      const hooksList = Array.isArray(entry.hooks) ? entry.hooks || [] : [];
+      return !hooksList.some((hook) => typeof hook.command === "string" && hook.command.includes("knowledge hook claude"));
+    });
+  }
+  const addHook = (eventName) => {
+    const current = Array.isArray(nextHooks[eventName]) ? nextHooks[eventName] : [];
+    current.push({
+      hooks: [
+        {
+          type: "command",
+          command: buildClaudeHookCommand(commandPrefix, eventName)
+        }
+      ]
+    });
+    nextHooks[eventName] = current;
+  };
+  addHook("UserPromptSubmit");
+  addHook("Stop");
+  return {
+    ...settings,
+    hooks: nextHooks
+  };
+}
+function syncCursorHooks(settings, commandPrefix) {
+  const hooks = normalizeObject(settings.hooks);
+  const stopEntries = Array.isArray(hooks.stop) ? hooks.stop : [];
+  const filtered = stopEntries.filter((entry) => typeof entry.command !== "string" || !entry.command.includes("knowledge hook cursor"));
+  return {
+    ...settings.version ? settings : { version: 1 },
+    ...settings,
+    hooks: {
+      ...hooks,
+      stop: [
+        ...filtered,
+        {
+          command: `${commandPrefix} knowledge hook cursor stop`
+        }
+      ]
+    }
+  };
+}
+async function initializeKnowledgeRepo(params) {
+  const root = (0, import_node_path13.resolve)(params.root || process.cwd());
+  const knowledgeDir = getKnowledgeDirectory(root);
+  const knowledgeFile = (0, import_node_path13.join)(knowledgeDir, "knowledge.md");
+  await ensureDirectory(knowledgeDir);
+  const knowledgeFileStatus = await writeIfMissing(knowledgeFile, `${buildKnowledgeDocumentTemplate()}
+`);
+  const agentsStatus = await upsertManagedBlock((0, import_node_path13.join)(root, "AGENTS.md"), buildAgentsTemplate(params.commandPrefix));
+  const claudeStatus = await upsertManagedBlock((0, import_node_path13.join)(root, "CLAUDE.md"), buildAgentsTemplate(params.commandPrefix));
+  const cursorRulesStatus = await writeOrUpdate((0, import_node_path13.join)(root, ".cursor", "rules", "docyrus-knowledge.md"), `${buildCursorRulesTemplate(params.commandPrefix)}
+`);
+  const bootstrap = (await generateInitialKnowledge({
+    root,
+    brief: params.brief
+  })).files;
+  await updateJsonFile((0, import_node_path13.join)(root, ".claude", "settings.json"), (value2) => syncClaudeHooks(value2, params.commandPrefix));
+  await updateJsonFile((0, import_node_path13.join)(root, ".cursor", "hooks.json"), (value2) => syncCursorHooks(value2, params.commandPrefix));
+  let huskyHookStatus;
+  const huskyDir = (0, import_node_path13.join)(root, ".husky");
+  if ((0, import_node_fs7.existsSync)(huskyDir)) {
+    const huskyHookPath = (0, import_node_path13.join)(huskyDir, "pre-commit");
+    const huskyHeader = (0, import_node_fs7.existsSync)((0, import_node_path13.join)(huskyDir, "_", "h")) ? '#!/usr/bin/env sh\n. "$(dirname -- "$0")/_/h"\n\n' : void 0;
+    huskyHookStatus = await upsertShellHook(huskyHookPath, `${params.commandPrefix} knowledge pre-commit
+`, huskyHeader);
+  }
+  let gitHookStatus;
+  if (!huskyHookStatus && params.installGitHook) {
+    const gitHookPath = (0, import_node_path13.join)(root, ".git", "hooks", "pre-commit");
+    gitHookStatus = await upsertShellHook(gitHookPath, `${params.commandPrefix} knowledge pre-commit
+`, "#!/usr/bin/env sh\n\n");
+  }
+  return {
+    root,
+    knowledgeDir,
+    knowledgeFile,
+    agentsStatus,
+    claudeStatus,
+    cursorRulesStatus,
+    knowledgeFileStatus,
+    bootstrap,
+    huskyHookStatus,
+    gitHookStatus
+  };
+}
+
 // src/project-plan/graph.ts
 var import_node_crypto3 = require("node:crypto");
-var import_node_fs8 = require("node:fs");
-var import_promises10 = __toESM(require("node:fs/promises"));
-var import_node_path14 = __toESM(require("node:path"));
-init_graph();
+var import_node_fs9 = require("node:fs");
+var import_promises11 = __toESM(require("node:fs/promises"));
+var import_node_path15 = __toESM(require("node:path"));
 
 // src/project-plan/localTodos.ts
 var import_node_crypto2 = __toESM(require("node:crypto"));
-var import_node_fs7 = require("node:fs");
-var import_promises9 = __toESM(require("node:fs/promises"));
-var import_node_path13 = __toESM(require("node:path"));
+var import_node_fs8 = require("node:fs");
+var import_promises10 = __toESM(require("node:fs/promises"));
+var import_node_path14 = __toESM(require("node:path"));
 var TODO_DIR_NAME = ".pi/todos";
 var TODO_PATH_ENV = "PI_TODO_PATH";
 function resolveTodosDirectory(root) {
   const overridePath = process.env[TODO_PATH_ENV]?.trim();
   if (overridePath) {
-    return import_node_path13.default.resolve(root, overridePath);
+    return import_node_path14.default.resolve(root, overridePath);
   }
-  return import_node_path13.default.resolve(root, TODO_DIR_NAME);
+  return import_node_path14.default.resolve(root, TODO_DIR_NAME);
 }
 function getTodoFilePath(todosDir, id) {
-  return import_node_path13.default.join(todosDir, `${id}.md`);
+  return import_node_path14.default.join(todosDir, `${id}.md`);
 }
 function splitFrontMatter(content3) {
   if (!content3.startsWith("{")) {
@@ -23102,7 +23355,7 @@ ${trimmedBody}
 async function generateTodoId(todosDir) {
   for (let attempt = 0; attempt < 10; attempt += 1) {
     const id = import_node_crypto2.default.randomBytes(4).toString("hex");
-    if (!(0, import_node_fs7.existsSync)(getTodoFilePath(todosDir, id))) {
+    if (!(0, import_node_fs8.existsSync)(getTodoFilePath(todosDir, id))) {
       return id;
     }
   }
@@ -23113,7 +23366,7 @@ async function listLinkedTodosByTask(root) {
   const result = /* @__PURE__ */ new Map();
   let entries = [];
   try {
-    entries = await import_promises9.default.readdir(todosDir);
+    entries = await import_promises10.default.readdir(todosDir);
   } catch {
     return result;
   }
@@ -23124,7 +23377,7 @@ async function listLinkedTodosByTask(root) {
     const id = entry.slice(0, -3);
     const filePath = getTodoFilePath(todosDir, id);
     try {
-      const raw2 = await import_promises9.default.readFile(filePath, "utf8");
+      const raw2 = await import_promises10.default.readFile(filePath, "utf8");
       const { frontMatter } = splitFrontMatter(raw2);
       const parsed = parseLocalTodoFrontMatter(frontMatter, id);
       if (!parsed.parent_task_id) {
@@ -23135,7 +23388,7 @@ async function listLinkedTodosByTask(root) {
         id,
         title: parsed.title,
         status: parsed.status,
-        filePath: import_node_path13.default.relative(root, filePath),
+        filePath: import_node_path14.default.relative(root, filePath),
         parentTaskId: parsed.parent_task_id
       });
       result.set(parsed.parent_task_id, existing);
@@ -23153,7 +23406,7 @@ async function listAllLinkedTodos(root) {
 }
 async function createLinkedTodo(params) {
   const todosDir = resolveTodosDirectory(params.root);
-  await import_promises9.default.mkdir(todosDir, {
+  await import_promises10.default.mkdir(todosDir, {
     recursive: true
   });
   const id = await generateTodoId(todosDir);
@@ -23167,12 +23420,12 @@ async function createLinkedTodo(params) {
     parent_task_id: params.parentTaskId,
     body: params.body ?? ""
   };
-  await import_promises9.default.writeFile(filePath, serializeLocalTodo(todo), "utf8");
+  await import_promises10.default.writeFile(filePath, serializeLocalTodo(todo), "utf8");
   return {
     id,
     title: todo.title,
     status: todo.status,
-    filePath: import_node_path13.default.relative(params.root, filePath),
+    filePath: import_node_path14.default.relative(params.root, filePath),
     parentTaskId: params.parentTaskId
   };
 }
@@ -23200,6 +23453,9 @@ var PROJECT_TASK_STATUSES = [
 var PROJECT_PLAN_DIR_SEGMENTS = ["docyrus", "project-plan"];
 var PROJECT_PLAN_JSON_FILE_NAME = "project-plan.json";
 var PROJECT_PLAN_MARKDOWN_FILE_NAME = "PROJECT_PLAN.md";
+var KNOWLEDGE_FEATURES_PATH_SEGMENTS = ["docyrus", "knowledge", "features", "features.md"];
+var FEATURES_MARKER_BEGIN = "<!-- docyrus-project-plan:features:begin -->";
+var FEATURES_MARKER_END = "<!-- docyrus-project-plan:features:end -->";
 function isRecord3(value2) {
   return typeof value2 === "object" && value2 !== null && !Array.isArray(value2);
 }
@@ -23219,6 +23475,9 @@ function slugify(value2) {
 function hashParts(parts2) {
   return (0, import_node_crypto3.createHash)("sha1").update(parts2.join("::")).digest("hex").slice(0, 12);
 }
+function normalizeSectionId(slug) {
+  return `section-${hashParts([slug])}`;
+}
 function normalizeFeatureId(sectionId, slug) {
   return `feature-${hashParts([sectionId, slug])}`;
 }
@@ -23231,7 +23490,7 @@ function compareStrings(left, right) {
 function sortGraph(graph) {
   return {
     version: 1,
-    sections: [...graph.sections].sort((left, right) => compareStrings(left.sectionId, right.sectionId)),
+    sections: [...graph.sections].sort((left, right) => compareStrings(left.id, right.id)),
     features: [...graph.features].sort((left, right) => {
       return compareStrings(left.sectionId, right.sectionId) || compareStrings(left.title, right.title) || compareStrings(left.id, right.id);
     }),
@@ -23241,13 +23500,13 @@ function sortGraph(graph) {
   };
 }
 function resolveProjectPlanDirectory(root) {
-  return import_node_path14.default.join(root, ...PROJECT_PLAN_DIR_SEGMENTS);
+  return import_node_path15.default.join(root, ...PROJECT_PLAN_DIR_SEGMENTS);
 }
 function resolveProjectPlanGraphPath(root) {
-  return import_node_path14.default.join(resolveProjectPlanDirectory(root), PROJECT_PLAN_JSON_FILE_NAME);
+  return import_node_path15.default.join(resolveProjectPlanDirectory(root), PROJECT_PLAN_JSON_FILE_NAME);
 }
 function resolveProjectPlanMarkdownPath(root) {
-  return import_node_path14.default.join(resolveProjectPlanDirectory(root), PROJECT_PLAN_MARKDOWN_FILE_NAME);
+  return import_node_path15.default.join(resolveProjectPlanDirectory(root), PROJECT_PLAN_MARKDOWN_FILE_NAME);
 }
 function createEmptyProjectPlanGraph() {
   return {
@@ -23257,20 +23516,16 @@ function createEmptyProjectPlanGraph() {
     tasks: []
   };
 }
-async function readKnowledgeSections(root) {
-  const knowledgeDir = import_node_path14.default.join(root, "docyrus", "knowledge");
-  if (!(0, import_node_fs8.existsSync)(knowledgeDir)) {
-    return [];
-  }
-  return flattenSections(await loadAllSections(knowledgeDir));
-}
 function parseProjectPlanGraph(rawValue) {
   if (!isRecord3(rawValue)) {
     return createEmptyProjectPlanGraph();
   }
   const sections = Array.isArray(rawValue.sections) ? rawValue.sections.filter((value2) => isRecord3(value2)).map((value2) => ({
-    sectionId: isNonEmptyString2(value2.sectionId) ? value2.sectionId.trim() : ""
-  })).filter((value2) => value2.sectionId.length > 0) : [];
+    id: isNonEmptyString2(value2.id) ? value2.id.trim() : "",
+    title: isNonEmptyString2(value2.title) ? value2.title.trim() : "",
+    slug: isNonEmptyString2(value2.slug) ? value2.slug.trim() : "",
+    summary: typeof value2.summary === "string" ? value2.summary.trim() : ""
+  })).filter((value2) => value2.id.length > 0) : [];
   const features = Array.isArray(rawValue.features) ? rawValue.features.filter((value2) => isRecord3(value2)).map((value2) => ({
     id: isNonEmptyString2(value2.id) ? value2.id.trim() : "",
     title: isNonEmptyString2(value2.title) ? value2.title.trim() : "",
@@ -23298,10 +23553,10 @@ function parseProjectPlanGraph(rawValue) {
 }
 async function readProjectPlanGraph(root) {
   const graphPath = resolveProjectPlanGraphPath(root);
-  if (!(0, import_node_fs8.existsSync)(graphPath)) {
+  if (!(0, import_node_fs9.existsSync)(graphPath)) {
     return createEmptyProjectPlanGraph();
   }
-  const raw2 = await import_promises10.default.readFile(graphPath, "utf8");
+  const raw2 = await import_promises11.default.readFile(graphPath, "utf8");
   return parseProjectPlanGraph(JSON.parse(raw2));
 }
 function deriveFeatureStatus(tasks) {
@@ -23334,21 +23589,7 @@ function deriveSectionStatus(features) {
   }
   return "planned";
 }
-function findKnowledgeSectionTitle(knowledgeSections, sectionId) {
-  const section = knowledgeSections.find((item) => item.id === sectionId);
-  if (!section) {
-    return {
-      heading: sectionId,
-      filePath: ""
-    };
-  }
-  return {
-    heading: section.heading,
-    filePath: section.filePath
-  };
-}
 async function buildProjectPlanHierarchy(root, graph) {
-  const knowledgeSections = await readKnowledgeSections(root);
   const currentGraph = graph ?? await readProjectPlanGraph(root);
   const linkedTodos = await listLinkedTodosByTask(root);
   const featureMap = /* @__PURE__ */ new Map();
@@ -23369,13 +23610,13 @@ async function buildProjectPlanHierarchy(root, graph) {
     });
   }
   const sections = currentGraph.sections.map((section) => {
-    const features = currentGraph.features.filter((feature) => feature.sectionId === section.sectionId).map((feature) => featureMap.get(feature.id)).filter((feature) => Boolean(feature));
-    const knowledgeMetadata = findKnowledgeSectionTitle(knowledgeSections, section.sectionId);
+    const features = currentGraph.features.filter((feature) => feature.sectionId === section.id).map((feature) => featureMap.get(feature.id)).filter((feature) => Boolean(feature));
     const taskCount = features.reduce((count, feature) => count + feature.taskCount, 0);
     return {
-      sectionId: section.sectionId,
-      heading: knowledgeMetadata.heading,
-      filePath: knowledgeMetadata.filePath,
+      id: section.id,
+      title: section.title,
+      slug: section.slug,
+      summary: section.summary,
       status: deriveSectionStatus(features),
       featureCount: features.length,
       taskCount,
@@ -23407,9 +23648,9 @@ async function renderProjectPlanMarkdown(root, graph) {
     return `${lines.join("\n")}`;
   }
   for (const section of populatedSections) {
-    lines.push(`## ${section.heading}`);
+    lines.push(`## ${section.title}`);
     lines.push("");
-    lines.push(`- Section ID: \`${section.sectionId}\``);
+    lines.push(`- Section ID: \`${section.id}\``);
     lines.push(`- Status: \`${section.status}\``);
     lines.push(`- Features: ${section.featureCount}`);
     lines.push(`- Tasks: ${section.taskCount}`);
@@ -23443,53 +23684,118 @@ async function renderProjectPlanMarkdown(root, graph) {
   return `${lines.join("\n").trimEnd()}
 `;
 }
-async function writeProjectPlanFiles(root, graph) {
-  const graphPath = resolveProjectPlanGraphPath(root);
-  const markdownPath = resolveProjectPlanMarkdownPath(root);
-  await import_promises10.default.mkdir(import_node_path14.default.dirname(graphPath), {
-    recursive: true
-  });
-  const sortedGraph = sortGraph(graph);
-  await import_promises10.default.writeFile(graphPath, `${JSON.stringify(sortedGraph, null, 2)}
-`, "utf8");
-  await import_promises10.default.writeFile(markdownPath, await renderProjectPlanMarkdown(root, sortedGraph), "utf8");
-  return {
-    graph: sortedGraph,
-    graphPath,
-    markdownPath
-  };
-}
-function buildProjectPlanCheckError(code, message, target) {
-  return {
-    code,
-    message,
-    target
-  };
-}
-async function validateProjectPlanGraph(root, graph) {
-  const currentGraph = graph ?? await readProjectPlanGraph(root);
+function buildKnowledgeFeaturesSection(graph) {
+  const sectionMap = new Map(graph.sections.map((section) => [section.id, section]));
+  const featuresBySection = /* @__PURE__ */ new Map();
+  for (const feature of graph.features) {
+    const list2 = featuresBySection.get(feature.sectionId) || [];
+    list2.push(feature);
+    featuresBySection.set(feature.sectionId, list2);
+  }
+  const lines = [
+    "## Planned Features",
+    "",
+    "Features tracked in the project plan.",
+    ""
+  ];
+  if (graph.features.length === 0) {
+    lines.push("No planned features yet.");
+    lines.push("");
+    return lines.join("\n");
+  }
+  for (const section of graph.sections) {
+    const features = featuresBySection.get(section.id);
+    if (!features || features.length === 0) {
+      continue;
+    }
+    lines.push(`### ${section.title}`);
+    lines.push("");
+    for (const feature of features) {
+      const summary = feature.summary ? ` \u2014 ${feature.summary}` : "";
+      lines.push(`- **${feature.title}**${summary}`);
+    }
+    lines.push("");
+  }
+  const ungrouped = graph.features.filter((feature) => !sectionMap.has(feature.sectionId));
+  if (ungrouped.length > 0) {
+    for (const feature of ungrouped) {
+      const summary = feature.summary ? ` \u2014 ${feature.summary}` : "";
+      lines.push(`- **${feature.title}**${summary}`);
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+async function syncFeaturesToKnowledge(root, graph) {
+  const featuresPath = import_node_path15.default.join(root, ...KNOWLEDGE_FEATURES_PATH_SEGMENTS);
+  if (!(0, import_node_fs9.existsSync)(featuresPath)) {
+    return;
+  }
+  const content3 = buildKnowledgeFeaturesSection(graph);
+  const wrapped = `${FEATURES_MARKER_BEGIN}
+${content3.trimEnd()}
+
+${FEATURES_MARKER_END}
+`;
+  const current = await import_promises11.default.readFile(featuresPath, "utf8");
+  const beginIndex = current.indexOf(FEATURES_MARKER_BEGIN);
+  const endIndex = current.indexOf(FEATURES_MARKER_END);
+  if (beginIndex !== -1 && endIndex !== -1 && endIndex > beginIndex) {
+    const replaceEnd = current[endIndex + FEATURES_MARKER_END.length] === "\n" ? endIndex + FEATURES_MARKER_END.length + 1 : endIndex + FEATURES_MARKER_END.length;
+    const next = `${current.slice(0, beginIndex)}${wrapped}${current.slice(replaceEnd)}`;
+    if (next !== current) {
+      await import_promises11.default.writeFile(featuresPath, next, "utf8");
+    }
+    return;
+  }
+  const separator = current.endsWith("\n") ? "\n" : "\n\n";
+  await import_promises11.default.writeFile(featuresPath, `${current}${separator}${wrapped}`, "utf8");
+}
+async function writeProjectPlanFiles(root, graph) {
+  const graphPath = resolveProjectPlanGraphPath(root);
+  const markdownPath = resolveProjectPlanMarkdownPath(root);
+  await import_promises11.default.mkdir(import_node_path15.default.dirname(graphPath), {
+    recursive: true
+  });
+  const sortedGraph = sortGraph(graph);
+  await import_promises11.default.writeFile(graphPath, `${JSON.stringify(sortedGraph, null, 2)}
+`, "utf8");
+  await import_promises11.default.writeFile(markdownPath, await renderProjectPlanMarkdown(root, sortedGraph), "utf8");
+  await syncFeaturesToKnowledge(root, sortedGraph);
+  return {
+    graph: sortedGraph,
+    graphPath,
+    markdownPath
+  };
+}
+function buildProjectPlanCheckError(code, message, target) {
+  return {
+    code,
+    message,
+    target
+  };
+}
+async function validateProjectPlanGraph(root, graph) {
+  const currentGraph = graph ?? await readProjectPlanGraph(root);
   const errors = [];
-  const knowledgeSections = await readKnowledgeSections(root);
-  const knowledgeSectionIds = new Set(knowledgeSections.map((section) => section.id));
   const sectionIds = /* @__PURE__ */ new Set();
   const featureIds = /* @__PURE__ */ new Set();
   const featureMap = /* @__PURE__ */ new Map();
   for (const section of currentGraph.sections) {
-    if (!section.sectionId) {
-      errors.push(buildProjectPlanCheckError("section_missing_id", "Project plan section is missing `sectionId`."));
+    if (!section.id) {
+      errors.push(buildProjectPlanCheckError("section_missing_id", "Project plan section is missing `id`."));
       continue;
     }
-    if (sectionIds.has(section.sectionId)) {
-      errors.push(buildProjectPlanCheckError("duplicate_section", `Duplicate section id "${section.sectionId}"`, section.sectionId));
+    if (sectionIds.has(section.id)) {
+      errors.push(buildProjectPlanCheckError("duplicate_section", `Duplicate section id "${section.id}"`, section.id));
       continue;
     }
-    sectionIds.add(section.sectionId);
-    if (!knowledgeSectionIds.has(section.sectionId)) {
-      errors.push(buildProjectPlanCheckError(
-        "unknown_knowledge_section",
-        `Project plan section "${section.sectionId}" does not exist in docyrus/knowledge.`,
-        section.sectionId
-      ));
+    sectionIds.add(section.id);
+    if (!section.title.trim()) {
+      errors.push(buildProjectPlanCheckError("section_missing_title", `Section "${section.id}" is missing a title.`, section.id));
+    }
+    if (!section.slug.trim()) {
+      errors.push(buildProjectPlanCheckError("section_missing_slug", `Section "${section.id}" is missing a slug.`, section.id));
     }
   }
   const allowedTypes = new Set(PROJECT_TASK_TYPES);
@@ -23539,395 +23845,159 @@ async function validateProjectPlanGraph(root, graph) {
     if (!feature) {
       errors.push(buildProjectPlanCheckError(
         "task_unknown_feature",
-        `Task "${task.id}" references unknown feature "${task.featureId}".`,
-        task.id
-      ));
-      continue;
-    }
-    if (!task.title.trim()) {
-      errors.push(buildProjectPlanCheckError("task_missing_title", `Task "${task.id}" is missing a title.`, task.id));
-    }
-    if (!allowedTypes.has(task.type)) {
-      errors.push(buildProjectPlanCheckError(
-        "task_invalid_type",
-        `Task "${task.id}" has invalid type "${task.type}".`,
-        task.id
-      ));
-    }
-    if (!allowedAssignees.has(task.assignee)) {
-      errors.push(buildProjectPlanCheckError(
-        "task_invalid_assignee",
-        `Task "${task.id}" has invalid assignee "${task.assignee}".`,
-        task.id
-      ));
-    }
-    if (!allowedStatuses.has(task.status)) {
-      errors.push(buildProjectPlanCheckError(
-        "task_invalid_status",
-        `Task "${task.id}" has invalid status "${task.status}".`,
-        task.id
-      ));
-    }
-    if (!sectionIds.has(task.sectionId)) {
-      errors.push(buildProjectPlanCheckError(
-        "task_unknown_section",
-        `Task "${task.id}" references unknown section "${task.sectionId}".`,
-        task.id
-      ));
-    }
-    if (task.sectionId !== feature.sectionId) {
-      errors.push(buildProjectPlanCheckError(
-        "task_section_mismatch",
-        `Task "${task.id}" section "${task.sectionId}" does not match feature "${feature.id}" section "${feature.sectionId}".`,
-        task.id
-      ));
-    }
-  }
-  return {
-    ok: errors.length === 0,
-    errors
-  };
-}
-async function resolveKnowledgeSectionIds(root) {
-  const sections = await readKnowledgeSections(root);
-  return sections.map((section) => section.id).sort(compareStrings);
-}
-async function syncProjectPlanSectionsFromKnowledge(root) {
-  const currentGraph = await readProjectPlanGraph(root);
-  const knowledgeSectionIds = await resolveKnowledgeSectionIds(root);
-  const syncedGraph = {
-    ...currentGraph,
-    sections: knowledgeSectionIds.map((sectionId) => ({
-      sectionId
-    }))
-  };
-  return writeProjectPlanFiles(root, syncedGraph);
-}
-async function ensureProjectPlanGraph(root) {
-  const graphPath = resolveProjectPlanGraphPath(root);
-  if (!(0, import_node_fs8.existsSync)(graphPath)) {
-    return syncProjectPlanSectionsFromKnowledge(root);
-  }
-  const graph = await readProjectPlanGraph(root);
-  return writeProjectPlanFiles(root, graph);
-}
-async function upsertProjectPlanFeature(params) {
-  const state = await ensureProjectPlanGraph(params.root);
-  const slug = slugify(params.slug?.trim() || params.title);
-  const featureId = params.featureId?.trim() || normalizeFeatureId(params.sectionId, slug);
-  const graph = state.graph;
-  const existing = graph.features.find((feature) => feature.id === featureId) || graph.features.find((feature) => feature.sectionId === params.sectionId && feature.slug === slug);
-  const nextFeature = {
-    id: existing?.id || featureId,
-    title: params.title.trim(),
-    slug,
-    summary: params.summary?.trim() || "",
-    sectionId: params.sectionId
-  };
-  const nextFeatures = existing ? graph.features.map((feature) => feature.id === existing.id ? nextFeature : feature) : [...graph.features, nextFeature];
-  await writeProjectPlanFiles(params.root, {
-    ...graph,
-    features: nextFeatures
-  });
-  return nextFeature;
-}
-async function getProjectPlanTask(params) {
-  const graph = await readProjectPlanGraph(params.root);
-  const linkedTodos = await listLinkedTodosByTask(params.root);
-  const task = graph.tasks.find((item) => item.id === params.taskId);
-  if (!task) {
-    return null;
-  }
-  const taskLinkedTodos = linkedTodos.get(task.id) || [];
-  return {
-    ...task,
-    linkedTodos: taskLinkedTodos,
-    linkedTodoCount: taskLinkedTodos.length
-  };
-}
-async function upsertProjectPlanTask(params) {
-  const state = await ensureProjectPlanGraph(params.root);
-  const graph = state.graph;
-  const feature = graph.features.find((item) => item.id === params.featureId);
-  if (!feature) {
-    throw new Error(`Feature "${params.featureId}" not found.`);
-  }
-  const sectionId = params.sectionId?.trim() || feature.sectionId;
-  const taskId = params.taskId?.trim() || normalizeTaskId(feature.id, params.type, params.title);
-  const existing = graph.tasks.find((task) => task.id === taskId) || graph.tasks.find((task) => task.featureId === feature.id && task.type === params.type && task.title === params.title.trim());
-  const nextTask = {
-    id: existing?.id || taskId,
-    title: params.title.trim(),
-    summary: params.summary?.trim() || "",
-    type: params.type,
-    assignee: params.assignee,
-    status: params.status || "planned",
-    acceptanceCriteria: [...new Set((params.acceptanceCriteria || []).map((item) => item.trim()).filter(Boolean))],
-    featureId: feature.id,
-    sectionId
-  };
-  const nextTasks = existing ? graph.tasks.map((task) => task.id === existing.id ? nextTask : task) : [...graph.tasks, nextTask];
-  await writeProjectPlanFiles(params.root, {
-    ...graph,
-    tasks: nextTasks
-  });
-  return nextTask;
-}
-async function updateProjectPlanTaskStatus(params) {
-  const graph = await readProjectPlanGraph(params.root);
-  const task = graph.tasks.find((item) => item.id === params.taskId);
-  if (!task) {
-    throw new Error(`Task "${params.taskId}" not found.`);
-  }
-  const nextTask = {
-    ...task,
-    status: params.status
-  };
-  await writeProjectPlanFiles(params.root, {
-    ...graph,
-    tasks: graph.tasks.map((item) => item.id === task.id ? nextTask : item)
-  });
-  return nextTask;
-}
-
-// src/knowledge/init.ts
-var MARKER_BEGIN = "%% docyrus-knowledge:begin %%";
-var MARKER_END = "%% docyrus-knowledge:end %%";
-var HOOK_MARKER_BEGIN = "# docyrus-knowledge:begin";
-var HOOK_MARKER_END = "# docyrus-knowledge:end";
-function wrapManagedBlock(content3) {
-  return `${MARKER_BEGIN}
-${content3}${content3.endsWith("\n") ? "" : "\n"}${MARKER_END}
-`;
-}
-async function ensureDirectory(pathValue) {
-  await (0, import_promises11.mkdir)(pathValue, {
-    recursive: true,
-    mode: 493
-  });
-}
-async function writeIfMissing(filePath, content3) {
-  if ((0, import_node_fs9.existsSync)(filePath)) {
-    return "kept";
-  }
-  await ensureDirectory((0, import_node_path15.dirname)(filePath));
-  await (0, import_promises11.writeFile)(filePath, content3, "utf8");
-  return "created";
-}
-async function writeOrUpdate(filePath, content3) {
-  if (!(0, import_node_fs9.existsSync)(filePath)) {
-    await ensureDirectory((0, import_node_path15.dirname)(filePath));
-    await (0, import_promises11.writeFile)(filePath, content3, "utf8");
-    return "created";
-  }
-  const current = await (0, import_promises11.readFile)(filePath, "utf8");
-  if (current === content3) {
-    return "kept";
-  }
-  await ensureDirectory((0, import_node_path15.dirname)(filePath));
-  await (0, import_promises11.writeFile)(filePath, content3, "utf8");
-  return "updated";
-}
-async function upsertManagedBlock(filePath, content3) {
-  const wrapped = wrapManagedBlock(content3);
-  if (!(0, import_node_fs9.existsSync)(filePath)) {
-    await ensureDirectory((0, import_node_path15.dirname)(filePath));
-    await (0, import_promises11.writeFile)(filePath, wrapped, "utf8");
-    return "created";
-  }
-  const current = await (0, import_promises11.readFile)(filePath, "utf8");
-  const beginIndex = current.indexOf(MARKER_BEGIN);
-  const endIndex = current.indexOf(MARKER_END);
-  if (beginIndex !== -1 && endIndex !== -1 && endIndex > beginIndex) {
-    const replaceEnd = current[endIndex + MARKER_END.length] === "\n" ? endIndex + MARKER_END.length + 1 : endIndex + MARKER_END.length;
-    const updated = `${current.slice(0, beginIndex)}${wrapped}${current.slice(replaceEnd)}`;
-    await (0, import_promises11.writeFile)(filePath, updated, "utf8");
-    return "updated";
-  }
-  const separator = current.endsWith("\n") ? "\n" : "\n\n";
-  await (0, import_promises11.writeFile)(filePath, `${current}${separator}${wrapped}`, "utf8");
-  return "appended";
-}
-function normalizeObject(value2) {
-  return typeof value2 === "object" && value2 !== null && !Array.isArray(value2) ? { ...value2 } : {};
-}
-async function updateJsonFile(filePath, updater) {
-  const current = (0, import_node_fs9.existsSync)(filePath) ? normalizeObject(JSON.parse((0, import_node_fs9.readFileSync)(filePath, "utf8"))) : {};
-  await ensureDirectory((0, import_node_path15.dirname)(filePath));
-  await (0, import_promises11.writeFile)(filePath, `${JSON.stringify(updater(current), null, 2)}
-`, "utf8");
-}
-function wrapHookBlock(content3) {
-  return `${HOOK_MARKER_BEGIN}
-${content3}${content3.endsWith("\n") ? "" : "\n"}${HOOK_MARKER_END}
-`;
-}
-async function upsertShellHook(filePath, content3, shellHeader) {
-  const wrapped = wrapHookBlock(content3);
-  if (!(0, import_node_fs9.existsSync)(filePath)) {
-    await ensureDirectory((0, import_node_path15.dirname)(filePath));
-    const initial = `${shellHeader || ""}${wrapped}`;
-    await (0, import_promises11.writeFile)(filePath, initial, {
-      encoding: "utf8",
-      mode: 493
-    });
-    await (0, import_promises11.chmod)(filePath, 493);
-    return "created";
-  }
-  const current = await (0, import_promises11.readFile)(filePath, "utf8");
-  const beginIndex = current.indexOf(HOOK_MARKER_BEGIN);
-  const endIndex = current.indexOf(HOOK_MARKER_END);
-  if (beginIndex !== -1 && endIndex !== -1 && endIndex > beginIndex) {
-    const replaceEnd = current[endIndex + HOOK_MARKER_END.length] === "\n" ? endIndex + HOOK_MARKER_END.length + 1 : endIndex + HOOK_MARKER_END.length;
-    const nextContent = `${current.slice(0, beginIndex)}${wrapped}${current.slice(replaceEnd)}`;
-    if (nextContent === current) {
-      return "kept";
-    }
-    await (0, import_promises11.writeFile)(filePath, nextContent, "utf8");
-    await (0, import_promises11.chmod)(filePath, 493);
-    return "updated";
-  }
-  const separator = current.endsWith("\n") ? "\n" : "\n\n";
-  await (0, import_promises11.writeFile)(filePath, `${current}${separator}${wrapped}`, "utf8");
-  await (0, import_promises11.chmod)(filePath, 493);
-  return "appended";
-}
-function buildKnowledgeDocumentTemplate() {
-  return [
-    "# Knowledge",
-    "",
-    "This directory captures the architecture, constraints, workflows, and test expectations that coding agents should read before changing the repo.",
-    "",
-    "## Working Agreement",
-    "",
-    "Search this knowledge graph before coding, keep it updated when behavior changes, and use \\[\\[wiki links\\]\\] plus `@docyrus` backlinks to connect decisions to implementation.",
-    "",
-    "## Backlinks",
-    "",
-    "Use `// @docyrus: \\[\\[knowledge#Section Name\\]\\]` or `# @docyrus: \\[\\[knowledge#Section Name\\]\\]` near the code or tests that implement a documented behavior.",
-    ""
-  ].join("\n");
-}
-function buildAgentsTemplate(commandPrefix) {
-  return [
-    "# Knowledge Graph Workflow",
-    "",
-    `- If \`docyrus/knowledge/\` exists, run \`${commandPrefix} knowledge search\` before coding so you start from documented intent instead of rediscovering it from source files.`,
-    `- Use \`${commandPrefix} knowledge expand\` when prompts contain \`[[refs]]\` so section names resolve to real file locations and summaries.`,
-    "- Keep `docyrus/knowledge/` in sync whenever you change functionality, architecture, tests, or behavior.",
-    `- Before finishing, run \`${commandPrefix} knowledge check\` and fix any broken links, stale references, or missing \`@docyrus\` backlinks.`,
-    ""
-  ].join("\n");
-}
-function buildCursorRulesTemplate(commandPrefix) {
-  return [
-    "# Knowledge Graph Workflow",
-    "",
-    `- Use \`${commandPrefix} knowledge search\` to find relevant documentation before reading or editing code.`,
-    `- Use \`${commandPrefix} knowledge section\` to read the full section once you have a relevant section id.`,
-    `- Use \`${commandPrefix} knowledge expand\` whenever the prompt includes \`[[refs]]\`.`,
-    `- Keep \`docyrus/knowledge/\` updated and finish with \`${commandPrefix} knowledge check\`.`,
-    ""
-  ].join("\n");
-}
-function buildClaudeHookCommand(commandPrefix, event) {
-  return `${commandPrefix} knowledge hook claude ${event}`;
-}
-function syncClaudeHooks(settings, commandPrefix) {
-  const hooks = normalizeObject(settings.hooks);
-  const nextHooks = { ...hooks };
-  for (const [eventName, entries] of Object.entries(nextHooks)) {
-    if (!Array.isArray(entries)) {
+        `Task "${task.id}" references unknown feature "${task.featureId}".`,
+        task.id
+      ));
       continue;
     }
-    nextHooks[eventName] = entries.filter((entry) => {
-      const hooksList = Array.isArray(entry.hooks) ? entry.hooks || [] : [];
-      return !hooksList.some((hook) => typeof hook.command === "string" && hook.command.includes("knowledge hook claude"));
-    });
+    if (!task.title.trim()) {
+      errors.push(buildProjectPlanCheckError("task_missing_title", `Task "${task.id}" is missing a title.`, task.id));
+    }
+    if (!allowedTypes.has(task.type)) {
+      errors.push(buildProjectPlanCheckError(
+        "task_invalid_type",
+        `Task "${task.id}" has invalid type "${task.type}".`,
+        task.id
+      ));
+    }
+    if (!allowedAssignees.has(task.assignee)) {
+      errors.push(buildProjectPlanCheckError(
+        "task_invalid_assignee",
+        `Task "${task.id}" has invalid assignee "${task.assignee}".`,
+        task.id
+      ));
+    }
+    if (!allowedStatuses.has(task.status)) {
+      errors.push(buildProjectPlanCheckError(
+        "task_invalid_status",
+        `Task "${task.id}" has invalid status "${task.status}".`,
+        task.id
+      ));
+    }
+    if (!sectionIds.has(task.sectionId)) {
+      errors.push(buildProjectPlanCheckError(
+        "task_unknown_section",
+        `Task "${task.id}" references unknown section "${task.sectionId}".`,
+        task.id
+      ));
+    }
+    if (task.sectionId !== feature.sectionId) {
+      errors.push(buildProjectPlanCheckError(
+        "task_section_mismatch",
+        `Task "${task.id}" section "${task.sectionId}" does not match feature "${feature.id}" section "${feature.sectionId}".`,
+        task.id
+      ));
+    }
   }
-  const addHook = (eventName) => {
-    const current = Array.isArray(nextHooks[eventName]) ? nextHooks[eventName] : [];
-    current.push({
-      hooks: [
-        {
-          type: "command",
-          command: buildClaudeHookCommand(commandPrefix, eventName)
-        }
-      ]
-    });
-    nextHooks[eventName] = current;
-  };
-  addHook("UserPromptSubmit");
-  addHook("Stop");
   return {
-    ...settings,
-    hooks: nextHooks
+    ok: errors.length === 0,
+    errors
   };
 }
-function syncCursorHooks(settings, commandPrefix) {
-  const hooks = normalizeObject(settings.hooks);
-  const stopEntries = Array.isArray(hooks.stop) ? hooks.stop : [];
-  const filtered = stopEntries.filter((entry) => typeof entry.command !== "string" || !entry.command.includes("knowledge hook cursor"));
+async function ensureProjectPlanGraph(root) {
+  const graphPath = resolveProjectPlanGraphPath(root);
+  if (!(0, import_node_fs9.existsSync)(graphPath)) {
+    return writeProjectPlanFiles(root, createEmptyProjectPlanGraph());
+  }
+  const graph = await readProjectPlanGraph(root);
+  return writeProjectPlanFiles(root, graph);
+}
+async function upsertProjectPlanSection(params) {
+  const state = await ensureProjectPlanGraph(params.root);
+  const slug = slugify(params.slug?.trim() || params.title);
+  const sectionId = params.id?.trim() || normalizeSectionId(slug);
+  const graph = state.graph;
+  const existing = graph.sections.find((section) => section.id === sectionId) || graph.sections.find((section) => section.slug === slug);
+  const nextSection = {
+    id: existing?.id || sectionId,
+    title: params.title.trim(),
+    slug,
+    summary: params.summary?.trim() || ""
+  };
+  const nextSections = existing ? graph.sections.map((section) => section.id === existing.id ? nextSection : section) : [...graph.sections, nextSection];
+  await writeProjectPlanFiles(params.root, {
+    ...graph,
+    sections: nextSections
+  });
+  return nextSection;
+}
+async function upsertProjectPlanFeature(params) {
+  const state = await ensureProjectPlanGraph(params.root);
+  const slug = slugify(params.slug?.trim() || params.title);
+  const featureId = params.featureId?.trim() || normalizeFeatureId(params.sectionId, slug);
+  const graph = state.graph;
+  const existing = graph.features.find((feature) => feature.id === featureId) || graph.features.find((feature) => feature.sectionId === params.sectionId && feature.slug === slug);
+  const nextFeature = {
+    id: existing?.id || featureId,
+    title: params.title.trim(),
+    slug,
+    summary: params.summary?.trim() || "",
+    sectionId: params.sectionId
+  };
+  const nextFeatures = existing ? graph.features.map((feature) => feature.id === existing.id ? nextFeature : feature) : [...graph.features, nextFeature];
+  await writeProjectPlanFiles(params.root, {
+    ...graph,
+    features: nextFeatures
+  });
+  return nextFeature;
+}
+async function getProjectPlanTask(params) {
+  const graph = await readProjectPlanGraph(params.root);
+  const linkedTodos = await listLinkedTodosByTask(params.root);
+  const task = graph.tasks.find((item) => item.id === params.taskId);
+  if (!task) {
+    return null;
+  }
+  const taskLinkedTodos = linkedTodos.get(task.id) || [];
   return {
-    ...settings.version ? settings : { version: 1 },
-    ...settings,
-    hooks: {
-      ...hooks,
-      stop: [
-        ...filtered,
-        {
-          command: `${commandPrefix} knowledge hook cursor stop`
-        }
-      ]
-    }
+    ...task,
+    linkedTodos: taskLinkedTodos,
+    linkedTodoCount: taskLinkedTodos.length
   };
 }
-async function initializeKnowledgeRepo(params) {
-  const root = (0, import_node_path15.resolve)(params.root || process.cwd());
-  const knowledgeDir = getKnowledgeDirectory(root);
-  const knowledgeFile = (0, import_node_path15.join)(knowledgeDir, "knowledge.md");
-  await ensureDirectory(knowledgeDir);
-  const knowledgeFileStatus = await writeIfMissing(knowledgeFile, `${buildKnowledgeDocumentTemplate()}
-`);
-  const agentsStatus = await upsertManagedBlock((0, import_node_path15.join)(root, "AGENTS.md"), buildAgentsTemplate(params.commandPrefix));
-  const claudeStatus = await upsertManagedBlock((0, import_node_path15.join)(root, "CLAUDE.md"), buildAgentsTemplate(params.commandPrefix));
-  const cursorRulesStatus = await writeOrUpdate((0, import_node_path15.join)(root, ".cursor", "rules", "docyrus-knowledge.md"), `${buildCursorRulesTemplate(params.commandPrefix)}
-`);
-  const bootstrap = (await generateInitialKnowledge({
-    root,
-    brief: params.brief
-  })).files;
-  const projectPlan = await syncProjectPlanSectionsFromKnowledge(root);
-  await updateJsonFile((0, import_node_path15.join)(root, ".claude", "settings.json"), (value2) => syncClaudeHooks(value2, params.commandPrefix));
-  await updateJsonFile((0, import_node_path15.join)(root, ".cursor", "hooks.json"), (value2) => syncCursorHooks(value2, params.commandPrefix));
-  let huskyHookStatus;
-  const huskyDir = (0, import_node_path15.join)(root, ".husky");
-  if ((0, import_node_fs9.existsSync)(huskyDir)) {
-    const huskyHookPath = (0, import_node_path15.join)(huskyDir, "pre-commit");
-    const huskyHeader = (0, import_node_fs9.existsSync)((0, import_node_path15.join)(huskyDir, "_", "h")) ? '#!/usr/bin/env sh\n. "$(dirname -- "$0")/_/h"\n\n' : void 0;
-    huskyHookStatus = await upsertShellHook(huskyHookPath, `${params.commandPrefix} knowledge pre-commit
-`, huskyHeader);
+async function upsertProjectPlanTask(params) {
+  const state = await ensureProjectPlanGraph(params.root);
+  const graph = state.graph;
+  const feature = graph.features.find((item) => item.id === params.featureId);
+  if (!feature) {
+    throw new Error(`Feature "${params.featureId}" not found.`);
   }
-  let gitHookStatus;
-  if (!huskyHookStatus && params.installGitHook) {
-    const gitHookPath = (0, import_node_path15.join)(root, ".git", "hooks", "pre-commit");
-    gitHookStatus = await upsertShellHook(gitHookPath, `${params.commandPrefix} knowledge pre-commit
-`, "#!/usr/bin/env sh\n\n");
+  const sectionId = params.sectionId?.trim() || feature.sectionId;
+  const taskId = params.taskId?.trim() || normalizeTaskId(feature.id, params.type, params.title);
+  const existing = graph.tasks.find((task) => task.id === taskId) || graph.tasks.find((task) => task.featureId === feature.id && task.type === params.type && task.title === params.title.trim());
+  const nextTask = {
+    id: existing?.id || taskId,
+    title: params.title.trim(),
+    summary: params.summary?.trim() || "",
+    type: params.type,
+    assignee: params.assignee,
+    status: params.status || "planned",
+    acceptanceCriteria: [...new Set((params.acceptanceCriteria || []).map((item) => item.trim()).filter(Boolean))],
+    featureId: feature.id,
+    sectionId
+  };
+  const nextTasks = existing ? graph.tasks.map((task) => task.id === existing.id ? nextTask : task) : [...graph.tasks, nextTask];
+  await writeProjectPlanFiles(params.root, {
+    ...graph,
+    tasks: nextTasks
+  });
+  return nextTask;
+}
+async function updateProjectPlanTaskStatus(params) {
+  const graph = await readProjectPlanGraph(params.root);
+  const task = graph.tasks.find((item) => item.id === params.taskId);
+  if (!task) {
+    throw new Error(`Task "${params.taskId}" not found.`);
   }
-  return {
-    root,
-    knowledgeDir,
-    knowledgeFile,
-    projectPlanGraphPath: projectPlan.graphPath,
-    projectPlanMarkdownPath: projectPlan.markdownPath,
-    agentsStatus,
-    claudeStatus,
-    cursorRulesStatus,
-    knowledgeFileStatus,
-    bootstrap,
-    huskyHookStatus,
-    gitHookStatus
+  const nextTask = {
+    ...task,
+    status: params.status
   };
+  await writeProjectPlanFiles(params.root, {
+    ...graph,
+    tasks: graph.tasks.map((item) => item.id === task.id ? nextTask : item)
+  });
+  return nextTask;
 }
 
 // src/agent/authFlows.ts
@@ -25366,6 +25436,49 @@ async function waitForIdle(session, timeoutMs = 3e4) {
 function resolveServerSettingsRootPath(agentDir) {
   return (0, import_node_path18.resolve)(agentDir, "..", "..");
 }
+var SESSION_MODE_COMMANDS = {
+  "read-only": "read-only",
+  "end-read-only": "normal"
+};
+var SESSION_MODE_COMMAND_LABELS = {
+  "read-only": "Read-only mode activated. Write and edit tools are disabled. Use /end-read-only to resume normal operation.",
+  "end-read-only": "Read-only mode deactivated. Normal operation resumed."
+};
+function parseModeSlashCommand(text3) {
+  const match2 = /^\/([a-z][a-z0-9-]*)(?:\s+([\s\S]+))?$/u.exec(text3.trim());
+  if (!match2) {
+    return null;
+  }
+  const command = match2[1];
+  if (!(command in SESSION_MODE_COMMANDS)) {
+    return null;
+  }
+  return {
+    command,
+    remainder: match2[2]?.trim() ?? ""
+  };
+}
+function makeModeNotificationStream(params) {
+  const { command, messageId, encoder } = params;
+  const label = SESSION_MODE_COMMAND_LABELS[command] ?? `/${command} executed.`;
+  return new ReadableStream({
+    start(controller) {
+      function write(chunk) {
+        controller.enqueue(encoder.encode(`data: ${JSON.stringify(chunk)}
+
+`));
+      }
+      write({ type: "start" });
+      write({ type: "start-step" });
+      write({ type: "text-start", id: messageId });
+      write({ type: "text-delta", id: messageId, delta: label });
+      write({ type: "text-end", id: messageId });
+      write({ type: "finish-step" });
+      write({ type: "finish" });
+      controller.close();
+    }
+  });
+}
 function serializeKnowledgeMatch(match2) {
   return {
     id: match2.section.id,
@@ -25660,6 +25773,7 @@ async function walkFiles(params) {
 async function createAgentServer(params) {
   const { port, sessionManager, modelRegistry, authRuntime, context, onCreateSession, onResumeSession, authToken } = params;
   let activeSession = params.session;
+  let sessionMode = "normal";
   const pendingAskUserRequests = /* @__PURE__ */ new Map();
   const pendingDocyrusWebBrowserRequests = /* @__PURE__ */ new Map();
   const oauthFlowManager = new OAuthFlowManager();
@@ -25700,7 +25814,8 @@ async function createAgentServer(params) {
   app.get("/api/status", (c) => {
     return c.json({
       isStreaming: activeSession.isStreaming,
-      model: activeSession.model ? { provider: activeSession.model.provider, id: activeSession.model.id } : null
+      model: activeSession.model ? { provider: activeSession.model.provider, id: activeSession.model.id } : null,
+      mode: sessionMode
     });
   });
   app.post("/api/chat", async (c) => {
@@ -25709,6 +25824,7 @@ async function createAgentServer(params) {
     if (body2.sessionId && body2.sessionId.trim() !== activeSession.id?.trim()) {
       try {
         activeSession = await onResumeSession(body2.sessionId);
+        sessionMode = "normal";
       } catch (error) {
         const msg = error instanceof Error ? error.message : String(error);
         return c.json({ error: `Failed to resume session: ${msg}` }, 400);
@@ -25745,6 +25861,34 @@ async function createAgentServer(params) {
         pendingDocyrusWebBrowserRequests.delete(sessionId);
       }
     }
+    let promptText = userMessage;
+    if (!askUserResponse && !docyrusWebBrowserResponse) {
+      const modeCmd = parseModeSlashCommand(userMessage);
+      if (modeCmd) {
+        if (activeSession.isStreaming) {
+          await activeSession.abort();
+          await waitForIdle(activeSession);
+        }
+        await activeSession.prompt(`/${modeCmd.command}`);
+        sessionMode = SESSION_MODE_COMMANDS[modeCmd.command] ?? sessionMode;
+        if (!modeCmd.remainder) {
+          const notifEncoder = new TextEncoder();
+          const notifMessageId = generateMessageId();
+          return c.body(
+            makeModeNotificationStream({ command: modeCmd.command, messageId: notifMessageId, encoder: notifEncoder }),
+            {
+              headers: {
+                "Content-Type": "text/event-stream",
+                "Cache-Control": "no-cache",
+                "Connection": "keep-alive",
+                "x-vercel-ai-ui-message-stream": "v1"
+              }
+            }
+          );
+        }
+        promptText = modeCmd.remainder;
+      }
+    }
     if (activeSession.isStreaming) {
       await activeSession.abort();
       await waitForIdle(activeSession);
@@ -25789,7 +25933,7 @@ async function createAgentServer(params) {
             unsubscribe();
           }
         });
-        activeSession.prompt(userMessage).then(() => {
+        activeSession.prompt(promptText).then(() => {
           if (!activeSession.isStreaming) {
             unsubscribe();
             writeChunk({ type: "finish-step" });
@@ -25815,6 +25959,19 @@ async function createAgentServer(params) {
       }
     });
   });
+  app.post("/api/chat/abort", async (c) => {
+    if (!activeSession.isStreaming) {
+      return c.json({ ok: true, wasStreaming: false });
+    }
+    try {
+      await activeSession.abort();
+      await waitForIdle(activeSession);
+      return c.json({ ok: true, wasStreaming: true });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      return c.json({ error: message }, 500);
+    }
+  });
   app.get("/api/sessions", async (c) => {
     try {
       const sessions = await sessionManager.list();
@@ -25857,6 +26014,7 @@ async function createAgentServer(params) {
         await waitForIdle(activeSession);
       }
       activeSession = await onCreateSession();
+      sessionMode = "normal";
       const sessionId = activeSession.id?.trim();
       if (!sessionId) {
         return c.json({ error: "Created session is missing an id" }, 500);
@@ -26064,8 +26222,7 @@ async function createAgentServer(params) {
       const codeRefs = await checkKnowledgeCodeRefs(knowledgeDir);
       const index2 = await checkKnowledgeIndex(knowledgeDir);
       const sections = await checkKnowledgeSections(knowledgeDir);
-      const projectPlan = await validateProjectPlanGraph(context.cwd);
-      const totalErrors = markdown.errors.length + codeRefs.errors.length + index2.length + sections.length + projectPlan.errors.length;
+      const totalErrors = markdown.errors.length + codeRefs.errors.length + index2.length + sections.length;
       return c.json({
         ok: totalErrors === 0,
         knowledgeDir,
@@ -26073,8 +26230,7 @@ async function createAgentServer(params) {
           markdown: markdown.errors,
           codeRefs: codeRefs.errors,
           index: index2,
-          sections,
-          projectPlan: projectPlan.errors
+          sections
         },
         files: {
           markdown: markdown.files,
@@ -26110,12 +26266,7 @@ async function createAgentServer(params) {
         brief: body2.brief?.trim() || void 0,
         targetSectionIds: Array.isArray(body2.sectionIds) ? body2.sectionIds : void 0
       });
-      const projectPlan = await syncProjectPlanSectionsFromKnowledge(context.cwd);
-      return c.json({
-        ...result,
-        projectPlanGraphPath: projectPlan.graphPath,
-        projectPlanMarkdownPath: projectPlan.markdownPath
-      });
+      return c.json(result);
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
       return c.json({ error: message }, 500);
@@ -26159,17 +26310,23 @@ async function createAgentServer(params) {
       return c.json({ error: message }, 500);
     }
   });
-  app.post("/api/project-plan/sync-sections", async (c) => {
+  app.post("/api/project-plan/sections", async (c) => {
+    const body2 = await c.req.json().catch(() => ({}));
+    if (!body2.title?.trim()) {
+      return c.json({ error: "Missing required field: title" }, 400);
+    }
     try {
-      const result = await syncProjectPlanSectionsFromKnowledge(context.cwd);
-      return c.json({
-        graph: result.graph,
-        graphPath: result.graphPath,
-        markdownPath: result.markdownPath
+      const section = await upsertProjectPlanSection({
+        root: context.cwd,
+        id: body2.id?.trim() || void 0,
+        title: body2.title.trim(),
+        slug: body2.slug?.trim() || void 0,
+        summary: body2.summary?.trim() || void 0
       });
+      return c.json(section);
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
-      return c.json({ error: message }, 500);
+      return c.json({ error: message }, 400);
     }
   });
   app.get("/api/project-plan/tasks/:taskId", async (c) => {
@@ -26466,6 +26623,20 @@ async function createAgentServer(params) {
       return c.json({ error: message }, 500);
     }
   });
+  app.post("/api/sessions/rename", async (c) => {
+    const body2 = await c.req.json();
+    const name2 = typeof body2.name === "string" ? body2.name.trim() : "";
+    if (!name2) {
+      return c.json({ error: "Missing required field: name" }, 400);
+    }
+    try {
+      activeSession.setSessionName(name2);
+      return c.json({ ok: true, name: name2 });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      return c.json({ error: message }, 500);
+    }
+  });
   app.get("/api/fs/tree", async (c) => {
     const requestPath = c.req.query("path") ?? ".";
     const maxDepth = Math.min(Number(c.req.query("depth") ?? 4), 10);
@@ -27276,6 +27447,8 @@ async function createAgentServer(params) {
 
 `);
     process.stderr.write(`  POST /api/chat                          \u2014 send chat messages (SSE UIMessage stream)
+`);
+    process.stderr.write(`  POST /api/chat/abort                    \u2014 abort active chat stream
 `);
     process.stderr.write(`  GET  /api/health                        \u2014 health check
 `);
@@ -27288,6 +27461,8 @@ async function createAgentServer(params) {
     process.stderr.write(`  GET  /api/sessions/:sessionId/messages  \u2014 session messages
 `);
     process.stderr.write(`  POST /api/sessions/:sessionId/resume    \u2014 resume a session
+`);
+    process.stderr.write(`  POST /api/sessions/rename               \u2014 rename active session
 `);
     process.stderr.write(`  GET  /api/context                       \u2014 server context
 `);
@@ -27303,11 +27478,11 @@ async function createAgentServer(params) {
 `);
     process.stderr.write(`  GET  /api/knowledge/search              \u2014 semantic knowledge search
 `);
-    process.stderr.write(`  GET  /api/knowledge/check               \u2014 knowledge + project-plan validation
+    process.stderr.write(`  GET  /api/knowledge/check               \u2014 knowledge validation
 `);
-    process.stderr.write(`  POST /api/knowledge/init                \u2014 initialize knowledge graph and project plan
+    process.stderr.write(`  POST /api/knowledge/init                \u2014 initialize knowledge graph
 `);
-    process.stderr.write(`  POST /api/knowledge/refresh             \u2014 refresh managed knowledge files and project-plan sections
+    process.stderr.write(`  POST /api/knowledge/refresh             \u2014 refresh managed knowledge files
 `);
     process.stderr.write(`  GET  /api/project-plan                  \u2014 canonical project-plan graph and hierarchy
 `);
@@ -27315,7 +27490,7 @@ async function createAgentServer(params) {
 `);
     process.stderr.write(`  POST /api/project-plan/ensure           \u2014 ensure project-plan files exist
 `);
-    process.stderr.write(`  POST /api/project-plan/sync-sections    \u2014 sync project-plan sections from knowledge ids
+    process.stderr.write(`  POST /api/project-plan/sections         \u2014 upsert project-plan section
 `);
     process.stderr.write(`  GET  /api/project-plan/tasks/:taskId    \u2014 project task detail
 `);
@@ -27552,6 +27727,12 @@ function createServerSessionAdapter(params) {
     supportsThinking() {
       return params.session.supportsThinking();
     },
+    get sessionName() {
+      return params.session.sessionName;
+    },
+    setSessionName(name2) {
+      params.session.setSessionName?.(name2);
+    },
     listCommands() {
       const getCommands = params.extensionsResult.runtime.getCommands;
       return typeof getCommands === "function" ? getCommands() : [];