@remnic/plugin-openclaw 1.0.5 → 1.0.6

package/dist/index.js

@@ -3,11 +3,13 @@ import {
   SharedContextManager,
   defaultTierMigrationCycleBudget,
   external_exports
-} from "./chunk-Y65XJVI3.js";
+} from "./chunk-GUKYM4XZ.js";
 import {
+  filterTrajectoriesByLookbackDays,
   getCausalTrajectoryStoreStatus,
+  readCausalTrajectoryRecords,
   searchCausalTrajectories
-} from "./chunk-RMFPW4VK.js";
+} from "./chunk-LN5UZQVG.js";
 import {
   compareVersions
 } from "./chunk-GUSMRW4H.js";
@@ -24,7 +26,7 @@ import {
   parseConsolidationResponse,
   renderExtensionsFooter,
   resolveExtensionsRoot
-} from "./chunk-J2FCINY7.js";
+} from "./chunk-QHMR3D7U.js";
 import {
   ContentHashIndex,
   MEMORY_LIFECYCLE_EVENT_SORT_ORDER,
@@ -66,7 +68,7 @@ import {
   sortMemoryLifecycleEvents,
   stripCitationForTemplate,
   toMemoryPathRel
-} from "./chunk-5VTGFKKU.js";
+} from "./chunk-KPMXWORS.js";
 import {
   BoxBuilder,
   assertIsoRecordedAt,
@@ -233,6 +235,18 @@ function coerceBool(value) {
 function coerceInstallExtension(value) {
   return coerceBool(value);
 }
+function coerceNumber(value) {
+  if (typeof value === "number") {
+    return Number.isFinite(value) ? value : void 0;
+  }
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    if (trimmed.length === 0) return void 0;
+    const n = Number(trimmed);
+    return Number.isFinite(n) ? n : void 0;
+  }
+  return void 0;
+}
 
 // ../remnic-core/src/config.ts
 var DEFAULT_MEMORY_DIR = path2.join(
@@ -327,7 +341,8 @@ var VALID_MEMORY_CATEGORIES = /* @__PURE__ */ new Set([
   "commitment",
   "moment",
   "skill",
-  "rule"
+  "rule",
+  "procedure"
 ]);
 var DEFAULT_BEHAVIOR_LOOP_PROTECTED_PARAMS = [
   "maxMemoryTokens",
@@ -494,6 +509,19 @@ function parseConfig(raw) {
     ) ? rawCodexCompat.compactionFlushMode : "auto",
     fingerprintDedup: rawCodexCompat.fingerprintDedup !== false
   };
+  const rawProcedural = cfg.procedural && typeof cfg.procedural === "object" && !Array.isArray(cfg.procedural) ? cfg.procedural : {};
+  const proceduralMinRaw = typeof rawProcedural.minOccurrences === "number" && Number.isFinite(rawProcedural.minOccurrences) ? Math.floor(rawProcedural.minOccurrences) : 3;
+  const procedural = {
+    enabled: coerceBool(rawProcedural.enabled) === true,
+    /** 0 disables miner emission threshold (no clusters qualify). */
+    minOccurrences: Math.min(1e3, Math.max(0, proceduralMinRaw)),
+    successFloor: typeof rawProcedural.successFloor === "number" && Number.isFinite(rawProcedural.successFloor) && rawProcedural.successFloor >= 0 && rawProcedural.successFloor <= 1 ? rawProcedural.successFloor : 0.7,
+    autoPromoteOccurrences: typeof rawProcedural.autoPromoteOccurrences === "number" && Number.isFinite(rawProcedural.autoPromoteOccurrences) ? rawProcedural.autoPromoteOccurrences <= 0 ? 0 : Math.min(1e4, Math.max(1, Math.floor(rawProcedural.autoPromoteOccurrences))) : 8,
+    autoPromoteEnabled: coerceBool(rawProcedural.autoPromoteEnabled) === true,
+    lookbackDays: typeof rawProcedural.lookbackDays === "number" && Number.isFinite(rawProcedural.lookbackDays) ? Math.min(3650, Math.max(1, Math.floor(rawProcedural.lookbackDays))) : 30,
+    proceduralMiningCronAutoRegister: coerceBool(rawProcedural.proceduralMiningCronAutoRegister) === true,
+    recallMaxProcedures: typeof rawProcedural.recallMaxProcedures === "number" && Number.isFinite(rawProcedural.recallMaxProcedures) ? Math.min(10, Math.max(1, Math.floor(rawProcedural.recallMaxProcedures))) : 3
+  };
   const memoryDir = typeof cfg.memoryDir === "string" && cfg.memoryDir.length > 0 ? cfg.memoryDir : DEFAULT_MEMORY_DIR;
   const rawIdentityInjectionMode = cfg.identityInjectionMode;
   const identityInjectionMode = rawIdentityInjectionMode && VALID_IDENTITY_INJECTION_MODES.includes(rawIdentityInjectionMode) ? rawIdentityInjectionMode : "recovery_only";
@@ -681,6 +709,25 @@ function parseConfig(raw) {
     // On by default
     temporalSupersessionIncludeInRecall: cfg.temporalSupersessionIncludeInRecall === true,
     // Off by default
+    // Direct-answer retrieval tier (issue #518)
+    recallDirectAnswerEnabled: coerceBool(cfg.recallDirectAnswerEnabled) ?? false,
+    recallDirectAnswerTokenOverlapFloor: (() => {
+      const n = coerceNumber(cfg.recallDirectAnswerTokenOverlapFloor);
+      return n !== void 0 && n >= 0 && n <= 1 ? n : 0.55;
+    })(),
+    recallDirectAnswerImportanceFloor: (() => {
+      const n = coerceNumber(cfg.recallDirectAnswerImportanceFloor);
+      return n !== void 0 && n >= 0 && n <= 1 ? n : 0.7;
+    })(),
+    recallDirectAnswerAmbiguityMargin: (() => {
+      const n = coerceNumber(cfg.recallDirectAnswerAmbiguityMargin);
+      return n !== void 0 && n >= 0 && n <= 1 ? n : 0.15;
+    })(),
+    recallDirectAnswerEligibleTaxonomyBuckets: Array.isArray(
+      cfg.recallDirectAnswerEligibleTaxonomyBuckets
+    ) ? cfg.recallDirectAnswerEligibleTaxonomyBuckets.filter(
+      (v) => typeof v === "string" && v.length > 0
+    ) : ["decisions", "principles", "conventions", "runbooks", "entities"],
     // Memory Linking (Phase 3A)
     memoryLinkingEnabled: cfg.memoryLinkingEnabled === true,
     // Off by default initially
@@ -756,6 +803,7 @@ function parseConfig(raw) {
     activeRecallAttachRecallExplain: cfg.activeRecallAttachRecallExplain === true,
     activeRecallAllowChainedActiveMemory: cfg.activeRecallAllowChainedActiveMemory === true,
     dreaming,
+    procedural,
     heartbeat,
     slotBehavior,
     codexCompat,
@@ -825,7 +873,7 @@ function parseConfig(raw) {
     semanticConsolidationMinClusterSize: typeof cfg.semanticConsolidationMinClusterSize === "number" ? Math.max(2, Math.floor(cfg.semanticConsolidationMinClusterSize)) : 3,
     semanticConsolidationExcludeCategories: Array.isArray(cfg.semanticConsolidationExcludeCategories) ? cfg.semanticConsolidationExcludeCategories.filter(
       (c) => typeof c === "string" && c.length > 0
-    ) : ["correction", "commitment"],
+    ) : ["correction", "commitment", "procedure"],
     semanticConsolidationIntervalHours: typeof cfg.semanticConsolidationIntervalHours === "number" ? Math.max(1, Math.floor(cfg.semanticConsolidationIntervalHours)) : 168,
     semanticConsolidationMaxPerRun: typeof cfg.semanticConsolidationMaxPerRun === "number" ? Math.max(0, Math.floor(cfg.semanticConsolidationMaxPerRun)) : 100,
     creationMemoryEnabled: cfg.creationMemoryEnabled === true,
@@ -1075,7 +1123,7 @@ function parseConfig(raw) {
     factArchivalAgeDays: typeof cfg.factArchivalAgeDays === "number" ? cfg.factArchivalAgeDays : 90,
     factArchivalMaxImportance: typeof cfg.factArchivalMaxImportance === "number" ? cfg.factArchivalMaxImportance : 0.3,
     factArchivalMaxAccessCount: typeof cfg.factArchivalMaxAccessCount === "number" ? cfg.factArchivalMaxAccessCount : 2,
-    factArchivalProtectedCategories: Array.isArray(cfg.factArchivalProtectedCategories) ? cfg.factArchivalProtectedCategories.filter((c) => typeof c === "string") : ["commitment", "preference", "decision", "principle"],
+    factArchivalProtectedCategories: Array.isArray(cfg.factArchivalProtectedCategories) ? cfg.factArchivalProtectedCategories.filter((c) => typeof c === "string") : ["commitment", "preference", "decision", "principle", "procedure"],
     // v8.3 lifecycle policy engine (default off)
     lifecyclePolicyEnabled: cfg.lifecyclePolicyEnabled === true,
     lifecycleFilterStaleEnabled: cfg.lifecycleFilterStaleEnabled === true,
@@ -1084,7 +1132,7 @@ function parseConfig(raw) {
     lifecycleArchiveDecayThreshold: typeof cfg.lifecycleArchiveDecayThreshold === "number" ? Math.min(1, Math.max(0, cfg.lifecycleArchiveDecayThreshold)) : 0.85,
     lifecycleProtectedCategories: Array.isArray(cfg.lifecycleProtectedCategories) ? cfg.lifecycleProtectedCategories.filter(
       (c) => typeof c === "string" && VALID_MEMORY_CATEGORIES.has(c)
-    ) : ["decision", "principle", "commitment", "preference"],
+    ) : ["decision", "principle", "commitment", "preference", "procedure"],
     lifecycleMetricsEnabled: typeof cfg.lifecycleMetricsEnabled === "boolean" ? cfg.lifecycleMetricsEnabled : cfg.lifecyclePolicyEnabled === true,
     // v8.3 proactive + policy learning (default off)
     proactiveExtractionEnabled: cfg.proactiveExtractionEnabled === true,
@@ -1356,6 +1404,11 @@ function buildDefaultRecallPipeline(cfg) {
       maxEntities: typeof cfg.knowledgeIndexMaxEntities === "number" ? Math.max(0, Math.floor(cfg.knowledgeIndexMaxEntities)) : 40
     },
     { id: "verbatim-artifacts", enabled: cfg.verbatimArtifactsEnabled === true },
+    {
+      id: "procedure-recall",
+      enabled: typeof cfg.procedural === "object" && cfg.procedural !== null && !Array.isArray(cfg.procedural) && cfg.procedural.enabled === true,
+      maxChars: 2400
+    },
     { id: "memory-boxes", enabled: cfg.memoryBoxesEnabled === true },
     { id: "temporal-memory-tree", enabled: cfg.temporalMemoryTreeEnabled === true },
     { id: "lcm-compressed-history", enabled: cfg.lcmEnabled === true },
@@ -1481,7 +1534,7 @@ function detectSdkCapabilities(api) {
 // ../remnic-core/src/orchestrator.ts
 import path43 from "path";
 import os3 from "os";
-import { createHash as createHash9 } from "crypto";
+import { createHash as createHash9, randomBytes } from "crypto";
 import { existsSync as existsSync8 } from "fs";
 import {
   mkdir as mkdir30,
@@ -2142,6 +2195,15 @@ var SmartBuffer = class {
     this.state = this.normalizeState(await this.storage.loadBuffer());
     this.loaded = true;
   }
+  /**
+   * Reset the buffer to an empty, usable state.
+   * Called when the persisted buffer file is corrupt and load() fails,
+   * so the buffer can still accept new turns for the rest of the session.
+   */
+  resetToEmpty() {
+    this.state = { turns: [], lastExtractionAt: null, extractionCount: 0 };
+    this.loaded = true;
+  }
   async save() {
     await this.storage.saveBuffer(this.state);
   }
@@ -3710,14 +3772,40 @@ function parseMemoryActionEligibilityContext(value) {
     source: "unknown"
   };
 }
+var ProcedureStepExtractSchema = external_exports.object({
+  order: external_exports.number(),
+  intent: external_exports.string(),
+  toolCall: external_exports.object({
+    kind: external_exports.string(),
+    signature: external_exports.string()
+  }).optional().nullable(),
+  expectedOutcome: external_exports.string().optional().nullable(),
+  optional: external_exports.boolean().optional().nullable()
+});
 var ExtractedFactSchema = external_exports.object({
-  category: external_exports.enum(["fact", "preference", "correction", "entity", "decision", "relationship", "principle", "commitment", "moment", "skill", "rule"]),
+  category: external_exports.enum([
+    "fact",
+    "preference",
+    "correction",
+    "entity",
+    "decision",
+    "relationship",
+    "principle",
+    "commitment",
+    "moment",
+    "skill",
+    "rule",
+    "procedure"
+  ]),
   content: external_exports.string().describe("The memory content \u2014 a clear, standalone statement"),
   confidence: external_exports.number().min(0).max(1).describe("How confident are you this is correct (0-1)"),
   tags: external_exports.array(external_exports.string()).describe("Relevant tags for categorization"),
   entityRef: external_exports.string().optional().nullable().describe("If about an entity, its normalized name (e.g. person-jane-doe)"),
   promptedByQuestion: external_exports.string().optional().nullable().describe("Optional proactive follow-up question that surfaced this fact."),
-  structuredAttributes: external_exports.record(external_exports.string(), external_exports.string()).optional().nullable().describe('Structured key-value attributes when the fact contains measurable or categorical data (e.g., {"price": "29.99", "color": "blue", "date": "2024-03-15"}).')
+  structuredAttributes: external_exports.record(external_exports.string(), external_exports.string()).optional().nullable().describe('Structured key-value attributes when the fact contains measurable or categorical data (e.g., {"price": "29.99", "color": "blue", "date": "2024-03-15"}).'),
+  procedureSteps: external_exports.array(ProcedureStepExtractSchema).optional().nullable().describe(
+    'For category "procedure" only: ordered steps (intent per step). At least two steps; include explicit trigger phrasing in content (e.g. "When you deploy\u2026").'
+  )
 });
 var EntityMentionSchema = external_exports.object({
   name: external_exports.string().describe("Normalized entity name (e.g. jane-doe, acme-corp, my-project)"),
@@ -4465,6 +4553,67 @@ function parallelEfficiency(group) {
   return Math.round(idealMs / group.wallMs * 100);
 }
 
+// ../remnic-core/src/procedural/procedure-types.ts
+function normalizeProcedureSteps(raw) {
+  if (!Array.isArray(raw)) return [];
+  const out = [];
+  for (let i = 0; i < raw.length; i++) {
+    const s = raw[i];
+    if (!s || typeof s !== "object") continue;
+    const o = s;
+    const intent = typeof o.intent === "string" ? o.intent.trim() : "";
+    if (!intent) continue;
+    const orderRaw = o.order;
+    const order = typeof orderRaw === "number" && Number.isFinite(orderRaw) ? Math.max(1, Math.floor(orderRaw)) : i + 1;
+    let toolCall;
+    const tc = o.toolCall;
+    if (tc && typeof tc === "object" && !Array.isArray(tc)) {
+      const t = tc;
+      const kind = typeof t.kind === "string" ? t.kind.trim() : "";
+      const signature = typeof t.signature === "string" ? t.signature.trim() : "";
+      if (kind && signature) {
+        toolCall = { kind, signature };
+      }
+    }
+    const expectedOutcome = typeof o.expectedOutcome === "string" && o.expectedOutcome.trim() ? o.expectedOutcome.trim() : void 0;
+    const optional = o.optional === true ? true : void 0;
+    out.push({ order, intent, toolCall, expectedOutcome, optional });
+  }
+  return out;
+}
+function buildProcedurePersistBody(title, procedureSteps) {
+  const head = typeof title === "string" ? title.trim() : "";
+  const steps = normalizeProcedureSteps(procedureSteps);
+  if (steps.length === 0) return head;
+  return `${head}
+
+${buildProcedureMarkdownBody(steps)}`.trimEnd() + "\n";
+}
+function buildProcedureMarkdownBody(steps) {
+  const sorted = [...steps].sort((a, b) => a.order - b.order);
+  const lines = [];
+  for (const step of sorted) {
+    const n = Number.isFinite(step.order) ? Math.max(1, Math.floor(step.order)) : 1;
+    lines.push(`## Step ${n}`);
+    lines.push("");
+    lines.push(step.intent.trim());
+    if (step.toolCall?.kind && step.toolCall.signature) {
+      lines.push("");
+      lines.push(`- Tool: \`${step.toolCall.kind}\` \u2014 ${step.toolCall.signature}`);
+    }
+    if (step.expectedOutcome?.trim()) {
+      lines.push("");
+      lines.push(`- Expected: ${step.expectedOutcome.trim()}`);
+    }
+    if (step.optional === true) {
+      lines.push("");
+      lines.push("- Optional: true");
+    }
+    lines.push("");
+  }
+  return lines.join("\n").trimEnd() + "\n";
+}
+
 // ../remnic-core/src/extraction.ts
 var PROACTIVE_MIN_CONFIDENCE = 0.8;
 function normalizeQuestion(question) {
@@ -4555,8 +4704,9 @@ var ExtractionEngine = class {
     return shouldAssumeOpenAiChatCompletions(this.config.openaiBaseUrl);
   }
   sanitizeExtractionResult(result, messageTimestamp) {
+    const proceduralOn = this.config.procedural?.enabled === true;
     const ts = messageTimestamp ?? /* @__PURE__ */ new Date();
-    const facts = result.facts.map((fact) => {
+    const facts = result.facts.filter((fact) => proceduralOn || fact.category !== "procedure").map((fact) => {
       const sanitized = sanitizeMemoryContent(fact.content);
       if (!sanitized.clean) {
         log.warn(`extraction fact sanitized; violations=${sanitized.violations.join(", ")}`);
@@ -4583,7 +4733,8 @@ var ExtractionEngine = class {
       promptedByQuestion: typeof f?.promptedByQuestion === "string" ? f.promptedByQuestion : void 0,
       structuredAttributes: f?.structuredAttributes && typeof f.structuredAttributes === "object" && !Array.isArray(f.structuredAttributes) ? Object.fromEntries(
         Object.entries(f.structuredAttributes).filter(([k, v]) => typeof k === "string" && typeof v === "string")
-      ) : void 0
+      ) : void 0,
+      procedureSteps: Array.isArray(f?.procedureSteps) ? normalizeProcedureSteps(f.procedureSteps) : void 0
     })).filter((f) => f.content.length > 0) : [];
     const questions = Array.isArray(parsed?.questions) ? parsed.questions.map((q) => {
       if (typeof q === "string") return { question: q, context: "", priority: 0.5 };
@@ -5426,7 +5577,9 @@ Respond with valid JSON matching this schema:
       "principle",
       "commitment",
       "moment",
-      "skill"
+      "skill",
+      "rule",
+      "procedure"
     ]);
     const allowedEntityTypes = /* @__PURE__ */ new Set([
       "person",
@@ -5483,6 +5636,7 @@ Memory categories:
 - moment: Emotionally significant events or milestones (e.g., "first successful deployment of engram")
 - skill: Capabilities the user or agent has demonstrated (e.g., "user is proficient with Kubernetes")${this.config.causalRuleExtractionEnabled ? `
 - rule: Causal rules discovered through experience (format: "IF <condition> THEN <action/outcome>", e.g., "IF Shopify API returns 401 THEN the admin token is missing read_products scope")` : ""}
+- procedure: A reusable workflow the user wants remembered the same way across sessions. Set category to "procedure". Use "content" for a short title that includes explicit trigger phrasing (e.g. "When you deploy to production\u2026", "Whenever you ship a release\u2026"). Add "procedureSteps": an array of at least two objects {"order": number, "intent": "concrete step description"} in execution order. Optional per-step "toolCall": {"kind": "\u2026", "signature": "\u2026"}, "expectedOutcome", "optional": true.
 
 Rules:
 - Only extract genuinely NEW information worth remembering across sessions
@@ -6692,6 +6846,8 @@ var CATEGORY_BOOSTS = {
   // Durable rules/values
   rule: 0.11,
   // Causal IF→THEN rules
+  procedure: 0.1,
+  // Repeatable workflows (issue #519)
   preference: 0.1,
   // User preferences matter
   commitment: 0.1,
@@ -6997,6 +7153,18 @@ function enforceMaxCacheSize(cache) {
   }
 }
 var AUTO_APPROVE_CATEGORIES = /* @__PURE__ */ new Set(["correction", "principle"]);
+var PROCEDURE_TRIGGER_RE = /(when you|whenever|before you|before running|always\s|first\b.*\bthen|to deploy|to ship|run these steps|follow these steps|how (i|we)\s|recipe for|workflow|each time you)/i;
+function validateProcedureExtraction(input) {
+  const steps = normalizeProcedureSteps(input.procedureSteps);
+  if (steps.length < 2) {
+    return { durable: false, reason: "Procedure requires at least two steps with intents" };
+  }
+  const combined = [input.content, ...steps.map((s) => s.intent)].join(" ").toLowerCase();
+  if (!PROCEDURE_TRIGGER_RE.test(combined)) {
+    return { durable: false, reason: "Procedure missing explicit trigger phrasing" };
+  }
+  return { durable: true, reason: "Procedure structure validated" };
+}
 async function judgeFactDurability(candidates, config, localLlm, fallbackLlm, cache) {
   const startMs = Date.now();
   const verdicts = /* @__PURE__ */ new Map();
@@ -7177,6 +7345,156 @@ function createVerdictCache() {
   return /* @__PURE__ */ new Map();
 }
 
+// ../remnic-core/src/intent.ts
+var GOAL_PATTERNS = [
+  { re: /\b(debug(?:s|ged|ging)?|fix(?:es|ed|ing)?|error(?:s)?|incident(?:s)?|outage(?:s)?|failure(?:s)?)\b/i, goal: "stabilize" },
+  { re: /\b(deploy(?:s|ed|ing)?|release(?:s|d|ing)?|ship(?:s|ped|ping)?|publish(?:es|ed|ing)?)\b/i, goal: "release" },
+  { re: /\b(plan(?:s|ned|ning)?|roadmap(?:s)?|strateg(?:y|ies)|design(?:s|ed|ing)?)\b/i, goal: "plan" },
+  { re: /\b(review(?:s|ed|ing)?|audit(?:s|ed|ing)?|security|hardening)\b/i, goal: "review" },
+  { re: /\b(sales|deal|customer|client|prospect)\b/i, goal: "close_deal" }
+];
+var ACTION_PATTERNS = [
+  { re: /\b(review(?:s|ed|ing)?|audit(?:s|ed|ing)?|inspect(?:s|ed|ing)?|check(?:s|ed|ing)?)\b/i, action: "review" },
+  { re: /\b(plan(?:s|ned|ning)?|design(?:s|ed|ing)?|brainstorm(?:s|ed|ing)?|spec(?:s)?)\b/i, action: "plan" },
+  { re: /\b(implement(?:s|ed|ing)?|build(?:s|ing)?|built|code(?:s|d|ing)?|patch(?:es|ed|ing)?|fix(?:es|ed|ing)?)\b/i, action: "execute" },
+  { re: /\b(summariz(?:e|es|ed|ing)|recap(?:s|ped|ping)?|what happened|timeline)\b/i, action: "summarize" },
+  { re: /\b(decid(?:e|es|ed|ing)|decision(?:s)?|cho(?:ose|oses|osing)|chose|chosen)\b/i, action: "decide" }
+];
+var ENTITY_PATTERNS = [
+  { re: /\b(pr|pull request|branch|repo|github|ci|workflow)\b/i, entityType: "repo" },
+  { re: /\b(discord|slack|channel|gateway|agent)\b/i, entityType: "ops" },
+  { re: /\b(customer|client|deal|lead|account)\b/i, entityType: "client" },
+  { re: /\b(model|llm|qmd|embedding|retrieval|memory)\b/i, entityType: "ai" },
+  { re: /\b(doc|readme|docs|changelog)\b/i, entityType: "docs" }
+];
+var TASK_INITIATION_RE = /\b(ship(?:ping|ped)?|deploy(?:ing|ed)?|release|publish|open(?:ing)?\s+(?:a\s+)?(?:pr|pull\s+request)|merge(?:ing)?\s+(?:the\s+)?(?:pr|pull\s+request)|run\s+(?:the\s+)?tests?|start(?:ing)?\s+(?:work|on|the)|kick\s+off|implement(?:ing|ed)?|let's\s+|going\s+to\s+(?:ship|deploy|release|open|run|merge)|need\s+to\s+(?:ship|deploy|run|open|merge|test)|fix(?:ing|ed)?\s+(?:the\s+)?(?:bug|build)|patch(?:ing|ed)?|build(?:ing)?\s+(?:and\s+)?(?:ship|deploy))\b/i;
+function normalizeTextInput(input) {
+  return typeof input === "string" ? input : "";
+}
+function inferIntentFromText(text) {
+  const safeText = normalizeTextInput(text);
+  const goal = GOAL_PATTERNS.find((p) => p.re.test(safeText))?.goal ?? "unknown";
+  const actionType = ACTION_PATTERNS.find((p) => p.re.test(safeText))?.action ?? "unknown";
+  const entityTypes = Array.from(
+    new Set(ENTITY_PATTERNS.filter((p) => p.re.test(safeText)).map((p) => p.entityType))
+  );
+  const taskInitiation = TASK_INITIATION_RE.test(safeText);
+  return {
+    goal,
+    actionType,
+    entityTypes,
+    taskInitiation
+  };
+}
+function isTaskInitiationIntent(intent) {
+  return intent.taskInitiation === true;
+}
+function intentCompatibilityScore(queryIntent, memoryIntent) {
+  const queryHasSignal = queryIntent.goal !== "unknown" || queryIntent.actionType !== "unknown" || queryIntent.entityTypes.length > 0;
+  const memoryHasSignal = memoryIntent.goal !== "unknown" || memoryIntent.actionType !== "unknown" || memoryIntent.entityTypes.length > 0;
+  if (!queryHasSignal || !memoryHasSignal) return 0;
+  let score = 0;
+  if (queryIntent.goal !== "unknown" && memoryIntent.goal !== "unknown" && queryIntent.goal === memoryIntent.goal) {
+    score += 0.5;
+  }
+  if (queryIntent.actionType !== "unknown" && memoryIntent.actionType !== "unknown" && queryIntent.actionType === memoryIntent.actionType) {
+    score += 0.3;
+  }
+  const overlap = queryIntent.entityTypes.filter((et) => memoryIntent.entityTypes.includes(et)).length;
+  if (overlap > 0) {
+    const denom = Math.max(queryIntent.entityTypes.length, memoryIntent.entityTypes.length, 1);
+    score += 0.2 * (overlap / denom);
+  }
+  return Math.max(0, Math.min(1, score));
+}
+function planRecallMode(prompt) {
+  const p = normalizeTextInput(prompt).trim();
+  let ackCandidate = p;
+  while (ackCandidate.length > 0) {
+    const ch = ackCandidate.charCodeAt(ackCandidate.length - 1);
+    const isDigit = ch >= 48 && ch <= 57;
+    const isUpper = ch >= 65 && ch <= 90;
+    const isLower = ch >= 97 && ch <= 122;
+    if (isDigit || isUpper || isLower) break;
+    ackCandidate = ackCandidate.slice(0, -1);
+  }
+  ackCandidate = ackCandidate.trim();
+  if (p.length === 0) return "no_recall";
+  if (/\b(timeline|sequence|history|what happened|chain of events|root cause)\b/i.test(p)) {
+    return "graph_mode";
+  }
+  if (p.length <= 18 && /^(ok|okay|kk|thanks|thx|got it|sounds good|yep|yes|nope|no|done|cool|works)$/i.test(ackCandidate)) {
+    return "no_recall";
+  }
+  if (/\b(previous|earlier|remember|last time|did we|what did we decide|context|summarize|summary|recap|key points|decision)\b/i.test(p) || /\?$/.test(p) || /^(what|why|how|when|where|who|which)\b/i.test(p.toLowerCase())) {
+    return "full";
+  }
+  if (p.length <= 100 && /^(check|reload|restart|run|verify|show|status|sync|update|open|close|set|enable|disable|fix|patch)\b/i.test(p)) {
+    return "minimal";
+  }
+  return "full";
+}
+function hasBroadGraphIntent(prompt) {
+  const p = normalizeTextInput(prompt).trim().toLowerCase();
+  if (!p) return false;
+  return /\b(what changed|how did we get here|why did this happen|what led to|cause chain|dependency chain|regression chain|failure chain)\b/i.test(
+    p
+  );
+}
+
+// ../remnic-core/src/procedural/procedure-recall.ts
+function tokenOverlapScore(prompt, memoryText) {
+  const norm = (s) => s.toLowerCase().split(/[^a-z0-9]+/).filter((t) => t.length > 2);
+  const promptTokens = new Set(norm(prompt));
+  const memTokens = new Set(norm(memoryText));
+  if (promptTokens.size === 0 || memTokens.size === 0) return 0;
+  let inter = 0;
+  for (const t of promptTokens) {
+    if (memTokens.has(t)) inter++;
+  }
+  const union = /* @__PURE__ */ new Set([...promptTokens, ...memTokens]);
+  return inter / Math.max(1, union.size);
+}
+function scoreProcedureForPrompt(m, prompt, queryIntent) {
+  const memText = `${m.content}
+${(m.frontmatter.tags ?? []).join(" ")}`;
+  const jaccard = tokenOverlapScore(prompt, memText);
+  const memIntent = inferIntentFromText(m.content.slice(0, 2e3));
+  const intentScore = intentCompatibilityScore(queryIntent, memIntent);
+  return jaccard * 0.55 + intentScore * 0.45;
+}
+async function buildProcedureRecallSection(storage, prompt, config) {
+  if (config.procedural?.enabled !== true) return null;
+  const trimmed = typeof prompt === "string" ? prompt.trim() : "";
+  if (!trimmed) return null;
+  const queryIntent = inferIntentFromText(trimmed);
+  if (!isTaskInitiationIntent(queryIntent)) return null;
+  const maxN = Math.min(
+    10,
+    Math.max(
+      1,
+      typeof config.procedural.recallMaxProcedures === "number" && Number.isFinite(config.procedural.recallMaxProcedures) ? Math.floor(config.procedural.recallMaxProcedures) : 3
+    )
+  );
+  const all = await storage.readAllMemories();
+  const scored = all.filter(
+    (m) => m.frontmatter.category === "procedure" && m.frontmatter.status !== "pending_review" && m.frontmatter.status !== "rejected" && m.frontmatter.status !== "quarantined" && m.frontmatter.status !== "superseded" && m.frontmatter.status !== "archived"
+  ).map((m) => ({ m, score: scoreProcedureForPrompt(m, trimmed, queryIntent) })).filter((x) => x.score > 0.04).sort((a, b) => b.score - a.score).slice(0, maxN);
+  if (scored.length === 0) return null;
+  const blocks = scored.map(({ m, score }) => {
+    const id = m.frontmatter.id;
+    const flat = m.content.replace(/\s+/g, " ").trim();
+    const preview = flat.slice(0, 320);
+    const suffix = flat.length > 320 ? "\u2026" : "";
+    return `### ${id} (match ${score.toFixed(2)})
+
+${preview}${suffix}`;
+  });
+  return `## Relevant procedures
+
+${blocks.join("\n\n")}`;
+}
+
 // ../remnic-core/src/reconstruct.ts
 function findUnresolvedEntityRefs(recalledSnippets, recalledEntityRefs, knownEntities) {
   const refSet = new Set(recalledEntityRefs.map((r) => r.toLowerCase()));
@@ -8714,6 +9032,26 @@ var QmdDaemonSession = class {
     this.buffer = "";
   }
 };
+var QMD_RESULT_LINE_RE = /^#([0-9a-fA-F]+)\s+(\d+)%\s+(.+)/;
+var QMD_PATH_TITLE_RE = /^(.+?\.[a-zA-Z]{2,10})\s+-\s+(.*)$/;
+function parseQmdMarkdownResultText(text, transport) {
+  const results = [];
+  for (const line of text.split("\n")) {
+    const m = QMD_RESULT_LINE_RE.exec(line.trim());
+    if (!m) continue;
+    const rest = m[3];
+    const pathTitleSplit = QMD_PATH_TITLE_RE.exec(rest);
+    if (!pathTitleSplit) continue;
+    results.push({
+      docid: m[1],
+      path: pathTitleSplit[1] ?? "unknown",
+      snippet: "",
+      score: parseInt(m[2], 10) / 100,
+      transport
+    });
+  }
+  return results;
+}
 function parseMcpSearchResult(result, transport = "daemon") {
   const resultObj = result;
   if (!resultObj) return [];
@@ -8746,6 +9084,15 @@ function parseMcpSearchResult(result, transport = "daemon") {
           const textResults = parsed?.results ?? parsed?.documents;
           if (Array.isArray(textResults)) pushDocs(textResults);
         } catch {
+          const existingKeys = new Set(results.map((r) => `${r.docid.toLowerCase()}|${r.path}`));
+          const parsed = parseQmdMarkdownResultText(item.text, transport);
+          for (const p of parsed) {
+            const key = `${p.docid.toLowerCase()}|${p.path}`;
+            if (!existingKeys.has(key)) {
+              results.push(p);
+              existingKeys.add(key);
+            }
+          }
         }
       }
     }
@@ -8801,9 +9148,22 @@ var QmdClient = class _QmdClient {
   collection;
   maxResults;
   available = null;
-  lastUpdateFailAtMs = null;
+  _lastUpdateFailAtMs = null;
   lastEmbedFailAtMs = null;
   lastUpdateRunAtMs = null;
+  get lastUpdateFailedAtMs() {
+    return this._lastUpdateFailAtMs;
+  }
+  get lastUpdateRanAtMs() {
+    return this.lastUpdateRunAtMs;
+  }
+  resetUpdateThrottles() {
+    this._lastUpdateFailAtMs = null;
+    this.lastUpdateRunAtMs = null;
+    const gs = getGlobalQmdState();
+    gs.lastGlobalUpdateRunAtMs = null;
+    gs.lastGlobalUpdateFailAtMs = null;
+  }
   updateTimeoutMs;
   updateMinIntervalMs;
   slowLog;
@@ -9420,13 +9780,13 @@ ${stderr}`.split("\n").map((s) => s.trim()).filter((s) => s.length > 0);
       return [];
     }
   }
-  async update() {
-    await this.runUpdateForCollection(this.collection, { perCollectionThrottle: false });
+  async update(signal) {
+    await this.runUpdateForCollection(this.collection, { perCollectionThrottle: false }, signal);
   }
   async updateCollection(collection) {
     await this.runUpdateForCollection(collection, { perCollectionThrottle: true });
   }
-  async runUpdateForCollection(collection, options) {
+  async runUpdateForCollection(collection, options, signal) {
     if (this.available === false) return;
     const name = collection.trim();
     if (!name) return;
@@ -9452,7 +9812,7 @@ ${stderr}`.split("\n").map((s) => s.trim()).filter((s) => s.length > 0);
         log.debug("QMD update: suppressed due to min-interval gate");
         return;
       }
-      if (this.lastUpdateFailAtMs && now - this.lastUpdateFailAtMs < QMD_UPDATE_BACKOFF_MS) {
+      if (this._lastUpdateFailAtMs && now - this._lastUpdateFailAtMs < QMD_UPDATE_BACKOFF_MS) {
         log.debug("QMD update: suppressed due to recent failures (backoff)");
         return;
       }
@@ -9473,7 +9833,7 @@ ${stderr}`.split("\n").map((s) => s.trim()).filter((s) => s.length > 0);
         );
       }
       const startedAtMs = Date.now();
-      await this.runQmdCommand(["update", "-c", name], this.updateTimeoutMs);
+      await this.runQmdCommand(["update", "-c", name], this.updateTimeoutMs, signal);
       const durationMs = Date.now() - startedAtMs;
       if (this.slowLog?.enabled && durationMs >= this.slowLog.thresholdMs) {
         log.warn(`SLOW QMD update: durationMs=${durationMs}`);
@@ -9493,7 +9853,7 @@ ${stderr}`.split("\n").map((s) => s.trim()).filter((s) => s.length > 0);
         globalState.lastUpdateFailByCollectionMs[name] = at;
         globalState.lastGlobalUpdateFailAtMs = at;
       } else {
-        this.lastUpdateFailAtMs = at;
+        this._lastUpdateFailAtMs = at;
         globalState.lastGlobalUpdateFailAtMs = at;
       }
       const msg = err instanceof Error ? err.message : String(err);
@@ -12622,6 +12982,7 @@ import { mkdir as mkdir8, readFile as readFile10, rename, rm as rm2, stat as sta
 import path15 from "path";
 var DAY_SUMMARY_CRON_ID = "engram-day-summary";
 var GOVERNANCE_CRON_ID = "engram-nightly-governance";
+var PROCEDURAL_MINING_CRON_ID = "engram-procedural-mining";
 async function acquireCronJobsLock(jobsPath) {
   const lockPath2 = `${jobsPath}.lock`;
   const start = Date.now();
@@ -12734,13 +13095,37 @@ async function ensureNightlyGovernanceCron(jobsPath, options) {
     delivery: { mode: "none" }
   }));
 }
+async function ensureProceduralMiningCron(jobsPath, options) {
+  const scheduleExpr = typeof options.scheduleExpr === "string" && options.scheduleExpr.trim().length > 0 ? options.scheduleExpr.trim() : "17 3 * * *";
+  const agentId = typeof options.agentId === "string" && options.agentId.trim().length > 0 ? options.agentId.trim() : "main";
+  return ensureCronJob(jobsPath, PROCEDURAL_MINING_CRON_ID, () => ({
+    id: PROCEDURAL_MINING_CRON_ID,
+    agentId,
+    name: "Remnic Procedural Mining (nightly)",
+    enabled: true,
+    schedule: {
+      kind: "cron",
+      expr: scheduleExpr,
+      tz: options.timezone
+    },
+    sessionTarget: "isolated",
+    wakeMode: "now",
+    payload: {
+      kind: "agentTurn",
+      timeoutSeconds: 900,
+      thinking: "off",
+      message: "You are OpenClaw automation. Call tool `engram.procedure_mining_run` with empty params. If successful output exactly NO_REPLY. On error output one concise line. Do NOT use message tool."
+    },
+    delivery: { mode: "none" }
+  }));
+}
 
 // ../remnic-core/src/lifecycle.ts
 var DEFAULT_POLICY = {
   promoteHeatThreshold: 0.55,
   staleDecayThreshold: 0.65,
   archiveDecayThreshold: 0.85,
-  protectedCategories: ["decision", "principle", "commitment", "preference"]
+  protectedCategories: ["decision", "principle", "commitment", "preference", "procedure"]
 };
 function clamp01(value) {
   if (!Number.isFinite(value)) return 0;
@@ -18168,97 +18553,6 @@ async function readRecentEntityTranscriptEntries(transcriptEntriesPromise, recen
 }
 var entityRecentTranscriptLookbackHours = RECENT_TRANSCRIPT_LOOKBACK_HOURS;
 
-// ../remnic-core/src/intent.ts
-var GOAL_PATTERNS = [
-  { re: /\b(debug(?:s|ged|ging)?|fix(?:es|ed|ing)?|error(?:s)?|incident(?:s)?|outage(?:s)?|failure(?:s)?)\b/i, goal: "stabilize" },
-  { re: /\b(deploy(?:s|ed|ing)?|release(?:s|d|ing)?|ship(?:s|ped|ping)?|publish(?:es|ed|ing)?)\b/i, goal: "release" },
-  { re: /\b(plan(?:s|ned|ning)?|roadmap(?:s)?|strateg(?:y|ies)|design(?:s|ed|ing)?)\b/i, goal: "plan" },
-  { re: /\b(review(?:s|ed|ing)?|audit(?:s|ed|ing)?|security|hardening)\b/i, goal: "review" },
-  { re: /\b(sales|deal|customer|client|prospect)\b/i, goal: "close_deal" }
-];
-var ACTION_PATTERNS = [
-  { re: /\b(review(?:s|ed|ing)?|audit(?:s|ed|ing)?|inspect(?:s|ed|ing)?|check(?:s|ed|ing)?)\b/i, action: "review" },
-  { re: /\b(plan(?:s|ned|ning)?|design(?:s|ed|ing)?|brainstorm(?:s|ed|ing)?|spec(?:s)?)\b/i, action: "plan" },
-  { re: /\b(implement(?:s|ed|ing)?|build(?:s|ing)?|built|code(?:s|d|ing)?|patch(?:es|ed|ing)?|fix(?:es|ed|ing)?)\b/i, action: "execute" },
-  { re: /\b(summariz(?:e|es|ed|ing)|recap(?:s|ped|ping)?|what happened|timeline)\b/i, action: "summarize" },
-  { re: /\b(decid(?:e|es|ed|ing)|decision(?:s)?|cho(?:ose|oses|osing)|chose|chosen)\b/i, action: "decide" }
-];
-var ENTITY_PATTERNS = [
-  { re: /\b(pr|pull request|branch|repo|github|ci|workflow)\b/i, entityType: "repo" },
-  { re: /\b(discord|slack|channel|gateway|agent)\b/i, entityType: "ops" },
-  { re: /\b(customer|client|deal|lead|account)\b/i, entityType: "client" },
-  { re: /\b(model|llm|qmd|embedding|retrieval|memory)\b/i, entityType: "ai" },
-  { re: /\b(doc|readme|docs|changelog)\b/i, entityType: "docs" }
-];
-function normalizeTextInput(input) {
-  return typeof input === "string" ? input : "";
-}
-function inferIntentFromText(text) {
-  const safeText = normalizeTextInput(text);
-  const goal = GOAL_PATTERNS.find((p) => p.re.test(safeText))?.goal ?? "unknown";
-  const actionType = ACTION_PATTERNS.find((p) => p.re.test(safeText))?.action ?? "unknown";
-  const entityTypes = Array.from(
-    new Set(ENTITY_PATTERNS.filter((p) => p.re.test(safeText)).map((p) => p.entityType))
-  );
-  return {
-    goal,
-    actionType,
-    entityTypes
-  };
-}
-function intentCompatibilityScore(queryIntent, memoryIntent) {
-  const queryHasSignal = queryIntent.goal !== "unknown" || queryIntent.actionType !== "unknown" || queryIntent.entityTypes.length > 0;
-  const memoryHasSignal = memoryIntent.goal !== "unknown" || memoryIntent.actionType !== "unknown" || memoryIntent.entityTypes.length > 0;
-  if (!queryHasSignal || !memoryHasSignal) return 0;
-  let score = 0;
-  if (queryIntent.goal !== "unknown" && memoryIntent.goal !== "unknown" && queryIntent.goal === memoryIntent.goal) {
-    score += 0.5;
-  }
-  if (queryIntent.actionType !== "unknown" && memoryIntent.actionType !== "unknown" && queryIntent.actionType === memoryIntent.actionType) {
-    score += 0.3;
-  }
-  const overlap = queryIntent.entityTypes.filter((et) => memoryIntent.entityTypes.includes(et)).length;
-  if (overlap > 0) {
-    const denom = Math.max(queryIntent.entityTypes.length, memoryIntent.entityTypes.length, 1);
-    score += 0.2 * (overlap / denom);
-  }
-  return Math.max(0, Math.min(1, score));
-}
-function planRecallMode(prompt) {
-  const p = normalizeTextInput(prompt).trim();
-  let ackCandidate = p;
-  while (ackCandidate.length > 0) {
-    const ch = ackCandidate.charCodeAt(ackCandidate.length - 1);
-    const isDigit = ch >= 48 && ch <= 57;
-    const isUpper = ch >= 65 && ch <= 90;
-    const isLower = ch >= 97 && ch <= 122;
-    if (isDigit || isUpper || isLower) break;
-    ackCandidate = ackCandidate.slice(0, -1);
-  }
-  ackCandidate = ackCandidate.trim();
-  if (p.length === 0) return "no_recall";
-  if (/\b(timeline|sequence|history|what happened|chain of events|root cause)\b/i.test(p)) {
-    return "graph_mode";
-  }
-  if (p.length <= 18 && /^(ok|okay|kk|thanks|thx|got it|sounds good|yep|yes|nope|no|done|cool|works)$/i.test(ackCandidate)) {
-    return "no_recall";
-  }
-  if (/\b(previous|earlier|remember|last time|did we|what did we decide|context|summarize|summary|recap|key points|decision)\b/i.test(p) || /\?$/.test(p) || /^(what|why|how|when|where|who|which)\b/i.test(p.toLowerCase())) {
-    return "full";
-  }
-  if (p.length <= 100 && /^(check|reload|restart|run|verify|show|status|sync|update|open|close|set|enable|disable|fix|patch)\b/i.test(p)) {
-    return "minimal";
-  }
-  return "full";
-}
-function hasBroadGraphIntent(prompt) {
-  const p = normalizeTextInput(prompt).trim().toLowerCase();
-  if (!p) return false;
-  return /\b(what changed|how did we get here|why did this happen|what led to|cause chain|dependency chain|regression chain|failure chain)\b/i.test(
-    p
-  );
-}
-
 // ../remnic-core/src/recall-query-policy.ts
 var DEFAULT_STOPWORDS = /* @__PURE__ */ new Set([
   "the",
@@ -18553,11 +18847,11 @@ function computeCompressionGuidelineCandidate(events, options = {}) {
         notes
       };
     }
-    const successRate = summary.outcomes.applied / summary.total;
+    const successRate2 = summary.outcomes.applied / summary.total;
     const failureRate = summary.outcomes.failed / summary.total;
     const qualitySeen = summary.quality.good + summary.quality.poor;
     const qualitySignal = qualitySeen > 0 ? (summary.quality.good - summary.quality.poor) / qualitySeen : 0;
-    const rawDelta = clamp((successRate - failureRate) * 0.12 + qualitySignal * 0.06, -MAX_DELTA, MAX_DELTA);
+    const rawDelta = clamp((successRate2 - failureRate) * 0.12 + qualitySignal * 0.06, -MAX_DELTA, MAX_DELTA);
     const delta = roundDelta(rawDelta);
     const direction = directionForDelta(delta);
     if (direction === "decrease" && summary.outcomes.failed > summary.outcomes.applied) {
@@ -20873,14 +21167,75 @@ async function getWorkProductLedgerStatus(options) {
   };
 }
 
+// ../remnic-core/src/utils/iso-timestamp.ts
+var ISO_UTC_TIMESTAMP_RE = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{3})?Z$/;
+var ISO_OFFSET_TIMESTAMP_RE = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})$/;
+function validateDateComponents(isoString) {
+  const match = isoString.match(
+    /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2})/
+  );
+  if (!match) return false;
+  const [, yStr, mStr, dStr, hStr, minStr, sStr] = match;
+  const y = Number(yStr);
+  const m = Number(mStr);
+  const d = Number(dStr);
+  const h = Number(hStr);
+  const min = Number(minStr);
+  const s = Number(sStr);
+  if (m < 1 || m > 12) return false;
+  if (d < 1 || d > 31) return false;
+  if (h > 23 || min > 59 || s > 59) return false;
+  const daysInMonth = new Date(y, m, 0).getDate();
+  if (d > daysInMonth) return false;
+  return true;
+}
+function validateOffset(isoString) {
+  const offsetMatch = isoString.match(/([+-])(\d{2}):(\d{2})$/);
+  if (!offsetMatch) return true;
+  const oh = Number(offsetMatch[2]);
+  const om = Number(offsetMatch[3]);
+  if (oh > 14 || om > 59) return false;
+  if (oh === 14 && om > 0) return false;
+  return true;
+}
+function normalizeUtcForComparison(value) {
+  const fracMatch = value.match(/\.(\d+)Z$/);
+  if (fracMatch) {
+    const ms = (fracMatch[1] + "000").slice(0, 3);
+    return value.replace(/\.\d+Z$/, `.${ms}Z`);
+  }
+  return value.replace(/Z$/, ".000Z");
+}
+function parseIsoUtcTimestamp(value) {
+  if (typeof value !== "string" || !ISO_UTC_TIMESTAMP_RE.test(value)) {
+    return null;
+  }
+  const ts = Date.parse(value);
+  if (!Number.isFinite(ts)) return null;
+  if (!validateDateComponents(value)) return null;
+  const roundTrip = new Date(ts).toISOString();
+  if (roundTrip !== normalizeUtcForComparison(value)) return null;
+  return ts;
+}
+function parseIsoOffsetTimestamp(value) {
+  if (typeof value !== "string" || !ISO_OFFSET_TIMESTAMP_RE.test(value)) {
+    return null;
+  }
+  const ts = Date.parse(value);
+  if (!Number.isFinite(ts)) return null;
+  if (!validateDateComponents(value)) return null;
+  if (!validateOffset(value)) return null;
+  if (value.endsWith("Z")) {
+    const roundTrip = new Date(ts).toISOString();
+    if (roundTrip !== normalizeUtcForComparison(value)) return null;
+  }
+  return ts;
+}
+
 // ../remnic-core/src/replay/types.ts
 var VALID_SOURCES = /* @__PURE__ */ new Set(["openclaw", "claude", "chatgpt"]);
 var VALID_ROLES = /* @__PURE__ */ new Set(["user", "assistant"]);
-var ISO_UTC_TIMESTAMP_RE = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{3})?Z$/;
 var REPLAY_UNKNOWN_SESSION_KEY = "replay:unknown";
-function normalizeIsoForComparison(value) {
-  return value.includes(".") ? value : value.replace("Z", ".000Z");
-}
 function isReplaySource(value) {
   return typeof value === "string" && VALID_SOURCES.has(value);
 }
@@ -20893,12 +21248,7 @@ function normalizeReplaySessionKey(value) {
   return trimmed.length > 0 ? trimmed : REPLAY_UNKNOWN_SESSION_KEY;
 }
 function parseIsoTimestamp(value) {
-  if (typeof value !== "string" || !ISO_UTC_TIMESTAMP_RE.test(value)) return null;
-  const ts = Date.parse(value);
-  if (!Number.isFinite(ts)) return null;
-  const roundTrip = new Date(ts).toISOString();
-  if (roundTrip !== normalizeIsoForComparison(value)) return null;
-  return ts;
+  return parseIsoUtcTimestamp(value);
 }
 function validateReplayTurn(turn, index) {
   const issues = [];
@@ -24961,7 +25311,8 @@ var DEFAULT_CATEGORIES = [
   "commitment",
   "moment",
   "skill",
-  "rule"
+  "rule",
+  "procedure"
 ];
 function normalizeNamespace(namespace) {
   return namespace.trim();
@@ -25066,7 +25417,8 @@ var INLINE_ALLOWED_CATEGORIES = /* @__PURE__ */ new Set([
   "commitment",
   "moment",
   "skill",
-  "rule"
+  "rule",
+  "procedure"
 ]);
 var SECRET_PATTERNS = [
   /\bsk-[A-Za-z0-9]{16,}\b/,
@@ -25665,15 +26017,24 @@ var NamespaceSearchRouter = class {
     );
     return mergeNamespaceSearchResults(resultsByNamespace, maxResults);
   }
+  /**
+   * Update all namespace backends.
+   * Returns the number of backends for which an update was attempted
+   * (i.e., available and collection present).  Callers can treat 0 as a
+   * signal that no backend was eligible — useful for success-verification in
+   * startup-sync when namespacesEnabled is true.
+   */
   async updateNamespaces(namespaces) {
     const unique = Array.from(new Set(namespaces.map((value) => value.trim()).filter(Boolean)));
-    await Promise.all(
+    const results = await Promise.all(
       unique.map(async (namespace) => {
         const record = await this.backendRecordFor(namespace);
-        if (!record.available || record.collectionState === "missing") return;
+        if (!record.available || record.collectionState === "missing") return 0;
         await record.backend.update();
+        return 1;
       })
     );
+    return results.reduce((sum, v) => sum + v, 0);
   }
   async embedNamespaces(namespaces) {
     const unique = Array.from(new Set(namespaces.map((value) => value.trim()).filter(Boolean)));
@@ -25689,6 +26050,10 @@ var NamespaceSearchRouter = class {
     const record = await this.backendRecordFor(namespace);
     return record.collectionState;
   }
+  /** Clear cached backend records so the next access re-probes availability. */
+  clearCache() {
+    this.cache.clear();
+  }
   async backendRecordFor(namespace) {
     const key = namespace.trim() || this.config.defaultNamespace;
     const existing = this.cache.get(key);
@@ -27108,7 +27473,8 @@ function parseMemoryIntentSnapshot(value) {
     actionType: typeof candidate.actionType === "string" ? candidate.actionType : "unknown",
     entityTypes: Array.isArray(candidate.entityTypes) ? candidate.entityTypes.filter(
       (item) => typeof item === "string"
-    ) : []
+    ) : [],
+    taskInitiation: candidate.taskInitiation === true
   };
 }
 function buildQmdIntentHint(intent) {
@@ -27122,6 +27488,9 @@ function buildQmdIntentHint(intent) {
   if (intent.entityTypes.length > 0) {
     parts.push(`entities:${intent.entityTypes.join(",")}`);
   }
+  if (intent.taskInitiation === true) {
+    parts.push("task_initiation");
+  }
   return parts.length > 0 ? parts.join(" ") : void 0;
 }
 function parseQmdRecallResults(value) {
@@ -27297,6 +27666,41 @@ var Orchestrator = class _Orchestrator {
   // Initialization gate: recall() awaits this before proceeding
   initPromise = null;
   resolveInit = null;
+  /**
+   * Resolves when deferred initialization (QMD probe, warmup, caches, cron)
+   * completes. CLI and http-serve callers that need `qmd.isAvailable()` to
+   * reflect reality should `await orchestrator.deferredReady` after
+   * `initialize()`. Gateway callers can ignore it — recall() degrades
+   * gracefully when QMD isn't ready yet.
+   *
+   * Also resolves (without error) when `initialize()` throws before reaching
+   * the deferred-init phase, so callers never hang on a permanently-pending
+   * promise.
+   *
+   * Host adapters that need to tie deferred init to their stop() lifecycle
+   * should `await orchestrator.deferredReady` before proceeding with teardown
+   * to prevent background QMD/warmup/cron tasks from racing with shutdown.
+   */
+  deferredReady = Promise.resolve();
+  resolveDeferredReady = null;
+  deferredInitAbort = null;
+  /**
+   * Whether the deferred init's QMD startup sync completed successfully.
+   * When false after deferredReady resolves, the server retry loop should
+   * attempt startupSearchSync() even if `qmd.isAvailable()` is true —
+   * availability only means probe succeeded, not that the index is current.
+   */
+  deferredSyncSucceeded = false;
+  /**
+   * Abort deferred initialization so background QMD sync/warmup stops
+   * promptly on shutdown. Safe to call multiple times or before init.
+   */
+  abortDeferredInit() {
+    if (this.deferredInitAbort) {
+      this.deferredInitAbort.abort();
+      this.deferredInitAbort = null;
+    }
+  }
   /** Set per-session workspace for the next recall() call (compaction reset). @internal */
   setRecallWorkspaceOverride(sessionKey, dir) {
     this._recallWorkspaceOverrides.set(sessionKey, dir);
@@ -27687,100 +28091,173 @@ var Orchestrator = class _Orchestrator {
     return this.fastLlm;
   }
   async initialize() {
-    await migrateFromEngram({
-      quiet: true,
-      logger: (message) => log.info(message)
+    this.deferredReady = new Promise((resolve) => {
+      this.resolveDeferredReady = resolve;
     });
-    await this.storage.ensureDirectories();
-    await this.storage.loadAliases();
-    if (this.config.namespacesEnabled) {
-      const namespaces = /* @__PURE__ */ new Set([
-        this.config.defaultNamespace,
-        this.config.sharedNamespace,
-        ...this.config.namespacePolicies.map((p) => p.name)
-      ]);
-      for (const ns of namespaces) {
-        const sm = await this.storageRouter.storageFor(ns);
-        await sm.ensureDirectories();
-        await sm.loadAliases().catch(() => void 0);
+    try {
+      await migrateFromEngram({
+        quiet: true,
+        logger: (message) => log.info(message)
+      });
+      await this.storage.ensureDirectories();
+      await this.storage.loadAliases();
+      if (this.config.namespacesEnabled) {
+        const namespaces = /* @__PURE__ */ new Set([
+          this.config.defaultNamespace,
+          this.config.sharedNamespace,
+          ...this.config.namespacePolicies.map((p) => p.name)
+        ]);
+        for (const ns of namespaces) {
+          const sm = await this.storageRouter.storageFor(ns);
+          await sm.ensureDirectories();
+          await sm.loadAliases().catch(() => void 0);
+        }
+      }
+      await this.relevance.load();
+      await this.negatives.load();
+      await this.lastRecall.load();
+      await this.tierMigrationStatus.load();
+      await this.sessionObserver.load();
+      this.runtimePolicyValues = await this.policyRuntime.loadRuntimeValues();
+      this.utilityRuntimeValues = await loadUtilityRuntimeValues({
+        memoryDir: this.config.memoryDir,
+        memoryUtilityLearningEnabled: this.config.memoryUtilityLearningEnabled,
+        promotionByOutcomeEnabled: this.config.promotionByOutcomeEnabled
+      });
+      if (this.config.factDeduplicationEnabled) {
+        const stateDir2 = path43.join(this.config.memoryDir, "state");
+        this.contentHashIndex = new ContentHashIndex(stateDir2);
+        await this.contentHashIndex.load();
+        log.info(
+          `content-hash dedup: loaded ${this.contentHashIndex.size} hashes`
+        );
       }
-    }
-    await this.relevance.load();
-    await this.negatives.load();
-    await this.lastRecall.load();
-    await this.tierMigrationStatus.load();
-    await this.sessionObserver.load();
-    this.runtimePolicyValues = await this.policyRuntime.loadRuntimeValues();
-    this.utilityRuntimeValues = await loadUtilityRuntimeValues({
-      memoryDir: this.config.memoryDir,
-      memoryUtilityLearningEnabled: this.config.memoryUtilityLearningEnabled,
-      promotionByOutcomeEnabled: this.config.promotionByOutcomeEnabled
-    });
-    if (this.config.factDeduplicationEnabled) {
-      const stateDir2 = path43.join(this.config.memoryDir, "state");
-      this.contentHashIndex = new ContentHashIndex(stateDir2);
-      await this.contentHashIndex.load();
-      log.info(
-        `content-hash dedup: loaded ${this.contentHashIndex.size} hashes`
-      );
-    }
-    await this.transcript.initialize();
-    await this.summarizer.initialize();
-    if (this.sharedContext) {
-      await this.sharedContext.ensureStructure();
-    }
-    if (this.compounding) {
-      await this.compounding.ensureDirs();
-    }
-    if (this.resolveInit) {
-      this.resolveInit();
-      this.resolveInit = null;
-      log.info("init gate opened (essential state loaded)");
-    }
-    {
-      const available = await this.qmd.probe();
-      if (available) {
-        log.info(`Search backend: available ${this.qmd.debugStatus()}`);
-        const namespaces = this.config.namespacesEnabled ? this.configuredNamespaces() : [this.config.defaultNamespace];
-        const states = await Promise.all(
-          namespaces.map(async (namespace) => ({
-            namespace,
-            state: this.config.namespacesEnabled ? await this.namespaceSearchRouter.ensureNamespaceCollection(
-              namespace
-            ) : await this.qmd.ensureCollection(this.config.memoryDir)
-          }))
+      await this.transcript.initialize();
+      await this.summarizer.initialize();
+      if (this.sharedContext) {
+        await this.sharedContext.ensureStructure();
+      }
+      if (this.compounding) {
+        await this.compounding.ensureDirs();
+      }
+      try {
+        await this.buffer.load();
+      } catch (bufErr) {
+        log.error(
+          `buffer.load() failed (init gate will still open): ${bufErr}`
         );
-        const defaultState2 = states.find(
-          (entry) => entry.namespace === this.config.defaultNamespace
-        )?.state ?? "unknown";
-        if (defaultState2 === "missing") {
-          this.qmd = new NoopSearchBackend();
-          log.warn(
-            "Search collection missing for Remnic memory store; disabling search retrieval for this runtime (fallback retrieval remains enabled)"
-          );
-        } else if (defaultState2 === "unknown") {
-          log.warn(
-            "Search collection check unavailable; keeping search retrieval enabled for fail-open behavior"
-          );
-        } else if (defaultState2 === "skipped") {
-          log.debug(
-            "Search collection check skipped (remote or daemon-only mode)"
-          );
+        this.buffer.resetToEmpty();
+      }
+      if (this.config.compactionResetEnabled) {
+        try {
+          const wsDir = this.config.workspaceDir || defaultWorkspaceDir();
+          const files = await readdir14(wsDir).catch(() => []);
+          for (const f of files) {
+            if (!f.startsWith(".compaction-reset-signal-")) continue;
+            const fp = path43.join(wsDir, f);
+            const s = await stat10(fp).catch(() => null);
+            if (s && Date.now() - s.mtimeMs >= COMPACTION_SIGNAL_MAX_AGE_MS) {
+              await unlink7(fp).catch(() => {
+              });
+              log.debug(`initialize: removed stale compaction signal ${f}`);
+            }
+          }
+        } catch (err) {
+          log.debug("initialize: stale signal sweep failed:", err);
         }
-        for (const entry of states) {
-          if (entry.namespace === this.config.defaultNamespace) continue;
-          if (entry.state === "missing") {
+      }
+      try {
+        const available = await this.qmd.probe();
+        if (available) {
+          log.info(`Search backend: available ${this.qmd.debugStatus()}`);
+          const namespaces = this.config.namespacesEnabled ? this.configuredNamespaces() : [this.config.defaultNamespace];
+          const states = await Promise.all(
+            namespaces.map(async (namespace) => ({
+              namespace,
+              state: this.config.namespacesEnabled ? await this.namespaceSearchRouter.ensureNamespaceCollection(
+                namespace
+              ) : await this.qmd.ensureCollection(this.config.memoryDir)
+            }))
+          );
+          const defaultState2 = states.find(
+            (entry) => entry.namespace === this.config.defaultNamespace
+          )?.state ?? "unknown";
+          if (defaultState2 === "missing") {
+            this.qmd = new NoopSearchBackend();
+            log.warn(
+              "Search collection missing for Remnic memory store; disabling search retrieval for this runtime (fallback retrieval remains enabled)"
+            );
+          } else if (defaultState2 === "unknown") {
             log.warn(
-              `Search collection missing for namespace '${entry.namespace}'; namespace retrieval will fail open to non-search paths`
+              "Search collection check unavailable; keeping search retrieval enabled for fail-open behavior"
             );
+          } else if (defaultState2 === "skipped") {
+            log.debug(
+              "Search collection check skipped (remote or daemon-only mode)"
+            );
+          }
+          for (const entry of states) {
+            if (entry.namespace === this.config.defaultNamespace) continue;
+            if (entry.state === "missing") {
+              log.warn(
+                `Search collection missing for namespace '${entry.namespace}'; namespace retrieval will fail open to non-search paths`
+              );
+            }
           }
+        } else if (this.qmd instanceof NoopSearchBackend) {
+          log.debug(`Search backend: noop (search intentionally disabled)`);
+        } else {
+          log.warn(`Search backend: not available ${this.qmd.debugStatus()}`);
         }
-      } else if (this.qmd instanceof NoopSearchBackend) {
-        log.debug(`Search backend: noop (search intentionally disabled)`);
-      } else {
-        log.warn(`Search backend: not available ${this.qmd.debugStatus()}`);
+      } catch (err) {
+        log.error(`QMD probe/collection check failed (non-fatal): ${err}`);
+      }
+      if (this.resolveInit) {
+        this.resolveInit();
+        this.resolveInit = null;
+        log.info("init gate opened (essential state + QMD state loaded)");
+      }
+      const resolveDeferred = this.resolveDeferredReady;
+      this.resolveDeferredReady = null;
+      this.deferredInitAbort = new AbortController();
+      this.deferredInitialize(this.deferredInitAbort.signal).catch((err) => {
+        log.error(`deferred initialization failed (non-fatal): ${err}`);
+      }).finally(() => {
+        resolveDeferred?.();
+      });
+    } catch (err) {
+      if (this.resolveInit) {
+        this.resolveInit();
+        this.resolveInit = null;
       }
+      if (this.resolveDeferredReady) {
+        this.resolveDeferredReady();
+        this.resolveDeferredReady = null;
+      }
+      throw err;
     }
+  }
+  async deferredInitialize(signal) {
+    if (this.qmd.isAvailable() && this.config.qmdMaintenanceEnabled) {
+      try {
+        log.info("QMD startup sync: updating index to match current disk state");
+        if (this.config.namespacesEnabled) {
+          await this.namespaceSearchRouter.updateNamespaces(
+            this.configuredNamespaces()
+          );
+        } else {
+          await this.qmd.update();
+        }
+        log.info("QMD startup sync: complete");
+        this.deferredSyncSucceeded = true;
+      } catch (err) {
+        log.warn(`QMD startup sync failed (non-fatal): ${err}`);
+      }
+    } else if (!this.qmd.isAvailable()) {
+    } else {
+      this.deferredSyncSucceeded = true;
+    }
+    if (signal.aborted) return;
     const warmupPromises = [];
     if (this.qmd.isAvailable()) {
       const warmupNs = this.config.defaultNamespace;
@@ -27805,68 +28282,173 @@ var Orchestrator = class _Orchestrator {
       );
     }
     await Promise.all(warmupPromises);
+    if (signal.aborted) return;
+    const cacheWarmups = [];
     if (this.config.knowledgeIndexEnabled) {
-      (async () => {
-        try {
-          const t0 = Date.now();
-          await this.storage.buildKnowledgeIndex(this.config);
-          log.info(`Knowledge Index warmup: complete in ${Date.now() - t0}ms`);
-        } catch (err) {
-          log.debug(`Knowledge Index warmup failed (non-fatal): ${err}`);
-        }
-      })().catch(() => {
-      });
+      cacheWarmups.push(
+        (async () => {
+          try {
+            const t0 = Date.now();
+            await this.storage.buildKnowledgeIndex(this.config);
+            log.info(`Knowledge Index warmup: complete in ${Date.now() - t0}ms`);
+          } catch (err) {
+            log.debug(`Knowledge Index warmup failed (non-fatal): ${err}`);
+          }
+        })()
+      );
     }
-    this.storage.readAllMemories().catch(() => {
-    });
-    this.storage.readAllEntityFiles().catch(() => {
-    });
+    cacheWarmups.push(this.storage.readAllMemories().then(() => {
+    }).catch(() => {
+    }));
+    cacheWarmups.push(this.storage.readAllEntityFiles().then(() => {
+    }).catch(() => {
+    }));
+    await Promise.all(cacheWarmups);
+    if (signal.aborted) return;
     if (this.config.conversationIndexEnabled && this.conversationIndexBackend) {
-      const init = await this.conversationIndexBackend.initialize();
-      if (!init.enabled) {
+      try {
+        const init = await this.conversationIndexBackend.initialize();
+        if (!init.enabled) {
+          this.config.conversationIndexEnabled = false;
+        }
+        if (init.logLevel === "info") {
+          log.info(init.message);
+        } else if (init.logLevel === "warn") {
+          log.warn(init.message);
+        } else {
+          log.debug(init.message);
+        }
+      } catch (err) {
+        log.error(`Conversation index initialization failed (non-fatal): ${err}`);
         this.config.conversationIndexEnabled = false;
       }
-      if (init.logLevel === "info") {
-        log.info(init.message);
-      } else if (init.logLevel === "warn") {
-        log.warn(init.message);
-      } else {
-        log.debug(init.message);
-      }
     }
-    await this.buffer.load();
+    if (signal.aborted) return;
     if (this.config.localLlmEnabled) {
-      await this.validateLocalLlmModel();
-    }
-    if (this.config.compactionResetEnabled) {
       try {
-        const wsDir = this.config.workspaceDir || defaultWorkspaceDir();
-        const files = await readdir14(wsDir).catch(() => []);
-        for (const f of files) {
-          if (!f.startsWith(".compaction-reset-signal-")) continue;
-          const fp = path43.join(wsDir, f);
-          const s = await stat10(fp).catch(() => null);
-          if (s && Date.now() - s.mtimeMs >= COMPACTION_SIGNAL_MAX_AGE_MS) {
-            await unlink7(fp).catch(() => {
-            });
-            log.debug(`initialize: removed stale compaction signal ${f}`);
-          }
-        }
+        await this.validateLocalLlmModel();
       } catch (err) {
-        log.debug("initialize: stale signal sweep failed:", err);
+        log.error(`Local LLM validation failed (non-fatal): ${err}`);
       }
     }
-    log.info("orchestrator initialized (full)");
+    if (signal.aborted) return;
     if (this.config.daySummaryEnabled) {
-      this.autoRegisterDaySummaryCron().catch((err) => {
+      try {
+        await this.autoRegisterDaySummaryCron();
+      } catch (err) {
         log.debug(`day-summary cron auto-register failed (non-fatal): ${err}`);
-      });
+      }
     }
     if (this.config.nightlyGovernanceCronAutoRegister) {
-      this.autoRegisterNightlyGovernanceCron().catch((err) => {
+      try {
+        await this.autoRegisterNightlyGovernanceCron();
+      } catch (err) {
         log.debug(`nightly governance cron auto-register failed (non-fatal): ${err}`);
-      });
+      }
+    }
+    if (this.config.procedural?.proceduralMiningCronAutoRegister) {
+      try {
+        await this.autoRegisterProceduralMiningCron();
+      } catch (err) {
+        log.debug(`procedural mining cron auto-register failed (non-fatal): ${err}`);
+      }
+    }
+    log.info("orchestrator initialized (full \u2014 deferred steps complete)");
+  }
+  /**
+   * Namespace-aware startup search sync. Re-probes QMD, ensures collections
+   * (namespace-aware when namespacesEnabled), runs update, and warms up search.
+   * Designed for server retry paths that run after the deferred init completes
+   * when QMD was not available during initial startup.
+   *
+   * Accepts an optional AbortSignal so callers can interrupt the sync during
+   * shutdown. The signal is checked between phases and forwarded into the QMD
+   * update and warmup search calls so a long-running `qmd update` subprocess
+   * is killed promptly rather than left in flight after `httpServer.stop()`.
+   *
+   * Returns true if the sync succeeded (QMD now available), false otherwise.
+   */
+  async startupSearchSync(signal) {
+    if (signal?.aborted) return false;
+    const available = await this.qmd.probe();
+    if (!available) return false;
+    if (signal?.aborted) {
+      log.debug("startupSearchSync: aborted after probe");
+      return false;
+    }
+    log.info(`startupSearchSync: backend now available ${this.qmd.debugStatus()}`);
+    if (this.config.namespacesEnabled) {
+      this.namespaceSearchRouter.clearCache();
+    }
+    const namespaces = this.config.namespacesEnabled ? this.configuredNamespaces() : [this.config.defaultNamespace];
+    const states = await Promise.all(
+      namespaces.map(async (namespace) => ({
+        namespace,
+        state: this.config.namespacesEnabled ? await this.namespaceSearchRouter.ensureNamespaceCollection(namespace) : await this.qmd.ensureCollection(this.config.memoryDir)
+      }))
+    );
+    if (signal?.aborted) {
+      log.debug("startupSearchSync: aborted after ensureCollection");
+      return false;
+    }
+    const defaultState2 = states.find((e) => e.namespace === this.config.defaultNamespace)?.state ?? "unknown";
+    if (defaultState2 === "missing") {
+      if ("available" in this.qmd) {
+        this.qmd.available = false;
+      }
+      this.qmd = new NoopSearchBackend();
+      log.warn("startupSearchSync: search collection missing; disabling search (fallback retrieval remains enabled)");
+      return false;
+    }
+    if (this.config.qmdMaintenanceEnabled) {
+      try {
+        const failTsBefore = "lastUpdateFailedAtMs" in this.qmd ? this.qmd.lastUpdateFailedAtMs : null;
+        const hasRunTs = "lastUpdateRanAtMs" in this.qmd;
+        if ("resetUpdateThrottles" in this.qmd) {
+          this.qmd.resetUpdateThrottles();
+        }
+        log.info("startupSearchSync: updating index to match current disk state");
+        let namespacesUpdated = 0;
+        if (this.config.namespacesEnabled) {
+          namespacesUpdated = await this.namespaceSearchRouter.updateNamespaces(namespaces);
+        } else {
+          await this.qmd.update(signal);
+        }
+        if (signal?.aborted) {
+          log.debug("startupSearchSync: aborted after update");
+          return false;
+        }
+        const failTsAfter = "lastUpdateFailedAtMs" in this.qmd ? this.qmd.lastUpdateFailedAtMs : null;
+        const runTsAfter = hasRunTs ? this.qmd.lastUpdateRanAtMs : null;
+        if (failTsAfter !== null && failTsAfter !== failTsBefore) {
+          log.warn("startupSearchSync: update silently failed (detected via fail timestamp)");
+          return false;
+        }
+        if (this.config.namespacesEnabled) {
+          if (namespacesUpdated === 0) {
+            log.warn("startupSearchSync: no namespace backends were eligible for update (all unavailable or collections missing)");
+            return false;
+          }
+          log.info(`startupSearchSync: namespace updates succeeded (${namespacesUpdated}/${namespaces.length} namespaces updated)`);
+        } else if (hasRunTs && runTsAfter === null) {
+          log.warn("startupSearchSync: update was throttled/skipped (run timestamp is null after reset + update)");
+          return false;
+        }
+        log.info("startupSearchSync: sync complete");
+      } catch (err) {
+        log.warn(`startupSearchSync: update failed: ${err}`);
+        return false;
+      }
+    }
+    if (!signal?.aborted) {
+      try {
+        await this.qmd.search("warmup", this.config.defaultNamespace, 1, void 0, { signal });
+        log.info("startupSearchSync: warmup complete");
+      } catch (err) {
+        log.debug(`startupSearchSync: warmup search failed (non-fatal): ${err}`);
+      }
     }
+    return true;
   }
   /**
    * Auto-register the engram-day-summary cron job in OpenClaw if it doesn't exist.
@@ -27918,6 +28500,26 @@ var Orchestrator = class _Orchestrator {
       log.debug(`nightly governance cron auto-register error: ${err}`);
     }
   }
+  async autoRegisterProceduralMiningCron() {
+    const home = resolveHomeDir();
+    const jobsPath = path43.join(home, ".openclaw", "cron", "jobs.json");
+    try {
+      if (!existsSync8(jobsPath)) {
+        log.debug("procedural mining cron: jobs.json not found, skipping auto-register");
+        return;
+      }
+      const created = await ensureProceduralMiningCron(jobsPath, {
+        timezone: Intl.DateTimeFormat().resolvedOptions().timeZone
+      });
+      if (created.created) {
+        log.info(`procedural mining cron auto-registered (${created.jobId})`);
+      } else {
+        log.debug("procedural mining cron already exists, skipping auto-register");
+      }
+    } catch (err) {
+      log.debug(`procedural mining cron auto-register error: ${err}`);
+    }
+  }
   async applyBehaviorRuntimePolicy(state) {
     const result = await this.policyRuntime.applyFromBehaviorState(state);
     this.runtimePolicyValues = await this.policyRuntime.loadRuntimeValues();
@@ -30381,7 +30983,7 @@ ${trimmedBody}`;
           return null;
         }
         try {
-          const { retrieveCausalChains } = await import("./causal-retrieval-5UPIKZ4I.js");
+          const { retrieveCausalChains } = await import("./causal-retrieval-3BKBXVXD.js");
           const section = await retrieveCausalChains({
             memoryDir: this.config.memoryDir,
             causalTrajectoryStoreDir: this.config.causalTrajectoryStoreDir,
@@ -31317,6 +31919,22 @@ ${formatted}`;
         });
         return section;
       })();
+      const procedureRecallPromise = (async () => {
+        if (this.config.procedural?.enabled !== true) return null;
+        if (!this.isRecallSectionEnabled("procedure-recall", true)) return null;
+        try {
+          return await buildProcedureRecallSection(
+            this.storage,
+            retrievalQuery,
+            this.config
+          );
+        } catch (err) {
+          log.debug(
+            `procedure-recall: failed open: ${err instanceof Error ? err.message : String(err)}`
+          );
+          return null;
+        }
+      })();
       const compoundingPromise = observeEnrichmentPromise(
         (async () => {
           const t0 = Date.now();
@@ -31381,6 +31999,7 @@ ${formatted}`;
         causalTrajectorySection,
         cmcCausalChainsSection,
         calibrationSection,
+        procedureRecallSection,
         trustZoneSection,
         verifiedRecallSection,
         verifiedRulesSection,
@@ -31402,6 +32021,7 @@ ${formatted}`;
             ["causalTraj", causalTrajectoryPromise],
             ["cmc", cmcRetrievalPromise],
             ["calibration", calibrationPromise],
+            ["procedureRecall", procedureRecallPromise],
             ["trustZone", trustZonePromise],
             ["verifiedRecall", verifiedRecallPromise],
             ["verifiedRules", verifiedRulesPromise],
@@ -31507,6 +32127,13 @@ ${profile}`
           calibrationSection
         );
       }
+      if (procedureRecallSection) {
+        this.appendRecallSection(
+          sectionBuckets,
+          "procedure-recall",
+          procedureRecallSection
+        );
+      }
       if (identityContinuity) {
         this.appendRecallSection(
           sectionBuckets,
@@ -32551,6 +33178,87 @@ _Context: ${topQuestion.context}_`
       }
     }
   }
+  /**
+   * Return the namespace that `ingestBulkImportBatch` writes into (#460).
+   *
+   * Exposed so host CLIs can snapshot the same storage root that extraction
+   * actually writes to, avoiding the "CLI counts files at namespace A while
+   * writes land in namespace B" footgun that a naïve
+   * `config.defaultNamespace` snapshot could hit when a namespace policy
+   * named `"default"` also exists.
+   *
+   * Today bulk-import is pinned to `config.defaultNamespace`; future
+   * per-invocation namespace routing would thread an explicit target here
+   * and through `ingestBulkImportBatch`.
+   */
+  bulkImportWriteNamespace() {
+    return this.config.defaultNamespace;
+  }
+  /**
+   * Ingest a batch of bulk-import turns (#460). Like ingestReplayBatch, this
+   * normalizes user/assistant turns into the extraction buffer and awaits
+   * settlement, but it intentionally bypasses the captureMode="explicit"
+   * gate because bulk-import is itself an explicit user action — the user
+   * ran `bulk-import --source <name> --file ...` and would be surprised to
+   * see the command silently no-op when capture is otherwise restricted.
+   *
+   * Turns with role="other" are skipped (not supported by the extraction
+   * pipeline).
+   *
+   * Two design decisions worth calling out:
+   *
+   * - **sessionKey is truthy and per-batch-unique.**
+   *   `ThreadingManager.shouldStartNewThread` only applies the session-key
+   *   boundary check when `turn.sessionKey` is truthy (threading.ts:82);
+   *   with an empty string, imported turns could attach to the current
+   *   live thread or merge across unrelated import batches. A unique
+   *   `bulk-import:batch:<timestamp>-<rand>` key forces a fresh thread per
+   *   batch without matching common prefix/map rules in
+   *   `principalFromSessionKeyRules`. (Catch-all regex rules could still
+   *   remap the principal, but that only affects metadata provenance —
+   *   see the next point for why write routing is unaffected.)
+   *
+   * - **writeNamespaceOverride pins the storage target.**
+   *   We pass `writeNamespaceOverride: this.bulkImportWriteNamespace()` to
+   *   `queueBufferedExtraction`, which tells `runExtraction` to skip
+   *   `defaultNamespaceForPrincipal` and write directly into the
+   *   orchestrator's declared bulk-import write namespace. This keeps
+   *   writes deterministic even when namespace policies named `"default"`
+   *   exist alongside a different `config.defaultNamespace`, and also
+   *   guards against regex-catch-all principal rules steering bulk-import
+   *   into an unexpected tenant.
+   *
+   * Per-invocation namespace routing (letting callers target a namespace
+   * other than `bulkImportWriteNamespace()`) is a separate feature tracked
+   * as a follow-up — the hook is the `writeNamespaceOverride` option, but
+   * the CLI surface does not yet expose a `--namespace` flag.
+   */
+  async ingestBulkImportBatch(turns, options = {}) {
+    if (!Array.isArray(turns) || turns.length === 0) return;
+    const sessionKey = `bulk-import:batch:${Date.now().toString(36)}-` + randomBytes(6).toString("hex");
+    const sessionTurns = [];
+    for (const turn of turns) {
+      if (turn.role !== "user" && turn.role !== "assistant") continue;
+      sessionTurns.push({
+        role: turn.role,
+        content: turn.content,
+        timestamp: turn.timestamp,
+        sessionKey
+      });
+    }
+    if (sessionTurns.length === 0) return;
+    await new Promise((resolve, reject) => {
+      void this.queueBufferedExtraction(sessionTurns, "trigger_mode", {
+        skipDedupeCheck: true,
+        clearBufferAfterExtraction: false,
+        skipCharThreshold: true,
+        bufferKey: sessionKey,
+        extractionDeadlineMs: options.deadlineMs,
+        writeNamespaceOverride: this.bulkImportWriteNamespace(),
+        onTaskSettled: (err) => err ? reject(err) : resolve()
+      }).catch(reject);
+    });
+  }
   async observeSessionHeartbeat(sessionKey, options = {}) {
     if (this.config.sessionObserverEnabled !== true) return;
     if (!sessionKey || sessionKey.length === 0) return;
@@ -32617,7 +33325,8 @@ _Context: ${topQuestion.context}_`
           skipCharThreshold: options.skipCharThreshold ?? false,
           deadlineMs: options.extractionDeadlineMs,
           bufferKey,
-          abortSignal: options.abortSignal
+          abortSignal: options.abortSignal,
+          writeNamespaceOverride: options.writeNamespaceOverride
         });
         options.onTaskSettled?.();
       } catch (err) {
@@ -32743,7 +33452,7 @@ ${normalized}`).digest("hex");
       return;
     }
     const principal = resolvePrincipal(sessionKey, this.config);
-    const selfNamespace = defaultNamespaceForPrincipal(principal, this.config);
+    const selfNamespace = typeof options.writeNamespaceOverride === "string" && options.writeNamespaceOverride.length > 0 ? options.writeNamespaceOverride : defaultNamespaceForPrincipal(principal, this.config);
     const storage = await this.storageRouter.storageFor(selfNamespace);
     const shouldPersistProcessedFingerprint = normalizedTurns.some(
       (turn) => turn.persistProcessedFingerprint === true
@@ -33427,6 +34136,9 @@ ${normalized}`).digest("hex");
             continue;
           }
           const judgeCategory = preRoutedCategories[fi] ?? f.category;
+          if (judgeCategory === "procedure") {
+            continue;
+          }
           const tags = Array.isArray(f.tags) ? f.tags : [];
           const imp = scoreImportance(
             f.content,
@@ -33521,6 +34233,10 @@ ${normalized}`).digest("hex");
         writeCategory,
         fact.tags
       );
+      if (writeCategory === "procedure" && this.config.procedural?.enabled !== true) {
+        log.debug("persistExtraction: skip procedure memory (procedural.enabled is false)");
+        continue;
+      }
       if (!isAboveImportanceThreshold(
         importance.level,
         this.config.extractionMinImportanceLevel
@@ -33549,6 +34265,24 @@ ${normalized}`).digest("hex");
           }
         }
       }
+      if (writeCategory === "procedure") {
+        const procGate = validateProcedureExtraction({
+          content: fact.content,
+          procedureSteps: fact.procedureSteps
+        });
+        if (!procGate.durable) {
+          if (this.config.extractionJudgeShadow) {
+            log.info(
+              `extraction-procedure-gate[shadow]: would reject "${fact.content.slice(0, 60)}\u2026" reason="${procGate.reason}"`
+            );
+          } else {
+            log.debug(
+              `extraction-procedure-gate: rejected "${fact.content.slice(0, 60)}\u2026" reason="${procGate.reason}"`
+            );
+            continue;
+          }
+        }
+      }
       let pendingSemanticSkip = null;
       if (this.config.semanticDedupEnabled) {
         let semanticDecision;
@@ -33628,7 +34362,7 @@ ${normalized}`).digest("hex");
         dedupedCount++;
         continue;
       }
-      if (this.config.chunkingEnabled) {
+      if (this.config.chunkingEnabled && writeCategory !== "procedure") {
         let chunkResult;
         if (this.config.semanticChunkingEnabled) {
           try {
@@ -33823,8 +34557,9 @@ ${normalized}`).digest("hex");
           links.push(...suggestedLinks);
         }
       }
-      const memoryKind = this.config.episodeNoteModeEnabled ? classifyMemoryKind(fact.content, fact.tags ?? [], writeCategory) : void 0;
-      const citedFactContent = applyInlineCitation(fact.content);
+      const memoryKind = writeCategory === "procedure" ? void 0 : this.config.episodeNoteModeEnabled ? classifyMemoryKind(fact.content, fact.tags ?? [], writeCategory) : void 0;
+      const rawPersistBody = writeCategory === "procedure" ? buildProcedurePersistBody(fact.content, fact.procedureSteps) : fact.content;
+      const citedFactContent = applyInlineCitation(rawPersistBody);
       const memoryId = await targetStorage.writeMemory(
         writeCategory,
         citedFactContent,
@@ -33841,7 +34576,7 @@ ${normalized}`).digest("hex");
           intentEntityTypes: inferredIntent?.entityTypes,
           memoryKind,
           structuredAttributes: fact.structuredAttributes,
-          contentHashSource: fact.content
+          contentHashSource: writeCategory === "fact" ? fact.content : void 0
         }
       );
       if (routedRuleId) {
@@ -39065,8 +39800,8 @@ Best for:
         ),
         category: Type.Optional(
           Type.String({
-            description: 'Category: "fact", "preference", "correction", "entity", "decision", "relationship", "principle", "commitment", "moment", "skill", "rule" (default: "fact")',
-            enum: ["fact", "preference", "correction", "entity", "decision", "relationship", "principle", "commitment", "moment", "skill", "rule"]
+            description: 'Category: "fact", "preference", "correction", "entity", "decision", "relationship", "principle", "commitment", "moment", "skill", "rule", "procedure" (default: "fact")',
+            enum: ["fact", "preference", "correction", "entity", "decision", "relationship", "principle", "commitment", "moment", "skill", "rule", "procedure"]
           })
         ),
         tags: Type.Optional(
@@ -39124,7 +39859,7 @@ Best for:
         category: Type.Optional(
           Type.String({
             description: "Memory category.",
-            enum: ["fact", "preference", "correction", "entity", "decision", "relationship", "principle", "commitment", "moment", "skill", "rule"]
+            enum: ["fact", "preference", "correction", "entity", "decision", "relationship", "principle", "commitment", "moment", "skill", "rule", "procedure"]
           })
         ),
         tags: Type.Optional(
@@ -40193,8 +40928,8 @@ Returns: Performance trace data with timing breakdown`,
 }
 
 // ../remnic-core/src/cli.ts
-import path71 from "path";
-import { access as access5, readFile as readFile45, readdir as readdir25, unlink as unlink11 } from "fs/promises";
+import path72 from "path";
+import { access as access5, readFile as readFile46, readdir as readdir26, unlink as unlink11 } from "fs/promises";
 import { createHash as createHash14 } from "crypto";
 
 // ../remnic-core/src/transfer/export-json.ts
@@ -41071,8 +41806,8 @@ function gatherCandidates(input, warnings) {
       const record = rec;
       const content = typeof record.content === "string" ? record.content : null;
       if (!content) continue;
-      const path99 = typeof record.path === "string" ? record.path : "";
-      if (!path99.startsWith("transcripts/") && !path99.includes("/transcripts/")) continue;
+      const path100 = typeof record.path === "string" ? record.path : "";
+      if (!path100.startsWith("transcripts/") && !path100.includes("/transcripts/")) continue;
       rows.push(...parseJsonl(content, warnings));
     }
     return rows;
@@ -41127,6 +41862,158 @@ var openclawReplayNormalizer = {
   }
 };
 
+// ../remnic-core/src/bulk-import/types.ts
+var VALID_ROLES2 = /* @__PURE__ */ new Set(["user", "assistant", "other"]);
+function isImportRole(value) {
+  return typeof value === "string" && VALID_ROLES2.has(value);
+}
+function parseIsoTimestamp2(value) {
+  return parseIsoOffsetTimestamp(value);
+}
+function validateImportTurn(turn, index) {
+  const issues = [];
+  if (!turn || typeof turn !== "object") {
+    issues.push({
+      code: "turn.invalid",
+      message: "Import turn must be an object.",
+      index
+    });
+    return issues;
+  }
+  if (!isImportRole(turn.role)) {
+    issues.push({
+      code: "turn.role.invalid",
+      message: `Import turn role must be 'user', 'assistant', or 'other', received '${String(turn.role)}'.`,
+      index
+    });
+  }
+  if (!turn.content || typeof turn.content !== "string" || turn.content.trim().length === 0) {
+    issues.push({
+      code: "turn.content.invalid",
+      message: "Import turn content must be a non-empty string.",
+      index
+    });
+  }
+  if (!turn.timestamp || typeof turn.timestamp !== "string" || parseIsoTimestamp2(turn.timestamp) === null) {
+    issues.push({
+      code: "turn.timestamp.invalid",
+      message: `Import turn timestamp must be a valid ISO timestamp, received '${String(turn.timestamp)}'.`,
+      index
+    });
+  }
+  return issues;
+}
+
+// ../remnic-core/src/bulk-import/registry.ts
+var adapters = /* @__PURE__ */ new Map();
+function registerBulkImportSource(adapter) {
+  if (!adapter || typeof adapter !== "object") {
+    throw new Error("bulk-import adapter must be an object");
+  }
+  if (!adapter.name || typeof adapter.name !== "string" || adapter.name.trim().length === 0) {
+    throw new Error("bulk-import adapter name must be a non-empty string");
+  }
+  if (typeof adapter.parse !== "function") {
+    throw new Error(
+      `bulk-import adapter '${adapter.name}' must have a parse function`
+    );
+  }
+  const key = adapter.name.trim();
+  if (adapters.has(key)) {
+    throw new Error(
+      `bulk-import source adapter '${key}' is already registered`
+    );
+  }
+  const normalized = adapter.name === key ? adapter : { ...adapter, name: key };
+  adapters.set(key, normalized);
+}
+function getBulkImportSource(name) {
+  if (typeof name !== "string") return void 0;
+  const key = name.trim();
+  if (key.length === 0) return void 0;
+  return adapters.get(key);
+}
+function listBulkImportSources() {
+  return [...adapters.keys()];
+}
+
+// ../remnic-core/src/bulk-import/pipeline.ts
+var DEFAULT_BATCH_SIZE = 20;
+var MIN_BATCH_SIZE = 1;
+var MAX_BATCH_SIZE = 1e3;
+function validateBatchSize(value) {
+  if (value === void 0) return DEFAULT_BATCH_SIZE;
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    throw new Error(
+      `batchSize must be a finite number, received ${String(value)}`
+    );
+  }
+  if (!Number.isInteger(value)) {
+    throw new Error(
+      `batchSize must be an integer, received ${value}`
+    );
+  }
+  if (value < MIN_BATCH_SIZE || value > MAX_BATCH_SIZE) {
+    throw new Error(
+      `batchSize must be between ${MIN_BATCH_SIZE} and ${MAX_BATCH_SIZE}, received ${value}`
+    );
+  }
+  return value;
+}
+async function runBulkImportPipeline(source, options = {}, processBatch) {
+  const batchSize = validateBatchSize(options.batchSize);
+  const dryRun = options.dryRun === true;
+  const result = {
+    memoriesCreated: 0,
+    duplicatesSkipped: 0,
+    entitiesCreated: 0,
+    turnsProcessed: 0,
+    batchesProcessed: 0,
+    errors: []
+  };
+  const turns = source.turns;
+  if (!turns || turns.length === 0) {
+    return result;
+  }
+  const validTurns = [];
+  for (let i = 0; i < turns.length; i += 1) {
+    const issues = validateImportTurn(turns[i], i);
+    if (issues.length > 0) {
+      const error = {
+        batchIndex: -1,
+        message: issues.map((iss) => iss.message).join("; ")
+      };
+      result.errors.push(error);
+    } else {
+      validTurns.push(turns[i]);
+    }
+  }
+  if (dryRun) {
+    result.turnsProcessed = validTurns.length;
+    result.batchesProcessed = validTurns.length > 0 ? Math.ceil(validTurns.length / batchSize) : 0;
+    return result;
+  }
+  let batchIndex = 0;
+  for (let i = 0; i < validTurns.length; i += batchSize) {
+    const batch = validTurns.slice(i, i + batchSize);
+    try {
+      const batchResult = await processBatch(batch);
+      result.memoriesCreated += batchResult.memoriesCreated;
+      result.duplicatesSkipped += batchResult.duplicatesSkipped;
+      if (typeof batchResult.entitiesCreated === "number") {
+        result.entitiesCreated += batchResult.entitiesCreated;
+      }
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      result.errors.push({ batchIndex, message });
+    }
+    result.turnsProcessed += batch.length;
+    result.batchesProcessed += 1;
+    batchIndex += 1;
+  }
+  return result;
+}
+
 // ../remnic-core/src/maintenance/archive-observations.ts
 import path55 from "path";
 import { mkdir as mkdir40, readdir as readdir19, readFile as readFile33, unlink as unlink8, writeFile as writeFile37 } from "fs/promises";
@@ -44475,6 +45362,98 @@ function sleep2(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
+// ../remnic-core/src/procedural/procedure-miner.ts
+function clusterKey(record) {
+  const goal = record.goal.trim().toLowerCase().replace(/\s+/g, " ").slice(0, 120);
+  const refs = [...record.entityRefs ?? []].map((r) => r.trim().toLowerCase()).sort();
+  return `${goal}|${refs.join(",")}`;
+}
+function successRate(group) {
+  if (group.length === 0) return 0;
+  const ok = group.filter((g) => g.outcomeKind === "success" || g.outcomeKind === "partial").length;
+  return ok / group.length;
+}
+function pseudoStepsFromCluster(group) {
+  const sentences = [];
+  const pushUnique = (raw) => {
+    const t = raw.trim();
+    if (t.length < 8) return;
+    if (!sentences.includes(t)) sentences.push(t);
+  };
+  for (const g of group) {
+    const parts = [g.actionSummary, g.observationSummary, g.outcomeSummary].join(" ").split(/[.!?]\s+|;|\n+/).map((s) => s.trim()).filter((s) => s.length > 12);
+    for (const p of parts) pushUnique(p);
+    if (sentences.length >= 5) break;
+  }
+  if (sentences.length < 2 && group[0]) {
+    pushUnique(`${group[0].goal.trim()} \u2014 confirm prerequisites and context.`);
+    pushUnique("Execute the planned actions, then record the outcome.");
+  }
+  return sentences.slice(0, 6).map((intent, i) => ({
+    order: i + 1,
+    intent
+  }));
+}
+async function hasExistingClusterWrite(storage, cluster) {
+  const memories = await storage.readAllMemories();
+  for (const m of memories) {
+    if (m.frontmatter.category !== "procedure") continue;
+    const c = m.frontmatter.structuredAttributes?.procedure_cluster;
+    if (c === cluster) return true;
+  }
+  return false;
+}
+async function runProcedureMining(options) {
+  const cfg = options.config.procedural;
+  if (!cfg?.enabled) {
+    return { clustersProcessed: 0, proceduresWritten: 0, skippedReason: "procedural_disabled" };
+  }
+  if (cfg.minOccurrences <= 0) {
+    return { clustersProcessed: 0, proceduresWritten: 0, skippedReason: "minOccurrences_zero" };
+  }
+  const { trajectories } = await readCausalTrajectoryRecords({
+    memoryDir: options.memoryDir
+  });
+  const recent = filterTrajectoriesByLookbackDays(trajectories, cfg.lookbackDays);
+  const clusters = /* @__PURE__ */ new Map();
+  for (const t of recent) {
+    const key = clusterKey(t);
+    const arr = clusters.get(key) ?? [];
+    arr.push(t);
+    clusters.set(key, arr);
+  }
+  let clustersProcessed = 0;
+  let proceduresWritten = 0;
+  for (const [key, group] of clusters) {
+    if (group.length < cfg.minOccurrences) continue;
+    const rate = successRate(group);
+    if (rate < cfg.successFloor) continue;
+    clustersProcessed += 1;
+    if (await hasExistingClusterWrite(options.storage, key)) {
+      log.debug(`procedure-miner: skip duplicate cluster key=${key.slice(0, 40)}\u2026`);
+      continue;
+    }
+    const steps = normalizeProcedureSteps(pseudoStepsFromCluster(group));
+    if (steps.length < 2) continue;
+    const title = `When you work on goals like: ${group[0].goal.trim().slice(0, 140)}`;
+    const body = buildProcedurePersistBody(title, steps);
+    const promote = cfg.autoPromoteEnabled === true && group.length >= cfg.autoPromoteOccurrences && rate >= cfg.successFloor;
+    await options.storage.writeMemory("procedure", body, {
+      source: "procedure-miner",
+      status: promote ? "active" : "pending_review",
+      tags: ["procedure-miner", "causal-trajectory"],
+      structuredAttributes: {
+        procedure_cluster: key.slice(0, 500),
+        trajectory_ids: group.map((g) => g.trajectoryId).join(",").slice(0, 1900),
+        trajectory_count: String(group.length),
+        success_rate: rate.toFixed(4)
+      }
+    });
+    proceduresWritten += 1;
+  }
+  return { clustersProcessed, proceduresWritten };
+}
+
 // ../remnic-core/src/briefing.ts
 import { readFile as readFile41 } from "fs/promises";
 import path67 from "path";
@@ -46186,6 +47165,25 @@ var EngramAccessService = class {
       reportPath: result.reportPath
     };
   }
+  async procedureMiningRun(request, principal) {
+    const resolvedNamespace = this.resolveWritableNamespace(
+      request.namespace,
+      void 0,
+      request.authenticatedPrincipal ?? principal
+    );
+    const storage = await this.orchestrator.getStorage(resolvedNamespace);
+    const result = await runProcedureMining({
+      memoryDir: storage.dir,
+      storage,
+      config: this.orchestrator.config
+    });
+    return {
+      namespace: resolvedNamespace,
+      clustersProcessed: result.clustersProcessed,
+      proceduresWritten: result.proceduresWritten,
+      skippedReason: result.skippedReason
+    };
+  }
   async trustZoneStatus(namespace, principal) {
     const resolvedNamespace = this.resolveReadableNamespace(namespace, principal);
     const storage = await this.orchestrator.getStorage(resolvedNamespace);
@@ -47214,6 +48212,17 @@ var EngramMcpServer = class {
           additionalProperties: false
         }
       },
+      {
+        name: "engram.procedure_mining_run",
+        description: "Run procedural memory mining from causal trajectories (issue #519). Respects procedural.enabled; writes under procedures/ when clusters qualify.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            namespace: { type: "string" }
+          },
+          additionalProperties: false
+        }
+      },
       {
         name: "engram.memory_get",
         description: "Fetch one Remnic memory by id.",
@@ -48093,6 +49102,14 @@ ${body}`;
           batchSize: typeof args.batchSize === "number" && Number.isFinite(args.batchSize) ? args.batchSize : void 0,
           authenticatedPrincipal: effectivePrincipal
         }, effectivePrincipal);
+      case "engram.procedure_mining_run":
+        return this.service.procedureMiningRun(
+          {
+            namespace: typeof args.namespace === "string" ? args.namespace : void 0,
+            authenticatedPrincipal: effectivePrincipal
+          },
+          effectivePrincipal
+        );
       case "engram.memory_get":
         return this.service.memoryGet(
           typeof args.memoryId === "string" ? args.memoryId : "",
@@ -48458,7 +49475,8 @@ var categorySchema = external_exports.enum([
   "commitment",
   "moment",
   "skill",
-  "rule"
+  "rule",
+  "procedure"
 ]).optional();
 var confidenceSchema = external_exports.number().min(0).max(1).optional();
 var tagsSchema = external_exports.array(external_exports.string().max(256)).max(50).optional();
@@ -48657,8 +49675,8 @@ var HermesAdapter = class {
 // ../remnic-core/src/adapters/registry.ts
 var AdapterRegistry = class {
   adapters;
-  constructor(adapters) {
-    this.adapters = adapters ?? [
+  constructor(adapters2) {
+    this.adapters = adapters2 ?? [
       new HermesAdapter(),
       new ReplitAdapter(),
       new CodexAdapter(),
@@ -50130,6 +51148,10 @@ async function promoteSemanticRuleFromMemory(options) {
   return report;
 }
 
+// ../remnic-core/src/training-export/converter.ts
+import { lstat as lstat2, readdir as readdir25, readFile as readFile45, realpath as realpath3 } from "fs/promises";
+import path71 from "path";
+
 // ../remnic-core/src/cli.ts
 function rankCandidateForKeep(a, b) {
   const aConfidence = typeof a.frontmatter.confidence === "number" ? a.frontmatter.confidence : 0;
@@ -50320,7 +51342,7 @@ async function runRepairMemoryProjectionCliCommand(options) {
   });
 }
 async function runMemoryTimelineCliCommand(options) {
-  const storage = new (await import("./storage-HW6SRQCK.js")).StorageManager(options.memoryDir);
+  const storage = new (await import("./storage-BA6OBLMK.js")).StorageManager(options.memoryDir);
   return storage.getMemoryTimeline(options.memoryId, options.limit);
 }
 async function runMemoryGovernanceCliCommand(options) {
@@ -50348,7 +51370,7 @@ async function runMemoryGovernanceRestoreCliCommand(options) {
   });
 }
 async function runMemoryReviewDispositionCliCommand(options) {
-  const storage = new (await import("./storage-HW6SRQCK.js")).StorageManager(options.memoryDir);
+  const storage = new (await import("./storage-BA6OBLMK.js")).StorageManager(options.memoryDir);
   const memory = await storage.getMemoryById(options.memoryId);
   if (!memory) throw new Error(`memory not found: ${options.memoryId}`);
   const updated = await storage.writeMemoryFrontmatter(memory, {
@@ -50514,7 +51536,7 @@ async function runSemanticRulePromoteCliCommand(options) {
   });
 }
 async function runCompoundingPromoteCliCommand(options) {
-  const { CompoundingEngine: CompoundingEngine2 } = await import("./engine-2TLD4YSC.js");
+  const { CompoundingEngine: CompoundingEngine2 } = await import("./engine-BU6GNUJ5.js");
   const config = parseConfig({
     memoryDir: options.memoryDir,
     qmdEnabled: false,
@@ -50931,7 +51953,7 @@ function policyVersionForValues(values, config) {
   return createHash14("sha256").update(JSON.stringify(normalized)).digest("hex").slice(0, 12);
 }
 async function readRuntimePolicySnapshot2(config, fileName) {
-  const filePath = path71.join(config.memoryDir, "state", fileName);
+  const filePath = path72.join(config.memoryDir, "state", fileName);
   const snapshot = await readRuntimePolicySnapshot(filePath, {
     maxStaleDecayThreshold: config.lifecycleArchiveDecayThreshold
   });
@@ -51487,7 +52509,7 @@ async function withTimeout(promise, timeoutMs, timeoutMessage) {
 }
 async function runReplayCliCommand(orchestrator, options) {
   const extractionIdleTimeoutMs = Number.isFinite(options.extractionIdleTimeoutMs) ? Math.max(1e3, Math.floor(options.extractionIdleTimeoutMs)) : 15 * 6e4;
-  const inputRaw = await readFile45(options.inputPath, "utf-8");
+  const inputRaw = await readFile46(options.inputPath, "utf-8");
   const registry = buildReplayNormalizerRegistry([
     openclawReplayNormalizer,
     claudeReplayNormalizer,
@@ -51549,10 +52571,101 @@ async function runReplayCliCommand(orchestrator, options) {
   }
   return summary;
 }
+async function ensureBuiltInBulkImportAdapters() {
+  if (!getBulkImportSource("weclone")) {
+    const wecloneSpecifier = "@remnic/import-weclone";
+    try {
+      const mod = await import(wecloneSpecifier);
+      if (mod.wecloneImportAdapter) {
+        try {
+          registerBulkImportSource(mod.wecloneImportAdapter);
+        } catch {
+        }
+      }
+    } catch {
+    }
+  }
+}
+async function runBulkImportCliCommand(opts) {
+  await ensureBuiltInBulkImportAdapters();
+  const adapter = getBulkImportSource(opts.source);
+  if (!adapter) {
+    const registered = listBulkImportSources();
+    const list = registered.length > 0 ? registered.map((n) => `'${n}'`).join(", ") : "(none registered)";
+    throw new Error(
+      `Unknown bulk-import source '${opts.source}'. Valid sources: ${list}`
+    );
+  }
+  if (opts.dryRun !== true && typeof opts.ingestBatch !== "function") {
+    throw new Error(
+      "Bulk import persistence is not wired: no ingestBatch callback was provided by the host CLI. Use --dry-run to validate without persisting, or invoke via `openclaw engram bulk-import` which supplies the orchestrator-backed ingestion path."
+    );
+  }
+  const inputRaw = await readFile46(opts.file, "utf-8");
+  let inputParsed;
+  try {
+    inputParsed = JSON.parse(inputRaw);
+  } catch (err) {
+    throw new Error(
+      `Failed to parse import file as JSON: ${err.message}`
+    );
+  }
+  if (typeof inputParsed !== "object" || inputParsed === null) {
+    throw new Error(
+      "Import file must contain a JSON object or array, got " + (inputParsed === null ? "null" : typeof inputParsed)
+    );
+  }
+  const parsed = await adapter.parse(inputParsed, {
+    strict: opts.strict === true,
+    platform: opts.platform
+  });
+  const processBatch = opts.ingestBatch ?? (async () => {
+    throw new Error(
+      "Bulk import persistence is not wired: no ingestBatch callback was provided by the host CLI."
+    );
+  });
+  const result = await runBulkImportPipeline(
+    parsed,
+    {
+      batchSize: opts.batchSize,
+      dryRun: opts.dryRun,
+      dedup: true,
+      trustLevel: "import"
+    },
+    processBatch
+  );
+  const out = opts.stdout;
+  out.write(`Bulk import complete (source: ${opts.source})
+`);
+  out.write(`  Turns processed:     ${result.turnsProcessed}
+`);
+  out.write(`  Batches processed:   ${result.batchesProcessed}
+`);
+  out.write(`  Memories created:    ${result.memoriesCreated}
+`);
+  out.write(`  Duplicates skipped:  ${result.duplicatesSkipped}
+`);
+  if (result.errors.length > 0) {
+    out.write(`  Errors:              ${result.errors.length}
+`);
+    if (opts.verbose) {
+      for (const err of result.errors) {
+        opts.stderr.write(
+          `    [batch ${err.batchIndex}] ${err.message}
+`
+        );
+      }
+    }
+  }
+  if (opts.dryRun) {
+    out.write("  (dry run \u2014 no memories were stored)\n");
+  }
+  return result;
+}
 async function getPluginVersion() {
   try {
     const pkgPath = new URL("../package.json", import.meta.url);
-    const raw = await readFile45(pkgPath, "utf-8");
+    const raw = await readFile46(pkgPath, "utf-8");
     const parsed = JSON.parse(raw);
     return parsed.version ?? "unknown";
   } catch {
@@ -51576,59 +52689,71 @@ async function resolveMemoryDirForNamespace(orchestrator, namespace, options) {
     }
     return orchestrator.config.memoryDir;
   }
-  const candidate = path71.join(orchestrator.config.memoryDir, "namespaces", ns);
+  const candidate = path72.join(orchestrator.config.memoryDir, "namespaces", ns);
   if (ns === orchestrator.config.defaultNamespace) {
     return await exists3(candidate) ? candidate : orchestrator.config.memoryDir;
   }
   return candidate;
 }
-async function readAllMemoryFiles(memoryDir) {
-  const roots = [path71.join(memoryDir, "facts"), path71.join(memoryDir, "corrections")];
-  const out = [];
+async function walkMemoryMarkdownFiles(memoryDir, visit) {
+  const roots = [path72.join(memoryDir, "facts"), path72.join(memoryDir, "corrections")];
   const walk = async (dir) => {
     let entries;
     try {
-      entries = await readdir25(dir, { withFileTypes: true });
+      entries = await readdir26(dir, { withFileTypes: true });
     } catch {
       return;
     }
     for (const entry of entries) {
       const entryName = typeof entry.name === "string" ? entry.name : entry.name.toString("utf-8");
-      const fullPath = path71.join(dir, entryName);
+      const fullPath = path72.join(dir, entryName);
       if (entry.isDirectory()) {
         await walk(fullPath);
         continue;
       }
       if (!entry.isFile() || !entryName.endsWith(".md")) continue;
-      try {
-        const raw = await readFile45(fullPath, "utf-8");
-        const parsed = raw.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
-        if (!parsed) continue;
-        const fmRaw = parsed[1];
-        const body = parsed[2] ?? "";
-        const get = (key) => {
-          const match = fmRaw.match(new RegExp(`^${key}:\\s*(.+)$`, "m"));
-          return match ? match[1].trim() : "";
-        };
-        const confidenceRaw = get("confidence");
-        const confidence = confidenceRaw.length > 0 ? Number(confidenceRaw) : void 0;
-        out.push({
-          path: fullPath,
-          content: body,
-          frontmatter: {
-            id: get("id") || void 0,
-            confidence: Number.isFinite(confidence) ? confidence : void 0,
-            updated: get("updated") || void 0,
-            created: get("created") || void 0
-          }
-        });
-      } catch {
-      }
+      await visit(fullPath);
     }
   };
   for (const root of roots) {
     await walk(root);
   }
+}
+async function listMemoryMarkdownFilePaths(memoryDir) {
+  const paths = [];
+  await walkMemoryMarkdownFiles(memoryDir, (fullPath) => {
+    paths.push(fullPath);
+  });
+  return paths;
+}
+async function readAllMemoryFiles(memoryDir) {
+  const out = [];
+  await walkMemoryMarkdownFiles(memoryDir, async (fullPath) => {
+    try {
+      const raw = await readFile46(fullPath, "utf-8");
+      const parsed = raw.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
+      if (!parsed) return;
+      const fmRaw = parsed[1];
+      const body = parsed[2] ?? "";
+      const get = (key) => {
+        const match = fmRaw.match(new RegExp(`^${key}:\\s*(.+)$`, "m"));
+        return match ? match[1].trim() : "";
+      };
+      const confidenceRaw = get("confidence");
+      const confidence = confidenceRaw.length > 0 ? Number(confidenceRaw) : void 0;
+      out.push({
+        path: fullPath,
+        content: body,
+        frontmatter: {
+          id: get("id") || void 0,
+          confidence: Number.isFinite(confidence) ? confidence : void 0,
+          updated: get("updated") || void 0,
+          created: get("created") || void 0
+        }
+      });
+    } catch {
+    }
+  });
   return out;
 }
 function formatContinuityIncidentCli(incident) {
@@ -51937,7 +53062,7 @@ function registerCli(api, orchestrator) {
         if (plan.moved.length > 0) {
           console.log("\nEntries:");
           for (const move of plan.moved) {
-            console.log(`- ${path71.basename(move.from)}`);
+            console.log(`- ${path72.basename(move.from)}`);
           }
         }
         if (dryRun) {
@@ -52135,6 +53260,64 @@ function registerCli(api, orchestrator) {
         }
         console.log("OK");
       });
+      cmd.command("bulk-import").description(
+        "Bulk-import chat history via a registered source adapter (e.g. --source weclone)."
+      ).option("--source <source>", "Bulk-import source adapter name (e.g. weclone)").option("--file <path>", "Path to the import file (JSON)").option("--platform <platform>", "Optional platform override forwarded to the adapter").option("--batch-size <n>", "Turns per batch", "50").option("--dry-run", "Parse and validate only; do not persist").option("--strict", "Fail on any invalid source row").option("--verbose", "Print per-batch error details").action(async (...args) => {
+        const options = args[0] ?? {};
+        const sourceRaw = typeof options.source === "string" ? options.source.trim() : "";
+        const filePathRaw = typeof options.file === "string" ? options.file.trim() : "";
+        if (sourceRaw.length === 0) {
+          console.log("Missing --source. Example: openclaw engram bulk-import --source weclone --file /tmp/export.json");
+          return;
+        }
+        if (filePathRaw.length === 0) {
+          console.log("Missing --file. Example: openclaw engram bulk-import --source weclone --file /tmp/export.json");
+          return;
+        }
+        const batchSizeRaw = parseInt(String(options.batchSize ?? "50"), 10);
+        const batchSize = Number.isFinite(batchSizeRaw) && batchSizeRaw > 0 ? batchSizeRaw : 50;
+        const platformRaw = typeof options.platform === "string" ? options.platform.trim() : "";
+        const writeNamespace = orchestrator.bulkImportWriteNamespace();
+        const writeStorage = await orchestrator.getStorageForNamespace(
+          writeNamespace
+        );
+        const writeRoot = writeStorage.dir;
+        const ingestBatch = async (turns) => {
+          const before = new Set(await listMemoryMarkdownFilePaths(writeRoot));
+          await orchestrator.ingestBulkImportBatch(turns, {});
+          const after = await listMemoryMarkdownFilePaths(writeRoot);
+          let memoriesCreated = 0;
+          for (const p of after) {
+            if (!before.has(p)) memoriesCreated += 1;
+          }
+          return { memoriesCreated, duplicatesSkipped: 0 };
+        };
+        try {
+          const result = await runBulkImportCliCommand({
+            memoryDir: writeRoot,
+            source: sourceRaw,
+            file: filePathRaw,
+            platform: platformRaw.length > 0 ? platformRaw : void 0,
+            batchSize,
+            dryRun: options.dryRun === true,
+            verbose: options.verbose === true,
+            strict: options.strict === true,
+            ingestBatch,
+            stdout: process.stdout,
+            stderr: process.stderr
+          });
+          if (result.errors.length > 0) {
+            console.error(`Bulk import completed with ${result.errors.length} batch error(s).`);
+            process.exitCode = 1;
+          } else {
+            console.log("OK");
+          }
+        } catch (err) {
+          const message = err instanceof Error ? err.message : String(err);
+          console.error(`Bulk import failed: ${message}`);
+          process.exitCode = 1;
+        }
+      });
       cmd.command("benchmark-status").description("Show benchmark/evaluation harness status, benchmark packs, and latest run summary").action(async () => {
         const status = await runBenchmarkStatusCliCommand({
           memoryDir: orchestrator.config.memoryDir,
@@ -53587,7 +54770,7 @@ Semantic consolidation complete. clusters=${result.clustersFound}, consolidated=
         }
       });
       cmd.command("identity").description("Show agent identity reflections").action(async () => {
-        const workspaceDir = path71.join(resolveHomeDir(), ".openclaw", "workspace");
+        const workspaceDir = path72.join(resolveHomeDir(), ".openclaw", "workspace");
         const identity = await orchestrator.storage.readIdentity(workspaceDir);
         if (!identity) {
           console.log("No identity file found.");
@@ -53810,8 +54993,8 @@ Semantic consolidation complete. clusters=${result.clustersFound}, consolidated=
         const options = args[0] ?? {};
         const threadId = options.thread;
         const top = parseInt(options.top ?? "10", 10);
-        const memoryDir = path71.join(resolveHomeDir(), ".openclaw", "workspace", "memory", "local");
-        const threading = new ThreadingManager(path71.join(memoryDir, "threads"));
+        const memoryDir = path72.join(resolveHomeDir(), ".openclaw", "workspace", "memory", "local");
+        const threading = new ThreadingManager(path72.join(memoryDir, "threads"));
         if (threadId) {
           const thread = await threading.loadThread(threadId);
           if (!thread) {
@@ -54287,19 +55470,19 @@ async function recordObjectiveStateSnapshotsFromAgentMessages(options) {
 }
 
 // ../../src/index.ts
-import { readFile as readFile51, writeFile as writeFile46 } from "fs/promises";
+import { readFile as readFile52, realpath as realpath5, writeFile as writeFile46 } from "fs/promises";
 import { readFileSync as readFileSync6 } from "fs";
-import path97 from "path";
+import path98 from "path";
 import os6 from "os";
 
 // ../remnic-core/src/opik-exporter.ts
-import { createHash as createHash15, randomBytes } from "crypto";
+import { createHash as createHash15, randomBytes as randomBytes2 } from "crypto";
 import { readFileSync as readFileSync4 } from "fs";
-import path72 from "path";
+import path73 from "path";
 var OPIK_EXPORTER_SLOT = "__openclawOpikExporter";
 function readOpikOpenclawConfig(log2) {
   try {
-    const configPath = readEnvVar("OPENCLAW_ENGRAM_CONFIG_PATH") || readEnvVar("OPENCLAW_CONFIG_PATH") || path72.join(resolveHomeDir(), ".openclaw", "openclaw.json");
+    const configPath = readEnvVar("OPENCLAW_ENGRAM_CONFIG_PATH") || readEnvVar("OPENCLAW_CONFIG_PATH") || path73.join(resolveHomeDir(), ".openclaw", "openclaw.json");
     const raw = JSON.parse(readFileSync4(configPath, "utf-8"));
     const entry = raw?.plugins?.entries?.["opik-openclaw"];
     if (!entry?.enabled || !entry?.config) return {};
@@ -54317,7 +55500,7 @@ function readOpikOpenclawConfig(log2) {
 }
 function uuidV7() {
   const now = Date.now();
-  const bytes = randomBytes(16);
+  const bytes = randomBytes2(16);
   bytes[0] = now / 2 ** 40 & 255;
   bytes[1] = now / 2 ** 32 & 255;
   bytes[2] = now / 2 ** 24 & 255;
@@ -54661,8 +55844,8 @@ function cleanUserMessage(content) {
 }
 
 // src/public-artifacts.ts
-import { readdir as readdir26, access as access6, stat as stat20, lstat as lstat2, realpath as realpath3 } from "fs/promises";
-import path73 from "path";
+import { readdir as readdir27, access as access6, stat as stat20, lstat as lstat3, realpath as realpath4 } from "fs/promises";
+import path74 from "path";
 var PUBLIC_DIRS = [
   { dir: "facts", kind: "fact", contentType: "markdown" },
   { dir: "entities", kind: "entity", contentType: "markdown" },
@@ -54674,9 +55857,9 @@ var PUBLIC_FILES = [
 ];
 async function isContainedWithin(target, boundary) {
   try {
-    const resolvedTarget = await realpath3(target);
-    const resolvedBoundary = await realpath3(boundary);
-    return resolvedTarget === resolvedBoundary || resolvedTarget.startsWith(resolvedBoundary + path73.sep);
+    const resolvedTarget = await realpath4(target);
+    const resolvedBoundary = await realpath4(boundary);
+    return resolvedTarget === resolvedBoundary || resolvedTarget.startsWith(resolvedBoundary + path74.sep);
   } catch {
     return false;
   }
@@ -54685,7 +55868,7 @@ async function listMarkdownFilesRecursive(rootDir, boundary, ancestorRealPaths)
   const boundaryDir = boundary ?? rootDir;
   let resolvedRoot;
   try {
-    resolvedRoot = await realpath3(rootDir);
+    resolvedRoot = await realpath4(rootDir);
   } catch {
     return [];
   }
@@ -54694,18 +55877,18 @@ async function listMarkdownFilesRecursive(rootDir, boundary, ancestorRealPaths)
   nextAncestors.add(resolvedRoot);
   let entries;
   try {
-    entries = await readdir26(rootDir, { withFileTypes: true });
+    entries = await readdir27(rootDir, { withFileTypes: true });
   } catch {
     return [];
   }
   entries.sort((a, b) => String(a.name).localeCompare(String(b.name)));
   const files = [];
   for (const entry of entries) {
-    const fullPath = path73.join(rootDir, String(entry.name));
+    const fullPath = path74.join(rootDir, String(entry.name));
     let isDir = entry.isDirectory();
     let isFile = entry.isFile();
     try {
-      const linkStat = await lstat2(fullPath);
+      const linkStat = await lstat3(fullPath);
       if (linkStat.isSymbolicLink()) {
         if (!await isContainedWithin(fullPath, boundaryDir)) {
           continue;
@@ -54739,21 +55922,21 @@ async function listRemnicPublicArtifacts(params) {
   const { memoryDir, workspaceDir, agentIds } = params;
   const artifacts = [];
   for (const spec of PUBLIC_DIRS) {
-    const dirPath = path73.join(memoryDir, spec.dir);
+    const dirPath = path74.join(memoryDir, spec.dir);
     if (!await pathExists2(dirPath)) continue;
     if (!await isContainedWithin(dirPath, memoryDir)) continue;
     try {
-      const resolvedDir = await realpath3(dirPath);
-      const expectedParent = await realpath3(memoryDir);
-      const resolvedName = path73.basename(resolvedDir);
+      const resolvedDir = await realpath4(dirPath);
+      const expectedParent = await realpath4(memoryDir);
+      const resolvedName = path74.basename(resolvedDir);
       if (resolvedName !== spec.dir) continue;
-      if (path73.dirname(resolvedDir) !== expectedParent) continue;
+      if (path74.dirname(resolvedDir) !== expectedParent) continue;
     } catch {
       continue;
     }
     const files = await listMarkdownFilesRecursive(dirPath, dirPath);
     for (const absolutePath of files) {
-      const relativePath = path73.relative(memoryDir, absolutePath).replace(/\\/g, "/");
+      const relativePath = path74.relative(memoryDir, absolutePath).replace(/\\/g, "/");
       artifacts.push({
         kind: spec.kind,
         workspaceDir,
@@ -54765,16 +55948,16 @@ async function listRemnicPublicArtifacts(params) {
     }
   }
   for (const spec of PUBLIC_FILES) {
-    const absolutePath = path73.join(memoryDir, spec.relativePath);
+    const absolutePath = path74.join(memoryDir, spec.relativePath);
     if (!await pathExists2(absolutePath)) continue;
     if (!await isContainedWithin(absolutePath, memoryDir)) continue;
     try {
-      const linkStat = await lstat2(absolutePath);
+      const linkStat = await lstat3(absolutePath);
       if (linkStat.isSymbolicLink()) {
-        const resolvedPath = await realpath3(absolutePath);
-        const expectedParent = await realpath3(memoryDir);
-        if (path73.dirname(resolvedPath) !== expectedParent) continue;
-        if (path73.basename(resolvedPath) !== path73.basename(spec.relativePath)) continue;
+        const resolvedPath = await realpath4(absolutePath);
+        const expectedParent = await realpath4(memoryDir);
+        if (path74.dirname(resolvedPath) !== expectedParent) continue;
+        if (path74.basename(resolvedPath) !== path74.basename(spec.relativePath)) continue;
       }
     } catch {
       continue;
@@ -54925,28 +56108,28 @@ var DEFAULT_MAX_BINARY_SIZE_BYTES = 50 * 1024 * 1024;
 // ../remnic-core/src/binary-lifecycle/backend.ts
 import fs3 from "fs";
 import fsp2 from "fs/promises";
-import path74 from "path";
+import path75 from "path";
 
 // ../remnic-core/src/binary-lifecycle/scanner.ts
 import fsp3 from "fs/promises";
-import path75 from "path";
+import path76 from "path";
 
 // ../remnic-core/src/binary-lifecycle/manifest.ts
 import fsp4 from "fs/promises";
-import path76 from "path";
+import path77 from "path";
 import crypto3 from "crypto";
 
 // ../remnic-core/src/binary-lifecycle/pipeline.ts
 import fsp5 from "fs/promises";
-import path77 from "path";
+import path78 from "path";
 import crypto4 from "crypto";
 
 // ../remnic-core/src/projection/index.ts
 import fs4 from "fs";
-import path79 from "path";
+import path80 from "path";
 
 // ../remnic-core/src/utils/category-dir.ts
-import path78 from "path";
+import path79 from "path";
 var CATEGORY_DIR_MAP = {
   correction: "corrections",
   question: "questions",
@@ -54957,7 +56140,8 @@ var CATEGORY_DIR_MAP = {
   principle: "principles",
   rule: "rules",
   skill: "skills",
-  relationship: "relationships"
+  relationship: "relationships",
+  procedure: "procedures"
 };
 var ALL_CATEGORY_DIRS = [
   "facts",
@@ -54970,30 +56154,30 @@ var ALL_CATEGORY_KEYS = [
 
 // ../remnic-core/src/onboarding/index.ts
 import fs5 from "fs";
-import path80 from "path";
+import path81 from "path";
 
 // ../remnic-core/src/curation/index.ts
 import fs6 from "fs";
-import path81 from "path";
+import path82 from "path";
 import crypto5 from "crypto";
 
 // ../remnic-core/src/dedup/index.ts
 import fs7 from "fs";
-import path82 from "path";
+import path83 from "path";
 import crypto6 from "crypto";
 
 // ../remnic-core/src/review/index.ts
 import fs8 from "fs";
-import path83 from "path";
+import path84 from "path";
 
 // ../remnic-core/src/sync/index.ts
 import fs9 from "fs";
-import path84 from "path";
+import path85 from "path";
 import crypto7 from "crypto";
 
 // ../remnic-core/src/connectors/index.ts
 import fs11 from "fs";
-import path87 from "path";
+import path88 from "path";
 import os4 from "os";
 import { spawnSync } from "child_process";
 import { createRequire as createRequire2 } from "module";
@@ -55001,31 +56185,31 @@ import { fileURLToPath as fileURLToPath4 } from "url";
 
 // ../remnic-core/src/tokens.ts
 import fs10 from "fs";
-import path85 from "path";
-import { randomBytes as randomBytes2 } from "crypto";
+import path86 from "path";
+import { randomBytes as randomBytes3 } from "crypto";
 
 // ../remnic-core/src/connectors/codex-marketplace.ts
 import { existsSync as existsSync10, mkdirSync as mkdirSync4, readFileSync as readFileSync5, renameSync as renameSync2, writeFileSync as writeFileSync4 } from "fs";
-import path86 from "path";
+import path87 from "path";
 
 // ../remnic-core/src/spaces/index.ts
 import fs12 from "fs";
-import path88 from "path";
+import path89 from "path";
 import crypto8 from "crypto";
 
 // ../remnic-core/src/memory-extension/codex-publisher.ts
 import fs13 from "fs";
 import os5 from "os";
-import path89 from "path";
+import path90 from "path";
 
 // ../remnic-core/src/taxonomy/taxonomy-loader.ts
-import { readFile as readFile46, mkdir as mkdir49, writeFile as writeFile43 } from "fs/promises";
-import path90 from "path";
+import { readFile as readFile47, mkdir as mkdir49, writeFile as writeFile43 } from "fs/promises";
+import path91 from "path";
 
 // ../remnic-core/src/enrichment/audit.ts
-import { mkdir as mkdir50, readFile as readFile47, appendFile as appendFile4 } from "fs/promises";
+import { mkdir as mkdir50, readFile as readFile48, appendFile as appendFile4 } from "fs/promises";
 import { existsSync as existsSync11 } from "fs";
-import path91 from "path";
+import path92 from "path";
 
 // src/openclaw-tools/shapes.ts
 var MemorySearchInputSchema = Type.Object({
@@ -55439,7 +56623,7 @@ async function syncHeartbeatOutcomeLinks(params) {
   }
   return { created: 0, updated: 0, linked };
 }
-function parseIsoTimestamp2(value) {
+function parseIsoTimestamp3(value) {
   if (!value) return null;
   const parsed = Date.parse(value);
   return Number.isFinite(parsed) ? parsed : null;
@@ -55448,7 +56632,7 @@ function planDreamEntryFromConsolidation(params) {
   const now = params.now ?? /* @__PURE__ */ new Date();
   const latestDreamAt = Math.max(
     -1,
-    ...params.existingDreams.map((entry) => parseIsoTimestamp2(entry.timestamp)).filter((value) => value !== null)
+    ...params.existingDreams.map((entry) => parseIsoTimestamp3(entry.timestamp)).filter((value) => value !== null)
   );
   if (latestDreamAt > 0 && now.getTime() - latestDreamAt < params.minIntervalMinutes * 6e4) {
     return null;
@@ -55592,88 +56776,100 @@ function resolveSession(commandCtx) {
   };
 }
 function buildSessionCommandDescriptors(pluginId, runtime) {
+  const subcommands = [
+    {
+      name: "off",
+      description: "Disable Remnic recall for this session",
+      args: [],
+      handler: async (commandCtx = {}) => {
+        const { sessionKey, agentId } = resolveSession(commandCtx);
+        await runtime.toggles.setDisabled(sessionKey, agentId, true);
+        return `Remnic recall disabled for session ${sessionKey}.`;
+      }
+    },
+    {
+      name: "on",
+      description: "Re-enable Remnic recall for this session",
+      args: [],
+      handler: async (commandCtx = {}) => {
+        const { sessionKey, agentId } = resolveSession(commandCtx);
+        await runtime.toggles.setDisabled(sessionKey, agentId, false);
+        return `Remnic recall re-enabled for session ${sessionKey}.`;
+      }
+    },
+    {
+      name: "status",
+      description: "Show Remnic recall status and last injected summary",
+      args: [],
+      handler: async (commandCtx = {}) => {
+        const { sessionKey, agentId } = resolveSession(commandCtx);
+        const resolved = await runtime.toggles.resolve(sessionKey, agentId);
+        const lastRecall = runtime.getLastRecall(sessionKey);
+        const summaryText = runtime.getLastRecallSummary(sessionKey);
+        const summary = summaryText && summaryText.length > 0 ? summaryText : lastRecall && lastRecall.memoryIds.length > 0 ? `${lastRecall.memoryIds.length} memory item(s), latency ${lastRecall.latencyMs ?? "?"}ms` : "NONE";
+        return [
+          `Remnic recall is ${resolved.disabled ? "disabled" : "enabled"} for session ${sessionKey}.`,
+          `Source: ${describeToggleSource(resolved.source)}.`,
+          `Last recall: ${summary}.`
+        ].join(" ");
+      }
+    },
+    {
+      name: "clear",
+      description: "Clear the session override and use global config again",
+      args: [],
+      handler: async (commandCtx = {}) => {
+        const { sessionKey, agentId } = resolveSession(commandCtx);
+        await runtime.toggles.clear(sessionKey, agentId);
+        return `Cleared the Remnic session override for ${sessionKey}.`;
+      }
+    },
+    {
+      name: "stats",
+      description: "Show Remnic extraction and recall stats for this session",
+      args: [],
+      handler: async (commandCtx = {}) => {
+        const { sessionKey } = resolveSession(commandCtx);
+        const lastRecall = runtime.getLastRecall(sessionKey);
+        if (!lastRecall) {
+          return `No Remnic recall stats are available for session ${sessionKey} yet.`;
+        }
+        return [
+          `Session ${sessionKey}.`,
+          `Planner mode: ${lastRecall.plannerMode ?? "unknown"}.`,
+          `Latency: ${lastRecall.latencyMs ?? "?"}ms.`,
+          `Memories: ${lastRecall.memoryIds.length}.`
+        ].join(" ");
+      }
+    },
+    {
+      name: "flush",
+      description: "Force-flush the extraction buffer now",
+      args: [],
+      handler: async (commandCtx = {}) => {
+        const { sessionKey } = resolveSession(commandCtx);
+        await runtime.flushSession(sessionKey);
+        return `Flushed the Remnic buffer for session ${sessionKey}.`;
+      }
+    }
+  ];
+  const subcommandNames = subcommands.map((entry) => entry.name).join(", ");
   return [
     {
       name: "remnic",
+      description: `Remnic memory controls (${subcommandNames})`,
       category: "memory",
       pluginId,
-      subcommands: [
-        {
-          name: "off",
-          description: "Disable Remnic recall for this session",
-          args: [],
-          handler: async (commandCtx = {}) => {
-            const { sessionKey, agentId } = resolveSession(commandCtx);
-            await runtime.toggles.setDisabled(sessionKey, agentId, true);
-            return `Remnic recall disabled for session ${sessionKey}.`;
-          }
-        },
-        {
-          name: "on",
-          description: "Re-enable Remnic recall for this session",
-          args: [],
-          handler: async (commandCtx = {}) => {
-            const { sessionKey, agentId } = resolveSession(commandCtx);
-            await runtime.toggles.setDisabled(sessionKey, agentId, false);
-            return `Remnic recall re-enabled for session ${sessionKey}.`;
-          }
-        },
-        {
-          name: "status",
-          description: "Show Remnic recall status and last injected summary",
-          args: [],
-          handler: async (commandCtx = {}) => {
-            const { sessionKey, agentId } = resolveSession(commandCtx);
-            const resolved = await runtime.toggles.resolve(sessionKey, agentId);
-            const lastRecall = runtime.getLastRecall(sessionKey);
-            const summaryText = runtime.getLastRecallSummary(sessionKey);
-            const summary = summaryText && summaryText.length > 0 ? summaryText : lastRecall && lastRecall.memoryIds.length > 0 ? `${lastRecall.memoryIds.length} memory item(s), latency ${lastRecall.latencyMs ?? "?"}ms` : "NONE";
-            return [
-              `Remnic recall is ${resolved.disabled ? "disabled" : "enabled"} for session ${sessionKey}.`,
-              `Source: ${describeToggleSource(resolved.source)}.`,
-              `Last recall: ${summary}.`
-            ].join(" ");
-          }
-        },
-        {
-          name: "clear",
-          description: "Clear the session override and use global config again",
-          args: [],
-          handler: async (commandCtx = {}) => {
-            const { sessionKey, agentId } = resolveSession(commandCtx);
-            await runtime.toggles.clear(sessionKey, agentId);
-            return `Cleared the Remnic session override for ${sessionKey}.`;
-          }
-        },
-        {
-          name: "stats",
-          description: "Show Remnic extraction and recall stats for this session",
-          args: [],
-          handler: async (commandCtx = {}) => {
-            const { sessionKey } = resolveSession(commandCtx);
-            const lastRecall = runtime.getLastRecall(sessionKey);
-            if (!lastRecall) {
-              return `No Remnic recall stats are available for session ${sessionKey} yet.`;
-            }
-            return [
-              `Session ${sessionKey}.`,
-              `Planner mode: ${lastRecall.plannerMode ?? "unknown"}.`,
-              `Latency: ${lastRecall.latencyMs ?? "?"}ms.`,
-              `Memories: ${lastRecall.memoryIds.length}.`
-            ].join(" ");
-          }
-        },
-        {
-          name: "flush",
-          description: "Force-flush the extraction buffer now",
-          args: [],
-          handler: async (commandCtx = {}) => {
-            const { sessionKey } = resolveSession(commandCtx);
-            await runtime.flushSession(sessionKey);
-            return `Flushed the Remnic buffer for session ${sessionKey}.`;
-          }
+      acceptsArgs: true,
+      subcommands,
+      handler: async (commandCtx = {}) => {
+        const requested = commandCtx.args?.[0]?.trim().toLowerCase() ?? "status";
+        const match = subcommands.find((entry) => entry.name === requested);
+        if (!match) {
+          return `Unknown Remnic subcommand "${requested}". Try one of: ${subcommandNames}.`;
         }
-      ]
+        return match.handler(commandCtx);
+      }
     }
   ];
 }
@@ -55773,8 +56969,8 @@ function validateSlotSelection(ctx) {
 }
 
 // ../remnic-core/src/session-toggles.ts
-import { mkdir as mkdir51, readFile as readFile48, writeFile as writeFile44 } from "fs/promises";
-import path92 from "path";
+import { mkdir as mkdir51, readFile as readFile49, writeFile as writeFile44 } from "fs/promises";
+import path93 from "path";
 function encodeToggleKey(sessionKey, agentId) {
   return `${encodeURIComponent(sessionKey)}::${encodeURIComponent(agentId)}`;
 }
@@ -55788,7 +56984,7 @@ function decodeToggleKey(key) {
 }
 async function safeReadToggleFile(filePath) {
   try {
-    const raw = await readFile48(filePath, "utf8");
+    const raw = await readFile49(filePath, "utf8");
     const parsed = JSON.parse(raw);
     if (!parsed || typeof parsed !== "object" || typeof parsed.entries !== "object") {
       return { version: 1, entries: {} };
@@ -55813,7 +57009,7 @@ function createFileToggleStore(filePath, options = {}) {
     await run;
   }
   async function writeToggleFile(next) {
-    await mkdir51(path92.dirname(filePath), { recursive: true });
+    await mkdir51(path93.dirname(filePath), { recursive: true });
     await writeFile44(filePath, JSON.stringify(next, null, 2), "utf8");
   }
   async function readPrimary() {
@@ -55886,8 +57082,8 @@ function createFileToggleStore(filePath, options = {}) {
 }
 
 // ../remnic-core/src/recall-audit.ts
-import { appendFile as appendFile5, mkdir as mkdir52, readdir as readdir27, rm as rm10 } from "fs/promises";
-import path93 from "path";
+import { appendFile as appendFile5, mkdir as mkdir52, readdir as readdir28, rm as rm10 } from "fs/promises";
+import path94 from "path";
 function formatIsoDate(ts) {
   const normalized = new Date(ts);
   if (Number.isNaN(normalized.getTime())) {
@@ -55897,24 +57093,24 @@ function formatIsoDate(ts) {
 }
 function buildRecallAuditPath(rootDir, ts, sessionKey) {
   const safeSessionKey = encodeURIComponent(sessionKey);
-  return path93.join(rootDir, "transcripts", formatIsoDate(ts), `${safeSessionKey}.jsonl`);
+  return path94.join(rootDir, "transcripts", formatIsoDate(ts), `${safeSessionKey}.jsonl`);
 }
 async function appendRecallAuditEntry(rootDir, entry) {
   const filePath = buildRecallAuditPath(rootDir, entry.ts, entry.sessionKey);
-  await mkdir52(path93.dirname(filePath), { recursive: true });
+  await mkdir52(path94.dirname(filePath), { recursive: true });
   await appendFile5(filePath, `${JSON.stringify(entry)}
 `, "utf8");
   return filePath;
 }
 async function pruneRecallAuditEntries(rootDir, retentionDays, now = /* @__PURE__ */ new Date()) {
-  const transcriptsDir = path93.join(rootDir, "transcripts");
+  const transcriptsDir = path94.join(rootDir, "transcripts");
   const removed = [];
   const cutoff = new Date(now);
   cutoff.setUTCHours(0, 0, 0, 0);
   cutoff.setUTCDate(cutoff.getUTCDate() - Math.max(1, Math.floor(retentionDays)));
   let entries;
   try {
-    entries = await readdir27(transcriptsDir, { withFileTypes: true });
+    entries = await readdir28(transcriptsDir, { withFileTypes: true });
   } catch {
     return removed;
   }
@@ -55923,7 +57119,7 @@ async function pruneRecallAuditEntries(rootDir, retentionDays, now = /* @__PURE_
     if (!/^\d{4}-\d{2}-\d{2}$/.test(entry.name)) continue;
     const day = /* @__PURE__ */ new Date(`${entry.name}T00:00:00.000Z`);
     if (Number.isNaN(day.getTime()) || day >= cutoff) continue;
-    const dirPath = path93.join(transcriptsDir, entry.name);
+    const dirPath = path94.join(transcriptsDir, entry.name);
     await rm10(dirPath, { recursive: true, force: true });
     removed.push(dirPath);
   }
@@ -55932,7 +57128,7 @@ async function pruneRecallAuditEntries(rootDir, retentionDays, now = /* @__PURE_
 
 // ../remnic-core/src/active-recall.ts
 import { appendFile as appendFile6, mkdir as mkdir53 } from "fs/promises";
-import path94 from "path";
+import path95 from "path";
 var ACTIVE_RECALL_CACHE_MAX_ENTRIES = 256;
 var NONE_SET = /* @__PURE__ */ new Set([
   "",
@@ -56075,14 +57271,14 @@ ${params.recallExplain}` : null,
 }
 async function appendActiveRecallTranscript(transcriptRoot, input, config, result, queryBundle) {
   const date = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
-  const filePath = path94.join(
+  const filePath = path95.join(
     transcriptRoot,
     "agents",
     sanitizeTranscriptPathSegment(input.agentId),
     date,
     `${sanitizeTranscriptPathSegment(input.sessionKey)}.jsonl`
   );
-  await mkdir53(path94.dirname(filePath), { recursive: true });
+  await mkdir53(path95.dirname(filePath), { recursive: true });
   await appendFile6(
     filePath,
     `${JSON.stringify({
@@ -56314,8 +57510,8 @@ import { resolvePrincipal as resolvePrincipal2 } from "@remnic/core";
 // ../remnic-core/src/surfaces/dreams.ts
 import { createHash as createHash16 } from "crypto";
 import { statSync, watch as watch2 } from "fs";
-import { mkdir as mkdir54, readFile as readFile49, writeFile as writeFile45 } from "fs/promises";
-import path95 from "path";
+import { mkdir as mkdir54, readFile as readFile50, writeFile as writeFile45 } from "fs/promises";
+import path96 from "path";
 var DIARY_START_MARKER = "<!-- openclaw:dreaming:diary:start -->";
 var DIARY_END_MARKER = "<!-- openclaw:dreaming:diary:end -->";
 function stableDreamId(params) {
@@ -56480,7 +57676,7 @@ function createDreamsSurface() {
   return {
     async read(filePath) {
       try {
-        const content = await readFile49(filePath, "utf8");
+        const content = await readFile50(filePath, "utf8");
         return parseDreamEntries(content);
       } catch (error) {
         if (error.code === "ENOENT") {
@@ -56490,10 +57686,10 @@ function createDreamsSurface() {
       }
     },
     async append(filePath, entry) {
-      await mkdir54(path95.dirname(filePath), { recursive: true });
+      await mkdir54(path96.dirname(filePath), { recursive: true });
       let content = "";
       try {
-        content = await readFile49(filePath, "utf8");
+        content = await readFile50(filePath, "utf8");
       } catch (error) {
         if (error.code !== "ENOENT") throw error;
       }
@@ -56511,22 +57707,22 @@ ${ensured.slice(endIndex)}` : `${ensureDiary("")}${block}`;
       let fileWatcher = null;
       let parentWatcher = null;
       let timer = null;
-      const watchedName = path95.basename(filePath);
-      const watchedDir = path95.dirname(filePath);
+      const watchedName = path96.basename(filePath);
+      const watchedDir = path96.dirname(filePath);
       const resolveParentWatchTarget = () => {
         let candidateDir = watchedDir;
         while (true) {
           try {
             if (statSync(candidateDir).isDirectory()) {
-              const relative = path95.relative(candidateDir, watchedDir);
+              const relative = path96.relative(candidateDir, watchedDir);
               return {
                 dir: candidateDir,
-                expectedName: relative.length === 0 ? watchedName : relative.split(path95.sep)[0] ?? watchedName
+                expectedName: relative.length === 0 ? watchedName : relative.split(path96.sep)[0] ?? watchedName
               };
             }
           } catch {
           }
-          const parentDir = path95.dirname(candidateDir);
+          const parentDir = path96.dirname(candidateDir);
           if (parentDir === candidateDir) {
             return null;
           }
@@ -56591,8 +57787,8 @@ ${ensured.slice(endIndex)}` : `${ensureDiary("")}${block}`;
 // ../remnic-core/src/surfaces/heartbeat.ts
 import { createHash as createHash17 } from "crypto";
 import { statSync as statSync2, watch as watch3 } from "fs";
-import { readFile as readFile50 } from "fs/promises";
-import path96 from "path";
+import { readFile as readFile51 } from "fs/promises";
+import path97 from "path";
 function stableHeartbeatId(params) {
   const digest = createHash17("sha1").update(
     JSON.stringify({
@@ -56755,7 +57951,7 @@ function createHeartbeatSurface() {
   return {
     async read(filePath) {
       try {
-        const content = await readFile50(filePath, "utf8");
+        const content = await readFile51(filePath, "utf8");
         return parseHeartbeatEntries(content);
       } catch (error) {
         if (error.code === "ENOENT") {
@@ -56768,22 +57964,22 @@ function createHeartbeatSurface() {
       let fileWatcher = null;
       let parentWatcher = null;
       let timer = null;
-      const watchedName = path96.basename(filePath);
-      const watchedDir = path96.dirname(filePath);
+      const watchedName = path97.basename(filePath);
+      const watchedDir = path97.dirname(filePath);
       const resolveParentWatchTarget = () => {
         let candidateDir = watchedDir;
         while (true) {
           try {
             if (statSync2(candidateDir).isDirectory()) {
-              const relative = path96.relative(candidateDir, watchedDir);
+              const relative = path97.relative(candidateDir, watchedDir);
               return {
                 dir: candidateDir,
-                expectedName: relative.length === 0 ? watchedName : relative.split(path96.sep)[0] ?? watchedName
+                expectedName: relative.length === 0 ? watchedName : relative.split(path97.sep)[0] ?? watchedName
               };
             }
           } catch {
           }
-          const parentDir = path96.dirname(candidateDir);
+          const parentDir = path97.dirname(candidateDir);
           if (parentDir === candidateDir) {
             return null;
           }
@@ -56869,7 +58065,7 @@ function loadPluginEntryFromFile(pluginId) {
   try {
     const explicitConfigPath = readEnvVar("OPENCLAW_ENGRAM_CONFIG_PATH") || readEnvVar("OPENCLAW_CONFIG_PATH");
     const homeDir = resolveHomeDir();
-    const configPath = explicitConfigPath && explicitConfigPath.length > 0 ? explicitConfigPath : path97.join(homeDir, ".openclaw", "openclaw.json");
+    const configPath = explicitConfigPath && explicitConfigPath.length > 0 ? explicitConfigPath : path98.join(homeDir, ".openclaw", "openclaw.json");
     const content = readFileSync6(configPath, "utf-8");
     const config = JSON.parse(content);
     return resolveRemnicPluginEntry(config, pluginId);
@@ -56885,7 +58081,7 @@ function loadRawConfigFromFile() {
   try {
     const explicitConfigPath = readEnvVar("OPENCLAW_ENGRAM_CONFIG_PATH") || readEnvVar("OPENCLAW_CONFIG_PATH");
     const homeDir = resolveHomeDir();
-    const configPath = explicitConfigPath && explicitConfigPath.length > 0 ? explicitConfigPath : path97.join(homeDir, ".openclaw", "openclaw.json");
+    const configPath = explicitConfigPath && explicitConfigPath.length > 0 ? explicitConfigPath : path98.join(homeDir, ".openclaw", "openclaw.json");
     const content = readFileSync6(configPath, "utf-8");
     const config = JSON.parse(content);
     return config && typeof config === "object" ? config : void 0;
@@ -57119,9 +58315,9 @@ var pluginDefinition = {
       citationsAutoDetect: cfg.citationsAutoDetect
     });
     globalThis[keys.ACCESS_HTTP_SERVER] = accessHttpServer;
-    const pluginStateDir = path97.join(cfg.memoryDir, "state", "plugins", serviceId);
-    const togglePrimaryPath = path97.join(pluginStateDir, "session-toggles.json");
-    const toggleSecondaryPath = cfg.respectBundledActiveMemoryToggle ? path97.join(cfg.memoryDir, "state", "plugins", "active-memory", "session-toggles.json") : void 0;
+    const pluginStateDir = path98.join(cfg.memoryDir, "state", "plugins", serviceId);
+    const togglePrimaryPath = path98.join(pluginStateDir, "session-toggles.json");
+    const toggleSecondaryPath = cfg.respectBundledActiveMemoryToggle ? path98.join(cfg.memoryDir, "state", "plugins", "active-memory", "session-toggles.json") : void 0;
     const sessionToggleStore = createFileToggleStore(togglePrimaryPath, {
       secondaryReadOnlyPath: toggleSecondaryPath
     });
@@ -57143,11 +58339,11 @@ var pluginDefinition = {
     }
     function resolveDreamJournalPath(runtimeWorkspaceDir) {
       const workspaceRoot = resolveWorkspaceRoot(runtimeWorkspaceDir);
-      return path97.isAbsolute(cfg.dreaming.journalPath) ? cfg.dreaming.journalPath : path97.join(workspaceRoot, cfg.dreaming.journalPath);
+      return path98.isAbsolute(cfg.dreaming.journalPath) ? cfg.dreaming.journalPath : path98.join(workspaceRoot, cfg.dreaming.journalPath);
     }
     function resolveHeartbeatJournalPath(runtimeWorkspaceDir) {
       const workspaceRoot = resolveWorkspaceRoot(runtimeWorkspaceDir);
-      return path97.isAbsolute(cfg.heartbeat.journalPath) ? cfg.heartbeat.journalPath : path97.join(workspaceRoot, cfg.heartbeat.journalPath);
+      return path98.isAbsolute(cfg.heartbeat.journalPath) ? cfg.heartbeat.journalPath : path98.join(workspaceRoot, cfg.heartbeat.journalPath);
     }
     function queueDreamSurfaceSync(runtimeWorkspaceDir) {
       if (!cfg.dreaming.enabled) return Promise.resolve();
@@ -57305,7 +58501,7 @@ Keep the reflection grounded in the evidence below.
         timeoutMs: cfg.activeRecallTimeoutMs,
         cacheTtlMs: cfg.activeRecallCacheTtlMs,
         persistTranscripts: cfg.activeRecallPersistTranscripts,
-        transcriptDir: path97.isAbsolute(cfg.activeRecallTranscriptDir) ? cfg.activeRecallTranscriptDir : path97.join(pluginStateDir, cfg.activeRecallTranscriptDir),
+        transcriptDir: path98.isAbsolute(cfg.activeRecallTranscriptDir) ? cfg.activeRecallTranscriptDir : path98.join(pluginStateDir, cfg.activeRecallTranscriptDir),
         entityGraphDepth: cfg.activeRecallEntityGraphDepth,
         includeCausalTrajectories: cfg.activeRecallIncludeCausalTrajectories,
         includeDaySummary: cfg.activeRecallIncludeDaySummary,
@@ -58173,6 +59369,219 @@ Keep the reflection grounded in the evidence below.
         const runtimeAgentId = typeof runtimeAgent?.id === "string" && runtimeAgent.id.length > 0 ? runtimeAgent.id : void 0;
         const capabilityAgentIds = runtimeAgentId ? [runtimeAgentId] : ["generalist"];
         const capabilityWorkspaceDir = (typeof runtimeAgent?.workspaceDir === "string" && runtimeAgent.workspaceDir.length > 0 ? runtimeAgent.workspaceDir : void 0) ?? orchestrator.config.workspaceDir ?? defaultWorkspaceDir();
+        const remnicUsesQmd = (orchestrator.config.searchBackend ?? "qmd") === "qmd" && orchestrator.config.qmdEnabled !== false;
+        const remnicQmdCommand = typeof orchestrator.config.qmdPath === "string" && orchestrator.config.qmdPath.trim().length > 0 ? orchestrator.config.qmdPath.trim() : "qmd";
+        const readAllowedRoots = [
+          orchestrator.config.memoryDir,
+          capabilityWorkspaceDir ? path98.join(capabilityWorkspaceDir, "memory") : void 0
+        ].filter((root) => typeof root === "string" && root.length > 0);
+        const canonicalizeRootForContainment = async (rawPath) => {
+          const resolved = path98.resolve(rawPath);
+          try {
+            return path98.normalize(await realpath5(resolved));
+          } catch {
+            return path98.normalize(resolved);
+          }
+        };
+        const canonicalizeForRead = async (rawPath) => {
+          const resolved = path98.resolve(rawPath);
+          const real = await realpath5(resolved);
+          return path98.normalize(real);
+        };
+        const readAllowedCanonicalRootsPromise = Promise.all(
+          readAllowedRoots.map((root) => canonicalizeRootForContainment(root))
+        );
+        const isWithinAllowedRoot = async (candidatePath) => {
+          let canonicalCandidatePath;
+          try {
+            canonicalCandidatePath = await canonicalizeForRead(candidatePath);
+          } catch {
+            return false;
+          }
+          const canonicalRoots = await readAllowedCanonicalRootsPromise;
+          return canonicalRoots.some((root) => {
+            const relative = path98.relative(root, canonicalCandidatePath);
+            return relative === "" || !relative.startsWith("..") && !path98.isAbsolute(relative);
+          });
+        };
+        const normalizeWorkspacePath = (rawPath) => {
+          if (!rawPath || typeof rawPath !== "string") return "memory";
+          const resolved = path98.isAbsolute(rawPath) ? path98.resolve(rawPath) : path98.resolve(capabilityWorkspaceDir, rawPath);
+          const relative = path98.relative(capabilityWorkspaceDir, resolved);
+          return relative && !relative.startsWith("..") && !path98.isAbsolute(relative) ? relative : rawPath;
+        };
+        const relativizeToMemoryRoot = (rawPath) => {
+          if (!rawPath || typeof rawPath !== "string") return "memory";
+          const resolved = path98.isAbsolute(rawPath) ? path98.resolve(rawPath) : path98.resolve(capabilityWorkspaceDir, rawPath);
+          for (const root of readAllowedRoots) {
+            const relative = path98.relative(root, resolved);
+            if (relative !== "" && !relative.startsWith("..") && !path98.isAbsolute(relative)) {
+              return relative;
+            }
+          }
+          return normalizeWorkspacePath(rawPath);
+        };
+        const resolveReadablePath = async (requestedPath) => {
+          const candidateAbsolutePaths = path98.isAbsolute(requestedPath) ? [path98.resolve(requestedPath)] : readAllowedRoots.map((root) => path98.resolve(root, requestedPath));
+          let canonicalPath;
+          let lastError;
+          for (const absolutePath of candidateAbsolutePaths) {
+            try {
+              canonicalPath = await canonicalizeForRead(absolutePath);
+              break;
+            } catch (err) {
+              lastError = err;
+            }
+          }
+          if (canonicalPath === void 0) {
+            throw new Error(
+              `memory read rejected (path unresolvable): ${requestedPath}`
+            );
+          }
+          const canonicalRoots = await readAllowedCanonicalRootsPromise;
+          const contained = canonicalRoots.some((root) => {
+            const relative = path98.relative(root, canonicalPath);
+            return relative === "" || !relative.startsWith("..") && !path98.isAbsolute(relative);
+          });
+          if (!contained) {
+            throw new Error(`memory read outside allowed roots: ${requestedPath}`);
+          }
+          if (!canonicalPath.toLowerCase().endsWith(".md")) {
+            throw new Error(
+              `memory read restricted to .md files: ${requestedPath}`
+            );
+          }
+          return canonicalPath;
+        };
+        const remnicMemoryRuntime = {
+          async getMemorySearchManager(_params) {
+            return {
+              manager: {
+                async search(query, opts) {
+                  const namespace = typeof orchestrator.resolveSelfNamespace === "function" ? orchestrator.resolveSelfNamespace(opts?.sessionKey) : void 0;
+                  const resolvedMode = opts?.qmdSearchModeOverride === "vsearch" ? "vector" : opts?.qmdSearchModeOverride === "query" ? "search" : opts?.qmdSearchModeOverride ?? "search";
+                  const rawResults = await orchestrator.searchAcrossNamespaces({
+                    query,
+                    maxResults: opts?.maxResults,
+                    namespaces: namespace ? [namespace] : void 0,
+                    mode: resolvedMode
+                  });
+                  const isArtifactPath2 = (p) => /(?:^|[\\/])artifacts(?:[\\/]|$)/i.test(p);
+                  return rawResults.filter((result) => {
+                    const candidate = result;
+                    const p = typeof candidate.path === "string" ? candidate.path : typeof candidate.id === "string" ? candidate.id : "";
+                    return !isArtifactPath2(p);
+                  }).map((result, index) => {
+                    const candidate = result;
+                    const rawPath = typeof candidate.path === "string" ? candidate.path : typeof candidate.id === "string" ? candidate.id : `memory-${index + 1}`;
+                    const absolutePath = path98.isAbsolute(rawPath) ? path98.resolve(rawPath) : (() => {
+                      for (const root of readAllowedRoots) {
+                        const candidateAbs = path98.resolve(root, rawPath);
+                        const relative = path98.relative(root, candidateAbs);
+                        if (!relative.startsWith("..") && !path98.isAbsolute(relative)) {
+                          return candidateAbs;
+                        }
+                      }
+                      return path98.resolve(capabilityWorkspaceDir, rawPath);
+                    })();
+                    const normalizedPath = relativizeToMemoryRoot(rawPath);
+                    const startLine = typeof candidate.startLine === "number" && Number.isFinite(candidate.startLine) ? Math.max(1, Math.floor(candidate.startLine)) : 1;
+                    const endLine = typeof candidate.endLine === "number" && Number.isFinite(candidate.endLine) ? Math.max(startLine, Math.floor(candidate.endLine)) : startLine;
+                    return {
+                      path: absolutePath,
+                      startLine,
+                      endLine,
+                      score: typeof candidate.score === "number" && Number.isFinite(candidate.score) ? candidate.score : 0,
+                      snippet: typeof candidate.snippet === "string" ? candidate.snippet : typeof candidate.text === "string" ? candidate.text : "",
+                      source: normalizedPath.includes("sessions/") ? "sessions" : "memory",
+                      citation: normalizedPath
+                    };
+                  }).filter(
+                    (result) => typeof opts?.minScore === "number" && Number.isFinite(opts.minScore) ? result.score >= opts.minScore : true
+                  );
+                },
+                async readFile(params) {
+                  const requestedPath = normalizeWorkspacePath(params.relPath);
+                  const absolutePath = await resolveReadablePath(params.relPath);
+                  const text = await readFile52(absolutePath, "utf-8");
+                  const allLines = text.split(/\r?\n/);
+                  const from = typeof params.from === "number" ? Math.max(1, Math.floor(params.from)) : 1;
+                  const lines = typeof params.lines === "number" && Number.isFinite(params.lines) ? Math.max(1, Math.floor(params.lines)) : void 0;
+                  const startIndex = from - 1;
+                  const endIndex = typeof lines === "number" ? startIndex + lines : allLines.length;
+                  const slice = allLines.slice(startIndex, endIndex);
+                  const truncated = endIndex < allLines.length;
+                  return {
+                    text: slice.join("\n"),
+                    path: requestedPath,
+                    truncated: truncated || void 0,
+                    from,
+                    lines,
+                    nextFrom: truncated ? endIndex + 1 : void 0
+                  };
+                },
+                status() {
+                  const qmdAvailable = remnicUsesQmd && typeof orchestrator.qmd?.isAvailable === "function" ? Boolean(orchestrator.qmd.isAvailable()) : !remnicUsesQmd;
+                  const qmdDebug = typeof orchestrator.qmd?.debugStatus === "function" ? orchestrator.qmd.debugStatus() : void 0;
+                  return {
+                    backend: remnicUsesQmd ? "qmd" : "builtin",
+                    provider: remnicUsesQmd ? "qmd" : "builtin",
+                    requestedProvider: remnicUsesQmd ? "qmd" : "builtin",
+                    model: remnicUsesQmd ? remnicQmdCommand : "builtin",
+                    dirty: false,
+                    workspaceDir: capabilityWorkspaceDir,
+                    dbPath: orchestrator.config.memoryDir,
+                    sources: ["memory"],
+                    sourceCounts: [],
+                    vector: remnicUsesQmd ? {
+                      enabled: true,
+                      available: qmdAvailable
+                    } : {
+                      enabled: false
+                    },
+                    fts: {
+                      enabled: true,
+                      available: qmdAvailable
+                    },
+                    custom: {
+                      remnic: {
+                        qmdAvailable,
+                        qmdDebug,
+                        memoryDir: orchestrator.config.memoryDir
+                      }
+                    }
+                  };
+                },
+                async sync(_params2) {
+                  if (remnicUsesQmd && typeof orchestrator.qmd?.update === "function") {
+                    await orchestrator.qmd.update();
+                  }
+                },
+                async probeEmbeddingAvailability() {
+                  if (!remnicUsesQmd) return { ok: true };
+                  const qmdAvailable = typeof orchestrator.qmd?.isAvailable === "function" ? Boolean(orchestrator.qmd.isAvailable()) : false;
+                  if (qmdAvailable) return { ok: true };
+                  const qmdDebug = typeof orchestrator.qmd?.debugStatus === "function" ? orchestrator.qmd.debugStatus() : void 0;
+                  return {
+                    ok: false,
+                    error: qmdDebug ?? "Remnic QMD backend unavailable"
+                  };
+                },
+                async probeVectorAvailability() {
+                  if (!remnicUsesQmd) return false;
+                  return typeof orchestrator.qmd?.isAvailable === "function" ? Boolean(orchestrator.qmd.isAvailable()) : false;
+                },
+                async close() {
+                }
+              }
+            };
+          },
+          resolveMemoryBackendConfig(_params) {
+            return remnicUsesQmd ? { backend: "qmd", qmd: { command: remnicQmdCommand } } : { backend: "builtin" };
+          },
+          async closeAllMemorySearchManagers() {
+          }
+        };
         const memoryCapability = {
           // Include the promptBuilder so runtimes that treat unified capability
           // registration as authoritative (SDK >=2026.4.5) continue to inject
@@ -58180,6 +59589,7 @@ Keep the reflection grounded in the evidence below.
           // Respect promptInjectionAllowed policy — omit promptBuilder if injection
           // is disabled, so the capability only provides publicArtifacts.
           ...promptInjectionAllowed ? { promptBuilder: capabilityPromptBuilder } : {},
+          runtime: remnicMemoryRuntime,
           publicArtifacts: {
             listArtifacts: async (_params) => {
               try {
@@ -58197,7 +59607,7 @@ Keep the reflection grounded in the evidence below.
         };
         api.registerMemoryCapability(memoryCapability);
         const builderDesc = !promptInjectionAllowed ? " (promptBuilder omitted \u2014 injection disabled by policy)" : memoryPromptBuilder ? " and promptBuilder (from registerMemoryPromptSection)" : " and promptBuilder (capability-only fallback)";
-        log.info(`registered memory capability with publicArtifacts provider${builderDesc}`);
+        log.info(`registered memory capability with runtime and publicArtifacts provider${builderDesc}`);
       }
       api.on(
         "agent_end",
@@ -58494,7 +59904,7 @@ Keep the reflection grounded in the evidence below.
                   `session reset via API for ${sessionKey}, new sessionId=${result.sessionId}`
                 );
                 const safeSessionKey = sanitizeSessionKeyForFilename(sessionKey);
-                const signalPath = path97.join(
+                const signalPath = path98.join(
                   workspaceDir,
                   `.compaction-reset-signal-${safeSessionKey}`
                 );
@@ -58746,7 +60156,7 @@ Keep the reflection grounded in the evidence below.
     }
     async function ensureHourlySummaryCron(api2) {
       const jobId = "engram-hourly-summary";
-      const cronFilePath = path97.join(
+      const cronFilePath = path98.join(
         os6.homedir(),
         ".openclaw",
         "cron",
@@ -58758,7 +60168,7 @@ Keep the reflection grounded in the evidence below.
           jobs: []
         };
         try {
-          const content = await readFile51(cronFilePath, "utf-8");
+          const content = await readFile52(cronFilePath, "utf-8");
           jobsData = JSON.parse(content);
         } catch {
         }
@@ -58773,7 +60183,7 @@ Keep the reflection grounded in the evidence below.
           id: jobId,
           agentId: "generalist",
           model,
-          name: "Engram Hourly Summary",
+          name: "Remnic Hourly Summary",
           enabled: true,
           createdAtMs: Date.now(),
           updatedAtMs: Date.now(),
@@ -58789,7 +60199,7 @@ Keep the reflection grounded in the evidence below.
             kind: "agentTurn",
             timeoutSeconds: 120,
             thinking: "off",
-            message: "You are OpenClaw automation.\n\nTask: Generate Engram hourly summaries.\n\nCall the tool `memory_summarize_hourly` with empty params.\n\nOutput policy:\n- If you generated summaries successfully: output exactly NO_REPLY.\n- If there is an error: output one concise line describing it.\n\nRules:\n- Do NOT send anything to Discord.\n- Never print secrets.\n"
+            message: "You are OpenClaw automation.\n\nTask: Generate Remnic hourly summaries.\n\nCall the tool `memory_summarize_hourly` with empty params.\n\nOutput policy:\n- If you generated summaries successfully: output exactly NO_REPLY.\n- If there is an error: output one concise line describing it.\n\nRules:\n- Do NOT send anything to Discord.\n- Never print secrets.\n"
           },
           delivery: { mode: "none" },
           state: {}
@@ -58959,39 +60369,33 @@ Keep the reflection grounded in the evidence below.
       stop: async () => {
         if (!didCountStart) return;
         didCountStart = false;
+        const initPromiseAtStopEntry = globalThis[keys.INIT_PROMISE];
+        try {
+          await orchestrator.deferredReady;
+        } catch {
+        }
         const remainingServices = Math.max(
           0,
           (globalThis[CLI_ACTIVE_SERVICE_COUNT] || 0) - 1
         );
         globalThis[CLI_ACTIVE_SERVICE_COUNT] = remainingServices;
-        try {
-          activeOpikExporter?.unsubscribe();
-        } catch (err) {
-          log.debug(`engram opik exporter unsubscribe failed: ${err}`);
-        }
-        activeOpikExporter = null;
-        try {
-          await accessHttpServer.stop();
-        } catch (err) {
-          log.debug(`engram access HTTP stop failed: ${err}`);
-        }
-        stopDreamWatcher?.();
-        stopDreamWatcher = null;
-        stopHeartbeatWatcher?.();
-        stopHeartbeatWatcher = null;
-        removeDreamingObserver?.();
-        removeDreamingObserver = null;
-        delete globalThis[keys.ACCESS_HTTP_SERVER];
-        delete globalThis[keys.ACCESS_SERVICE];
-        const currentInitPromise = globalThis[keys.INIT_PROMISE];
+        const currentInitPromise = initPromiseAtStopEntry;
         let secondaryTookOver = false;
+        if (!currentInitPromise && globalThis[keys.INIT_PROMISE]) {
+          secondaryTookOver = true;
+        }
         if (!currentInitPromise) {
-          globalThis[keys.REGISTERED_GUARD] = false;
-          if (remainingServices === 0) {
-            globalThis[CLI_REGISTERED_GUARD] = false;
-            globalThis[SESSION_COMMANDS_REGISTERED_GUARD] = false;
+          if (!secondaryTookOver) {
+            globalThis[keys.REGISTERED_GUARD] = false;
+            if (remainingServices === 0) {
+              globalThis[CLI_REGISTERED_GUARD] = false;
+              globalThis[SESSION_COMMANDS_REGISTERED_GUARD] = false;
+            }
           }
         } else {
+          if (globalThis[keys.INIT_PROMISE] && globalThis[keys.INIT_PROMISE] !== currentInitPromise) {
+            secondaryTookOver = true;
+          }
           try {
             await currentInitPromise;
           } catch {
@@ -59001,6 +60405,27 @@ Keep the reflection grounded in the evidence below.
             secondaryTookOver = true;
           }
         }
+        if (!secondaryTookOver) {
+          try {
+            activeOpikExporter?.unsubscribe();
+          } catch (err) {
+            log.debug(`engram opik exporter unsubscribe failed: ${err}`);
+          }
+          activeOpikExporter = null;
+          try {
+            await accessHttpServer.stop();
+          } catch (err) {
+            log.debug(`engram access HTTP stop failed: ${err}`);
+          }
+          stopDreamWatcher?.();
+          stopDreamWatcher = null;
+          stopHeartbeatWatcher?.();
+          stopHeartbeatWatcher = null;
+          removeDreamingObserver?.();
+          removeDreamingObserver = null;
+          delete globalThis[keys.ACCESS_HTTP_SERVER];
+          delete globalThis[keys.ACCESS_SERVICE];
+        }
         if (!secondaryTookOver) {
           globalThis[keys.HOOK_APIS] = /* @__PURE__ */ new WeakSet();
         }
@@ -59036,7 +60461,7 @@ function extractTextContent2(msg) {
 // src/bridge.ts
 import { existsSync as existsSync12, readFileSync as readFileSync7 } from "fs";
 import * as childProcess from "child_process";
-import path98 from "path";
+import path99 from "path";
 
 // src/service-candidates.ts
 function firstSuccessfulResult(candidates, attempt) {
@@ -59063,17 +60488,17 @@ function readCompatEnv(primary, legacy) {
 function configPathCandidates() {
   const envPath = readCompatEnv("REMNIC_CONFIG_PATH", "ENGRAM_CONFIG_PATH");
   return [
-    ...envPath ? [path98.resolve(envPath)] : [],
-    path98.join(resolveHomeDir2(), ".config", "remnic", "config.json"),
-    path98.join(resolveHomeDir2(), ".config", "engram", "config.json"),
-    path98.join(process.cwd(), "remnic.config.json"),
-    path98.join(process.cwd(), "engram.config.json")
+    ...envPath ? [path99.resolve(envPath)] : [],
+    path99.join(resolveHomeDir2(), ".config", "remnic", "config.json"),
+    path99.join(resolveHomeDir2(), ".config", "engram", "config.json"),
+    path99.join(process.cwd(), "remnic.config.json"),
+    path99.join(process.cwd(), "engram.config.json")
   ];
 }
 function isDaemonRunning() {
   for (const pidFile of [
-    path98.join(resolveHomeDir2(), ".remnic", "server.pid"),
-    path98.join(resolveHomeDir2(), ".engram", "server.pid")
+    path99.join(resolveHomeDir2(), ".remnic", "server.pid"),
+    path99.join(resolveHomeDir2(), ".engram", "server.pid")
   ]) {
     try {
       const pid = parseInt(readFileSync7(pidFile, "utf8").trim(), 10);
@@ -59146,8 +60571,8 @@ function detectBridgeMode() {
 }
 function loadAnyToken() {
   const tokenPaths = [
-    path98.join(resolveHomeDir2(), ".remnic", "tokens.json"),
-    path98.join(resolveHomeDir2(), ".engram", "tokens.json")
+    path99.join(resolveHomeDir2(), ".remnic", "tokens.json"),
+    path99.join(resolveHomeDir2(), ".engram", "tokens.json")
   ];
   for (const tokensPath of tokenPaths) {
     if (!existsSync12(tokensPath)) continue;