u-foo 2.2.3 → 2.3.0

package/src/status/index.js

@@ -3,6 +3,11 @@ const path = require("path");
 const childProcess = require("child_process");
 const { readJSON } = require("../bus/utils");
 const { getUfooPaths } = require("../ufoo/paths");
+const { resolveDisplayNickname } = require("../daemon/nicknameScope");
+const {
+  inspectDirectAuthStatus,
+  formatDirectAuthStatus,
+} = require("../agent/directAuthStatus");
 
 function normalizeTty(ttyPath) {
   if (!ttyPath) return "";
@@ -51,10 +56,16 @@ function detectCurrentTty() {
  * 显示项目状态
  */
 class StatusDisplay {
-  constructor(projectRoot) {
+  constructor(projectRoot, options = {}) {
     this.projectRoot = projectRoot;
     this.paths = getUfooPaths(projectRoot);
     this.ufooDir = this.paths.ufooDir;
+    this.inspectDirectAuthStatus = options.inspectDirectAuthStatus
+      || options.inspectCodexDirectAuth
+      || inspectDirectAuthStatus;
+    this.formatDirectAuthStatus = options.formatDirectAuthStatus
+      || options.formatCodexDirectAuthStatus
+      || formatDirectAuthStatus;
   }
 
   /**
@@ -233,7 +244,7 @@ class StatusDisplay {
     const busData = readJSON(agentsFile);
     if (!busData || !busData.agents) return null;
     const meta = busData.agents[subscriber];
-    return meta && meta.nickname ? meta.nickname : null;
+    return meta ? resolveDisplayNickname(this.projectRoot, meta) : null;
   }
 
   /**
@@ -248,6 +259,16 @@ class StatusDisplay {
     }
   }
 
+  async showDirectApiStatus() {
+    const status = await this.inspectDirectAuthStatus({
+      projectRoot: this.projectRoot,
+      autoRefresh: false,
+    });
+    for (const line of this.formatDirectAuthStatus(status)) {
+      console.log(line);
+    }
+  }
+
   /**
    * 显示完整状态
    */
@@ -262,6 +283,9 @@ class StatusDisplay {
     // 显示项目路径
     console.log(`Project: ${this.projectRoot}`);
 
+    // 显示直连 API 凭证状态
+    await this.showDirectApiStatus();
+
     // 显示未读消息
     const unread = this.countUnreadMessages();
     console.log(`Unread messages: ${unread.total}`);

package/src/tools/handlers/memory.js

@@ -0,0 +1,168 @@
+const MemoryManager = require("../../memory");
+const { estimateTokens } = require("../../memory");
+const { searchHistory } = require("../../memory/historySearch");
+const { buildToolError, extractAuditFields, requireSubscriber } = require("./common");
+
+const BANNED_TIME_PATTERNS = [
+  /\bjust decided\b/i,
+  /\bjust now\b/i,
+  /\btoday\b/i,
+  /\bcurrent\b/i,
+  /现在/,
+  /今天/,
+  /本月/,
+  /最近/,
+  /正在/,
+  /刚才/,
+  /本\s*sprint/i,
+  /本阶段/,
+];
+
+function getMemoryManager(ctx = {}) {
+  return ctx.memoryManager || new MemoryManager(ctx.projectRoot);
+}
+
+function normalizeTags(value = []) {
+  return Array.isArray(value)
+    ? value.map((item) => String(item || "").trim()).filter(Boolean)
+    : String(value || "").split(",").map((item) => item.trim()).filter(Boolean);
+}
+
+function extractMemoryEvidence(args = {}) {
+  const evidence = {};
+  if (args.history_session_id) evidence.history_session_id = String(args.history_session_id);
+  if (args.history_offset) evidence.history_offset = String(args.history_offset);
+  if (Array.isArray(args.recall_ids)) {
+    evidence.recall_ids = args.recall_ids.map((id) => String(id || "").trim()).filter(Boolean);
+  }
+  return evidence;
+}
+
+function assertAgentWriteQuality(args = {}, fields = ["title", "body"]) {
+  const title = String(args.title || "").trim();
+  const body = String(args.body || "").trim();
+  if (fields.includes("body")) {
+    if (body.length < 20 || body.length > 2000) {
+      throw buildToolError(
+        "invalid_memory_body",
+        "memory body must be between 20 and 2000 characters"
+      );
+    }
+  }
+  const combined = `${title}\n${body}`;
+  if (BANNED_TIME_PATTERNS.some((pattern) => pattern.test(combined))) {
+    throw buildToolError(
+      "memory_not_durable",
+      "memory text contains time-relative wording; record durable facts only"
+    );
+  }
+}
+
+function rememberHandler(ctx = {}, args = {}) {
+  const subscriber = requireSubscriber(ctx);
+  assertAgentWriteQuality(args);
+  const manager = getMemoryManager(ctx);
+  const entry = manager.add({
+    title: args.title,
+    body: args.body,
+    tags: normalizeTags(args.tags),
+    source: `agent:${subscriber}`,
+  }, {
+    source: "tool",
+    actor: subscriber,
+    ...extractAuditFields(ctx),
+    ...extractMemoryEvidence(args),
+  });
+  return { ok: true, entry };
+}
+
+function recallHandler(ctx = {}, args = {}) {
+  const manager = getMemoryManager(ctx);
+  if (args.id) {
+    const entries = [manager.get(args.id, { includeArchived: args.include_archived === true })];
+    return { ok: true, count: 1, entries, dynamic_memory_tokens: estimateTokens(JSON.stringify(entries)) };
+  }
+  const tags = normalizeTags(args.tags);
+  const limit = Number.isFinite(Number(args.limit)) && Number(args.limit) > 0
+    ? Math.floor(Number(args.limit))
+    : 10;
+  let entries = manager.list({ limit, includeArchived: args.include_archived === true });
+  if (tags.length) {
+    entries = entries.filter((entry) => tags.every((tag) => entry.tags.includes(String(tag).toLowerCase())));
+  }
+  return { ok: true, count: entries.length, entries, dynamic_memory_tokens: estimateTokens(JSON.stringify(entries)) };
+}
+
+function searchMemoryHandler(ctx = {}, args = {}) {
+  const query = String(args.query || "").trim();
+  if (!query) throw buildToolError("invalid_memory_query", "search_memory requires query");
+  const manager = getMemoryManager(ctx);
+  const entries = manager.search(query, {
+    limit: args.limit,
+    includeArchived: args.include_archived === true,
+  });
+  return { ok: true, count: entries.length, entries, dynamic_memory_tokens: estimateTokens(JSON.stringify(entries)) };
+}
+
+function searchHistoryHandler(ctx = {}, args = {}) {
+  const query = String(args.query || "").trim();
+  if (!query) throw buildToolError("invalid_history_query", "search_history requires query");
+  const manager = getMemoryManager(ctx);
+  const result = searchHistory(ctx.projectRoot, args, {
+    homeDir: ctx.historyHomeDir,
+    claudeProjectDir: ctx.claudeProjectDir,
+    claudeHistoryFile: ctx.claudeHistoryFile,
+    codexSessionsDir: ctx.codexSessionsDir,
+    codexHistoryFile: ctx.codexHistoryFile,
+  });
+  manager.recordHistorySearch(query, result.snippets, {
+    source: "tool",
+    actor: ctx.subscriber || "",
+    ...extractAuditFields(ctx),
+  });
+  return {
+    ...result,
+    dynamic_memory_tokens: estimateTokens(JSON.stringify(result.snippets || [])),
+  };
+}
+
+function editMemoryHandler(ctx = {}, args = {}) {
+  const subscriber = requireSubscriber(ctx);
+  const hasBody = Object.prototype.hasOwnProperty.call(args, "body");
+  if (hasBody) assertAgentWriteQuality(args, ["body"]);
+  const manager = getMemoryManager(ctx);
+  const patch = {};
+  if (Object.prototype.hasOwnProperty.call(args, "title")) patch.title = args.title;
+  if (Object.prototype.hasOwnProperty.call(args, "body")) patch.body = args.body;
+  if (Object.prototype.hasOwnProperty.call(args, "tags")) patch.tags = normalizeTags(args.tags);
+  if (Object.prototype.hasOwnProperty.call(args, "expected_updated_at")) {
+    patch.expected_updated_at = args.expected_updated_at;
+  }
+  const entry = manager.update(args.id, patch, {
+    source: "tool",
+    actor: subscriber,
+    ...extractAuditFields(ctx),
+    ...extractMemoryEvidence(args),
+  });
+  return { ok: true, entry };
+}
+
+function forgetMemoryHandler(ctx = {}, args = {}) {
+  const subscriber = requireSubscriber(ctx);
+  const manager = getMemoryManager(ctx);
+  const entry = manager.archive(args.id, {
+    source: "tool",
+    actor: subscriber,
+    ...extractAuditFields(ctx),
+  });
+  return { ok: true, entry };
+}
+
+module.exports = {
+  rememberHandler,
+  recallHandler,
+  searchMemoryHandler,
+  searchHistoryHandler,
+  editMemoryHandler,
+  forgetMemoryHandler,
+};

package/src/tools/index.js

@@ -16,6 +16,12 @@ const {
   ROUTE_AGENT_SCHEMA,
   DISPATCH_MESSAGE_SCHEMA,
   ACK_BUS_SCHEMA,
+  REMEMBER_SCHEMA,
+  RECALL_SCHEMA,
+  SEARCH_MEMORY_SCHEMA,
+  SEARCH_HISTORY_SCHEMA,
+  EDIT_MEMORY_SCHEMA,
+  FORGET_MEMORY_SCHEMA,
   LAUNCH_AGENT_SCHEMA,
   RENAME_AGENT_SCHEMA,
   CLOSE_AGENT_SCHEMA,
@@ -45,6 +51,12 @@ module.exports = {
   ROUTE_AGENT_SCHEMA,
   DISPATCH_MESSAGE_SCHEMA,
   ACK_BUS_SCHEMA,
+  REMEMBER_SCHEMA,
+  RECALL_SCHEMA,
+  SEARCH_MEMORY_SCHEMA,
+  SEARCH_HISTORY_SCHEMA,
+  EDIT_MEMORY_SCHEMA,
+  FORGET_MEMORY_SCHEMA,
   LAUNCH_AGENT_SCHEMA,
   RENAME_AGENT_SCHEMA,
   CLOSE_AGENT_SCHEMA,

package/src/tools/registry.js

@@ -5,7 +5,13 @@ const readProjectRegistry = require("./tier0/readProjectRegistry");
 const readPromptHistory = require("./tier0/readPromptHistory");
 const ackBus = require("./tier1/ackBus");
 const dispatchMessage = require("./tier1/dispatchMessage");
+const editMemory = require("./tier1/editMemory");
+const forget = require("./tier1/forget");
+const recall = require("./tier1/recall");
+const remember = require("./tier1/remember");
 const routeAgent = require("./tier1/routeAgent");
+const searchHistory = require("./tier1/searchHistory");
+const searchMemory = require("./tier1/searchMemory");
 const closeAgent = require("./tier2/closeAgent");
 const launchAgent = require("./tier2/launchAgent");
 const manageCron = require("./tier2/manageCron");
@@ -26,6 +32,12 @@ const SHARED_TOOL_REGISTRY = Object.freeze([
   routeAgent,
   dispatchMessage,
   ackBus,
+  remember,
+  recall,
+  searchMemory,
+  searchHistory,
+  editMemory,
+  forget,
   launchAgent,
   renameAgent,
   closeAgent,

package/src/tools/schemaFixtures.js

@@ -243,6 +243,207 @@ const ACK_BUS_SCHEMA = Object.freeze({
   }),
 });
 
+const REMEMBER_SCHEMA = Object.freeze({
+  schema_version: SCHEMA_VERSION,
+  name: "remember",
+  tier: "tier1-coordination",
+  allowed_tiers: CALLER_TIERS_READ_COORD,
+  description: "Record a durable project memory fact.",
+  input_schema: Object.freeze({
+    type: "object",
+    required: Object.freeze(["title", "body"]),
+    properties: Object.freeze({
+      title: Object.freeze({ type: "string", maxLength: 150 }),
+      body: Object.freeze({ type: "string", minLength: 20 }),
+      tags: Object.freeze({
+        type: "array",
+        items: Object.freeze({ type: "string" }),
+      }),
+      history_session_id: Object.freeze({ type: "string" }),
+      history_offset: Object.freeze({ type: "string" }),
+      recall_ids: Object.freeze({
+        type: "array",
+        items: Object.freeze({ type: "string" }),
+      }),
+    }),
+    additionalProperties: false,
+  }),
+  output_schema: Object.freeze({
+    type: "object",
+    required: Object.freeze(["ok", "entry"]),
+    properties: Object.freeze({
+      ok: Object.freeze({ type: "boolean" }),
+      entry: Object.freeze({ type: "object", additionalProperties: true }),
+    }),
+    additionalProperties: false,
+  }),
+});
+
+const RECALL_SCHEMA = Object.freeze({
+  schema_version: SCHEMA_VERSION,
+  name: "recall",
+  tier: "tier1-coordination",
+  allowed_tiers: CALLER_TIERS_READ_COORD,
+  description: "Read project memory entries by id or tags.",
+  input_schema: Object.freeze({
+    type: "object",
+    properties: Object.freeze({
+      id: Object.freeze({ type: "string" }),
+      tags: Object.freeze({
+        type: "array",
+        items: Object.freeze({ type: "string" }),
+      }),
+      limit: Object.freeze({ type: "integer", minimum: 1 }),
+      include_archived: Object.freeze({ type: "boolean" }),
+    }),
+    additionalProperties: false,
+  }),
+  output_schema: Object.freeze({
+    type: "object",
+    required: Object.freeze(["ok", "count", "entries"]),
+    properties: Object.freeze({
+      ok: Object.freeze({ type: "boolean" }),
+      count: Object.freeze({ type: "integer" }),
+      dynamic_memory_tokens: Object.freeze({ type: "integer" }),
+      entries: Object.freeze({
+        type: "array",
+        items: Object.freeze({ type: "object", additionalProperties: true }),
+      }),
+    }),
+    additionalProperties: false,
+  }),
+});
+
+const SEARCH_MEMORY_SCHEMA = Object.freeze({
+  schema_version: SCHEMA_VERSION,
+  name: "search_memory",
+  tier: "tier1-coordination",
+  allowed_tiers: CALLER_TIERS_READ_COORD,
+  description: "Search project memory entries with token and substring matching.",
+  input_schema: Object.freeze({
+    type: "object",
+    required: Object.freeze(["query"]),
+    properties: Object.freeze({
+      query: Object.freeze({ type: "string" }),
+      limit: Object.freeze({ type: "integer", minimum: 1 }),
+      include_archived: Object.freeze({ type: "boolean" }),
+    }),
+    additionalProperties: false,
+  }),
+  output_schema: Object.freeze({
+    type: "object",
+    required: Object.freeze(["ok", "count", "entries"]),
+    properties: Object.freeze({
+      ok: Object.freeze({ type: "boolean" }),
+      count: Object.freeze({ type: "integer" }),
+      dynamic_memory_tokens: Object.freeze({ type: "integer" }),
+      entries: Object.freeze({
+        type: "array",
+        items: Object.freeze({ type: "object", additionalProperties: true }),
+      }),
+    }),
+    additionalProperties: false,
+  }),
+});
+
+const SEARCH_HISTORY_SCHEMA = Object.freeze({
+  schema_version: SCHEMA_VERSION,
+  name: "search_history",
+  tier: "tier1-coordination",
+  allowed_tiers: CALLER_TIERS_READ_COORD,
+  description: "Search local Claude/Codex session history snippets as evidence for memory work.",
+  input_schema: Object.freeze({
+    type: "object",
+    required: Object.freeze(["query"]),
+    properties: Object.freeze({
+      query: Object.freeze({ type: "string" }),
+      agent: Object.freeze({ type: "string" }),
+      session_id: Object.freeze({ type: "string" }),
+      limit: Object.freeze({ type: "integer", minimum: 1, maximum: 3 }),
+    }),
+    additionalProperties: false,
+  }),
+  output_schema: Object.freeze({
+    type: "object",
+    required: Object.freeze(["ok", "from_history", "query", "count", "snippets"]),
+    properties: Object.freeze({
+      ok: Object.freeze({ type: "boolean" }),
+      from_history: Object.freeze({ type: "boolean" }),
+      query: Object.freeze({ type: "string" }),
+      count: Object.freeze({ type: "integer" }),
+      dynamic_memory_tokens: Object.freeze({ type: "integer" }),
+      snippets: Object.freeze({
+        type: "array",
+        items: Object.freeze({ type: "object", additionalProperties: true }),
+      }),
+    }),
+    additionalProperties: false,
+  }),
+});
+
+const EDIT_MEMORY_SCHEMA = Object.freeze({
+  schema_version: SCHEMA_VERSION,
+  name: "edit_memory",
+  tier: "tier1-coordination",
+  allowed_tiers: CALLER_TIERS_READ_COORD,
+  description: "Edit an existing project memory entry.",
+  input_schema: Object.freeze({
+    type: "object",
+    required: Object.freeze(["id"]),
+    properties: Object.freeze({
+      id: Object.freeze({ type: "string" }),
+      title: Object.freeze({ type: "string", maxLength: 150 }),
+      body: Object.freeze({ type: "string", minLength: 20 }),
+      tags: Object.freeze({
+        type: "array",
+        items: Object.freeze({ type: "string" }),
+      }),
+      expected_updated_at: Object.freeze({ type: "string" }),
+      history_session_id: Object.freeze({ type: "string" }),
+      history_offset: Object.freeze({ type: "string" }),
+      recall_ids: Object.freeze({
+        type: "array",
+        items: Object.freeze({ type: "string" }),
+      }),
+    }),
+    additionalProperties: false,
+  }),
+  output_schema: Object.freeze({
+    type: "object",
+    required: Object.freeze(["ok", "entry"]),
+    properties: Object.freeze({
+      ok: Object.freeze({ type: "boolean" }),
+      entry: Object.freeze({ type: "object", additionalProperties: true }),
+    }),
+    additionalProperties: false,
+  }),
+});
+
+const FORGET_MEMORY_SCHEMA = Object.freeze({
+  schema_version: SCHEMA_VERSION,
+  name: "forget",
+  tier: "tier1-coordination",
+  allowed_tiers: CALLER_TIERS_READ_COORD,
+  description: "Archive a project memory entry.",
+  input_schema: Object.freeze({
+    type: "object",
+    required: Object.freeze(["id"]),
+    properties: Object.freeze({
+      id: Object.freeze({ type: "string" }),
+    }),
+    additionalProperties: false,
+  }),
+  output_schema: Object.freeze({
+    type: "object",
+    required: Object.freeze(["ok", "entry"]),
+    properties: Object.freeze({
+      ok: Object.freeze({ type: "boolean" }),
+      entry: Object.freeze({ type: "object", additionalProperties: true }),
+    }),
+    additionalProperties: false,
+  }),
+});
+
 const LAUNCH_AGENT_SCHEMA = Object.freeze({
   schema_version: SCHEMA_VERSION,
   name: "launch_agent",
@@ -391,6 +592,12 @@ const PHASE0_TOOL_SCHEMAS = Object.freeze({
   route_agent: ROUTE_AGENT_SCHEMA,
   dispatch_message: DISPATCH_MESSAGE_SCHEMA,
   ack_bus: ACK_BUS_SCHEMA,
+  remember: REMEMBER_SCHEMA,
+  recall: RECALL_SCHEMA,
+  search_memory: SEARCH_MEMORY_SCHEMA,
+  search_history: SEARCH_HISTORY_SCHEMA,
+  edit_memory: EDIT_MEMORY_SCHEMA,
+  forget: FORGET_MEMORY_SCHEMA,
   launch_agent: LAUNCH_AGENT_SCHEMA,
   rename_agent: RENAME_AGENT_SCHEMA,
   close_agent: CLOSE_AGENT_SCHEMA,
@@ -407,6 +614,12 @@ module.exports = {
   ROUTE_AGENT_SCHEMA,
   DISPATCH_MESSAGE_SCHEMA,
   ACK_BUS_SCHEMA,
+  REMEMBER_SCHEMA,
+  RECALL_SCHEMA,
+  SEARCH_MEMORY_SCHEMA,
+  SEARCH_HISTORY_SCHEMA,
+  EDIT_MEMORY_SCHEMA,
+  FORGET_MEMORY_SCHEMA,
   LAUNCH_AGENT_SCHEMA,
   RENAME_AGENT_SCHEMA,
   CLOSE_AGENT_SCHEMA,

package/src/tools/tier1/editMemory.js

@@ -0,0 +1,14 @@
+const { EDIT_MEMORY_SCHEMA } = require("../schemaFixtures");
+const { CALLER_TIERS, TOOL_TIERS, createToolDefinition } = require("../types");
+const { editMemoryHandler } = require("../handlers/memory");
+
+module.exports = createToolDefinition({
+  name: EDIT_MEMORY_SCHEMA.name,
+  description: EDIT_MEMORY_SCHEMA.description,
+  tier: TOOL_TIERS.TIER_1,
+  allowedCallerTiers: [CALLER_TIERS.CONTROLLER, CALLER_TIERS.WORKER],
+  inputSchema: EDIT_MEMORY_SCHEMA.input_schema,
+  outputSchema: EDIT_MEMORY_SCHEMA.output_schema,
+  schemaVersion: EDIT_MEMORY_SCHEMA.schema_version,
+  handler: editMemoryHandler,
+});

package/src/tools/tier1/forget.js

@@ -0,0 +1,14 @@
+const { FORGET_MEMORY_SCHEMA } = require("../schemaFixtures");
+const { CALLER_TIERS, TOOL_TIERS, createToolDefinition } = require("../types");
+const { forgetMemoryHandler } = require("../handlers/memory");
+
+module.exports = createToolDefinition({
+  name: FORGET_MEMORY_SCHEMA.name,
+  description: FORGET_MEMORY_SCHEMA.description,
+  tier: TOOL_TIERS.TIER_1,
+  allowedCallerTiers: [CALLER_TIERS.CONTROLLER, CALLER_TIERS.WORKER],
+  inputSchema: FORGET_MEMORY_SCHEMA.input_schema,
+  outputSchema: FORGET_MEMORY_SCHEMA.output_schema,
+  schemaVersion: FORGET_MEMORY_SCHEMA.schema_version,
+  handler: forgetMemoryHandler,
+});

package/src/tools/tier1/recall.js

@@ -0,0 +1,14 @@
+const { RECALL_SCHEMA } = require("../schemaFixtures");
+const { CALLER_TIERS, TOOL_TIERS, createToolDefinition } = require("../types");
+const { recallHandler } = require("../handlers/memory");
+
+module.exports = createToolDefinition({
+  name: RECALL_SCHEMA.name,
+  description: RECALL_SCHEMA.description,
+  tier: TOOL_TIERS.TIER_1,
+  allowedCallerTiers: [CALLER_TIERS.CONTROLLER, CALLER_TIERS.WORKER],
+  inputSchema: RECALL_SCHEMA.input_schema,
+  outputSchema: RECALL_SCHEMA.output_schema,
+  schemaVersion: RECALL_SCHEMA.schema_version,
+  handler: recallHandler,
+});

package/src/tools/tier1/remember.js

@@ -0,0 +1,14 @@
+const { REMEMBER_SCHEMA } = require("../schemaFixtures");
+const { CALLER_TIERS, TOOL_TIERS, createToolDefinition } = require("../types");
+const { rememberHandler } = require("../handlers/memory");
+
+module.exports = createToolDefinition({
+  name: REMEMBER_SCHEMA.name,
+  description: REMEMBER_SCHEMA.description,
+  tier: TOOL_TIERS.TIER_1,
+  allowedCallerTiers: [CALLER_TIERS.CONTROLLER, CALLER_TIERS.WORKER],
+  inputSchema: REMEMBER_SCHEMA.input_schema,
+  outputSchema: REMEMBER_SCHEMA.output_schema,
+  schemaVersion: REMEMBER_SCHEMA.schema_version,
+  handler: rememberHandler,
+});

package/src/tools/tier1/searchHistory.js

@@ -0,0 +1,14 @@
+const { SEARCH_HISTORY_SCHEMA } = require("../schemaFixtures");
+const { CALLER_TIERS, TOOL_TIERS, createToolDefinition } = require("../types");
+const { searchHistoryHandler } = require("../handlers/memory");
+
+module.exports = createToolDefinition({
+  name: SEARCH_HISTORY_SCHEMA.name,
+  description: SEARCH_HISTORY_SCHEMA.description,
+  tier: TOOL_TIERS.TIER_1,
+  allowedCallerTiers: [CALLER_TIERS.CONTROLLER, CALLER_TIERS.WORKER],
+  inputSchema: SEARCH_HISTORY_SCHEMA.input_schema,
+  outputSchema: SEARCH_HISTORY_SCHEMA.output_schema,
+  schemaVersion: SEARCH_HISTORY_SCHEMA.schema_version,
+  handler: searchHistoryHandler,
+});

package/src/tools/tier1/searchMemory.js

@@ -0,0 +1,14 @@
+const { SEARCH_MEMORY_SCHEMA } = require("../schemaFixtures");
+const { CALLER_TIERS, TOOL_TIERS, createToolDefinition } = require("../types");
+const { searchMemoryHandler } = require("../handlers/memory");
+
+module.exports = createToolDefinition({
+  name: SEARCH_MEMORY_SCHEMA.name,
+  description: SEARCH_MEMORY_SCHEMA.description,
+  tier: TOOL_TIERS.TIER_1,
+  allowedCallerTiers: [CALLER_TIERS.CONTROLLER, CALLER_TIERS.WORKER],
+  inputSchema: SEARCH_MEMORY_SCHEMA.input_schema,
+  outputSchema: SEARCH_MEMORY_SCHEMA.output_schema,
+  schemaVersion: SEARCH_MEMORY_SCHEMA.schema_version,
+  handler: searchMemoryHandler,
+});