newtype-profile 1.0.63 → 1.0.64

package/dist/cli/index.js

@@ -2253,7 +2253,7 @@ var require_picocolors = __commonJS((exports, module) => {
 var require_package = __commonJS((exports, module) => {
   module.exports = {
     name: "newtype-profile",
-    version: "1.0.63",
+    version: "1.0.64",
     description: "AI Agent Collaboration System for Content Creation - Based on oh-my-opencode",
     main: "dist/index.js",
     types: "dist/index.d.ts",

package/dist/index.js

@@ -1980,11 +1980,11 @@ var require_codegen = __commonJS((exports) => {
       const rhs = this.rhs === undefined ? "" : ` = ${this.rhs}`;
       return `${varKind} ${this.name}${rhs};` + _n;
     }
-    optimizeNames(names, constants15) {
+    optimizeNames(names, constants16) {
       if (!names[this.name.str])
         return;
       if (this.rhs)
-        this.rhs = optimizeExpr(this.rhs, names, constants15);
+        this.rhs = optimizeExpr(this.rhs, names, constants16);
       return this;
     }
     get names() {
@@ -2002,10 +2002,10 @@ var require_codegen = __commonJS((exports) => {
     render({ _n }) {
       return `${this.lhs} = ${this.rhs};` + _n;
     }
-    optimizeNames(names, constants15) {
+    optimizeNames(names, constants16) {
       if (this.lhs instanceof code_1.Name && !names[this.lhs.str] && !this.sideEffects)
         return;
-      this.rhs = optimizeExpr(this.rhs, names, constants15);
+      this.rhs = optimizeExpr(this.rhs, names, constants16);
       return this;
     }
     get names() {
@@ -2071,8 +2071,8 @@ var require_codegen = __commonJS((exports) => {
     optimizeNodes() {
       return `${this.code}` ? this : undefined;
     }
-    optimizeNames(names, constants15) {
-      this.code = optimizeExpr(this.code, names, constants15);
+    optimizeNames(names, constants16) {
+      this.code = optimizeExpr(this.code, names, constants16);
       return this;
     }
     get names() {
@@ -2102,12 +2102,12 @@ var require_codegen = __commonJS((exports) => {
       }
       return nodes.length > 0 ? this : undefined;
     }
-    optimizeNames(names, constants15) {
+    optimizeNames(names, constants16) {
       const { nodes } = this;
       let i2 = nodes.length;
       while (i2--) {
         const n = nodes[i2];
-        if (n.optimizeNames(names, constants15))
+        if (n.optimizeNames(names, constants16))
           continue;
         subtractNames(names, n.names);
         nodes.splice(i2, 1);
@@ -2164,12 +2164,12 @@ var require_codegen = __commonJS((exports) => {
         return;
       return this;
     }
-    optimizeNames(names, constants15) {
+    optimizeNames(names, constants16) {
       var _a;
-      this.else = (_a = this.else) === null || _a === undefined ? undefined : _a.optimizeNames(names, constants15);
-      if (!(super.optimizeNames(names, constants15) || this.else))
+      this.else = (_a = this.else) === null || _a === undefined ? undefined : _a.optimizeNames(names, constants16);
+      if (!(super.optimizeNames(names, constants16) || this.else))
         return;
-      this.condition = optimizeExpr(this.condition, names, constants15);
+      this.condition = optimizeExpr(this.condition, names, constants16);
       return this;
     }
     get names() {
@@ -2194,10 +2194,10 @@ var require_codegen = __commonJS((exports) => {
     render(opts) {
       return `for(${this.iteration})` + super.render(opts);
     }
-    optimizeNames(names, constants15) {
-      if (!super.optimizeNames(names, constants15))
+    optimizeNames(names, constants16) {
+      if (!super.optimizeNames(names, constants16))
         return;
-      this.iteration = optimizeExpr(this.iteration, names, constants15);
+      this.iteration = optimizeExpr(this.iteration, names, constants16);
       return this;
     }
     get names() {
@@ -2235,10 +2235,10 @@ var require_codegen = __commonJS((exports) => {
     render(opts) {
       return `for(${this.varKind} ${this.name} ${this.loop} ${this.iterable})` + super.render(opts);
     }
-    optimizeNames(names, constants15) {
-      if (!super.optimizeNames(names, constants15))
+    optimizeNames(names, constants16) {
+      if (!super.optimizeNames(names, constants16))
         return;
-      this.iterable = optimizeExpr(this.iterable, names, constants15);
+      this.iterable = optimizeExpr(this.iterable, names, constants16);
       return this;
     }
     get names() {
@@ -2283,11 +2283,11 @@ var require_codegen = __commonJS((exports) => {
       (_b = this.finally) === null || _b === undefined || _b.optimizeNodes();
       return this;
     }
-    optimizeNames(names, constants15) {
+    optimizeNames(names, constants16) {
       var _a, _b;
-      super.optimizeNames(names, constants15);
-      (_a = this.catch) === null || _a === undefined || _a.optimizeNames(names, constants15);
-      (_b = this.finally) === null || _b === undefined || _b.optimizeNames(names, constants15);
+      super.optimizeNames(names, constants16);
+      (_a = this.catch) === null || _a === undefined || _a.optimizeNames(names, constants16);
+      (_b = this.finally) === null || _b === undefined || _b.optimizeNames(names, constants16);
       return this;
     }
     get names() {
@@ -2561,7 +2561,7 @@ var require_codegen = __commonJS((exports) => {
   function addExprNames(names, from) {
     return from instanceof code_1._CodeOrName ? addNames(names, from.names) : names;
   }
-  function optimizeExpr(expr, names, constants15) {
+  function optimizeExpr(expr, names, constants16) {
     if (expr instanceof code_1.Name)
       return replaceName(expr);
     if (!canOptimize(expr))
@@ -2576,14 +2576,14 @@ var require_codegen = __commonJS((exports) => {
       return items;
     }, []));
     function replaceName(n) {
-      const c = constants15[n.str];
+      const c = constants16[n.str];
       if (c === undefined || names[n.str] !== 1)
         return n;
       delete names[n.str];
       return c;
     }
     function canOptimize(e2) {
-      return e2 instanceof code_1._Code && e2._items.some((c) => c instanceof code_1.Name && names[c.str] === 1 && constants15[c.str] !== undefined);
+      return e2 instanceof code_1._Code && e2._items.some((c) => c instanceof code_1.Name && names[c.str] === 1 && constants16[c.str] !== undefined);
     }
   }
   function subtractNames(names, from) {
@@ -3030,37 +3030,37 @@ var require_dataType = __commonJS((exports) => {
     DataType2[DataType2["Wrong"] = 1] = "Wrong";
   })(DataType || (exports.DataType = DataType = {}));
   function getSchemaTypes(schema2) {
-    const types19 = getJSONTypes(schema2.type);
-    const hasNull = types19.includes("null");
+    const types20 = getJSONTypes(schema2.type);
+    const hasNull = types20.includes("null");
     if (hasNull) {
       if (schema2.nullable === false)
         throw new Error("type: null contradicts nullable: false");
     } else {
-      if (!types19.length && schema2.nullable !== undefined) {
+      if (!types20.length && schema2.nullable !== undefined) {
         throw new Error('"nullable" cannot be used without "type"');
       }
       if (schema2.nullable === true)
-        types19.push("null");
+        types20.push("null");
     }
-    return types19;
+    return types20;
   }
   exports.getSchemaTypes = getSchemaTypes;
   function getJSONTypes(ts) {
-    const types19 = Array.isArray(ts) ? ts : ts ? [ts] : [];
-    if (types19.every(rules_1.isJSONType))
-      return types19;
-    throw new Error("type must be JSONType or JSONType[]: " + types19.join(","));
+    const types20 = Array.isArray(ts) ? ts : ts ? [ts] : [];
+    if (types20.every(rules_1.isJSONType))
+      return types20;
+    throw new Error("type must be JSONType or JSONType[]: " + types20.join(","));
   }
   exports.getJSONTypes = getJSONTypes;
-  function coerceAndCheckDataType(it, types19) {
+  function coerceAndCheckDataType(it, types20) {
     const { gen, data, opts } = it;
-    const coerceTo = coerceToTypes(types19, opts.coerceTypes);
-    const checkTypes = types19.length > 0 && !(coerceTo.length === 0 && types19.length === 1 && (0, applicability_1.schemaHasRulesForType)(it, types19[0]));
+    const coerceTo = coerceToTypes(types20, opts.coerceTypes);
+    const checkTypes = types20.length > 0 && !(coerceTo.length === 0 && types20.length === 1 && (0, applicability_1.schemaHasRulesForType)(it, types20[0]));
     if (checkTypes) {
-      const wrongType = checkDataTypes(types19, data, opts.strictNumbers, DataType.Wrong);
+      const wrongType = checkDataTypes(types20, data, opts.strictNumbers, DataType.Wrong);
       gen.if(wrongType, () => {
         if (coerceTo.length)
-          coerceData(it, types19, coerceTo);
+          coerceData(it, types20, coerceTo);
         else
           reportTypeError(it);
       });
@@ -3069,15 +3069,15 @@ var require_dataType = __commonJS((exports) => {
   }
   exports.coerceAndCheckDataType = coerceAndCheckDataType;
   var COERCIBLE = new Set(["string", "number", "integer", "boolean", "null"]);
-  function coerceToTypes(types19, coerceTypes) {
-    return coerceTypes ? types19.filter((t) => COERCIBLE.has(t) || coerceTypes === "array" && t === "array") : [];
+  function coerceToTypes(types20, coerceTypes) {
+    return coerceTypes ? types20.filter((t) => COERCIBLE.has(t) || coerceTypes === "array" && t === "array") : [];
   }
-  function coerceData(it, types19, coerceTo) {
+  function coerceData(it, types20, coerceTo) {
     const { gen, data, opts } = it;
     const dataType = gen.let("dataType", (0, codegen_1._)`typeof ${data}`);
     const coerced = gen.let("coerced", (0, codegen_1._)`undefined`);
     if (opts.coerceTypes === "array") {
-      gen.if((0, codegen_1._)`${dataType} == 'object' && Array.isArray(${data}) && ${data}.length == 1`, () => gen.assign(data, (0, codegen_1._)`${data}[0]`).assign(dataType, (0, codegen_1._)`typeof ${data}`).if(checkDataTypes(types19, data, opts.strictNumbers), () => gen.assign(coerced, data)));
+      gen.if((0, codegen_1._)`${dataType} == 'object' && Array.isArray(${data}) && ${data}.length == 1`, () => gen.assign(data, (0, codegen_1._)`${data}[0]`).assign(dataType, (0, codegen_1._)`typeof ${data}`).if(checkDataTypes(types20, data, opts.strictNumbers), () => gen.assign(coerced, data)));
     }
     gen.if((0, codegen_1._)`${coerced} !== undefined`);
     for (const t of coerceTo) {
@@ -3153,19 +3153,19 @@ var require_dataType = __commonJS((exports) => {
       return checkDataType(dataTypes[0], data, strictNums, correct);
     }
     let cond;
-    const types19 = (0, util_1.toHash)(dataTypes);
-    if (types19.array && types19.object) {
+    const types20 = (0, util_1.toHash)(dataTypes);
+    if (types20.array && types20.object) {
       const notObj = (0, codegen_1._)`typeof ${data} != "object"`;
-      cond = types19.null ? notObj : (0, codegen_1._)`!${data} || ${notObj}`;
-      delete types19.null;
-      delete types19.array;
-      delete types19.object;
+      cond = types20.null ? notObj : (0, codegen_1._)`!${data} || ${notObj}`;
+      delete types20.null;
+      delete types20.array;
+      delete types20.object;
     } else {
       cond = codegen_1.nil;
     }
-    if (types19.number)
-      delete types19.integer;
-    for (const t in types19)
+    if (types20.number)
+      delete types20.integer;
+    for (const t in types20)
       cond = (0, codegen_1.and)(cond, checkDataType(t, data, strictNums, correct));
     return cond;
   }
@@ -3953,9 +3953,9 @@ var require_validate = __commonJS((exports) => {
   function typeAndKeywords(it, errsCount) {
     if (it.opts.jtd)
       return schemaKeywords(it, [], false, errsCount);
-    const types19 = (0, dataType_1.getSchemaTypes)(it.schema);
-    const checkedTypes = (0, dataType_1.coerceAndCheckDataType)(it, types19);
-    schemaKeywords(it, types19, !checkedTypes, errsCount);
+    const types20 = (0, dataType_1.getSchemaTypes)(it.schema);
+    const checkedTypes = (0, dataType_1.coerceAndCheckDataType)(it, types20);
+    schemaKeywords(it, types20, !checkedTypes, errsCount);
   }
   function checkRefsAndKeywords(it) {
     const { schema: schema2, errSchemaPath, opts, self } = it;
@@ -4005,7 +4005,7 @@ var require_validate = __commonJS((exports) => {
     if (items instanceof codegen_1.Name)
       gen.assign((0, codegen_1._)`${evaluated}.items`, items);
   }
-  function schemaKeywords(it, types19, typeErrors, errsCount) {
+  function schemaKeywords(it, types20, typeErrors, errsCount) {
     const { gen, schema: schema2, data, allErrors, opts, self } = it;
     const { RULES } = self;
     if (schema2.$ref && (opts.ignoreKeywordsWithRef || !(0, util_1.schemaHasRulesButRef)(schema2, RULES))) {
@@ -4013,7 +4013,7 @@ var require_validate = __commonJS((exports) => {
       return;
     }
     if (!opts.jtd)
-      checkStrictTypes(it, types19);
+      checkStrictTypes(it, types20);
     gen.block(() => {
       for (const group of RULES.rules)
         groupKeywords(group);
@@ -4025,7 +4025,7 @@ var require_validate = __commonJS((exports) => {
       if (group.type) {
         gen.if((0, dataType_2.checkDataType)(group.type, data, opts.strictNumbers));
         iterateKeywords(it, group);
-        if (types19.length === 1 && types19[0] === group.type && typeErrors) {
+        if (types20.length === 1 && types20[0] === group.type && typeErrors) {
           gen.else();
           (0, dataType_2.reportTypeError)(it);
         }
@@ -4049,27 +4049,27 @@ var require_validate = __commonJS((exports) => {
       }
     });
   }
-  function checkStrictTypes(it, types19) {
+  function checkStrictTypes(it, types20) {
     if (it.schemaEnv.meta || !it.opts.strictTypes)
       return;
-    checkContextTypes(it, types19);
+    checkContextTypes(it, types20);
     if (!it.opts.allowUnionTypes)
-      checkMultipleTypes(it, types19);
+      checkMultipleTypes(it, types20);
     checkKeywordTypes(it, it.dataTypes);
   }
-  function checkContextTypes(it, types19) {
-    if (!types19.length)
+  function checkContextTypes(it, types20) {
+    if (!types20.length)
       return;
     if (!it.dataTypes.length) {
-      it.dataTypes = types19;
+      it.dataTypes = types20;
       return;
     }
-    types19.forEach((t) => {
+    types20.forEach((t) => {
       if (!includesType(it.dataTypes, t)) {
         strictTypesError(it, `type "${t}" not allowed by context "${it.dataTypes.join(",")}"`);
       }
     });
-    narrowSchemaTypes(it, types19);
+    narrowSchemaTypes(it, types20);
   }
   function checkMultipleTypes(it, ts) {
     if (ts.length > 1 && !(ts.length === 2 && ts.includes("null"))) {
@@ -45321,6 +45321,277 @@ var session_info = tool({
     }
   }
 });
+// src/tools/knowledge-base/constants.ts
+var TOOL_DESCRIPTION = `Progressive disclosure tool for accessing memory and knowledge.
+
+Three actions, from lightweight to detailed:
+
+1. list \u2014 Browse all memory entries (dates, tags, summary headlines)
+   knowledge_base({ action: "list" })
+
+2. search \u2014 Find relevant memories with matching snippets  
+   knowledge_base({ action: "search", query: "API design discussion" })
+
+3. get \u2014 Retrieve full content of a specific memory entry
+   knowledge_base({ action: "get", id: "2026-02-20/ses_abc123" })
+
+Sources: "memory" (default, conversation memories), "archive" (long-term MEMORY.md), "knowledge" (KNOWLEDGE.md)
+Only "memory" source is currently supported.`;
+
+// src/tools/knowledge-base/memory-source.ts
+import { existsSync as existsSync51, readdirSync as readdirSync19, readFileSync as readFileSync32 } from "fs";
+import { join as join59 } from "path";
+
+// src/tools/knowledge-base/utils.ts
+function formatMemoryList(entries) {
+  if (entries.length === 0) {
+    return "No memory entries found.";
+  }
+  const lines = [
+    "| Date | Session | Tags | Decisions | Summary |",
+    "|------|---------|------|-----------|---------|"
+  ];
+  for (const entry of entries) {
+    const sessionDisplay = entry.sessionID ? entry.sessionID.slice(0, 12) : "-";
+    const tagsDisplay = entry.tags.length > 0 ? entry.tags.join(", ") : "-";
+    const summaryDisplay = entry.summaryLine.length > 50 ? entry.summaryLine.slice(0, 50) + "..." : entry.summaryLine;
+    lines.push(`| ${entry.date} | ${sessionDisplay} | ${tagsDisplay} | ${entry.decisionsCount} | ${summaryDisplay} |`);
+  }
+  return lines.join(`
+`);
+}
+function formatMemorySearchResults(results, query) {
+  if (results.length === 0) {
+    return `No matches found for "${query}".`;
+  }
+  const lines = [`Found ${results.length} match(es) for "${query}":
+`];
+  for (let i2 = 0;i2 < results.length; i2++) {
+    const result = results[i2];
+    const sessionDisplay = result.sessionID ? ` (${result.sessionID.slice(0, 12)})` : "";
+    const tagsDisplay = result.tags.length > 0 ? ` [${result.tags.join(", ")}]` : "";
+    lines.push(`${i2 + 1}. **${result.date}${sessionDisplay}**${tagsDisplay}`);
+    lines.push(`   ${result.snippet}`);
+    if (result.matchCount > 1) {
+      lines.push(`   _(${result.matchCount} matches in this entry)_`);
+    }
+    lines.push("");
+  }
+  return lines.join(`
+`);
+}
+function extractSnippet(text, query, contextChars = 80) {
+  const lowerText = text.toLowerCase();
+  const lowerQuery = query.toLowerCase();
+  const matchIndex = lowerText.indexOf(lowerQuery);
+  if (matchIndex === -1) {
+    return text.slice(0, contextChars * 2) + (text.length > contextChars * 2 ? "..." : "");
+  }
+  const start = Math.max(0, matchIndex - contextChars);
+  const end = Math.min(text.length, matchIndex + query.length + contextChars);
+  let snippet2 = text.slice(start, end);
+  if (start > 0) {
+    snippet2 = "..." + snippet2;
+  }
+  if (end < text.length) {
+    snippet2 = snippet2 + "...";
+  }
+  return snippet2.replace(/\n+/g, " ").trim();
+}
+function extractSummaryLine(rawBlock) {
+  const lines = rawBlock.split(`
+`);
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed)
+      continue;
+    if (trimmed.startsWith("#"))
+      continue;
+    if (trimmed.startsWith("SessionID:"))
+      continue;
+    if (trimmed.startsWith("Full transcript:"))
+      continue;
+    if (trimmed.startsWith("**") && trimmed.endsWith(":**"))
+      continue;
+    return trimmed;
+  }
+  return "";
+}
+
+// src/tools/knowledge-base/memory-source.ts
+function listMemoryEntries(projectDir, limit) {
+  const memoryDir = join59(projectDir, MEMORY_DIR);
+  if (!existsSync51(memoryDir)) {
+    return "No memory entries found.";
+  }
+  const files = readdirSync19(memoryDir).filter((f) => f.endsWith(".md") && f !== "full").sort().reverse();
+  const entries = [];
+  const effectiveLimit = limit ?? 20;
+  for (const file2 of files) {
+    if (entries.length >= effectiveLimit)
+      break;
+    const filePath = join59(memoryDir, file2);
+    const dateMatch = file2.match(/^(\d{4}-\d{2}-\d{2})\.md$/);
+    if (!dateMatch)
+      continue;
+    const date5 = dateMatch[1];
+    try {
+      const content = readFileSync32(filePath, "utf-8");
+      const sessions = parseDailyLogSessions(content);
+      for (const session of sessions) {
+        if (entries.length >= effectiveLimit)
+          break;
+        entries.push({
+          date: date5,
+          sessionID: session.sessionID,
+          tags: session.tags,
+          decisionsCount: session.decisions.length,
+          todosCount: session.todos.length,
+          summaryLine: extractSummaryLine(session.raw)
+        });
+      }
+    } catch {
+      continue;
+    }
+  }
+  return formatMemoryList(entries);
+}
+function searchMemoryEntries(projectDir, query, limit) {
+  const memoryDir = join59(projectDir, MEMORY_DIR);
+  if (!existsSync51(memoryDir)) {
+    return `No matches found for "${query}".`;
+  }
+  const files = readdirSync19(memoryDir).filter((f) => f.endsWith(".md") && f !== "full").sort().reverse();
+  const results = [];
+  const effectiveLimit = limit ?? 10;
+  const lowerQuery = query.toLowerCase();
+  for (const file2 of files) {
+    if (results.length >= effectiveLimit)
+      break;
+    const filePath = join59(memoryDir, file2);
+    const dateMatch = file2.match(/^(\d{4}-\d{2}-\d{2})\.md$/);
+    if (!dateMatch)
+      continue;
+    const date5 = dateMatch[1];
+    try {
+      const content = readFileSync32(filePath, "utf-8");
+      const sessions = parseDailyLogSessions(content);
+      for (const session of sessions) {
+        if (results.length >= effectiveLimit)
+          break;
+        const lowerRaw = session.raw.toLowerCase();
+        if (!lowerRaw.includes(lowerQuery))
+          continue;
+        const matches = lowerRaw.split(lowerQuery).length - 1;
+        results.push({
+          date: date5,
+          sessionID: session.sessionID,
+          tags: session.tags,
+          snippet: extractSnippet(session.raw, query),
+          matchCount: matches
+        });
+      }
+    } catch {
+      continue;
+    }
+  }
+  return formatMemorySearchResults(results, query);
+}
+function getMemoryEntry(projectDir, id, includeFull) {
+  const parts = id.split("/");
+  const date5 = parts[0];
+  const sessionID = parts[1];
+  const dateMatch = date5.match(/^\d{4}-\d{2}-\d{2}$/);
+  if (!dateMatch) {
+    return `Invalid id format: ${id}. Expected YYYY-MM-DD or YYYY-MM-DD/sessionID`;
+  }
+  const memoryDir = join59(projectDir, MEMORY_DIR);
+  const filePath = join59(memoryDir, `${date5}.md`);
+  if (!existsSync51(filePath)) {
+    return `Memory entry not found: ${id}`;
+  }
+  try {
+    const content = readFileSync32(filePath, "utf-8");
+    const sessions = parseDailyLogSessions(content);
+    if (!sessionID) {
+      const output2 = sessions.map((s) => s.raw).join(`
+
+---
+
+`);
+      return output2 || `Memory entry not found: ${id}`;
+    }
+    const session = sessions.find((s) => s.sessionID === sessionID || s.sessionID?.startsWith(sessionID));
+    if (!session) {
+      return `Memory entry not found: ${id}`;
+    }
+    let output = session.raw;
+    if (includeFull && session.sessionID) {
+      const fullPath = getFullTranscriptPath(projectDir, session.sessionID);
+      if (existsSync51(fullPath)) {
+        try {
+          const fullContent = readFileSync32(fullPath, "utf-8");
+          output += `
+
+---
+
+## Full Transcript
+
+` + fullContent;
+        } catch {
+          output += `
+
+_(Full transcript could not be read)_`;
+        }
+      } else {
+        output += `
+
+_(Full transcript not available)_`;
+      }
+    }
+    return output;
+  } catch (error45) {
+    return `Error reading memory entry: ${error45 instanceof Error ? error45.message : String(error45)}`;
+  }
+}
+
+// src/tools/knowledge-base/tools.ts
+var knowledge_base = tool({
+  description: TOOL_DESCRIPTION,
+  args: {
+    action: tool.schema.enum(["list", "search", "get"]).describe("Action: list (browse), search (find), get (retrieve full)"),
+    source: tool.schema.enum(["memory", "archive", "knowledge"]).optional().describe("Data source (default: memory)"),
+    query: tool.schema.string().optional().describe("Search query (required for search action)"),
+    id: tool.schema.string().optional().describe("Entry ID in format YYYY-MM-DD/sessionID (required for get action)"),
+    limit: tool.schema.number().optional().describe("Max results to return (default: 20 for list, 10 for search)"),
+    include_full: tool.schema.boolean().optional().describe("Include full transcript in get results (default: false)")
+  },
+  execute: async (args, _context) => {
+    try {
+      const source = args.source ?? "memory";
+      const projectDir = process.cwd();
+      if (source !== "memory") {
+        return `Source "${source}" is not yet supported. Currently available: memory`;
+      }
+      switch (args.action) {
+        case "list":
+          return listMemoryEntries(projectDir, args.limit);
+        case "search":
+          if (!args.query)
+            return "Error: query is required for search action";
+          return searchMemoryEntries(projectDir, args.query, args.limit);
+        case "get":
+          if (!args.id)
+            return "Error: id is required for get action";
+          return getMemoryEntry(projectDir, args.id, args.include_full);
+        default:
+          return `Unknown action: ${args.action}. Available: list, search, get`;
+      }
+    } catch (error45) {
+      return `Error: ${error45 instanceof Error ? error45.message : String(error45)}`;
+    }
+  }
+});
 // src/tools/interactive-bash/tools.ts
 import { spawn as spawn4 } from "child_process";
 
@@ -45491,7 +45762,7 @@ Skills provide specialized knowledge and step-by-step guidance.
 Use this when a task matches an available skill's description.`;
 // src/tools/skill/tools.ts
 import { dirname as dirname14 } from "path";
-import { readFileSync as readFileSync32 } from "fs";
+import { readFileSync as readFileSync33 } from "fs";
 function loadedSkillToInfo(skill) {
   return {
     name: skill.name,
@@ -45534,7 +45805,7 @@ async function extractSkillBody(skill) {
     return templateMatch2 ? templateMatch2[1].trim() : fullTemplate;
   }
   if (skill.path) {
-    const content = readFileSync32(skill.path, "utf-8");
+    const content = readFileSync33(skill.path, "utf-8");
     const { body } = parseFrontmatter(content);
     return body.trim();
   }
@@ -45559,15 +45830,15 @@ async function formatMcpCapabilities(skill, manager, sessionID) {
     sections.push(`### ${serverName}`);
     sections.push("");
     try {
-      const [tools4, resources, prompts] = await Promise.all([
+      const [tools5, resources, prompts] = await Promise.all([
         manager.listTools(info, context).catch(() => []),
         manager.listResources(info, context).catch(() => []),
         manager.listPrompts(info, context).catch(() => [])
       ]);
-      if (tools4.length > 0) {
+      if (tools5.length > 0) {
         sections.push("**Tools:**");
         sections.push("");
-        for (const t of tools4) {
+        for (const t of tools5) {
           sections.push(`#### \`${t.name}\``);
           if (t.description) {
             sections.push(t.description);
@@ -45586,7 +45857,7 @@ async function formatMcpCapabilities(skill, manager, sessionID) {
       if (prompts.length > 0) {
         sections.push(`**Prompts**: ${prompts.map((p2) => p2.name).join(", ")}`);
       }
-      if (tools4.length === 0 && resources.length === 0 && prompts.length === 0) {
+      if (tools5.length === 0 && resources.length === 0 && prompts.length === 0) {
         sections.push("*No capabilities discovered*");
       }
     } catch (error45) {
@@ -46148,8 +46419,8 @@ If the requested information is not found, clearly state what is missing.`;
   });
 }
 // src/tools/chief-task/tools.ts
-import { existsSync as existsSync51, readdirSync as readdirSync19 } from "fs";
-import { join as join59 } from "path";
+import { existsSync as existsSync52, readdirSync as readdirSync20 } from "fs";
+import { join as join60 } from "path";
 
 // src/tools/chief-task/constants.ts
 var RESEARCH_CATEGORY_PROMPT_APPEND = `<Category_Context>
@@ -46724,14 +46995,14 @@ function parseModelString(model) {
   return;
 }
 function getMessageDir12(sessionID) {
-  if (!existsSync51(MESSAGE_STORAGE))
+  if (!existsSync52(MESSAGE_STORAGE))
     return null;
-  const directPath = join59(MESSAGE_STORAGE, sessionID);
-  if (existsSync51(directPath))
+  const directPath = join60(MESSAGE_STORAGE, sessionID);
+  if (existsSync52(directPath))
     return directPath;
-  for (const dir of readdirSync19(MESSAGE_STORAGE)) {
-    const sessionPath = join59(MESSAGE_STORAGE, dir, sessionID);
-    if (existsSync51(sessionPath))
+  for (const dir of readdirSync20(MESSAGE_STORAGE)) {
+    const sessionPath = join60(MESSAGE_STORAGE, dir, sessionID);
+    if (existsSync52(sessionPath))
       return sessionPath;
   }
   return null;
@@ -47173,7 +47444,8 @@ var builtinTools = {
   session_list,
   session_read,
   session_search,
-  session_info
+  session_info,
+  knowledge_base
 };
 // src/features/background-agent/concurrency.ts
 class ConcurrencyManager {
@@ -50016,11 +50288,11 @@ class Client extends Protocol {
   isToolTaskRequired(toolName) {
     return this._cachedRequiredTaskTools.has(toolName);
   }
-  cacheToolMetadata(tools4) {
+  cacheToolMetadata(tools5) {
     this._cachedToolOutputValidators.clear();
     this._cachedKnownTaskTools.clear();
     this._cachedRequiredTaskTools.clear();
-    for (const tool3 of tools4) {
+    for (const tool3 of tools5) {
       if (tool3.outputSchema) {
         const toolValidator = this._jsonSchemaValidator.getValidator(tool3.outputSchema);
         this._cachedToolOutputValidators.set(tool3.name, toolValidator);
@@ -50935,6 +51207,7 @@ var CHIEF_ALLOWED_TOOLS = [
   "read",
   "glob",
   "grep",
+  "knowledge_base",
   "lsp_hover",
   "lsp_goto_definition",
   "lsp_find_references",
@@ -51213,44 +51486,37 @@ When discussion crystallizes into a task:
 
 <Memory_System>
 ## \u8BB0\u5FC6\u7CFB\u7EDF
+\u4F60\u6709\u4E00\u4E2A\u8DE8\u4F1A\u8BDD\u8BB0\u5FC6\u7CFB\u7EDF\u3002\u901A\u8FC7 \`knowledge_base\` \u5DE5\u5177\u8BBF\u95EE\uFF0C**\u6E10\u8FDB\u5F0F**\u83B7\u53D6\u4FE1\u606F\u3002
 
-\u4F60\u6709\u4E00\u4E2A\u53CC\u5C42\u6587\u4EF6\u7CFB\u7EDF\u8BB0\u5FC6\uFF0C\u7528\u4E8E\u8DE8\u4F1A\u8BDD\u4FDD\u7559\u91CD\u8981\u4FE1\u606F\u3002
-
-### \u5B58\u50A8\u7ED3\u6784
-
-| \u5C42\u7EA7 | \u8DEF\u5F84 | \u7528\u9014 |
-|------|------|------|
-| \u77E5\u8BC6\u5E93 | \`KNOWLEDGE.md\` | \u9879\u76EE\u7EA7\u77E5\u8BC6\uFF08\u7ED3\u6784\u5316\u4E8B\u5B9E\uFF09 |
-| \u957F\u671F\u8BB0\u5FC6 | \`.opencode/MEMORY.md\` | \u5F52\u6863\u7CBE\u534E\uFF087\u5929\u540E\u81EA\u52A8\u6574\u7406\uFF09 |
-| \u65E5\u8BB0\u6458\u8981 | \`.opencode/memory/YYYY-MM-DD.md\` | \u6BCF\u65E5\u5BF9\u8BDD\u6458\u8981\uFF08\u542B SessionID\uFF09 |
-| \u5B8C\u6574\u5BF9\u8BDD | \`.opencode/memory/full/<sessionID>.md\` | \u539F\u59CB\u5BF9\u8BDD\u5168\u6587 |
+### \u4F7F\u7528\u65B9\u5F0F\uFF08\u5148\u7C97\u540E\u7EC6\uFF09
 
-### \u68C0\u7D22\u6A21\u5F0F
+**\u7B2C\u4E00\u6B65\uFF1A\u6D4F\u89C8\u6982\u89C8**
+\`\`\`
+knowledge_base({ action: "list" })
+\`\`\`
+\u2192 \u8FD4\u56DE\u6240\u6709\u8BB0\u5FC6\u6761\u76EE\u7684\u65E5\u671F\u3001\u6807\u7B7E\u3001\u51B3\u7B56\u6570\u3001\u6458\u8981\u9996\u884C
 
-**\u6A21\u5F0F 1\uFF1A\u5FEB\u901F\u68C0\u7D22**\uFF08\u627E\u5F97\u5230\u3001\u626B\u5F97\u5FEB\u3001\u53EF\u805A\u5408\uFF09
+**\u7B2C\u4E8C\u6B65\uFF1A\u641C\u7D22\u5B9A\u4F4D**
 \`\`\`
-grep("\u5173\u952E\u8BCD", ".opencode/memory/")   # \u641C\u7D22\u6240\u6709\u6458\u8981
-read(".opencode/MEMORY.md")           # \u67E5\u770B\u957F\u671F\u8BB0\u5FC6\u7CBE\u534E
-glob(".opencode/memory/*.md")         # \u5217\u51FA\u6240\u6709\u65E5\u8BB0
+knowledge_base({ action: "search", query: "API\u8BBE\u8BA1" })
 \`\`\`
-\u8FD4\u56DE\uFF1ATopic + Key Points + SessionID
+\u2192 \u8FD4\u56DE\u5339\u914D\u7684\u6761\u76EE + \u5173\u952E\u7247\u6BB5
 
-**\u6A21\u5F0F 2\uFF1A\u5B8C\u6574\u8FFD\u6EAF**\uFF08\u53EF\u8FD8\u539F\u3001\u53EF\u5BA1\u8BA1\u3001\u53EF\u5F15\u7528\uFF09
+**\u7B2C\u4E09\u6B65\uFF1A\u83B7\u53D6\u8BE6\u60C5**
 \`\`\`
-# \u4ECE\u6458\u8981\u4E2D\u627E\u5230 SessionID\uFF08\u5982 ses_abc123\uFF09
-read(".opencode/memory/full/ses_abc123.md")
+knowledge_base({ action: "get", id: "2026-02-20/ses_abc123" })
 \`\`\`
-\u8FD4\u56DE\uFF1A\u539F\u59CB\u5BF9\u8BDD\u5168\u6587\uFF0C\u53EF\u5F15\u7528\u5177\u4F53\u5185\u5BB9
+\u2192 \u8FD4\u56DE\u5B8C\u6574\u6458\u8981\u548C\u51B3\u7B56
+\u2192 \u52A0 \`include_full: true\` \u53EF\u83B7\u53D6\u539F\u59CB\u5BF9\u8BDD\u5168\u6587
 
 ### \u4F55\u65F6\u4F7F\u7528
 
-| \u89E6\u53D1\u4FE1\u53F7 | \u68C0\u7D22\u6A21\u5F0F |
-|----------|----------|
-| "\u4E4B\u524D\u8BA8\u8BBA\u8FC7"\u3001"\u4E0A\u6B21"\u3001"\u6211\u4EEC\u51B3\u5B9A\u7684" | \u5FEB\u901F\u68C0\u7D22 |
-| "\u4F60\u8FD8\u8BB0\u5F97...\u5417"\u3001"\u5927\u6982\u4EC0\u4E48\u65F6\u5019" | \u5FEB\u901F\u68C0\u7D22 |
-| "\u539F\u8BDD\u600E\u4E48\u8BF4\u7684"\u3001"\u5B8C\u6574\u4E0A\u4E0B\u6587" | \u5B8C\u6574\u8FFD\u6EAF |
-| "\u90A3\u6B21\u5BF9\u8BDD\u7684\u7EC6\u8282" | \u5B8C\u6574\u8FFD\u6EAF |
-
+| \u89E6\u53D1\u4FE1\u53F7 | \u64CD\u4F5C |
+|----------|------|
+| "\u4E4B\u524D\u8BA8\u8BBA\u8FC7"\u3001"\u4E0A\u6B21"\u3001"\u6211\u4EEC\u51B3\u5B9A\u7684" | search \u2192 get |
+| "\u4F60\u8FD8\u8BB0\u5F97...\u5417" | search |
+| "\u539F\u8BDD\u600E\u4E48\u8BF4\u7684"\u3001"\u5B8C\u6574\u4E0A\u4E0B\u6587" | get with include_full: true |
+| \u65B0\u4F1A\u8BDD\u5F00\u59CB\uFF0C\u9700\u8981\u4E86\u89E3\u4E0A\u4E0B\u6587 | list\uFF08\u6D4F\u89C8\u8FD1\u671F\uFF09 |
 **\u8BB0\u5FC6\u662F\u4F60\u7684\u8D44\u4EA7**\uFF1A\u5584\u7528\u5B83\u4FDD\u6301\u8FDE\u8D2F\u6027\uFF0C\u907F\u514D\u91CD\u590D\u8BA8\u8BBA\u5DF2\u51B3\u5B9A\u7684\u4E8B\u9879\u3002
 </Memory_System>`;
 var CHIEF_INNER_PERSONA = `<Philosophy>
@@ -51976,16 +52242,16 @@ function isGptModel(model) {
   return model.startsWith("openai/") || model.startsWith("github-copilot/gpt-");
 }
 // src/features/soul-loader/index.ts
-import { existsSync as existsSync53, readFileSync as readFileSync34 } from "fs";
-import { join as join61 } from "path";
+import { existsSync as existsSync54, readFileSync as readFileSync35 } from "fs";
+import { join as join62 } from "path";
 var SOUL_FILE_PATH = ".opencode/SOUL.md";
 function loadSoulFile(directory) {
-  const soulPath = join61(directory, SOUL_FILE_PATH);
-  if (!existsSync53(soulPath)) {
+  const soulPath = join62(directory, SOUL_FILE_PATH);
+  if (!existsSync54(soulPath)) {
     return;
   }
   try {
-    const content = readFileSync34(soulPath, "utf-8").trim();
+    const content = readFileSync35(soulPath, "utf-8").trim();
     if (!content) {
       return;
     }
@@ -52322,7 +52588,7 @@ function createDeputyAgent(categoryConfig, promptAppend) {
 }
 // src/features/claude-code-command-loader/loader.ts
 import { promises as fs19 } from "fs";
-import { join as join62, basename as basename6 } from "path";
+import { join as join63, basename as basename6 } from "path";
 import { homedir as homedir17 } from "os";
 async function loadCommandsFromDir(commandsDir, scope, visited = new Set, prefix = "") {
   try {
@@ -52353,7 +52619,7 @@ async function loadCommandsFromDir(commandsDir, scope, visited = new Set, prefix
     if (entry.isDirectory()) {
       if (entry.name.startsWith("."))
         continue;
-      const subDirPath = join62(commandsDir, entry.name);
+      const subDirPath = join63(commandsDir, entry.name);
       const subPrefix = prefix ? `${prefix}:${entry.name}` : entry.name;
       const subCommands = await loadCommandsFromDir(subDirPath, scope, visited, subPrefix);
       commands.push(...subCommands);
@@ -52361,7 +52627,7 @@ async function loadCommandsFromDir(commandsDir, scope, visited = new Set, prefix
     }
     if (!isMarkdownFile(entry))
       continue;
-    const commandPath = join62(commandsDir, entry.name);
+    const commandPath = join63(commandsDir, entry.name);
     const baseCommandName = basename6(entry.name, ".md");
     const commandName = prefix ? `${prefix}:${baseCommandName}` : baseCommandName;
     try {
@@ -52408,22 +52674,22 @@ function commandsToRecord(commands) {
   return result;
 }
 async function loadUserCommands() {
-  const userCommandsDir = join62(getClaudeConfigDir(), "commands");
+  const userCommandsDir = join63(getClaudeConfigDir(), "commands");
   const commands = await loadCommandsFromDir(userCommandsDir, "user");
   return commandsToRecord(commands);
 }
 async function loadProjectCommands() {
-  const projectCommandsDir = join62(process.cwd(), ".claude", "commands");
+  const projectCommandsDir = join63(process.cwd(), ".claude", "commands");
   const commands = await loadCommandsFromDir(projectCommandsDir, "project");
   return commandsToRecord(commands);
 }
 async function loadOpencodeGlobalCommands() {
-  const opencodeCommandsDir = join62(homedir17(), ".config", "opencode", "command");
+  const opencodeCommandsDir = join63(homedir17(), ".config", "opencode", "command");
   const commands = await loadCommandsFromDir(opencodeCommandsDir, "opencode");
   return commandsToRecord(commands);
 }
 async function loadOpencodeProjectCommands() {
-  const opencodeProjectDir = join62(process.cwd(), ".opencode", "command");
+  const opencodeProjectDir = join63(process.cwd(), ".opencode", "command");
   const commands = await loadCommandsFromDir(opencodeProjectDir, "opencode-project");
   return commandsToRecord(commands);
 }
@@ -53233,33 +53499,33 @@ function loadBuiltinCommands(disabledCommands) {
   return commands;
 }
 // src/features/claude-code-agent-loader/loader.ts
-import { existsSync as existsSync54, readdirSync as readdirSync20, readFileSync as readFileSync35 } from "fs";
-import { join as join63, basename as basename7 } from "path";
+import { existsSync as existsSync55, readdirSync as readdirSync21, readFileSync as readFileSync36 } from "fs";
+import { join as join64, basename as basename7 } from "path";
 function parseToolsConfig(toolsStr) {
   if (!toolsStr)
     return;
-  const tools4 = toolsStr.split(",").map((t) => t.trim()).filter(Boolean);
-  if (tools4.length === 0)
+  const tools5 = toolsStr.split(",").map((t) => t.trim()).filter(Boolean);
+  if (tools5.length === 0)
     return;
   const result = {};
-  for (const tool3 of tools4) {
+  for (const tool3 of tools5) {
     result[tool3.toLowerCase()] = true;
   }
   return result;
 }
 function loadAgentsFromDir(agentsDir, scope) {
-  if (!existsSync54(agentsDir)) {
+  if (!existsSync55(agentsDir)) {
     return [];
   }
-  const entries = readdirSync20(agentsDir, { withFileTypes: true });
+  const entries = readdirSync21(agentsDir, { withFileTypes: true });
   const agents = [];
   for (const entry of entries) {
     if (!isMarkdownFile(entry))
       continue;
-    const agentPath = join63(agentsDir, entry.name);
+    const agentPath = join64(agentsDir, entry.name);
     const agentName = basename7(entry.name, ".md");
     try {
-      const content = readFileSync35(agentPath, "utf-8");
+      const content = readFileSync36(agentPath, "utf-8");
       const { data, body } = parseFrontmatter(content);
       const name = data.name || agentName;
       const originalDescription = data.description || "";
@@ -53286,7 +53552,7 @@ function loadAgentsFromDir(agentsDir, scope) {
   return agents;
 }
 function loadUserAgents() {
-  const userAgentsDir = join63(getClaudeConfigDir(), "agents");
+  const userAgentsDir = join64(getClaudeConfigDir(), "agents");
   const agents = loadAgentsFromDir(userAgentsDir, "user");
   const result = {};
   for (const agent of agents) {
@@ -53295,7 +53561,7 @@ function loadUserAgents() {
   return result;
 }
 function loadProjectAgents() {
-  const projectAgentsDir = join63(process.cwd(), ".claude", "agents");
+  const projectAgentsDir = join64(process.cwd(), ".claude", "agents");
   const agents = loadAgentsFromDir(projectAgentsDir, "project");
   const result = {};
   for (const agent of agents) {
@@ -53304,18 +53570,18 @@ function loadProjectAgents() {
   return result;
 }
 // src/features/claude-code-plugin-loader/loader.ts
-import { existsSync as existsSync55, readdirSync as readdirSync21, readFileSync as readFileSync36 } from "fs";
+import { existsSync as existsSync56, readdirSync as readdirSync22, readFileSync as readFileSync37 } from "fs";
 import { homedir as homedir18 } from "os";
-import { join as join64, basename as basename8 } from "path";
+import { join as join65, basename as basename8 } from "path";
 var CLAUDE_PLUGIN_ROOT_VAR = "${CLAUDE_PLUGIN_ROOT}";
 function getPluginsBaseDir() {
   if (process.env.CLAUDE_PLUGINS_HOME) {
     return process.env.CLAUDE_PLUGINS_HOME;
   }
-  return join64(homedir18(), ".claude", "plugins");
+  return join65(homedir18(), ".claude", "plugins");
 }
 function getInstalledPluginsPath() {
-  return join64(getPluginsBaseDir(), "installed_plugins.json");
+  return join65(getPluginsBaseDir(), "installed_plugins.json");
 }
 function resolvePluginPath(path10, pluginRoot) {
   return path10.replace(CLAUDE_PLUGIN_ROOT_VAR, pluginRoot);
@@ -53340,11 +53606,11 @@ function resolvePluginPaths(obj, pluginRoot) {
 }
 function loadInstalledPlugins() {
   const dbPath = getInstalledPluginsPath();
-  if (!existsSync55(dbPath)) {
+  if (!existsSync56(dbPath)) {
     return null;
   }
   try {
-    const content = readFileSync36(dbPath, "utf-8");
+    const content = readFileSync37(dbPath, "utf-8");
     return JSON.parse(content);
   } catch (error45) {
     log("Failed to load installed plugins database", error45);
@@ -53355,15 +53621,15 @@ function getClaudeSettingsPath() {
   if (process.env.CLAUDE_SETTINGS_PATH) {
     return process.env.CLAUDE_SETTINGS_PATH;
   }
-  return join64(homedir18(), ".claude", "settings.json");
+  return join65(homedir18(), ".claude", "settings.json");
 }
 function loadClaudeSettings() {
   const settingsPath = getClaudeSettingsPath();
-  if (!existsSync55(settingsPath)) {
+  if (!existsSync56(settingsPath)) {
     return null;
   }
   try {
-    const content = readFileSync36(settingsPath, "utf-8");
+    const content = readFileSync37(settingsPath, "utf-8");
     return JSON.parse(content);
   } catch (error45) {
     log("Failed to load Claude settings", error45);
@@ -53371,12 +53637,12 @@ function loadClaudeSettings() {
   }
 }
 function loadPluginManifest(installPath) {
-  const manifestPath = join64(installPath, ".claude-plugin", "plugin.json");
-  if (!existsSync55(manifestPath)) {
+  const manifestPath = join65(installPath, ".claude-plugin", "plugin.json");
+  if (!existsSync56(manifestPath)) {
     return null;
   }
   try {
-    const content = readFileSync36(manifestPath, "utf-8");
+    const content = readFileSync37(manifestPath, "utf-8");
     return JSON.parse(content);
   } catch (error45) {
     log(`Failed to load plugin manifest from ${manifestPath}`, error45);
@@ -53423,7 +53689,7 @@ function discoverInstalledPlugins(options) {
       continue;
     }
     const { installPath, scope, version: version2 } = installation;
-    if (!existsSync55(installPath)) {
+    if (!existsSync56(installPath)) {
       errors3.push({
         pluginKey,
         installPath,
@@ -53441,21 +53707,21 @@ function discoverInstalledPlugins(options) {
       pluginKey,
       manifest: manifest ?? undefined
     };
-    if (existsSync55(join64(installPath, "commands"))) {
-      loadedPlugin.commandsDir = join64(installPath, "commands");
+    if (existsSync56(join65(installPath, "commands"))) {
+      loadedPlugin.commandsDir = join65(installPath, "commands");
     }
-    if (existsSync55(join64(installPath, "agents"))) {
-      loadedPlugin.agentsDir = join64(installPath, "agents");
+    if (existsSync56(join65(installPath, "agents"))) {
+      loadedPlugin.agentsDir = join65(installPath, "agents");
     }
-    if (existsSync55(join64(installPath, "skills"))) {
-      loadedPlugin.skillsDir = join64(installPath, "skills");
+    if (existsSync56(join65(installPath, "skills"))) {
+      loadedPlugin.skillsDir = join65(installPath, "skills");
     }
-    const hooksPath = join64(installPath, "hooks", "hooks.json");
-    if (existsSync55(hooksPath)) {
+    const hooksPath = join65(installPath, "hooks", "hooks.json");
+    if (existsSync56(hooksPath)) {
       loadedPlugin.hooksPath = hooksPath;
     }
-    const mcpPath = join64(installPath, ".mcp.json");
-    if (existsSync55(mcpPath)) {
+    const mcpPath = join65(installPath, ".mcp.json");
+    if (existsSync56(mcpPath)) {
       loadedPlugin.mcpPath = mcpPath;
     }
     plugins.push(loadedPlugin);
@@ -53466,17 +53732,17 @@ function discoverInstalledPlugins(options) {
 function loadPluginCommands(plugins) {
   const commands2 = {};
   for (const plugin2 of plugins) {
-    if (!plugin2.commandsDir || !existsSync55(plugin2.commandsDir))
+    if (!plugin2.commandsDir || !existsSync56(plugin2.commandsDir))
       continue;
-    const entries = readdirSync21(plugin2.commandsDir, { withFileTypes: true });
+    const entries = readdirSync22(plugin2.commandsDir, { withFileTypes: true });
     for (const entry of entries) {
       if (!isMarkdownFile(entry))
         continue;
-      const commandPath = join64(plugin2.commandsDir, entry.name);
+      const commandPath = join65(plugin2.commandsDir, entry.name);
       const commandName = basename8(entry.name, ".md");
       const namespacedName = `${plugin2.name}:${commandName}`;
       try {
-        const content = readFileSync36(commandPath, "utf-8");
+        const content = readFileSync37(commandPath, "utf-8");
         const { data, body } = parseFrontmatter(content);
         const wrappedTemplate = `<command-instruction>
 ${body.trim()}
@@ -53508,21 +53774,21 @@ $ARGUMENTS
 function loadPluginSkillsAsCommands(plugins) {
   const skills = {};
   for (const plugin2 of plugins) {
-    if (!plugin2.skillsDir || !existsSync55(plugin2.skillsDir))
+    if (!plugin2.skillsDir || !existsSync56(plugin2.skillsDir))
       continue;
-    const entries = readdirSync21(plugin2.skillsDir, { withFileTypes: true });
+    const entries = readdirSync22(plugin2.skillsDir, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.name.startsWith("."))
         continue;
-      const skillPath = join64(plugin2.skillsDir, entry.name);
+      const skillPath = join65(plugin2.skillsDir, entry.name);
       if (!entry.isDirectory() && !entry.isSymbolicLink())
         continue;
       const resolvedPath = resolveSymlink(skillPath);
-      const skillMdPath = join64(resolvedPath, "SKILL.md");
-      if (!existsSync55(skillMdPath))
+      const skillMdPath = join65(resolvedPath, "SKILL.md");
+      if (!existsSync56(skillMdPath))
         continue;
       try {
-        const content = readFileSync36(skillMdPath, "utf-8");
+        const content = readFileSync37(skillMdPath, "utf-8");
         const { data, body } = parseFrontmatter(content);
         const skillName = data.name || entry.name;
         const namespacedName = `${plugin2.name}:${skillName}`;
@@ -53557,11 +53823,11 @@ $ARGUMENTS
 function parseToolsConfig2(toolsStr) {
   if (!toolsStr)
     return;
-  const tools4 = toolsStr.split(",").map((t) => t.trim()).filter(Boolean);
-  if (tools4.length === 0)
+  const tools5 = toolsStr.split(",").map((t) => t.trim()).filter(Boolean);
+  if (tools5.length === 0)
     return;
   const result = {};
-  for (const tool3 of tools4) {
+  for (const tool3 of tools5) {
     result[tool3.toLowerCase()] = true;
   }
   return result;
@@ -53569,17 +53835,17 @@ function parseToolsConfig2(toolsStr) {
 function loadPluginAgents(plugins) {
   const agents = {};
   for (const plugin2 of plugins) {
-    if (!plugin2.agentsDir || !existsSync55(plugin2.agentsDir))
+    if (!plugin2.agentsDir || !existsSync56(plugin2.agentsDir))
       continue;
-    const entries = readdirSync21(plugin2.agentsDir, { withFileTypes: true });
+    const entries = readdirSync22(plugin2.agentsDir, { withFileTypes: true });
     for (const entry of entries) {
       if (!isMarkdownFile(entry))
         continue;
-      const agentPath = join64(plugin2.agentsDir, entry.name);
+      const agentPath = join65(plugin2.agentsDir, entry.name);
       const agentName = basename8(entry.name, ".md");
       const namespacedName = `${plugin2.name}:${agentName}`;
       try {
-        const content = readFileSync36(agentPath, "utf-8");
+        const content = readFileSync37(agentPath, "utf-8");
         const { data, body } = parseFrontmatter(content);
         const name = data.name || agentName;
         const originalDescription = data.description || "";
@@ -53605,7 +53871,7 @@ function loadPluginAgents(plugins) {
 async function loadPluginMcpServers(plugins) {
   const servers = {};
   for (const plugin2 of plugins) {
-    if (!plugin2.mcpPath || !existsSync55(plugin2.mcpPath))
+    if (!plugin2.mcpPath || !existsSync56(plugin2.mcpPath))
       continue;
     try {
       const content = await Bun.file(plugin2.mcpPath).text();
@@ -53637,10 +53903,10 @@ async function loadPluginMcpServers(plugins) {
 function loadPluginHooksConfigs(plugins) {
   const configs = [];
   for (const plugin2 of plugins) {
-    if (!plugin2.hooksPath || !existsSync55(plugin2.hooksPath))
+    if (!plugin2.hooksPath || !existsSync56(plugin2.hooksPath))
       continue;
     try {
-      const content = readFileSync36(plugin2.hooksPath, "utf-8");
+      const content = readFileSync37(plugin2.hooksPath, "utf-8");
       let config3 = JSON.parse(content);
       config3 = resolvePluginPaths(config3, plugin2.installPath);
       configs.push(config3);

package/dist/tools/knowledge-base/constants.d.ts

@@ -0,0 +1,2 @@
+export declare const TOOL_NAME = "knowledge_base";
+export declare const TOOL_DESCRIPTION = "Progressive disclosure tool for accessing memory and knowledge.\n\nThree actions, from lightweight to detailed:\n\n1. list \u2014 Browse all memory entries (dates, tags, summary headlines)\n   knowledge_base({ action: \"list\" })\n\n2. search \u2014 Find relevant memories with matching snippets  \n   knowledge_base({ action: \"search\", query: \"API design discussion\" })\n\n3. get \u2014 Retrieve full content of a specific memory entry\n   knowledge_base({ action: \"get\", id: \"2026-02-20/ses_abc123\" })\n\nSources: \"memory\" (default, conversation memories), \"archive\" (long-term MEMORY.md), \"knowledge\" (KNOWLEDGE.md)\nOnly \"memory\" source is currently supported.";

package/dist/tools/knowledge-base/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./tools";
+export * from "./types";
+export * from "./constants";

package/dist/tools/knowledge-base/memory-source.d.ts

@@ -0,0 +1,3 @@
+export declare function listMemoryEntries(projectDir: string, limit?: number): string;
+export declare function searchMemoryEntries(projectDir: string, query: string, limit?: number): string;
+export declare function getMemoryEntry(projectDir: string, id: string, includeFull?: boolean): string;

package/dist/tools/knowledge-base/memory-source.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tools/knowledge-base/tools.d.ts

@@ -0,0 +1,2 @@
+import { type ToolDefinition } from "@opencode-ai/plugin/tool";
+export declare const knowledge_base: ToolDefinition;

package/dist/tools/knowledge-base/tools.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tools/knowledge-base/types.d.ts

@@ -0,0 +1,23 @@
+export interface KnowledgeBaseArgs {
+    action: "list" | "search" | "get";
+    source?: "memory" | "archive" | "knowledge";
+    query?: string;
+    id?: string;
+    limit?: number;
+    include_full?: boolean;
+}
+export interface MemoryListEntry {
+    date: string;
+    sessionID?: string;
+    tags: string[];
+    decisionsCount: number;
+    todosCount: number;
+    summaryLine: string;
+}
+export interface MemorySearchResult {
+    date: string;
+    sessionID?: string;
+    tags: string[];
+    snippet: string;
+    matchCount: number;
+}

package/dist/tools/knowledge-base/utils.d.ts

@@ -0,0 +1,5 @@
+import type { MemoryListEntry, MemorySearchResult } from "./types";
+export declare function formatMemoryList(entries: MemoryListEntry[]): string;
+export declare function formatMemorySearchResults(results: MemorySearchResult[], query: string): string;
+export declare function extractSnippet(text: string, query: string, contextChars?: number): string;
+export declare function extractSummaryLine(rawBlock: string): string;

package/dist/tools/knowledge-base/utils.test.d.ts

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "newtype-profile",
-  "version": "1.0.63",
+  "version": "1.0.64",
   "description": "AI Agent Collaboration System for Content Creation - Based on oh-my-opencode",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",