@jayjiang/byoao 1.1.1 → 2.0.0

package/dist/index.js

@@ -4682,13 +4682,13 @@ var require_ast = __commonJS({
         helperExpression: function helperExpression(node) {
           return node.type === "SubExpression" || (node.type === "MustacheStatement" || node.type === "BlockStatement") && !!(node.params && node.params.length || node.hash);
         },
-        scopedId: function scopedId(path17) {
-          return /^\.|this\b/.test(path17.original);
+        scopedId: function scopedId(path13) {
+          return /^\.|this\b/.test(path13.original);
         },
         // an ID is simple if it only has one part, and that part is not
         // `..` or `this`.
-        simpleId: function simpleId(path17) {
-          return path17.parts.length === 1 && !AST.helpers.scopedId(path17) && !path17.depth;
+        simpleId: function simpleId(path13) {
+          return path13.parts.length === 1 && !AST.helpers.scopedId(path13) && !path13.depth;
         }
       }
     };
@@ -5758,12 +5758,12 @@ var require_helpers2 = __commonJS({
         loc
       };
     }
-    function prepareMustache(path17, params, hash2, open, strip, locInfo) {
+    function prepareMustache(path13, params, hash2, open, strip, locInfo) {
       var escapeFlag = open.charAt(3) || open.charAt(2), escaped = escapeFlag !== "{" && escapeFlag !== "&";
       var decorator = /\*/.test(open);
       return {
         type: decorator ? "Decorator" : "MustacheStatement",
-        path: path17,
+        path: path13,
         params,
         hash: hash2,
         escaped,
@@ -6033,9 +6033,9 @@ var require_compiler = __commonJS({
       },
       DecoratorBlock: function DecoratorBlock(decorator) {
         var program = decorator.program && this.compileProgram(decorator.program);
-        var params = this.setupFullMustacheParams(decorator, program, void 0), path17 = decorator.path;
+        var params = this.setupFullMustacheParams(decorator, program, void 0), path13 = decorator.path;
         this.useDecorators = true;
-        this.opcode("registerDecorator", params.length, path17.original);
+        this.opcode("registerDecorator", params.length, path13.original);
       },
       PartialStatement: function PartialStatement(partial2) {
         this.usePartial = true;
@@ -6099,46 +6099,46 @@ var require_compiler = __commonJS({
         }
       },
       ambiguousSexpr: function ambiguousSexpr(sexpr, program, inverse) {
-        var path17 = sexpr.path, name = path17.parts[0], isBlock = program != null || inverse != null;
-        this.opcode("getContext", path17.depth);
+        var path13 = sexpr.path, name = path13.parts[0], isBlock = program != null || inverse != null;
+        this.opcode("getContext", path13.depth);
         this.opcode("pushProgram", program);
         this.opcode("pushProgram", inverse);
-        path17.strict = true;
-        this.accept(path17);
+        path13.strict = true;
+        this.accept(path13);
         this.opcode("invokeAmbiguous", name, isBlock);
       },
       simpleSexpr: function simpleSexpr(sexpr) {
-        var path17 = sexpr.path;
-        path17.strict = true;
-        this.accept(path17);
+        var path13 = sexpr.path;
+        path13.strict = true;
+        this.accept(path13);
         this.opcode("resolvePossibleLambda");
       },
       helperSexpr: function helperSexpr(sexpr, program, inverse) {
-        var params = this.setupFullMustacheParams(sexpr, program, inverse), path17 = sexpr.path, name = path17.parts[0];
+        var params = this.setupFullMustacheParams(sexpr, program, inverse), path13 = sexpr.path, name = path13.parts[0];
         if (this.options.knownHelpers[name]) {
           this.opcode("invokeKnownHelper", params.length, name);
         } else if (this.options.knownHelpersOnly) {
           throw new _exception2["default"]("You specified knownHelpersOnly, but used the unknown helper " + name, sexpr);
         } else {
-          path17.strict = true;
-          path17.falsy = true;
-          this.accept(path17);
-          this.opcode("invokeHelper", params.length, path17.original, _ast2["default"].helpers.simpleId(path17));
+          path13.strict = true;
+          path13.falsy = true;
+          this.accept(path13);
+          this.opcode("invokeHelper", params.length, path13.original, _ast2["default"].helpers.simpleId(path13));
         }
       },
-      PathExpression: function PathExpression(path17) {
-        this.addDepth(path17.depth);
-        this.opcode("getContext", path17.depth);
-        var name = path17.parts[0], scoped = _ast2["default"].helpers.scopedId(path17), blockParamId = !path17.depth && !scoped && this.blockParamIndex(name);
+      PathExpression: function PathExpression(path13) {
+        this.addDepth(path13.depth);
+        this.opcode("getContext", path13.depth);
+        var name = path13.parts[0], scoped = _ast2["default"].helpers.scopedId(path13), blockParamId = !path13.depth && !scoped && this.blockParamIndex(name);
         if (blockParamId) {
-          this.opcode("lookupBlockParam", blockParamId, path17.parts);
+          this.opcode("lookupBlockParam", blockParamId, path13.parts);
         } else if (!name) {
           this.opcode("pushContext");
-        } else if (path17.data) {
+        } else if (path13.data) {
           this.options.data = true;
-          this.opcode("lookupData", path17.depth, path17.parts, path17.strict);
+          this.opcode("lookupData", path13.depth, path13.parts, path13.strict);
         } else {
-          this.opcode("lookupOnContext", path17.parts, path17.falsy, path17.strict, scoped);
+          this.opcode("lookupOnContext", path13.parts, path13.falsy, path13.strict, scoped);
         }
       },
       StringLiteral: function StringLiteral(string4) {
@@ -6488,16 +6488,16 @@ var require_util = __commonJS({
     }
     exports2.urlGenerate = urlGenerate;
     function normalize(aPath) {
-      var path17 = aPath;
+      var path13 = aPath;
       var url2 = urlParse(aPath);
       if (url2) {
         if (!url2.path) {
           return aPath;
         }
-        path17 = url2.path;
+        path13 = url2.path;
       }
-      var isAbsolute = exports2.isAbsolute(path17);
-      var parts = path17.split(/\/+/);
+      var isAbsolute = exports2.isAbsolute(path13);
+      var parts = path13.split(/\/+/);
       for (var part, up = 0, i = parts.length - 1; i >= 0; i--) {
         part = parts[i];
         if (part === ".") {
@@ -6514,15 +6514,15 @@ var require_util = __commonJS({
           }
         }
       }
-      path17 = parts.join("/");
-      if (path17 === "") {
-        path17 = isAbsolute ? "/" : ".";
+      path13 = parts.join("/");
+      if (path13 === "") {
+        path13 = isAbsolute ? "/" : ".";
       }
       if (url2) {
-        url2.path = path17;
+        url2.path = path13;
         return urlGenerate(url2);
       }
-      return path17;
+      return path13;
     }
     exports2.normalize = normalize;
     function join2(aRoot, aPath) {
@@ -9303,8 +9303,8 @@ var require_printer = __commonJS({
       return this.accept(sexpr.path) + " " + params + hash2;
     };
     PrintVisitor.prototype.PathExpression = function(id) {
-      var path17 = id.parts.join("/");
-      return (id.data ? "@" : "") + "PATH:" + path17;
+      var path13 = id.parts.join("/");
+      return (id.data ? "@" : "") + "PATH:" + path13;
     };
     PrintVisitor.prototype.StringLiteral = function(string4) {
       return '"' + string4.value + '"';
@@ -12015,10 +12015,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path17) {
-  if (!path17)
+function getElementAtPath(obj, path13) {
+  if (!path13)
     return obj;
-  return path17.reduce((acc, key) => acc?.[key], obj);
+  return path13.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -12379,11 +12379,11 @@ function aborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path17, issues) {
+function prefixIssues(path13, issues) {
   return issues.map((iss) => {
     var _a;
     (_a = iss).path ?? (_a.path = []);
-    iss.path.unshift(path17);
+    iss.path.unshift(path13);
     return iss;
   });
 }
@@ -12551,7 +12551,7 @@ function treeifyError(error45, _mapper) {
     return issue2.message;
   };
   const result = { errors: [] };
-  const processError = (error46, path17 = []) => {
+  const processError = (error46, path13 = []) => {
     var _a, _b;
     for (const issue2 of error46.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
@@ -12561,7 +12561,7 @@ function treeifyError(error45, _mapper) {
       } else if (issue2.code === "invalid_element") {
         processError({ issues: issue2.issues }, issue2.path);
       } else {
-        const fullpath = [...path17, ...issue2.path];
+        const fullpath = [...path13, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -12593,8 +12593,8 @@ function treeifyError(error45, _mapper) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path17 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path17) {
+  const path13 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path13) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -23791,9 +23791,6 @@ function renderTemplate(templateStr, data) {
   }
   return compiled(data);
 }
-function today() {
-  return (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
-}
 
 // dist/vault/preset.js
 import path from "node:path";
@@ -24276,8 +24273,8 @@ function getErrorMap2() {
 
 // node_modules/zod/v3/helpers/parseUtil.js
 var makeIssue = (params) => {
-  const { data, path: path17, errorMaps, issueData } = params;
-  const fullPath = [...path17, ...issueData.path || []];
+  const { data, path: path13, errorMaps, issueData } = params;
+  const fullPath = [...path13, ...issueData.path || []];
   const fullIssue = {
     ...issueData,
     path: fullPath
@@ -24393,11 +24390,11 @@ var errorUtil;
 
 // node_modules/zod/v3/types.js
 var ParseInputLazyPath = class {
-  constructor(parent, value, path17, key) {
+  constructor(parent, value, path13, key) {
     this._cachedPath = [];
     this.parent = parent;
     this.data = value;
-    this._path = path17;
+    this._path = path13;
     this._key = key;
   }
   get path() {
@@ -27840,52 +27837,26 @@ var coerce = {
 var NEVER2 = INVALID;
 
 // dist/plugin-config.js
-var MemberSchema = external_exports2.object({
-  name: external_exports2.string(),
-  role: external_exports2.string().default("")
-});
-var ProjectSchema = external_exports2.object({
-  name: external_exports2.string(),
-  description: external_exports2.string().default("")
-});
-var GlossaryEntrySchema = external_exports2.object({
+var TaxonomyEntrySchema = external_exports2.object({
   term: external_exports2.string(),
   definition: external_exports2.string(),
-  domain: external_exports2.string().default("")
+  domain: external_exports2.string().default(""),
+  tags: external_exports2.array(external_exports2.string()).default([])
 });
 var VaultConfigSchema = external_exports2.object({
   kbName: external_exports2.string().min(1),
   ownerName: external_exports2.string().default(""),
   vaultPath: external_exports2.string(),
-  members: external_exports2.array(MemberSchema).default([]),
-  projects: external_exports2.array(ProjectSchema).default([]),
-  glossaryEntries: external_exports2.array(GlossaryEntrySchema).default([]),
-  jiraHost: external_exports2.string().default(""),
-  jiraProject: external_exports2.string().default(""),
   preset: external_exports2.string().default("minimal"),
   provider: external_exports2.enum(["copilot", "gemini", "skip"]).default("skip"),
   /** GCP Project ID — used for BigQuery MCP env and Gemini provider config */
   gcpProjectId: external_exports2.string().default(""),
   /** MCP server names to skip (user deselected in init flow) */
-  mcpSkip: external_exports2.array(external_exports2.string()).default([])
-});
-var AddMemberSchema = external_exports2.object({
-  vaultPath: external_exports2.string(),
-  name: external_exports2.string(),
-  role: external_exports2.string().default(""),
-  team: external_exports2.string().default("")
-});
-var AddProjectSchema = external_exports2.object({
-  vaultPath: external_exports2.string(),
-  name: external_exports2.string(),
-  description: external_exports2.string().default(""),
-  team: external_exports2.string().default("")
-});
-var AddGlossaryTermSchema = external_exports2.object({
-  vaultPath: external_exports2.string(),
-  term: external_exports2.string(),
-  definition: external_exports2.string(),
-  domain: external_exports2.string().default("")
+  mcpSkip: external_exports2.array(external_exports2.string()).default([]),
+  /** What domain this knowledge base covers (used in SCHEMA.md generation) */
+  wikiDomain: external_exports2.string().default(""),
+  /** Agent autonomy level: auto = agent applies changes, review = agent reports first */
+  compilationMode: external_exports2.enum(["auto", "review"]).default("review")
 });
 var VaultStatusSchema = external_exports2.object({
   vaultPath: external_exports2.string()
@@ -27921,15 +27892,19 @@ var VaultDoctorSchema = external_exports2.object({
 
 // dist/vault/preset.js
 function getPresetsDir() {
+  const distAssets = path.resolve(import.meta.dirname, "assets", "presets");
   const srcPresets = path.resolve(import.meta.dirname, "..", "assets", "presets");
-  const distPresets = path.resolve(import.meta.dirname, "..", "..", "src", "assets", "presets");
+  const devPresets = path.resolve(import.meta.dirname, "..", "..", "src", "assets", "presets");
+  if (fs.existsSync(distAssets))
+    return distAssets;
   if (fs.existsSync(srcPresets))
     return srcPresets;
-  if (fs.existsSync(distPresets))
-    return distPresets;
+  if (fs.existsSync(devPresets))
+    return devPresets;
   throw new Error(`Cannot find presets directory. Looked in:
+  ${distAssets}
   ${srcPresets}
-  ${distPresets}`);
+  ${devPresets}`);
 }
 function listPresets() {
   const presetsDir = getPresetsDir();
@@ -28287,7 +28262,7 @@ async function configureProvider(provider, gcpProjectId) {
 
 // dist/vault/manifest.js
 import path4 from "node:path";
-var PKG_VERSION = "1.1.1";
+var PKG_VERSION = "2.0.0";
 var InfrastructureSchema = external_exports2.object({
   skills: external_exports2.array(external_exports2.string()).default([]),
   commands: external_exports2.array(external_exports2.string()).default([]),
@@ -28303,7 +28278,7 @@ var ManifestSchema = external_exports2.object({
 });
 var MANIFEST_DIR = ".byoao";
 var MANIFEST_FILE = "manifest.json";
-function today2() {
+function today() {
   return (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
 }
 function manifestPath(vaultPath) {
@@ -28326,8 +28301,8 @@ async function writeManifest(vaultPath, preset, installedFiles, versionOverride)
   const manifest = {
     version: versionOverride ?? PKG_VERSION,
     preset,
-    createdAt: existing?.createdAt ?? today2(),
-    updatedAt: today2(),
+    createdAt: existing?.createdAt ?? today(),
+    updatedAt: today(),
     infrastructure: {
       skills: installedFiles.skills,
       commands: installedFiles.commands,
@@ -28354,8 +28329,7 @@ function detectVaultContext(dir) {
       continue;
     const hasAgentsMd = fs.existsSync(path5.join(candidate, "AGENTS.md"));
     const hasAgentMdFallback = fs.existsSync(path5.join(candidate, "AGENT.md"));
-    const hasGlossary = fs.existsSync(path5.join(candidate, "Knowledge", "Glossary.md"));
-    if (hasAgentsMd || hasAgentMdFallback || hasGlossary) {
+    if (hasAgentsMd || hasAgentMdFallback) {
       return candidate;
     }
   }
@@ -28389,11 +28363,6 @@ function countWikilinks(content) {
   const matches = stripped.match(/\[\[([^\]|]+)(?:\|[^\]]+)?\]\]/g);
   return matches ? matches.length : 0;
 }
-var MINIMAL_DIRECTORIES = [
-  "Daily",
-  "Knowledge",
-  "Knowledge/templates"
-];
 function makeContext(vaultPath, kbName, preserveObsidian = false) {
   return {
     vaultPath,
@@ -28415,11 +28384,7 @@ var MCP_DISPLAY_NAMES = {
   atlassian: { name: "Atlassian", description: "Jira issues, Confluence pages" },
   bigquery: { name: "BigQuery", description: "Data warehouse queries and analysis" }
 };
-async function createMinimalCore(ctx, glossaryEntries = []) {
-  for (const dir of MINIMAL_DIRECTORIES) {
-    await fs.ensureDir(path6.join(ctx.vaultPath, dir));
-  }
-  ctx.directories.push(...MINIMAL_DIRECTORIES);
+async function createMinimalCore(ctx) {
   if (!ctx.preserveObsidian) {
     await fs.ensureDir(path6.join(ctx.vaultPath, ".obsidian"));
     const obsidianSrc = path6.join(ctx.commonDir, "obsidian");
@@ -28432,31 +28397,6 @@ async function createMinimalCore(ctx, glossaryEntries = []) {
       }
     }
   }
-  const templateDest = path6.join(ctx.vaultPath, "Knowledge/templates");
-  const commonTemplatesDir = path6.join(ctx.commonDir, "templates");
-  if (await fs.pathExists(commonTemplatesDir)) {
-    const files = await fs.readdir(commonTemplatesDir);
-    for (const file2 of files) {
-      await fs.copy(path6.join(commonTemplatesDir, file2), path6.join(templateDest, file2), { overwrite: false });
-      ctx.filesCreated++;
-      ctx.installedFiles.templates.push(`Knowledge/templates/${file2}`);
-    }
-  }
-  const glossaryTemplate = await fs.readFile(path6.join(ctx.commonDir, "Glossary.md.hbs"), "utf-8");
-  let glossaryRows = "";
-  if (glossaryEntries.length > 0) {
-    glossaryRows = glossaryEntries.map((e) => `| **${e.term}** | ${e.definition} | ${e.domain} |`).join("\n");
-  }
-  const glossaryContent = renderTemplate(glossaryTemplate, {
-    KB_NAME: ctx.kbName,
-    date: today(),
-    GLOSSARY_ENTRIES: glossaryRows
-  });
-  const glossaryPath = path6.join(ctx.vaultPath, "Knowledge/Glossary.md");
-  if (!await fs.pathExists(glossaryPath)) {
-    await fs.writeFile(glossaryPath, glossaryContent);
-    ctx.filesCreated++;
-  }
   const startHereTemplate = await fs.readFile(path6.join(ctx.commonDir, "Start Here.md.hbs"), "utf-8");
   const startHereContent = renderTemplate(startHereTemplate, {
     KB_NAME: ctx.kbName,
@@ -28469,23 +28409,51 @@ async function createMinimalCore(ctx, glossaryEntries = []) {
     ctx.filesCreated++;
   }
 }
-async function createAgentsMd(ctx, ownerName, presetConfig, presetDir, projects, jiraHost, jiraProject) {
+async function createLlmWikiCore(ctx, wikiDomain = "") {
+  const agentDirs = ["entities", "concepts", "comparisons", "queries"];
+  for (const dir of agentDirs) {
+    const dirPath = path6.join(ctx.vaultPath, dir);
+    if (!await fs.pathExists(dirPath)) {
+      await fs.ensureDir(dirPath);
+      ctx.filesCreated++;
+      ctx.directories.push(dir);
+    }
+  }
+  const schemaTemplatePath = path6.join(ctx.commonDir, "SCHEMA.md.hbs");
+  if (await fs.pathExists(schemaTemplatePath)) {
+    const schemaTemplate = await fs.readFile(schemaTemplatePath, "utf-8");
+    const schemaContent = renderTemplate(schemaTemplate, {
+      KB_NAME: ctx.kbName,
+      WIKI_DOMAIN: wikiDomain || ""
+    });
+    const schemaPath = path6.join(ctx.vaultPath, "SCHEMA.md");
+    if (!await fs.pathExists(schemaPath)) {
+      await fs.writeFile(schemaPath, schemaContent);
+      ctx.filesCreated++;
+    }
+  }
+  const logContent = `# Agent Activity Log
+
+Entries are appended here during /cook operations.
+
+`;
+  const logPath = path6.join(ctx.vaultPath, "log.md");
+  if (!await fs.pathExists(logPath)) {
+    await fs.writeFile(logPath, logContent);
+    ctx.filesCreated++;
+  }
+}
+async function createAgentsMd(ctx, ownerName, presetConfig, presetDir) {
   const agentsTemplate = await fs.readFile(path6.join(ctx.commonDir, "AGENTS.md.hbs"), "utf-8");
   let roleSection = "";
   const agentSectionPath = path6.join(presetDir, "agent-section.hbs");
   if (await fs.pathExists(agentSectionPath)) {
     const agentSectionTemplate = await fs.readFile(agentSectionPath, "utf-8");
-    let projectsList;
-    if (projects.length > 0) {
-      projectsList = projects.map((p) => `- [[${p.name}]] \u2014 ${p.description}`).join("\n");
-    } else {
-      projectsList = "(No projects added yet \u2014 create notes in Projects/)";
-    }
     roleSection = renderTemplate(agentSectionTemplate, {
-      PROJECTS: projectsList,
-      JIRA_HOST: jiraHost,
-      JIRA_PROJECT: jiraProject,
-      HAS_JIRA: !!(jiraHost && jiraProject)
+      PROJECTS: "(Use /cook to discover projects from your notes)",
+      JIRA_HOST: "",
+      JIRA_PROJECT: "",
+      HAS_JIRA: false
     });
   }
   const agentsContent = renderTemplate(agentsTemplate, {
@@ -28504,127 +28472,24 @@ async function applyPresetOverlay(ctx, presetConfig, presetDir) {
     await fs.ensureDir(path6.join(ctx.vaultPath, dir));
   }
   ctx.directories.push(...presetConfig.directories);
-  const templateDest = path6.join(ctx.vaultPath, "Knowledge/templates");
   const allTemplateNames = [];
-  if (await fs.pathExists(templateDest)) {
-    const existing = await fs.readdir(templateDest);
-    for (const file2 of existing) {
-      if (file2.endsWith(".md")) {
-        allTemplateNames.push(file2.replace(/\.md$/, ""));
-      }
-    }
-  }
   const presetTemplatesDir = path6.join(presetDir, "templates");
   if (await fs.pathExists(presetTemplatesDir)) {
+    const templateDest = path6.join(ctx.vaultPath, "templates");
+    await fs.ensureDir(templateDest);
     const files = await fs.readdir(presetTemplatesDir);
     for (const file2 of files) {
       await fs.copy(path6.join(presetTemplatesDir, file2), path6.join(templateDest, file2), { overwrite: false });
       allTemplateNames.push(file2.replace(/\.md$/, ""));
       ctx.filesCreated++;
-      ctx.installedFiles.templates.push(`Knowledge/templates/${file2}`);
+      ctx.installedFiles.templates.push(`templates/${file2}`);
     }
   }
   return allTemplateNames;
 }
-async function createPeopleNotes(ctx, members) {
-  if (members.length === 0)
-    return;
-  await fs.ensureDir(path6.join(ctx.vaultPath, "People"));
-  if (!ctx.directories.includes("People")) {
-    ctx.directories.push("People");
-  }
-  for (const member of members) {
-    const content = `---
-title: "${member.name}"
-type: person
-team: "${ctx.kbName}"
-role: "${member.role}"
-status: active
-tags: [person]
----
-
-# ${member.name}
-
-**Role**: ${member.role}
-**Team**: ${ctx.kbName}
-`;
-    const memberPath = path6.join(ctx.vaultPath, `People/${member.name}.md`);
-    if (!await fs.pathExists(memberPath)) {
-      await fs.writeFile(memberPath, content);
-      ctx.filesCreated++;
-    }
-  }
-}
-async function createProjectNotes(ctx, projects) {
-  if (projects.length === 0)
-    return;
-  await fs.ensureDir(path6.join(ctx.vaultPath, "Projects"));
-  if (!ctx.directories.includes("Projects")) {
-    ctx.directories.push("Projects");
-  }
-  for (const project of projects) {
-    const content = `---
-title: "${project.name}"
-type: feature
-status: active
-date: ${today()}
-team: "${ctx.kbName}"
-jira: ""
-stakeholders: []
-priority: ""
-tags: [project]
----
-
-# ${project.name}
-
-${project.description}
-`;
-    const projectPath = path6.join(ctx.vaultPath, `Projects/${project.name}.md`);
-    if (!await fs.pathExists(projectPath)) {
-      await fs.writeFile(projectPath, content);
-      ctx.filesCreated++;
-    }
-  }
-}
-async function createTeamIndex(ctx, members, projects) {
-  await fs.ensureDir(path6.join(ctx.vaultPath, "People"));
-  if (!ctx.directories.includes("People")) {
-    ctx.directories.push("People");
-  }
-  let teamIndexContent = `---
-title: "${ctx.kbName} Team"
-type: reference
-team: "${ctx.kbName}"
-tags: [team]
----
-
-# ${ctx.kbName} Team
-
-## Members
-
-`;
-  if (members.length > 0) {
-    teamIndexContent += "| Name | Role |\n|------|------|\n";
-    teamIndexContent += members.map((m) => `| [[${m.name}]] | ${m.role} |`).join("\n");
-  } else {
-    teamIndexContent += "(No members added yet)";
-  }
-  teamIndexContent += "\n\n## Active Projects\n\n";
-  if (projects.length > 0) {
-    teamIndexContent += projects.map((p) => `- [[${p.name}]] \u2014 ${p.description}`).join("\n");
-  } else {
-    teamIndexContent += "(No projects added yet)";
-  }
-  teamIndexContent += "\n";
-  const teamIndexPath = path6.join(ctx.vaultPath, `People/${ctx.kbName} Team.md`);
-  if (!await fs.pathExists(teamIndexPath)) {
-    await fs.writeFile(teamIndexPath, teamIndexContent);
-    ctx.filesCreated++;
-  }
-}
 async function createVault(config2) {
-  const { kbName, vaultPath, members, projects, glossaryEntries, jiraHost, jiraProject, preset } = config2;
-  const presetName = preset ?? "pm-tpm";
+  const { kbName, vaultPath, preset } = config2;
+  const presetName = preset ?? "minimal";
   const { config: presetConfig, presetsDir } = loadPreset(presetName);
   const presetDir = path6.join(presetsDir, presetName);
   const initMode = detectInitMode(vaultPath);
@@ -28637,15 +28502,10 @@ async function createVault(config2) {
       ctx.mcpServices.push(info);
     }
   }
-  await createMinimalCore(ctx, glossaryEntries);
-  const allTemplateNames = await applyPresetOverlay(ctx, presetConfig, presetDir);
-  await createAgentsMd(ctx, config2.ownerName, presetConfig, presetDir, projects, jiraHost, jiraProject);
-  await createPeopleNotes(ctx, members);
-  await createProjectNotes(ctx, projects);
-  const hasPeopleDir = presetConfig.directories.includes("People") || members.length > 0;
-  if (hasPeopleDir) {
-    await createTeamIndex(ctx, members, projects);
-  }
+  await createMinimalCore(ctx);
+  await createLlmWikiCore(ctx, config2.wikiDomain);
+  await applyPresetOverlay(ctx, presetConfig, presetDir);
+  await createAgentsMd(ctx, config2.ownerName, presetConfig, presetDir);
   await configureOpenCodeProject(ctx.vaultPath, ctx.installedFiles);
   const mcpOptions = {};
   if (config2.mcpSkip && config2.mcpSkip.length > 0) {
@@ -28726,13 +28586,16 @@ async function configureOpenCodeProject(vaultPath, installedFiles) {
   }
 }
 function resolveAssetsDir() {
+  const distAssets = path6.resolve(import.meta.dirname, "assets");
   const srcAssets = path6.resolve(import.meta.dirname, "..", "assets");
-  const distAssets = path6.resolve(import.meta.dirname, "..", "..", "src", "assets");
-  if (fs.existsSync(srcAssets))
-    return srcAssets;
+  const devAssets = path6.resolve(import.meta.dirname, "..", "..", "src", "assets");
   if (fs.existsSync(distAssets))
     return distAssets;
-  return srcAssets;
+  if (fs.existsSync(srcAssets))
+    return srcAssets;
+  if (fs.existsSync(devAssets))
+    return devAssets;
+  return distAssets;
 }
 
 // dist/vault/obsidian-check.js
@@ -28852,26 +28715,13 @@ function formatObsidianStatus(status) {
 import path7 from "node:path";
 import os3 from "node:os";
 var byoao_init_vault = tool({
-  description: "Create a personal knowledge base in Obsidian. Creates directory structure, templates, glossary, agent routing file (AGENTS.md), and optional people/project notes with wikilinks. Checks that Obsidian is installed first.",
+  description: "Create an LLM Wiki knowledge base in Obsidian. Sets up agent directories (entities/, concepts/, comparisons/, queries/), SCHEMA.md, log.md, and AI routing (AGENTS.md). Your existing notes become raw material for /cook.",
   args: {
     kbName: tool.schema.string().describe(`Knowledge base name (e.g. "Jay's KB")`),
     ownerName: tool.schema.string().optional().describe("Owner's name"),
     vaultPath: tool.schema.string().optional().describe("Where to create the vault. Defaults to ~/Documents/{kbName}"),
-    members: tool.schema.array(tool.schema.object({
-      name: tool.schema.string().describe("Person's name"),
-      role: tool.schema.string().optional().describe("Person's role")
-    })).optional().describe("People to create notes for"),
-    projects: tool.schema.array(tool.schema.object({
-      name: tool.schema.string().describe("Project name"),
-      description: tool.schema.string().optional().describe("One-line description")
-    })).optional().describe("Active projects to create project notes for"),
-    glossaryEntries: tool.schema.array(tool.schema.object({
-      term: tool.schema.string().describe("Domain term"),
-      definition: tool.schema.string().describe("Brief definition")
-    })).optional().describe("Domain terms to add to the glossary"),
-    jiraHost: tool.schema.string().optional().describe("JIRA host (e.g. 'mycompany.atlassian.net')"),
-    jiraProject: tool.schema.string().optional().describe("JIRA project key (e.g. 'HDR')"),
-    preset: tool.schema.string().optional().describe("Role preset (default: 'minimal'). Use 'pm-tpm' for project management.")
+    preset: tool.schema.string().optional().describe("Work profile (default: 'minimal'). Use 'pm-tpm' for PM/TPM with Atlassian + BigQuery."),
+    wikiDomain: tool.schema.string().optional().describe("What domain this knowledge base covers (e.g. 'AI/ML research', 'product management')")
   },
   async execute(args) {
     const obsidianStatus = checkObsidian();
@@ -28885,12 +28735,8 @@ Please install Obsidian first, then try again.`;
       kbName: args.kbName,
       ownerName: args.ownerName || "",
       vaultPath: resolvedPath,
-      members: args.members || [],
-      projects: args.projects || [],
-      glossaryEntries: args.glossaryEntries || [],
-      jiraHost: args.jiraHost || "",
-      jiraProject: args.jiraProject || "",
-      preset: args.preset || "minimal"
+      preset: args.preset || "minimal",
+      wikiDomain: args.wikiDomain || ""
     });
     const result = await createVault(config2);
     let output = `\u2713 Knowledge base created at: ${result.vaultPath}
@@ -28990,235 +28836,18 @@ Open in Obsidian: "Open folder as vault" \u2192 select "${result.vaultPath}"`;
     if (result.initMode === "existing" || result.initMode === "obsidian-vault") {
       output += `
 
-\u2192 Next step: run /weave now \u2014 it will scan your existing notes, add frontmatter metadata (including dates), create wikilinks between related content, and build your Glossary from frequently mentioned concepts.`;
+\u2192 Next step: run /cook now \u2014 it will scan your existing notes, identify entities and concepts, and compile them into structured knowledge pages.`;
     } else {
       output += `
 
-\u2192 Next step: add a few notes, then run /weave to connect them into a knowledge graph. See "Start Here" in the vault for details.`;
+\u2192 Next step: add a few notes, then run /cook to compile them into knowledge pages. See "Start Here" in the vault for details.`;
     }
     return output;
   }
 });
 
-// dist/vault/member.js
-import path8 from "node:path";
-async function addMember(input) {
-  const { vaultPath, name, role, team } = input;
-  let wikilinksAdded = 0;
-  const personPath = path8.join(vaultPath, `People/${name}.md`);
-  if (await fs.pathExists(personPath)) {
-    throw new Error(`Person note already exists: ${personPath}`);
-  }
-  const content = `---
-title: "${name}"
-type: person
-team: "${team}"
-role: "${role}"
-status: active
-tags: [person]
----
-
-# ${name}
-
-**Role**: ${role}
-**Team**: ${team}
-`;
-  await fs.writeFile(personPath, content);
-  const teamFiles = await fs.readdir(path8.join(vaultPath, "People"));
-  const teamIndexFile = teamFiles.find((f) => f.endsWith("Team.md"));
-  if (teamIndexFile) {
-    const teamIndexPath = path8.join(vaultPath, "People", teamIndexFile);
-    let teamContent = await fs.readFile(teamIndexPath, "utf-8");
-    const tableRow = `| [[${name}]] | ${role} |`;
-    if (teamContent.includes("|------|------|")) {
-      teamContent = teamContent.replace(/(^\|------|------\|$)/m, `$1
-${tableRow}`);
-      wikilinksAdded++;
-    }
-    await fs.writeFile(teamIndexPath, teamContent);
-  }
-  for (const agentFile of ["AGENTS.md", "AGENT.md"]) {
-    const agentPath = path8.join(vaultPath, agentFile);
-    if (await fs.pathExists(agentPath)) {
-      let agentContent = await fs.readFile(agentPath, "utf-8");
-      if (agentContent.includes("(No members added yet")) {
-        const table = `| Name | Role |
-|------|------|
-| [[${name}]] | ${role} |`;
-        agentContent = agentContent.replace(/\(No members added yet[^)]*\)/, table);
-        wikilinksAdded++;
-      } else if (agentContent.includes("|------|------|")) {
-        const teamSectionMatch = agentContent.match(/## Team[^\n]*\n[\s\S]*?(\|------|------\|[^\n]*(?:\n\|[^\n]*)*)/);
-        if (teamSectionMatch) {
-          const existingTable = teamSectionMatch[1];
-          const newTable = existingTable + `
-| [[${name}]] | ${role} |`;
-          agentContent = agentContent.replace(existingTable, newTable);
-          wikilinksAdded++;
-        }
-      }
-      await fs.writeFile(agentPath, agentContent);
-    }
-  }
-  return { filePath: personPath, wikilinksAdded };
-}
-
-// dist/tools/add-person.js
-var byoao_add_person = tool({
-  description: "Add a person note to an existing vault. Creates a person note in People/ and updates the team index and AGENTS.md wikilinks.",
-  args: {
-    vaultPath: tool.schema.string().describe("Path to the Obsidian vault"),
-    name: tool.schema.string().describe("Person's full name"),
-    role: tool.schema.string().optional().describe("Person's role/title"),
-    team: tool.schema.string().optional().describe("Team or KB name")
-  },
-  async execute(args) {
-    const result = await addMember({
-      vaultPath: args.vaultPath,
-      name: args.name,
-      role: args.role || "",
-      team: args.team || ""
-    });
-    return `Added person: ${args.name}
-  File: ${result.filePath}
-  Wikilinks updated: ${result.wikilinksAdded}`;
-  }
-});
-
-// dist/vault/project.js
-import path9 from "node:path";
-async function addProject(input) {
-  const { vaultPath, name, description, team } = input;
-  let wikilinksAdded = 0;
-  const projectPath = path9.join(vaultPath, `Projects/${name}.md`);
-  if (await fs.pathExists(projectPath)) {
-    throw new Error(`Project note already exists: ${projectPath}`);
-  }
-  const content = `---
-title: "${name}"
-type: feature
-status: active
-date: ${today()}
-team: "${team}"
-jira: ""
-stakeholders: []
-priority: ""
-tags: [project]
----
-
-# ${name}
-
-${description}
-`;
-  await fs.writeFile(projectPath, content);
-  const peoplePath = path9.join(vaultPath, "People");
-  if (await fs.pathExists(peoplePath)) {
-    const teamFiles = await fs.readdir(peoplePath);
-    const teamIndexFile = teamFiles.find((f) => f.endsWith("Team.md"));
-    if (teamIndexFile) {
-      const teamIndexPath = path9.join(peoplePath, teamIndexFile);
-      let teamContent = await fs.readFile(teamIndexPath, "utf-8");
-      const projectLine = `- [[${name}]] \u2014 ${description}`;
-      if (teamContent.includes("(No projects added yet)")) {
-        teamContent = teamContent.replace("(No projects added yet)", projectLine);
-      } else if (teamContent.includes("## Active Projects")) {
-        teamContent = teamContent.replace(/(## Active Projects\n\n)([\s\S]*?)(\n\n|$)/, `$1$2
-${projectLine}$3`);
-      }
-      wikilinksAdded++;
-      await fs.writeFile(teamIndexPath, teamContent);
-    }
-  }
-  for (const agentFile of ["AGENTS.md", "AGENT.md"]) {
-    const agentPath = path9.join(vaultPath, agentFile);
-    if (await fs.pathExists(agentPath)) {
-      let agentContent = await fs.readFile(agentPath, "utf-8");
-      const projectLine = `- [[${name}]] \u2014 ${description}`;
-      if (agentContent.includes("(No projects added yet")) {
-        agentContent = agentContent.replace(/\(No projects added yet[^)]*\)/, projectLine);
-        wikilinksAdded++;
-      } else if (agentContent.includes("## Active Projects")) {
-        agentContent = agentContent.replace(/(## Active Projects[^\n]*\n\n)([\s\S]*?)(\n\n|$)/, `$1$2
-${projectLine}$3`);
-        wikilinksAdded++;
-      }
-      await fs.writeFile(agentPath, agentContent);
-    }
-  }
-  return { filePath: projectPath, wikilinksAdded };
-}
-
-// dist/tools/add-project.js
-var byoao_add_project = tool({
-  description: "Add a new project note to an existing vault. Creates a project note in Projects/ and updates the team index and AGENTS.md wikilinks.",
-  args: {
-    vaultPath: tool.schema.string().describe("Path to the Obsidian vault"),
-    name: tool.schema.string().describe("Project name"),
-    description: tool.schema.string().optional().describe("One-line project description"),
-    team: tool.schema.string().optional().describe("Team name")
-  },
-  async execute(args) {
-    const result = await addProject({
-      vaultPath: args.vaultPath,
-      name: args.name,
-      description: args.description || "",
-      team: args.team || ""
-    });
-    return `\u2713 Added project: ${args.name}
-  File: ${result.filePath}
-  Wikilinks updated: ${result.wikilinksAdded}`;
-  }
-});
-
-// dist/vault/glossary.js
-import path10 from "node:path";
-async function addGlossaryTerm(input) {
-  const { vaultPath, term, definition, domain: domain2 } = input;
-  const glossaryPath = path10.join(vaultPath, "Knowledge/Glossary.md");
-  if (!await fs.pathExists(glossaryPath)) {
-    throw new Error(`Glossary not found at: ${glossaryPath}`);
-  }
-  let content = await fs.readFile(glossaryPath, "utf-8");
-  const newRow = `| **${term}** | ${definition} | ${domain2 ?? ""} |`;
-  const tableMatch = content.match(/(\| Term \| Definition \| Domain \|\n\|------\|-----------|--------\|\n)([\s\S]*?)(\n*$)/);
-  if (tableMatch) {
-    const [fullMatch, tableHeader, existingRows, trailing] = tableMatch;
-    const updatedRows = existingRows.trim() ? `${existingRows.trim()}
-${newRow}` : newRow;
-    content = content.replace(fullMatch, `${tableHeader}${updatedRows}
-`);
-  } else {
-    content = content.trimEnd() + `
-${newRow}
-`;
-  }
-  await fs.writeFile(glossaryPath, content);
-  return { glossaryPath, termAdded: term };
-}
-
-// dist/tools/add-glossary-term.js
-var byoao_add_glossary_term = tool({
-  description: "Add a new term to the vault's Glossary.md. Appends a row to the Core Terms table.",
-  args: {
-    vaultPath: tool.schema.string().describe("Path to the Obsidian vault"),
-    term: tool.schema.string().describe("The domain term to add"),
-    definition: tool.schema.string().describe("Brief definition (1-2 sentences)"),
-    domain: tool.schema.string().optional().describe("Knowledge domain (e.g. analytics, infrastructure)")
-  },
-  async execute(args) {
-    const result = await addGlossaryTerm({
-      vaultPath: args.vaultPath,
-      term: args.term,
-      definition: args.definition,
-      domain: args.domain ?? ""
-    });
-    return `\u2713 Added glossary term: ${result.termAdded}
-  File: ${result.glossaryPath}`;
-  }
-});
-
 // dist/vault/status.js
-import path11 from "node:path";
+import path8 from "node:path";
 async function getAllMarkdownFiles(dirPath) {
   const results = [];
   async function walk(dir) {
@@ -29226,7 +28855,7 @@ async function getAllMarkdownFiles(dirPath) {
       return;
     const entries = await fs.readdir(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = path11.join(dir, entry.name);
+      const fullPath = path8.join(dir, entry.name);
       if (entry.isDirectory()) {
         if (!entry.name.startsWith(".")) {
           await walk(fullPath);
@@ -29258,11 +28887,14 @@ async function getVaultStatus(vaultPath) {
       directories: {},
       hasObsidianConfig: false,
       hasAgentMd: false,
-      hasGlossary: false
+      agentPages: { entities: 0, concepts: 0, comparisons: 0, queries: 0 },
+      hasSchema: false,
+      hasLog: false,
+      hasIndexBase: false
     };
   }
   const allFiles = await getAllMarkdownFiles(vaultPath);
-  const noteNames = new Set(allFiles.map((f) => path11.basename(f, ".md")));
+  const noteNames = new Set(allFiles.map((f) => path8.basename(f, ".md")));
   let wikilinkCount = 0;
   const brokenLinksSet = /* @__PURE__ */ new Set();
   for (const file2 of allFiles) {
@@ -29287,12 +28919,24 @@ async function getVaultStatus(vaultPath) {
     "Daily"
   ];
   for (const dir of topDirs) {
-    const dirPath = path11.join(vaultPath, dir);
+    const dirPath = path8.join(vaultPath, dir);
     if (await fs.pathExists(dirPath)) {
       const files = await getAllMarkdownFiles(dirPath);
       directories[dir] = files.length;
     }
   }
+  const agentDirNames = ["entities", "concepts", "comparisons", "queries"];
+  const agentPages = {
+    entities: 0,
+    concepts: 0,
+    comparisons: 0,
+    queries: 0
+  };
+  for (const name of agentDirNames) {
+    const dirPath = path8.join(vaultPath, name);
+    const mdFiles = await getAllMarkdownFiles(dirPath);
+    agentPages[name] = mdFiles.length;
+  }
   return {
     exists: true,
     vaultPath,
@@ -29300,9 +28944,12 @@ async function getVaultStatus(vaultPath) {
     wikilinkCount,
     brokenLinks: Array.from(brokenLinksSet),
     directories,
-    hasObsidianConfig: await fs.pathExists(path11.join(vaultPath, ".obsidian")),
-    hasAgentMd: await fs.pathExists(path11.join(vaultPath, "AGENTS.md")) || await fs.pathExists(path11.join(vaultPath, "AGENT.md")),
-    hasGlossary: await fs.pathExists(path11.join(vaultPath, "Knowledge/Glossary.md"))
+    hasObsidianConfig: await fs.pathExists(path8.join(vaultPath, ".obsidian")),
+    hasAgentMd: await fs.pathExists(path8.join(vaultPath, "AGENTS.md")) || await fs.pathExists(path8.join(vaultPath, "AGENT.md")),
+    agentPages,
+    hasSchema: await fs.pathExists(path8.join(vaultPath, "SCHEMA.md")),
+    hasLog: await fs.pathExists(path8.join(vaultPath, "log.md")),
+    hasIndexBase: await fs.pathExists(path8.join(vaultPath, "INDEX.base"))
   };
 }
 function formatVaultStatus(status) {
@@ -29322,7 +28969,10 @@ function formatVaultStatus(status) {
   lines.push("");
   lines.push(`Config: ${status.hasObsidianConfig ? "\u2713" : "\u2717"} .obsidian/`);
   lines.push(`Agent:  ${status.hasAgentMd ? "\u2713" : "\u2717"} AGENTS.md`);
-  lines.push(`Glossary: ${status.hasGlossary ? "\u2713" : "\u2717"} Glossary.md`);
+  lines.push("");
+  lines.push("LLM Wiki v2 (agent pages):");
+  lines.push(`  entities: ${status.agentPages.entities} \xB7 concepts: ${status.agentPages.concepts} \xB7 comparisons: ${status.agentPages.comparisons} \xB7 queries: ${status.agentPages.queries}`);
+  lines.push(`  SCHEMA.md: ${status.hasSchema ? "\u2713" : "\u2717"} \xB7 log.md: ${status.hasLog ? "\u2713" : "\u2717"} \xB7 INDEX.base: ${status.hasIndexBase ? "\u2713" : "\u2717"}`);
   if (status.brokenLinks.length > 0) {
     lines.push("");
     lines.push(`\u26A0\uFE0F Broken links (${status.brokenLinks.length}):`);
@@ -29340,7 +28990,7 @@ function formatVaultStatus(status) {
 
 // dist/tools/vault-status.js
 var byoao_vault_status = tool({
-  description: "Check the health of an Obsidian vault \u2014 note count, wikilink count, broken links, directory breakdown, and Obsidian installation status.",
+  description: "Check the health of an Obsidian vault \u2014 note count, wikilink count, broken links, directory breakdown, Obsidian installation status, and LLM Wiki v2 signals: per-directory markdown counts under entities/, concepts/, comparisons/, queries/, plus presence of SCHEMA.md, log.md, and INDEX.base at the vault root.",
   args: {
     vaultPath: tool.schema.string().describe("Path to the Obsidian vault")
   },
@@ -29355,12 +29005,18 @@ var byoao_vault_status = tool({
 });
 
 // dist/vault/doctor.js
-import path12 from "node:path";
+import path9 from "node:path";
+import { stat } from "node:fs/promises";
+var LLM_WIKI_V2_AGENT_DIRS = ["entities", "concepts", "comparisons", "queries"];
+function isAgentWikiPage(relativePath) {
+  const top = relativePath.split(path9.sep)[0];
+  return LLM_WIKI_V2_AGENT_DIRS.includes(top);
+}
 async function collectMarkdownFiles(dir) {
   const results = [];
   const entries = await fs.readdir(dir, { withFileTypes: true });
   for (const entry of entries) {
-    const fullPath = path12.join(dir, entry.name);
+    const fullPath = path9.join(dir, entry.name);
     if (entry.isDirectory()) {
       if (entry.name === ".obsidian" || entry.name === ".git")
         continue;
@@ -29381,10 +29037,10 @@ function extractWikilinks2(content) {
 async function getVaultDiagnosis(vaultPath) {
   const issues = [];
   const allFiles = await collectMarkdownFiles(vaultPath);
-  const noteNames = new Set(allFiles.map((f) => path12.basename(f, ".md")));
+  const noteNames = new Set(allFiles.map((f) => path9.basename(f, ".md")));
   let healthyNotes = 0;
   for (const filePath of allFiles) {
-    const relativePath = path12.relative(vaultPath, filePath);
+    const relativePath = path9.relative(vaultPath, filePath);
     if (relativePath.startsWith("Knowledge/templates/"))
       continue;
     const content = await fs.readFile(filePath, "utf-8");
@@ -29418,15 +29074,26 @@ async function getVaultDiagnosis(vaultPath) {
         hasIssue = true;
       }
     }
+    const contra = data?.contradictions;
+    const contraList = Array.isArray(contra) && contra.some((x) => x != null && String(x).trim() !== "");
+    const contraStr = typeof contra === "string" && contra.trim() !== "";
+    if (contraList || contraStr) {
+      issues.push({
+        severity: "warning",
+        category: "contradiction",
+        file: relativePath,
+        message: "Note lists `contradictions` in frontmatter \u2014 review conflicting claims against linked agent pages"
+      });
+    }
     if (!hasIssue)
       healthyNotes++;
   }
   let agentContent = null;
-  let agentResolvedPath = path12.join(vaultPath, "AGENTS.md");
+  let agentResolvedPath = path9.join(vaultPath, "AGENTS.md");
   if (await fs.pathExists(agentResolvedPath)) {
     agentContent = await fs.readFile(agentResolvedPath, "utf-8");
   } else {
-    agentResolvedPath = path12.join(vaultPath, "AGENT.md");
+    agentResolvedPath = path9.join(vaultPath, "AGENT.md");
     if (await fs.pathExists(agentResolvedPath)) {
       agentContent = await fs.readFile(agentResolvedPath, "utf-8");
     }
@@ -29443,24 +29110,54 @@ async function getVaultDiagnosis(vaultPath) {
       }
     }
   }
+  for (const dirName of LLM_WIKI_V2_AGENT_DIRS) {
+    const dirPath = path9.join(vaultPath, dirName);
+    const exists = await fs.pathExists(dirPath);
+    const isDir = exists && (await stat(dirPath)).isDirectory();
+    if (!isDir) {
+      issues.push({
+        severity: "warning",
+        category: "agent-drift",
+        message: `LLM Wiki v2: expected agent directory \`${dirName}/\` at vault root`
+      });
+    }
+  }
+  const schemaPath = path9.join(vaultPath, "SCHEMA.md");
+  if (!await fs.pathExists(schemaPath)) {
+    issues.push({
+      severity: "warning",
+      category: "agent-drift",
+      message: "LLM Wiki v2: missing SCHEMA.md at vault root"
+    });
+  }
+  const logMdPath = path9.join(vaultPath, "log.md");
+  if (!await fs.pathExists(logMdPath)) {
+    issues.push({
+      severity: "warning",
+      category: "agent-drift",
+      message: "LLM Wiki v2: missing log.md at vault root"
+    });
+  }
   const allLinksMap = /* @__PURE__ */ new Map();
   const incomingLinks = /* @__PURE__ */ new Set();
   for (const filePath of allFiles) {
     const content = await fs.readFile(filePath, "utf-8");
     const links = extractWikilinks2(content);
-    const name = path12.basename(filePath, ".md");
+    const name = path9.basename(filePath, ".md");
     allLinksMap.set(name, new Set(links));
     for (const link of links) {
       incomingLinks.add(link);
     }
   }
   for (const filePath of allFiles) {
-    const relativePath = path12.relative(vaultPath, filePath);
+    const relativePath = path9.relative(vaultPath, filePath);
     if (relativePath.startsWith("Knowledge/templates/"))
       continue;
     if (relativePath === "AGENT.md" || relativePath === "AGENTS.md")
       continue;
-    const name = path12.basename(filePath, ".md");
+    if (isAgentWikiPage(relativePath))
+      continue;
+    const name = path9.basename(filePath, ".md");
     const outgoing = allLinksMap.get(name) || /* @__PURE__ */ new Set();
     const hasIncoming = incomingLinks.has(name);
     const hasOutgoing = outgoing.size > 0;
@@ -29474,7 +29171,7 @@ async function getVaultDiagnosis(vaultPath) {
     }
   }
   for (const filePath of allFiles) {
-    const relativePath = path12.relative(vaultPath, filePath);
+    const relativePath = path9.relative(vaultPath, filePath);
     const content = await fs.readFile(filePath, "utf-8");
     const links = extractWikilinks2(content);
     for (const link of links) {
@@ -29500,7 +29197,7 @@ async function getVaultDiagnosis(vaultPath) {
 
 // dist/tools/vault-doctor.js
 var byoao_vault_doctor = tool({
-  description: "Scan an Obsidian vault and produce a diagnostic report. Checks: missing frontmatter, missing type/tags, AGENTS.md drift, orphan notes, broken wikilinks.",
+  description: "Scan an Obsidian vault and produce a diagnostic report. Checks: missing frontmatter, missing type/tags, AGENTS.md drift, orphan notes (user notes only; agent pages under entities/, concepts/, comparisons/, queries/ are excluded), broken wikilinks, LLM Wiki v2 layout (agent directories, SCHEMA.md, log.md at vault root), and notes with contradictions frontmatter.",
   args: {
     vaultPath: tool.schema.string().describe("Absolute path to the Obsidian vault")
   },
@@ -29566,323 +29263,16 @@ var byoao_switch_provider = tool({
   }
 });
 
-// dist/vault/search-vault.js
-import path13 from "node:path";
-
-// dist/vault/obsidian-cli.js
-import { execFileSync, execSync as execSync3 } from "node:child_process";
-import { platform as platform2 } from "node:os";
-var _cliAvailableCache = null;
-function isObsidianCliAvailable() {
-  if (_cliAvailableCache !== null)
-    return _cliAvailableCache;
-  const os5 = platform2();
-  try {
-    if (os5 === "darwin") {
-      execSync3("pgrep -x Obsidian", { stdio: "pipe", timeout: 3e3 });
-      _cliAvailableCache = true;
-    } else if (os5 === "linux") {
-      execSync3("pgrep -x obsidian", { stdio: "pipe", timeout: 3e3 });
-      _cliAvailableCache = true;
-    } else if (os5 === "win32") {
-      const result = execSync3('tasklist /FI "IMAGENAME eq Obsidian.exe" /NH', { stdio: "pipe", timeout: 3e3, encoding: "utf-8" });
-      _cliAvailableCache = result.includes("Obsidian.exe");
-    } else {
-      _cliAvailableCache = false;
-    }
-  } catch {
-    _cliAvailableCache = false;
-  }
-  return _cliAvailableCache;
-}
-function execObsidianCmd(args) {
-  try {
-    const output = execFileSync("obsidian", args, {
-      stdio: "pipe",
-      encoding: "utf-8",
-      timeout: 1e4
-    });
-    return { success: true, output: output.trim() };
-  } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err);
-    return { success: false, output: "", error: msg };
-  }
-}
-
-// dist/vault/retrieval-types.js
-var DEFAULT_RESULT_LIMIT = 20;
-var MAX_SNIPPET_LENGTH = 240;
-
-// dist/vault/search-vault.js
-async function searchVault(input) {
-  const { vaultPath, query, limit = DEFAULT_RESULT_LIMIT } = input;
-  const mode = "search:context";
-  const base = {
-    mode,
-    vault: vaultPath,
-    fallback: "none"
-  };
-  if (!isObsidianCliAvailable()) {
-    return {
-      ...base,
-      status: "runtime_unavailable",
-      summary: "Obsidian CLI not available",
-      results: [],
-      truncated: false,
-      diagnostics: ["Obsidian CLI not available"]
-    };
-  }
-  const cliResult = execObsidianCmd([
-    "search:context",
-    "--vault",
-    vaultPath,
-    query
-  ]);
-  if (!cliResult.success) {
-    return {
-      ...base,
-      status: "runtime_unavailable",
-      summary: "Obsidian CLI command failed",
-      results: [],
-      truncated: false,
-      diagnostics: [cliResult.error ?? "Unknown CLI error"]
-    };
-  }
-  const lines = cliResult.output.split("\n").filter((l) => l.trim().length > 0);
-  if (lines.length === 0) {
-    return {
-      ...base,
-      status: "no_results",
-      summary: `No matches for "${query}"`,
-      results: [],
-      truncated: false,
-      diagnostics: []
-    };
-  }
-  const allItems = [];
-  for (const line of lines) {
-    const colonIdx = line.indexOf(":");
-    if (colonIdx === -1)
-      continue;
-    const filePath = line.substring(0, colonIdx);
-    const snippet = line.substring(colonIdx + 1).trim();
-    const title = path13.basename(filePath, ".md");
-    allItems.push({
-      title,
-      path: filePath,
-      file: title,
-      snippet: snippet.length > MAX_SNIPPET_LENGTH ? snippet.substring(0, MAX_SNIPPET_LENGTH) : snippet
-    });
-  }
-  const truncated = allItems.length > limit;
-  const results = allItems.slice(0, limit);
-  return {
-    ...base,
-    status: "ok",
-    summary: `${allItems.length} matching notes for "${query}"`,
-    results,
-    truncated,
-    totalMatches: allItems.length,
-    diagnostics: []
-  };
-}
-
-// dist/tools/search-vault.js
-var byoao_search_vault = tool({
-  description: "Search an Obsidian vault for notes matching a text query. Uses Obsidian CLI search:context for vault-aware results. Preferred over grep/rg for Obsidian vault knowledge queries about notes, tags, and content.",
-  args: {
-    vaultPath: tool.schema.string().describe("Absolute path to the Obsidian vault"),
-    query: tool.schema.string().describe("Text query to search for in vault notes"),
-    limit: tool.schema.number().optional().describe("Maximum number of results to return (default: 20)")
-  },
-  async execute(args) {
-    const result = await searchVault({
-      vaultPath: args.vaultPath,
-      query: args.query,
-      limit: args.limit
-    });
-    return JSON.stringify(result, null, 2);
-  }
-});
-
-// dist/vault/note-read.js
-async function readNote(input) {
-  const { vaultPath, file: file2 } = input;
-  const mode = "read";
-  const base = {
-    mode,
-    vault: vaultPath,
-    fallback: "none"
-  };
-  if (!isObsidianCliAvailable()) {
-    return {
-      ...base,
-      status: "runtime_unavailable",
-      summary: "Obsidian CLI not available",
-      results: [],
-      truncated: false,
-      diagnostics: ["Obsidian CLI not available"]
-    };
-  }
-  const cliResult = execObsidianCmd(["read", "--vault", vaultPath, file2]);
-  if (!cliResult.success) {
-    return {
-      ...base,
-      status: "runtime_unavailable",
-      summary: `Failed to read note "${file2}"`,
-      results: [],
-      truncated: false,
-      diagnostics: [cliResult.error ?? "Unknown CLI error"]
-    };
-  }
-  const content = cliResult.output.trim();
-  if (content.length === 0) {
-    return {
-      ...base,
-      status: "no_results",
-      summary: `Note "${file2}" is empty or not found`,
-      results: [],
-      truncated: false,
-      diagnostics: []
-    };
-  }
-  const snippet = content.length > MAX_SNIPPET_LENGTH ? content.substring(0, MAX_SNIPPET_LENGTH) : content;
-  return {
-    ...base,
-    status: "ok",
-    summary: `Read note "${file2}" (${content.length} chars)`,
-    results: [
-      {
-        title: file2,
-        path: "",
-        file: file2,
-        snippet
-      }
-    ],
-    truncated: false,
-    diagnostics: []
-  };
-}
-
-// dist/tools/note-read.js
-var byoao_note_read = tool({
-  description: "Read a specific note from an Obsidian vault by name. Uses Obsidian CLI to resolve and read the note. Preferred over cat/Read for Obsidian vault notes.",
-  args: {
-    vaultPath: tool.schema.string().describe("Absolute path to the Obsidian vault"),
-    file: tool.schema.string().describe("Note name to read (without .md extension, e.g. 'Refund Automation')")
-  },
-  async execute(args) {
-    const result = await readNote({
-      vaultPath: args.vaultPath,
-      file: args.file
-    });
-    return JSON.stringify(result, null, 2);
-  }
-});
-
-// dist/vault/graph-health.js
-import path14 from "node:path";
-var ALL_CHECKS = ["orphans", "unresolved", "deadends"];
-function parseCheckOutput(check2, output) {
-  const lines = output.split("\n").filter((l) => l.trim().length > 0);
-  return lines.map((line) => {
-    const trimmed = line.trim();
-    const isPath = trimmed.includes("/") || trimmed.endsWith(".md");
-    const title = isPath ? path14.basename(trimmed, ".md") : trimmed;
-    return {
-      title,
-      path: isPath ? trimmed : "",
-      file: title,
-      metadata: { check: check2 }
-    };
-  });
-}
-async function getGraphHealth(input) {
-  const { vaultPath, check: check2 = "all", limit = DEFAULT_RESULT_LIMIT } = input;
-  const mode = "graph-health";
-  const base = {
-    mode,
-    vault: vaultPath,
-    fallback: "none"
-  };
-  if (!isObsidianCliAvailable()) {
-    return {
-      ...base,
-      status: "runtime_unavailable",
-      summary: "Obsidian CLI not available",
-      results: [],
-      truncated: false,
-      diagnostics: ["Obsidian CLI not available"]
-    };
-  }
-  const checks = check2 === "all" ? ALL_CHECKS : [check2];
-  const allItems = [];
-  const diagnostics = [];
-  for (const checkType of checks) {
-    const cliResult = execObsidianCmd([checkType, "--vault", vaultPath]);
-    if (!cliResult.success) {
-      diagnostics.push(`${checkType} check failed: ${cliResult.error ?? "unknown error"}`);
-      continue;
-    }
-    if (cliResult.output.trim().length > 0) {
-      allItems.push(...parseCheckOutput(checkType, cliResult.output));
-    }
-  }
-  if (allItems.length === 0 && diagnostics.length === 0) {
-    return {
-      ...base,
-      status: "no_results",
-      summary: "No issues found \u2014 vault graph is healthy",
-      results: [],
-      truncated: false,
-      diagnostics
-    };
-  }
-  const truncated = allItems.length > limit;
-  const results = allItems.slice(0, limit);
-  return {
-    ...base,
-    status: allItems.length > 0 ? "ok" : "no_results",
-    summary: `Found ${allItems.length} graph issues across ${checks.join(", ")} checks`,
-    results,
-    truncated,
-    totalMatches: allItems.length,
-    diagnostics
-  };
-}
-
-// dist/tools/graph-health.js
-var byoao_graph_health = tool({
-  description: "Diagnose Obsidian vault graph health \u2014 find orphan notes (no links in or out), unresolved links (broken wikilinks), and dead-end notes. Uses Obsidian CLI for vault-aware analysis.",
-  args: {
-    vaultPath: tool.schema.string().describe("Absolute path to the Obsidian vault"),
-    check: tool.schema.enum(["all", "orphans", "unresolved", "deadends"]).optional().describe("Which check to run: 'all' (default), 'orphans', 'unresolved', or 'deadends'"),
-    limit: tool.schema.number().optional().describe("Maximum number of results to return (default: 20)")
-  },
-  async execute(args) {
-    const result = await getGraphHealth({
-      vaultPath: args.vaultPath,
-      check: args.check,
-      limit: args.limit
-    });
-    return JSON.stringify(result, null, 2);
-  }
-});
-
 // dist/vault/upgrade.js
-import path15 from "node:path";
-var OBSIDIAN_CONFIG_FILES = [
-  "core-plugins.json",
-  "daily-notes.json",
-  "templates.json"
-];
+import path10 from "node:path";
+var OBSIDIAN_CONFIG_FILES = ["core-plugins.json"];
 async function scanInstalledAssets(vaultPath) {
   const skills = await scanSkillDirs(vaultPath);
   const commands = await scanDir(vaultPath, ".opencode/commands", ".md");
   const templates = await scanDir(vaultPath, "Knowledge/templates", ".md");
   const obsidianConfig = [];
   for (const file2 of OBSIDIAN_CONFIG_FILES) {
-    const abs = path15.join(vaultPath, ".obsidian", file2);
+    const abs = path10.join(vaultPath, ".obsidian", file2);
     if (await fs.pathExists(abs)) {
       obsidianConfig.push(`.obsidian/${file2}`);
     }
@@ -29890,21 +29280,21 @@ async function scanInstalledAssets(vaultPath) {
   return { skills, commands, obsidianConfig, templates };
 }
 async function scanDir(vaultPath, relDir, ext) {
-  const absDir = path15.join(vaultPath, relDir);
+  const absDir = path10.join(vaultPath, relDir);
   if (!await fs.pathExists(absDir))
     return [];
   const files = await fs.readdir(absDir);
   return files.filter((f) => f.endsWith(ext)).map((f) => `${relDir}/${f}`);
 }
 async function scanSkillDirs(vaultPath) {
-  const skillsRoot = path15.join(vaultPath, ".opencode", "skills");
+  const skillsRoot = path10.join(vaultPath, ".opencode", "skills");
   if (!await fs.pathExists(skillsRoot))
     return [];
   const results = [];
   const entries = await fs.readdir(skillsRoot, { withFileTypes: true });
   for (const entry of entries) {
     if (entry.isDirectory()) {
-      const skillMd = path15.join(skillsRoot, entry.name, "SKILL.md");
+      const skillMd = path10.join(skillsRoot, entry.name, "SKILL.md");
       if (await fs.pathExists(skillMd)) {
         results.push(`.opencode/skills/${entry.name}/SKILL.md`);
       }
@@ -29912,7 +29302,7 @@ async function scanSkillDirs(vaultPath) {
   }
   return results;
 }
-var DEFAULT_PRESET = "pm-tpm";
+var DEFAULT_PRESET = "minimal";
 async function bootstrapManifest(vaultPath, preset) {
   const installedFiles = await scanInstalledAssets(vaultPath);
   await writeManifest(vaultPath, preset ?? DEFAULT_PRESET, installedFiles, "0.0.0");
@@ -29933,7 +29323,7 @@ function buildUpgradePlan(vaultPath, manifest, packageAssets) {
     const installed = new Set(manifest.infrastructure[key]);
     const shippedPaths = new Set(shipped.map((s) => s.relativePath));
     for (const entry of shipped) {
-      const onDisk = fs.existsSync(path15.join(vaultPath, entry.relativePath));
+      const onDisk = fs.existsSync(path10.join(vaultPath, entry.relativePath));
       items.push({
         file: entry.relativePath,
         action: onDisk ? "update" : "add",
@@ -29956,23 +29346,103 @@ function buildUpgradePlan(vaultPath, manifest, packageAssets) {
     items
   };
 }
+var LLM_WIKI_AGENT_DIRS = ["entities", "concepts", "comparisons", "queries"];
+var LOG_MD_PLACEHOLDER = `# Agent Activity Log
+
+Entries are appended here during /cook operations.
+
+`;
+async function migrateV1ToV2Infrastructure(vaultPath) {
+  for (const dir of LLM_WIKI_AGENT_DIRS) {
+    const dirPath = path10.join(vaultPath, dir);
+    if (!await fs.pathExists(dirPath)) {
+      await fs.ensureDir(dirPath);
+    }
+  }
+  const schemaPath = path10.join(vaultPath, "SCHEMA.md");
+  if (!await fs.pathExists(schemaPath)) {
+    const commonDir = getCommonDir();
+    const schemaTemplatePath = path10.join(commonDir, "SCHEMA.md.hbs");
+    let content;
+    if (await fs.pathExists(schemaTemplatePath)) {
+      const schemaTemplate = await fs.readFile(schemaTemplatePath, "utf-8");
+      content = renderTemplate(schemaTemplate, {
+        KB_NAME: path10.basename(vaultPath),
+        WIKI_DOMAIN: ""
+      });
+    } else {
+      content = `# SCHEMA
+
+This file describes the vault knowledge schema. Update it as your model evolves.
+
+`;
+    }
+    await fs.writeFile(schemaPath, content, "utf-8");
+  }
+  const logPath = path10.join(vaultPath, "log.md");
+  if (!await fs.pathExists(logPath)) {
+    await fs.writeFile(logPath, LOG_MD_PLACEHOLDER, "utf-8");
+  }
+}
+async function collectV1DeprecatedInfrastructureItems(vaultPath) {
+  const items = [];
+  const templatesDir = path10.join(vaultPath, "Knowledge", "templates");
+  if (await fs.pathExists(templatesDir)) {
+    const files = await fs.readdir(templatesDir);
+    for (const f of files) {
+      if (f.endsWith(".md")) {
+        items.push({
+          file: `Knowledge/templates/${f}`,
+          action: "deprecated",
+          category: "templates"
+        });
+      }
+    }
+  }
+  for (const cmd of ["weave.md", "emerge.md"]) {
+    const rel = `.opencode/commands/${cmd}`;
+    if (await fs.pathExists(path10.join(vaultPath, rel))) {
+      items.push({
+        file: rel,
+        action: "deprecated",
+        category: "commands"
+      });
+    }
+  }
+  return items;
+}
+function mergeForcedDeprecatedIntoPlan(items, forced) {
+  const forcedFiles = new Set(forced.map((i) => i.file));
+  const filtered = items.filter((i) => !(forcedFiles.has(i.file) && (i.action === "add" || i.action === "update")));
+  const byFile = new Map(filtered.map((i) => [i.file, i]));
+  for (const f of forced) {
+    byFile.set(f.file, f);
+  }
+  return [...byFile.values()];
+}
 function resolveAssetsDir2() {
-  const srcAssets = path15.resolve(import.meta.dirname, "..", "assets");
-  const distAssets = path15.resolve(import.meta.dirname, "..", "..", "src", "assets");
-  if (fs.existsSync(srcAssets))
-    return srcAssets;
+  const distAssets = path10.resolve(import.meta.dirname, "assets");
+  const srcAssets = path10.resolve(import.meta.dirname, "..", "assets");
+  const devAssets = path10.resolve(import.meta.dirname, "..", "..", "src", "assets");
   if (fs.existsSync(distAssets))
     return distAssets;
-  return srcAssets;
+  if (fs.existsSync(srcAssets))
+    return srcAssets;
+  if (fs.existsSync(devAssets))
+    return devAssets;
+  return distAssets;
 }
 function resolveSkillsDir() {
-  const srcSkills = path15.resolve(import.meta.dirname, "..", "skills");
-  const distSkills = path15.resolve(import.meta.dirname, "..", "..", "src", "skills");
-  if (fs.existsSync(srcSkills))
-    return srcSkills;
+  const distSkills = path10.resolve(import.meta.dirname, "assets", "skills");
+  const srcSkills = path10.resolve(import.meta.dirname, "..", "skills");
+  const devSkills = path10.resolve(import.meta.dirname, "..", "..", "src", "skills");
   if (fs.existsSync(distSkills))
     return distSkills;
-  return srcSkills;
+  if (fs.existsSync(srcSkills))
+    return srcSkills;
+  if (fs.existsSync(devSkills))
+    return devSkills;
+  return distSkills;
 }
 function resolvePackageAssets(preset) {
   const assetsDir = resolveAssetsDir2();
@@ -29982,14 +29452,14 @@ function resolvePackageAssets(preset) {
   const commands = [];
   const obsidianConfig = [];
   const templates = [];
-  const obsidianSkillsDir = path15.join(assetsDir, "obsidian-skills");
+  const obsidianSkillsDir = path10.join(assetsDir, "obsidian-skills");
   if (fs.existsSync(obsidianSkillsDir)) {
     for (const file2 of fs.readdirSync(obsidianSkillsDir)) {
       if (file2.endsWith(".md")) {
         const skillName = file2.replace(/\.md$/, "");
         skills.push({
           relativePath: `.opencode/skills/${skillName}/SKILL.md`,
-          sourcePath: path15.join(obsidianSkillsDir, file2)
+          sourcePath: path10.join(obsidianSkillsDir, file2)
         });
       }
     }
@@ -29999,15 +29469,15 @@ function resolvePackageAssets(preset) {
       if (file2.endsWith(".md")) {
         commands.push({
           relativePath: `.opencode/commands/${file2}`,
-          sourcePath: path15.join(skillsDir, file2)
+          sourcePath: path10.join(skillsDir, file2)
         });
       }
     }
   }
-  const obsidianSrcDir = path15.join(commonDir, "obsidian");
+  const obsidianSrcDir = path10.join(commonDir, "obsidian");
   if (fs.existsSync(obsidianSrcDir)) {
     for (const file2 of OBSIDIAN_CONFIG_FILES) {
-      const srcPath = path15.join(obsidianSrcDir, file2);
+      const srcPath = path10.join(obsidianSrcDir, file2);
       if (fs.existsSync(srcPath)) {
         obsidianConfig.push({
           relativePath: `.obsidian/${file2}`,
@@ -30016,26 +29486,26 @@ function resolvePackageAssets(preset) {
       }
     }
   }
-  const commonTemplatesDir = path15.join(commonDir, "templates");
+  const commonTemplatesDir = path10.join(commonDir, "templates");
   if (fs.existsSync(commonTemplatesDir)) {
     for (const file2 of fs.readdirSync(commonTemplatesDir)) {
       if (file2.endsWith(".md")) {
         templates.push({
           relativePath: `Knowledge/templates/${file2}`,
-          sourcePath: path15.join(commonTemplatesDir, file2)
+          sourcePath: path10.join(commonTemplatesDir, file2)
         });
       }
     }
   }
   try {
     const { presetsDir } = loadPreset(preset);
-    const presetTemplatesDir = path15.join(presetsDir, preset, "templates");
+    const presetTemplatesDir = path10.join(presetsDir, preset, "templates");
     if (fs.existsSync(presetTemplatesDir)) {
       for (const file2 of fs.readdirSync(presetTemplatesDir)) {
         if (file2.endsWith(".md")) {
           templates.push({
             relativePath: `Knowledge/templates/${file2}`,
-            sourcePath: path15.join(presetTemplatesDir, file2)
+            sourcePath: path10.join(presetTemplatesDir, file2)
           });
         }
       }
@@ -30048,7 +29518,7 @@ async function upgradeVault(vaultPath, options2) {
   const { preset, dryRun = false, force = false } = options2 ?? {};
   const detectedPath = detectVaultContext(vaultPath);
   if (!detectedPath) {
-    throw new Error(`No BYOAO vault detected at "${vaultPath}". Expected .obsidian/ and AGENTS.md or Knowledge/Glossary.md.`);
+    throw new Error(`No BYOAO vault detected at "${vaultPath}". Expected .obsidian/ and AGENTS.md.`);
   }
   let manifest = await readManifest(vaultPath);
   if (!manifest) {
@@ -30067,14 +29537,21 @@ async function upgradeVault(vaultPath, options2) {
       dryRun
     };
   }
-  const legacyAgentMd = path15.join(vaultPath, "AGENT.md");
-  const newAgentsMd = path15.join(vaultPath, "AGENTS.md");
+  const legacyAgentMd = path10.join(vaultPath, "AGENT.md");
+  const newAgentsMd = path10.join(vaultPath, "AGENTS.md");
   if (!dryRun && await fs.pathExists(legacyAgentMd) && !await fs.pathExists(newAgentsMd)) {
     await fs.rename(legacyAgentMd, newAgentsMd);
   }
+  if (!dryRun) {
+    await migrateV1ToV2Infrastructure(vaultPath);
+  }
   const effectivePreset = preset ?? manifest.preset;
   const packageAssets = resolvePackageAssets(effectivePreset);
-  const plan = buildUpgradePlan(vaultPath, manifest, packageAssets);
+  let plan = buildUpgradePlan(vaultPath, manifest, packageAssets);
+  plan = {
+    ...plan,
+    items: mergeForcedDeprecatedIntoPlan(plan.items, await collectV1DeprecatedInfrastructureItems(vaultPath))
+  };
   const added = [];
   const updated = [];
   const deprecated = [];
@@ -30091,8 +29568,8 @@ async function upgradeVault(vaultPath, options2) {
         if (item.action === "add" || item.action === "update") {
           const source = sourceMap.get(item.file);
           if (source) {
-            const dest = path15.join(vaultPath, item.file);
-            await fs.ensureDir(path15.dirname(dest));
+            const dest = path10.join(vaultPath, item.file);
+            await fs.ensureDir(path10.dirname(dest));
             await fs.copy(source, dest, { overwrite: true });
             if (item.action === "add") {
               added.push(item.file);
@@ -30187,17 +29664,17 @@ var byoao_vault_upgrade = tool({
 });
 
 // dist/tools/mcp-auth.js
-import { spawn, execSync as execSync4 } from "node:child_process";
-import path16 from "node:path";
+import { spawn, execSync as execSync3 } from "node:child_process";
+import path11 from "node:path";
 import os4 from "node:os";
 function findOpencodeBinary() {
   const candidates = [
-    path16.join(os4.homedir(), ".opencode/bin/opencode"),
+    path11.join(os4.homedir(), ".opencode/bin/opencode"),
     "/usr/local/bin/opencode"
   ];
   for (const p of candidates) {
     try {
-      execSync4(`test -x "${p}"`, { stdio: "pipe" });
+      execSync3(`test -x "${p}"`, { stdio: "pipe" });
       return p;
     } catch {
     }
@@ -30295,10 +29772,13 @@ The user may need to:
   }
 });
 
+// dist/hooks/system-transform.js
+import path12 from "node:path";
+
 // dist/lib/logger.js
 import { join } from "node:path";
 import { homedir } from "node:os";
-import { appendFile, stat, rename as rename3, mkdir as mkdir2, readFile as readFile2, unlink } from "node:fs/promises";
+import { appendFile, stat as stat2, rename as rename3, mkdir as mkdir2, readFile as readFile2, unlink } from "node:fs/promises";
 var LOG_DIR = process.env.BYOAO_LOG_DIR || join(homedir(), ".byoao", "logs");
 var LOG_FILE = join(LOG_DIR, "error.log");
 var MAX_LOG_SIZE = 512 * 1024;
@@ -30341,7 +29821,7 @@ async function ensureLogDir() {
 }
 async function rotateIfNeeded() {
   try {
-    const s = await stat(LOG_FILE);
+    const s = await stat2(LOG_FILE);
     if (s.size >= MAX_LOG_SIZE) {
       await rename3(LOG_FILE, ROTATED_FILE);
     }
@@ -30372,6 +29852,20 @@ async function log(level, source, message, options2) {
 }
 
 // dist/hooks/system-transform.js
+function readVaultMarkdown(vaultPath, fileName) {
+  const full = path12.join(vaultPath, fileName);
+  if (!fs.existsSync(full))
+    return null;
+  try {
+    return fs.readFileSync(full, "utf-8");
+  } catch {
+    void log("warn", "hook:system-transform", `Failed to read ${fileName}`, {
+      context: { path: full }
+    }).catch(() => {
+    });
+    return null;
+  }
+}
 async function buildMcpAuthGuidance() {
   try {
     const config2 = await readOpencodeConfig();
@@ -30409,6 +29903,31 @@ async function buildMcpAuthGuidance() {
   }
 }
 async function systemTransformHook(_input, output) {
+  const vaultPath = detectVaultContext(process.cwd());
+  if (vaultPath) {
+    let agentsTitle = "## AGENTS.md";
+    let agents = readVaultMarkdown(vaultPath, "AGENTS.md");
+    if (!agents) {
+      agents = readVaultMarkdown(vaultPath, "AGENT.md");
+      if (agents)
+        agentsTitle = "## AGENT.md";
+    }
+    if (agents) {
+      output.system.push(`
+---
+${agentsTitle}
+
+${agents}`);
+    }
+    const schema = readVaultMarkdown(vaultPath, "SCHEMA.md");
+    if (schema) {
+      output.system.push(`
+---
+## SCHEMA.md
+
+${schema}`);
+    }
+  }
   const mcpGuidance = await buildMcpAuthGuidance();
   if (mcpGuidance) {
     output.system.push(mcpGuidance);
@@ -30418,15 +29937,15 @@ async function systemTransformHook(_input, output) {
 // dist/hooks/idle-suggestions.js
 function getIdleSuggestion() {
   const suggestions = [
-    "Tip: run /weave to connect your notes with frontmatter and wikilinks",
+    "Tip: run /cook to compile your notes into structured knowledge pages",
+    "Tip: run /health to check knowledge page health",
+    "Tip: run /wiki to regenerate INDEX.base",
     "Tip: run /trace to see how an idea evolved over time",
-    "Tip: run /emerge to discover patterns across your notes",
     "Tip: run /connect to bridge two topics using your vault's link graph",
     "Tip: run /ideas to generate actionable insights from your vault",
     "Tip: run /challenge to pressure-test a belief against your own notes",
     "Tip: run /drift to compare intentions vs actions over the past month",
-    "Tip: run /diagnose to check knowledge graph health",
-    "Tip: run /explain to document a codebase system in your vault"
+    "Tip: run /diagnose to check overall vault health"
   ];
   const idx = (/* @__PURE__ */ new Date()).getMinutes() % suggestions.length;
   return suggestions[idx];
@@ -30437,15 +29956,9 @@ var BYOAOPlugin = async (ctx) => {
   const { client } = ctx;
   const tools = {
     byoao_init_vault,
-    byoao_add_person,
-    byoao_add_project,
-    byoao_add_glossary_term,
     byoao_vault_status,
     byoao_vault_doctor,
     byoao_switch_provider,
-    byoao_search_vault,
-    byoao_note_read,
-    byoao_graph_health,
     byoao_vault_upgrade,
     byoao_mcp_auth
   };