@agenr/agenr-plugin 1.9.3 → 2.0.1

package/dist/chunk-ZYADFKX3.js

@@ -0,0 +1,115 @@
+// src/core/procedures/hashing.ts
+import { createHash } from "crypto";
+function computeProcedureSourceHash(sourceText) {
+  return createHash("sha256").update(sourceText).digest("hex");
+}
+function computeProcedureRevisionHash(procedure) {
+  return createHash("sha256").update(stringifyCanonical(procedure)).digest("hex");
+}
+function stringifyCanonical(value) {
+  if (value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+    return JSON.stringify(value);
+  }
+  if (Array.isArray(value)) {
+    return `[${value.map((item) => stringifyCanonical(item)).join(",")}]`;
+  }
+  const keys = Object.keys(value).sort((left, right) => left.localeCompare(right));
+  return `{${keys.map((key) => `${JSON.stringify(key)}:${stringifyCanonical(value[key])}`).join(",")}}`;
+}
+
+// src/core/procedures/recall-text.ts
+function composeProcedureRecallText(procedure) {
+  const lines = [
+    `procedure_key: ${procedure.procedure_key}`,
+    `title: ${procedure.title}`,
+    `goal: ${procedure.goal}`,
+    ...formatSection("when_to_use", procedure.when_to_use),
+    ...formatSection("when_not_to_use", procedure.when_not_to_use),
+    ...formatSection("prerequisites", procedure.prerequisites),
+    "steps:",
+    ...procedure.steps.flatMap((step, index) => formatStep(step, index)),
+    ...formatSection("verification", procedure.verification),
+    ...formatSection("failure_modes", procedure.failure_modes),
+    "sources:",
+    ...procedure.sources.map((source, index) => `  ${index + 1}. ${formatSource(source)}`)
+  ];
+  return lines.join("\n");
+}
+function formatSection(label, values) {
+  if (values.length === 0) {
+    return [`${label}: none`];
+  }
+  return [`${label}:`, ...values.map((value, index) => `  ${index + 1}. ${value}`)];
+}
+function formatStep(step, index) {
+  const lines = [`  ${index + 1}. [${step.kind}] ${step.id} - ${step.instruction}`];
+  switch (step.kind) {
+    case "run_command":
+      lines.push(`     command: ${step.command}`);
+      break;
+    case "read_reference":
+      lines.push(`     ref: ${formatSource(step.ref)}`);
+      break;
+    case "inspect_state":
+      if (step.target) {
+        lines.push(`     target: ${step.target}`);
+      }
+      if (step.query) {
+        lines.push(`     query: ${step.query}`);
+      }
+      break;
+    case "edit_file":
+      lines.push(`     path: ${step.path}`);
+      lines.push(`     edit: ${step.edit}`);
+      break;
+    case "ask_user":
+      lines.push(`     prompt: ${step.prompt}`);
+      break;
+    case "invoke_tool":
+      lines.push(`     tool: ${step.tool}`);
+      if (step.arguments) {
+        lines.push(`     arguments: ${JSON.stringify(step.arguments)}`);
+      }
+      break;
+    case "verify":
+      lines.push(...step.checks.map((check, checkIndex) => `     check ${checkIndex + 1}: ${check}`));
+      break;
+  }
+  if (step.conditions?.length) {
+    lines.push(`     conditions: ${step.conditions.map((condition) => formatCondition(condition)).join("; ")}`);
+  }
+  if (step.stop_if?.length) {
+    lines.push(`     stop_if: ${step.stop_if.map((condition) => formatCondition(condition)).join("; ")}`);
+  }
+  return lines;
+}
+function formatCondition(condition) {
+  switch (condition.kind) {
+    case "file_exists":
+    case "path_exists":
+      return `${condition.kind}=${condition.path}`;
+    case "env_flag":
+      return condition.value ? `${condition.kind}=${condition.name}:${condition.value}` : `${condition.kind}=${condition.name}`;
+    default:
+      return `${condition.kind}=${condition.value}`;
+  }
+}
+function formatSource(source) {
+  const parts = [source.kind];
+  if (source.path) {
+    parts.push(`path=${source.path}`);
+  }
+  if (source.locator) {
+    parts.push(`locator=${source.locator}`);
+  }
+  if (source.label) {
+    parts.push(`label=${source.label}`);
+  }
+  return parts.join(" ");
+}
+
+export {
+  computeProcedureSourceHash,
+  computeProcedureRevisionHash,
+  composeProcedureRecallText
+};

package/dist/index.js

@@ -7,7 +7,7 @@ import {
   parseTuiSessionKey,
   readOpenClawSessionsStore,
   storeEntriesDetailed
-} from "./chunk-I6A6DPNF.js";
+} from "./chunk-XD3446YW.js";
 import {
   EMBEDDING_DIMENSIONS,
   ENTRY_TYPES,
@@ -24,10 +24,10 @@ import {
   resolveEmbeddingModel,
   runUnifiedRecall,
   validateTemporalValidityRange
-} from "./chunk-EMRMV2QR.js";
+} from "./chunk-Y2BC7RCE.js";
 import {
   resolveClaimSlotPolicy
-} from "./chunk-GUDCFFRV.js";
+} from "./chunk-MEHOGUZE.js";
 
 // src/adapters/openclaw/index.ts
 import { definePluginEntry } from "openclaw/plugin-sdk/plugin-entry";
@@ -41,7 +41,7 @@ var ENTRY_TYPE_DESCRIPTION = "Knowledge type to store. Use fact for durable trut
 var EXPIRY_DESCRIPTION = "Lifetime bucket: core (always injected at session start, use sparingly), permanent (durable and recalled on demand), or temporary (short-horizon).";
 var UPDATE_EXPIRY_DESCRIPTION = `${EXPIRY_DESCRIPTION} Accepted values: ${EXPIRY_LEVELS.join(", ")}.`;
 var DEFAULT_RECALL_LIMIT = 10;
-var RECALL_MODES = ["auto", "entries", "episodes"];
+var RECALL_MODES = ["auto", "entries", "episodes", "procedures"];
 var RESULT_SUBJECT_LOG_LIMIT = 5;
 async function resolveTargetEntry(services, params, options = {}) {
   const id = readStringParam(params, "id");
@@ -89,7 +89,7 @@ function parseRecallMode(value) {
   if (value === void 0) {
     return void 0;
   }
-  if (value === "auto" || value === "entries" || value === "episodes") {
+  if (value === "auto" || value === "entries" || value === "episodes" || value === "procedures") {
     return value;
   }
   throw new Error(`Unsupported recall mode "${value}".`);
@@ -233,6 +233,10 @@ function formatUnifiedRecallResults(result) {
     lines.push(result.asOf);
     lines.push("");
   }
+  if (result.routing.queried.includes("procedures") || result.procedure || result.procedureCandidates.length > 0 || result.procedureNotices.length > 0) {
+    appendProcedureMatches(lines, result);
+    lines.push("");
+  }
   const renderEntriesFirst = result.routing.detectedIntent === "historical_state";
   if (renderEntriesFirst) {
     appendEntryMatches(lines, result);
@@ -256,6 +260,33 @@ function formatUnifiedRecallResults(result) {
   }
   return lines.join("\n");
 }
+function appendProcedureMatches(lines, result) {
+  lines.push("Procedure Matches");
+  if (!result.procedure && result.procedureCandidates.length === 0) {
+    lines.push("None.");
+  } else {
+    if (result.procedure) {
+      appendCanonicalProcedure(lines, result.procedure, result.procedureCandidates);
+    } else {
+      lines.push("Canonical procedure: none.");
+    }
+    const additionalCandidates = result.procedureCandidates.filter((candidate) => candidate.procedure.id !== result.procedure?.id);
+    if (additionalCandidates.length > 0) {
+      lines.push("Other Candidates");
+      for (const [index, candidate] of additionalCandidates.entries()) {
+        lines.push(
+          `${index + 1}. ${candidate.procedure.procedure_key} | ${candidate.procedure.title} | score ${candidate.score.toFixed(2)} | lexical=${candidate.scores.lexical.toFixed(2)} | vector=${candidate.scores.vector.toFixed(2)}`
+        );
+      }
+    }
+  }
+  if (result.procedureNotices.length > 0) {
+    lines.push("Procedure Notices");
+    for (const notice of result.procedureNotices) {
+      lines.push(`- ${notice}`);
+    }
+  }
+}
 function appendEntryMatches(lines, result) {
   lines.push("Entry Matches");
   if (result.projectedEntries.length === 0) {
@@ -294,6 +325,32 @@ function appendEpisodeMatches(lines, result) {
     lines.push(`   why_matched=${describeEpisodeMatch(episode)}`);
   }
 }
+function appendCanonicalProcedure(lines, procedure, candidates) {
+  const leadCandidate = candidates.find((candidate) => candidate.procedure.id === procedure.id);
+  lines.push(
+    leadCandidate ? `Canonical Procedure. ${procedure.procedure_key} | ${procedure.title} | score ${leadCandidate.score.toFixed(2)}` : `Canonical Procedure. ${procedure.procedure_key} | ${procedure.title}`
+  );
+  lines.push(`   goal=${procedure.goal}`);
+  appendLabeledList(lines, "when_to_use", procedure.when_to_use);
+  appendLabeledList(lines, "when_not_to_use", procedure.when_not_to_use);
+  appendLabeledList(lines, "prerequisites", procedure.prerequisites);
+  lines.push("   steps");
+  for (const [index, step] of procedure.steps.entries()) {
+    lines.push(`   ${index + 1}. [${step.kind}] ${step.instruction}`);
+    const stepDetails = formatProcedureStepDetails(step);
+    if (stepDetails.length > 0) {
+      for (const detail of stepDetails) {
+        lines.push(`      ${detail}`);
+      }
+    }
+  }
+  appendLabeledList(lines, "verification", procedure.verification);
+  appendLabeledList(lines, "failure_modes", procedure.failure_modes);
+  lines.push("   sources");
+  for (const source of procedure.sources) {
+    lines.push(`   - ${formatProcedureSource(source)}`);
+  }
+}
 function appendClaimTransitions(lines, result) {
   lines.push("Claim Transitions");
   if (result.claimTransitions.length === 0) {
@@ -314,11 +371,55 @@ function appendClaimTransitions(lines, result) {
   }
 }
 function formatUnifiedRecallLogSummary(result) {
+  const procedureCount = result.procedureCandidates.length;
+  const procedureSummary = result.procedure ? ` [procedure: ${JSON.stringify(truncate(result.procedure.title, 80))}]` : "";
   const entrySubjects = result.entries.map((entry) => entry.entry.subject.trim()).filter((subject) => subject.length > 0);
   const displayed = entrySubjects.slice(0, RESULT_SUBJECT_LOG_LIMIT).map((subject) => JSON.stringify(truncate(subject, 80)));
   const remaining = entrySubjects.length - RESULT_SUBJECT_LOG_LIMIT;
   const suffix = displayed.length === 0 ? "" : ` [entry subjects: ${displayed.join(", ")}${remaining > 0 ? `, ... and ${remaining} more` : ""}]`;
-  return `${result.episodes.length} episode${result.episodes.length === 1 ? "" : "s"}, ${result.entries.length} entr${result.entries.length === 1 ? "y" : "ies"}${suffix}`;
+  const entryEpisodeSummary = `${result.episodes.length} episode${result.episodes.length === 1 ? "" : "s"}, ${result.entries.length} entr${result.entries.length === 1 ? "y" : "ies"}`;
+  if (procedureCount === 0 && !result.procedure) {
+    return `${entryEpisodeSummary}${suffix}`;
+  }
+  return `${procedureCount} procedure candidate${procedureCount === 1 ? "" : "s"}, ${entryEpisodeSummary}${procedureSummary}${suffix}`;
+}
+function appendLabeledList(lines, label, values) {
+  lines.push(`   ${label}`);
+  if (values.length === 0) {
+    lines.push("   - none");
+    return;
+  }
+  for (const value of values) {
+    lines.push(`   - ${value}`);
+  }
+}
+function formatProcedureStepDetails(step) {
+  switch (step.kind) {
+    case "run_command":
+      return [`command=${step.command}`];
+    case "read_reference":
+      return [`ref=${formatProcedureSource(step.ref)}`];
+    case "inspect_state":
+      return [step.target ? `target=${step.target}` : void 0, step.query ? `query=${step.query}` : void 0].filter(
+        (value) => value !== void 0
+      );
+    case "edit_file":
+      return [`path=${step.path}`, `edit=${step.edit}`];
+    case "ask_user":
+      return [`prompt=${step.prompt}`];
+    case "invoke_tool":
+      return [step.tool ? `tool=${step.tool}` : void 0, step.arguments ? `arguments=${JSON.stringify(step.arguments)}` : void 0].filter(
+        (value) => value !== void 0
+      );
+    case "verify":
+      return step.checks.map((check) => `check=${check}`);
+    default:
+      return [];
+  }
+}
+function formatProcedureSource(source) {
+  const parts = [source.kind, source.label, source.path, source.locator].filter((value) => Boolean(value && value.length > 0));
+  return parts.join(" | ");
 }
 function formatTrace(entry, supersededBy, supersedes, claimFamily, recallEvents) {
   const slotPolicy = entry.claim_key ? claimFamily ? {
@@ -469,12 +570,12 @@ var RECALL_TOOL_PARAMETERS = {
   properties: {
     query: {
       type: "string",
-      description: "What you need to remember. Use a focused natural-language query rather than a broad 'everything' search. Phrase prior-state asks directly, for example 'what was the previous approach' or 'what changed from X to Y'."
+      description: "What you need to remember. Use a focused natural-language query rather than a broad 'everything' search. Phrase prior-state asks directly, for example 'what was the previous approach' or 'what changed from X to Y'. Phrase procedural asks directly, for example 'how do I rotate credentials' or 'what steps should I follow'."
     },
     mode: {
       type: "string",
       enum: [...RECALL_MODES],
-      description: "Recall mode: auto routes between exact entry recall, historical-state recall, and episodes; entries forces semantic recall; episodes forces temporal or semantic session recall."
+      description: "Recall mode: auto routes between exact entry recall, historical-state recall, procedural recall, and episodes; entries forces semantic recall; episodes forces temporal or semantic session recall; procedures forces procedural recall."
     },
     limit: {
       type: "integer",
@@ -512,7 +613,7 @@ function createAgenrRecallTool(ctx, servicesPromise, logger) {
   return {
     name: "agenr_recall",
     label: "Agenr Recall",
-    description: "Retrieve knowledge from agenr long-term memory. Use mode=auto for the normal path, including historical-state questions like what was the previous approach or what changed from X to Y; use mode=entries for exact facts and decisions; use mode=episodes for time-bounded 'what happened' questions. Time periods are parsed from the query text. Session-start recall is already handled automatically.",
+    description: "Retrieve knowledge from agenr long-term memory. Use mode=auto for the normal path, including historical-state questions like what was the previous approach or what changed from X to Y and procedural questions like how to do something or what steps to follow; use mode=entries for exact facts and decisions; use mode=episodes for time-bounded 'what happened' questions; use mode=procedures for canonical methods and checklists. Time periods are parsed from the query text. Session-start recall is already handled automatically.",
     parameters: RECALL_TOOL_PARAMETERS,
     async execute(_toolCallId, rawParams) {
       try {
@@ -559,6 +660,7 @@ function createAgenrRecallTool(ctx, servicesPromise, logger) {
         );
         const result = await runUnifiedRecall(request, {
           database: services.episodes,
+          procedures: services.procedures,
           recall: services.recall,
           embeddingAvailable: services.embeddingStatus.available,
           embeddingError: services.embeddingStatus.error,
@@ -588,6 +690,24 @@ function createAgenrRecallTool(ctx, servicesPromise, logger) {
           },
           ...result.asOf ? { asOf: result.asOf } : {},
           ...result.timeWindow ? { timeWindow: result.timeWindow } : {},
+          ...result.procedure ? {
+            procedure: {
+              id: result.procedure.id,
+              procedureKey: result.procedure.procedure_key,
+              title: result.procedure.title,
+              goal: result.procedure.goal
+            }
+          } : {},
+          procedures: result.procedureCandidates.map((candidate) => ({
+            id: candidate.procedure.id,
+            procedureKey: candidate.procedure.procedure_key,
+            title: candidate.procedure.title,
+            goal: candidate.procedure.goal,
+            score: candidate.score,
+            lexicalScore: candidate.scores.lexical,
+            vectorScore: candidate.scores.vector
+          })),
+          procedureNotices: result.procedureNotices,
           episodes: result.episodes.map((episode) => ({
             id: episode.episode.id,
             source: episode.episode.source,
@@ -1055,7 +1175,7 @@ function registerAgenrOpenClawTools(api, servicesPromise, logger) {
 var openclaw_plugin_default = {
   id: "agenr",
   name: "agenr",
-  version: "1.9.3",
+  version: "2.0.1",
   description: "agenr memory plugin for OpenClaw",
   kind: "memory",
   contracts: {
@@ -3116,59 +3236,69 @@ function buildAgenrMemoryFlushPlan(_params, logger) {
 function createAgenrMemoryRuntime(servicesPromise) {
   return {
     async getMemorySearchManager() {
-      const services = await servicesPromise;
-      const snapshot = await services.memory.getMemoryStatusSnapshot();
-      const vectorAvailable = await services.memory.probeVectorAvailability();
-      const status = {
-        backend: "builtin",
-        provider: "agenr",
-        model: services.embeddingStatus.model,
-        dbPath: services.dbPath,
-        files: snapshot.sourceFiles,
-        chunks: snapshot.activeEntries,
-        vector: {
-          enabled: true,
-          available: vectorAvailable,
-          dims: EMBEDDING_DIMENSIONS
-        },
-        custom: {
-          activeEntries: snapshot.activeEntries,
-          coreEntries: snapshot.coreEntries,
-          sourceFiles: snapshot.sourceFiles
-        }
-      };
-      return {
-        manager: {
-          async search() {
-            return [];
-          },
-          async readFile({ relPath }) {
-            throw new Error(`[agenr] memory file reads are not supported for "${relPath}"`);
-          },
-          status() {
-            return status;
-          },
-          async probeEmbeddingAvailability() {
-            return {
-              ok: services.embeddingStatus.available,
-              ...services.embeddingStatus.error ? { error: services.embeddingStatus.error } : {}
-            };
-          },
-          async probeVectorAvailability() {
-            return vectorAvailable;
+      try {
+        const services = await servicesPromise;
+        const snapshot = await services.memory.getMemoryStatusSnapshot();
+        const vectorAvailable = await services.memory.probeVectorAvailability();
+        const status = {
+          backend: "builtin",
+          provider: "agenr",
+          model: services.embeddingStatus.model,
+          dbPath: services.dbPath,
+          files: snapshot.sourceFiles,
+          chunks: snapshot.activeEntries,
+          vector: {
+            enabled: true,
+            available: vectorAvailable,
+            dims: EMBEDDING_DIMENSIONS
           },
-          async sync() {
-            return;
+          custom: {
+            activeEntries: snapshot.activeEntries,
+            coreEntries: snapshot.coreEntries,
+            sourceFiles: snapshot.sourceFiles
           }
-        }
-      };
+        };
+        return {
+          manager: {
+            async search() {
+              return [];
+            },
+            async readFile({ relPath }) {
+              throw new Error(`[agenr] memory file reads are not supported for "${relPath}"`);
+            },
+            status() {
+              return status;
+            },
+            async probeEmbeddingAvailability() {
+              return {
+                ok: services.embeddingStatus.available,
+                ...services.embeddingStatus.error ? { error: services.embeddingStatus.error } : {}
+              };
+            },
+            async probeVectorAvailability() {
+              return vectorAvailable;
+            },
+            async sync() {
+              return;
+            }
+          }
+        };
+      } catch (error) {
+        return {
+          manager: null,
+          error: `[agenr] memory runtime unavailable: ${formatErrorMessage2(error)}`
+        };
+      }
     },
     resolveMemoryBackendConfig() {
       return { backend: "builtin" };
     },
     async closeAllMemorySearchManagers() {
-      const services = await servicesPromise;
-      await services.close();
+      try {
+        const services = await servicesPromise;
+        await services.close();
+      } catch {
+      }
     }
   };
 }
@@ -3193,6 +3323,7 @@ async function createAgenrOpenClawServices(config, options) {
     dbPath: resolvedConfig.dbPath,
     entries: runtimeServices.entries,
     episodes: runtimeServices.episodes,
+    procedures: runtimeServices.procedures,
     memory: runtimeServices.memory,
     embedding: runtimeServices.embedding,
     recall: runtimeServices.recall,
@@ -3229,6 +3360,7 @@ async function createRuntimeServices(dbPath, config, embeddingStatus, openClawCo
   return {
     entries: database,
     episodes: database,
+    procedures: database,
     memory: createOpenClawRepository(database, {
       claimSlotPolicyConfig: openClawContext.pluginConfig.memoryPolicy?.slotPolicies
     }),
@@ -3331,6 +3463,9 @@ var openclaw_default = definePluginEntry({
       },
       resolvePath: api.resolvePath
     });
+    void servicesPromise.catch((error) => {
+      api.logger.error(`[agenr] startup failed: ${formatErrorMessage2(error)}`);
+    });
     api.registerMemoryCapability({
       promptBuilder: buildAgenrMemoryPromptSection,
       flushPlanResolver: (params) => buildAgenrMemoryFlushPlan(params, api.logger),

package/openclaw.plugin.json

@@ -1,7 +1,7 @@
 {
   "id": "agenr",
   "name": "agenr",
-  "version": "1.9.3",
+  "version": "2.0.1",
   "description": "agenr memory plugin for OpenClaw",
   "kind": "memory",
   "contracts": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agenr/agenr-plugin",
-  "version": "1.9.3",
+  "version": "2.0.1",
   "description": "agenr memory plugin for OpenClaw",
   "type": "module",
   "exports": {