@joshuaswarren/openclaw-engram 8.3.78 → 8.3.80

package/dist/index.js

@@ -450,9 +450,9 @@ function parseConfig(raw) {
 }
 
 // src/orchestrator.ts
-import path26 from "path";
+import path27 from "path";
 import { createHash as createHash6 } from "crypto";
-import { mkdir as mkdir19, readdir as readdir11, readFile as readFile18, writeFile as writeFile17 } from "fs/promises";
+import { mkdir as mkdir20, readdir as readdir11, readFile as readFile19, writeFile as writeFile18 } from "fs/promises";
 
 // src/signal.ts
 var BUILTIN_HIGH_PATTERNS = [
@@ -8665,6 +8665,192 @@ ${truncatedConversation}`;
   }
 };
 
+// src/lifecycle.ts
+var DEFAULT_POLICY = {
+  promoteHeatThreshold: 0.55,
+  staleDecayThreshold: 0.65,
+  archiveDecayThreshold: 0.85,
+  protectedCategories: ["decision", "principle", "commitment", "preference"]
+};
+function clamp01(value) {
+  if (!Number.isFinite(value)) return 0;
+  if (value < 0) return 0;
+  if (value > 1) return 1;
+  return value;
+}
+function clampLifecycleThreshold(value) {
+  return clamp01(value);
+}
+function parseIsoMs(value) {
+  if (!value) return null;
+  const ms = Date.parse(value);
+  return Number.isFinite(ms) ? ms : null;
+}
+function daysSince(value, nowMs) {
+  const ts = parseIsoMs(value);
+  if (ts === null) return 365;
+  return Math.max(0, (nowMs - ts) / 864e5);
+}
+function confidenceTierWeight(frontmatter) {
+  switch (frontmatter.confidenceTier) {
+    case "explicit":
+      return 1;
+    case "implied":
+      return 0.8;
+    case "inferred":
+      return 0.6;
+    case "speculative":
+      return 0.35;
+    default:
+      return clamp01(frontmatter.confidence ?? 0.5);
+  }
+}
+function accessWeight(accessCount) {
+  const raw = accessCount ?? 0;
+  if (raw <= 0) return 0;
+  return clamp01(Math.log1p(raw) / Math.log1p(20));
+}
+function recencyWeight(frontmatter, nowMs) {
+  const lastTouch = frontmatter.lastAccessed ?? frontmatter.updated ?? frontmatter.created;
+  const ageDays = daysSince(lastTouch, nowMs);
+  return clamp01(1 - ageDays / 90);
+}
+function feedbackWeight(signals) {
+  const raw = (signals?.feedbackScore ?? 0) + (signals?.actionPriorScore ?? 0);
+  return clamp01((raw + 1) / 2);
+}
+function boundedFeedbackScore(signals) {
+  const raw = (signals?.feedbackScore ?? 0) + (signals?.actionPriorScore ?? 0);
+  if (!Number.isFinite(raw)) return 0;
+  if (raw < -1) return -1;
+  if (raw > 1) return 1;
+  return raw;
+}
+function isProtectedMemory(frontmatter, policy) {
+  return frontmatter.policyClass === "protected" || policy.protectedCategories.includes(frontmatter.category);
+}
+function resolveLifecycleState(frontmatter) {
+  if (frontmatter.status === "archived") return "archived";
+  return frontmatter.lifecycleState ?? "candidate";
+}
+function computeHeat(memory, now, signals) {
+  const frontmatter = memory.frontmatter;
+  if (frontmatter.status === "archived") return 0;
+  const inputs = computeLifecycleValueInputs(memory, now, signals);
+  const score = inputs.confidence * 0.25 + inputs.access * 0.3 + inputs.recency * 0.2 + inputs.importance * 0.15 + inputs.feedback * 0.1 - inputs.disputedPenalty;
+  return clamp01(score);
+}
+function computeLifecycleValueInputs(memory, now, signals) {
+  const frontmatter = memory.frontmatter;
+  const nowMs = now.getTime();
+  return {
+    confidence: confidenceTierWeight(frontmatter),
+    access: accessWeight(frontmatter.accessCount),
+    recency: recencyWeight(frontmatter, nowMs),
+    importance: clamp01(frontmatter.importance?.score ?? 0.5),
+    feedback: feedbackWeight(signals),
+    disputedPenalty: frontmatter.verificationState === "disputed" ? 0.2 : 0
+  };
+}
+function computeDecay(memory, now, signals) {
+  const frontmatter = memory.frontmatter;
+  if (frontmatter.status === "archived") return 1;
+  const nowMs = now.getTime();
+  const ageDays = daysSince(frontmatter.updated ?? frontmatter.created, nowMs);
+  const staleAccessDays = daysSince(frontmatter.lastAccessed, nowMs);
+  const ageRisk = clamp01(ageDays / 180);
+  const staleAccessRisk = clamp01(staleAccessDays / 120);
+  const confidenceRisk = 1 - confidenceTierWeight(frontmatter);
+  const feedbackRisk = clamp01((boundedFeedbackScore(signals) * -1 + 1) / 2);
+  const heat = computeHeat(memory, now, signals);
+  const score = ageRisk * 0.3 + staleAccessRisk * 0.25 + confidenceRisk * 0.2 + feedbackRisk * 0.1 + (1 - heat) * 0.15;
+  return clamp01(score);
+}
+function toTerminalDisputedState(currentState) {
+  if (currentState === "archived") return "archived";
+  return "stale";
+}
+function isActiveEligible(verificationState) {
+  return verificationState === "user_confirmed" || verificationState === "system_inferred";
+}
+function decideLifecycleTransition(memory, policy, now, signals) {
+  const mergedPolicy = { ...DEFAULT_POLICY, ...policy };
+  const frontmatter = memory.frontmatter;
+  const currentState = resolveLifecycleState(frontmatter);
+  const heatScore = computeHeat(memory, now, signals);
+  const decayScore = computeDecay(memory, now, signals);
+  const protectedMemory = isProtectedMemory(frontmatter, mergedPolicy);
+  if (currentState === "archived") {
+    return {
+      currentState,
+      nextState: "archived",
+      heatScore,
+      decayScore,
+      changed: false,
+      reason: "archived_is_terminal"
+    };
+  }
+  if (frontmatter.verificationState === "disputed") {
+    const nextState = toTerminalDisputedState(currentState);
+    return {
+      currentState,
+      nextState,
+      heatScore,
+      decayScore,
+      changed: nextState !== currentState,
+      reason: "disputed_memories_do_not_promote_to_active"
+    };
+  }
+  if (decayScore >= mergedPolicy.archiveDecayThreshold && !protectedMemory) {
+    return {
+      currentState,
+      nextState: "archived",
+      heatScore,
+      decayScore,
+      changed: true,
+      reason: "decay_exceeded_archive_threshold"
+    };
+  }
+  if (decayScore >= mergedPolicy.staleDecayThreshold) {
+    return {
+      currentState,
+      nextState: "stale",
+      heatScore,
+      decayScore,
+      changed: currentState !== "stale",
+      reason: "decay_exceeded_stale_threshold"
+    };
+  }
+  if (heatScore >= mergedPolicy.promoteHeatThreshold) {
+    const nextState = isActiveEligible(frontmatter.verificationState) ? "active" : "validated";
+    return {
+      currentState,
+      nextState,
+      heatScore,
+      decayScore,
+      changed: currentState !== nextState,
+      reason: "heat_exceeded_promote_threshold"
+    };
+  }
+  return {
+    currentState,
+    nextState: currentState,
+    heatScore,
+    decayScore,
+    changed: false,
+    reason: "no_transition"
+  };
+}
+
+// src/retrieval.ts
+function applyRuntimeRetrievalPolicy(base, runtime) {
+  const fromRuntime = runtime?.recencyWeight;
+  if (typeof fromRuntime !== "number") {
+    return { recencyWeight: clamp01(base.recencyWeight) };
+  }
+  return { recencyWeight: clamp01(fromRuntime) };
+}
+
 // src/rerank.ts
 var RerankCache = class {
   entries = /* @__PURE__ */ new Map();
@@ -9049,18 +9235,18 @@ function sanitizeNonNegativeInt(value) {
   if (!Number.isFinite(value)) return 0;
   return Math.max(0, Math.floor(value));
 }
-function parseIsoMs(value) {
+function parseIsoMs2(value) {
   if (!value) return 0;
   const ms = Date.parse(value);
   return Number.isFinite(ms) ? ms : 0;
 }
 function mergeSessionCursor(existing, incoming) {
-  const existingObservedMs = parseIsoMs(existing.lastObservedAt);
-  const incomingObservedMs = parseIsoMs(incoming.lastObservedAt);
-  const existingTriggeredMs = parseIsoMs(existing.lastTriggeredAt);
-  const incomingTriggeredMs = parseIsoMs(incoming.lastTriggeredAt);
-  const existingResetMs = parseIsoMs(existing.lastResetAt);
-  const incomingResetMs = parseIsoMs(incoming.lastResetAt);
+  const existingObservedMs = parseIsoMs2(existing.lastObservedAt);
+  const incomingObservedMs = parseIsoMs2(incoming.lastObservedAt);
+  const existingTriggeredMs = parseIsoMs2(existing.lastTriggeredAt);
+  const incomingTriggeredMs = parseIsoMs2(incoming.lastTriggeredAt);
+  const existingResetMs = parseIsoMs2(existing.lastResetAt);
+  const incomingResetMs = parseIsoMs2(incoming.lastResetAt);
   const observedAt = incomingObservedMs >= existingObservedMs ? incoming.lastObservedAt : existing.lastObservedAt;
   const triggeredAt = incomingTriggeredMs >= existingTriggeredMs ? incoming.lastTriggeredAt : existing.lastTriggeredAt;
   const incomingIsNewer = incomingObservedMs >= existingObservedMs;
@@ -9818,6 +10004,10 @@ function buildInstructionHeavyQuery(prompt, tokenCap, maxChars) {
   if (compact.length <= maxChars) return compact;
   return compact.slice(0, maxChars).trim();
 }
+function clampInstructionHeavyTokenCap(value) {
+  if (!Number.isFinite(value)) return 8;
+  return Math.max(8, Math.round(value));
+}
 function buildStandardQuery(prompt, maxChars) {
   const trimmed = collapseWhitespace(prompt);
   if (trimmed.length <= maxChars) return trimmed;
@@ -9836,7 +10026,7 @@ function buildRecallQueryPolicy(prompt, sessionKey, cfg) {
   }
   const promptShape = classifyRecallPromptShape(prompt);
   const maxChars = Math.max(120, cfg.cronRecallNormalizedQueryMaxChars);
-  const tokenCap = Math.max(8, cfg.cronRecallInstructionHeavyTokenCap);
+  const tokenCap = clampInstructionHeavyTokenCap(cfg.cronRecallInstructionHeavyTokenCap);
   const retrievalQuery = promptShape === "instruction_heavy" ? buildInstructionHeavyQuery(prompt, tokenCap, maxChars) : buildStandardQuery(prompt, maxChars);
   const skipConversationRecall = cfg.cronConversationRecallMode === "never" ? true : cfg.cronConversationRecallMode === "always" ? false : promptShape === "instruction_heavy";
   const retrievalBudgetMode = promptShape === "instruction_heavy" ? "minimal" : "full";
@@ -10870,180 +11060,6 @@ var TmtBuilder = class {
   }
 };
 
-// src/lifecycle.ts
-var DEFAULT_POLICY = {
-  promoteHeatThreshold: 0.55,
-  staleDecayThreshold: 0.65,
-  archiveDecayThreshold: 0.85,
-  protectedCategories: ["decision", "principle", "commitment", "preference"]
-};
-function clamp01(value) {
-  if (!Number.isFinite(value)) return 0;
-  if (value < 0) return 0;
-  if (value > 1) return 1;
-  return value;
-}
-function parseIsoMs2(value) {
-  if (!value) return null;
-  const ms = Date.parse(value);
-  return Number.isFinite(ms) ? ms : null;
-}
-function daysSince(value, nowMs) {
-  const ts = parseIsoMs2(value);
-  if (ts === null) return 365;
-  return Math.max(0, (nowMs - ts) / 864e5);
-}
-function confidenceTierWeight(frontmatter) {
-  switch (frontmatter.confidenceTier) {
-    case "explicit":
-      return 1;
-    case "implied":
-      return 0.8;
-    case "inferred":
-      return 0.6;
-    case "speculative":
-      return 0.35;
-    default:
-      return clamp01(frontmatter.confidence ?? 0.5);
-  }
-}
-function accessWeight(accessCount) {
-  const raw = accessCount ?? 0;
-  if (raw <= 0) return 0;
-  return clamp01(Math.log1p(raw) / Math.log1p(20));
-}
-function recencyWeight(frontmatter, nowMs) {
-  const lastTouch = frontmatter.lastAccessed ?? frontmatter.updated ?? frontmatter.created;
-  const ageDays = daysSince(lastTouch, nowMs);
-  return clamp01(1 - ageDays / 90);
-}
-function feedbackWeight(signals) {
-  const raw = (signals?.feedbackScore ?? 0) + (signals?.actionPriorScore ?? 0);
-  return clamp01((raw + 1) / 2);
-}
-function boundedFeedbackScore(signals) {
-  const raw = (signals?.feedbackScore ?? 0) + (signals?.actionPriorScore ?? 0);
-  if (!Number.isFinite(raw)) return 0;
-  if (raw < -1) return -1;
-  if (raw > 1) return 1;
-  return raw;
-}
-function isProtectedMemory(frontmatter, policy) {
-  return frontmatter.policyClass === "protected" || policy.protectedCategories.includes(frontmatter.category);
-}
-function resolveLifecycleState(frontmatter) {
-  if (frontmatter.status === "archived") return "archived";
-  return frontmatter.lifecycleState ?? "candidate";
-}
-function computeHeat(memory, now, signals) {
-  const frontmatter = memory.frontmatter;
-  if (frontmatter.status === "archived") return 0;
-  const inputs = computeLifecycleValueInputs(memory, now, signals);
-  const score = inputs.confidence * 0.25 + inputs.access * 0.3 + inputs.recency * 0.2 + inputs.importance * 0.15 + inputs.feedback * 0.1 - inputs.disputedPenalty;
-  return clamp01(score);
-}
-function computeLifecycleValueInputs(memory, now, signals) {
-  const frontmatter = memory.frontmatter;
-  const nowMs = now.getTime();
-  return {
-    confidence: confidenceTierWeight(frontmatter),
-    access: accessWeight(frontmatter.accessCount),
-    recency: recencyWeight(frontmatter, nowMs),
-    importance: clamp01(frontmatter.importance?.score ?? 0.5),
-    feedback: feedbackWeight(signals),
-    disputedPenalty: frontmatter.verificationState === "disputed" ? 0.2 : 0
-  };
-}
-function computeDecay(memory, now, signals) {
-  const frontmatter = memory.frontmatter;
-  if (frontmatter.status === "archived") return 1;
-  const nowMs = now.getTime();
-  const ageDays = daysSince(frontmatter.updated ?? frontmatter.created, nowMs);
-  const staleAccessDays = daysSince(frontmatter.lastAccessed, nowMs);
-  const ageRisk = clamp01(ageDays / 180);
-  const staleAccessRisk = clamp01(staleAccessDays / 120);
-  const confidenceRisk = 1 - confidenceTierWeight(frontmatter);
-  const feedbackRisk = clamp01((boundedFeedbackScore(signals) * -1 + 1) / 2);
-  const heat = computeHeat(memory, now, signals);
-  const score = ageRisk * 0.3 + staleAccessRisk * 0.25 + confidenceRisk * 0.2 + feedbackRisk * 0.1 + (1 - heat) * 0.15;
-  return clamp01(score);
-}
-function toTerminalDisputedState(currentState) {
-  if (currentState === "archived") return "archived";
-  return "stale";
-}
-function isActiveEligible(verificationState) {
-  return verificationState === "user_confirmed" || verificationState === "system_inferred";
-}
-function decideLifecycleTransition(memory, policy, now, signals) {
-  const mergedPolicy = { ...DEFAULT_POLICY, ...policy };
-  const frontmatter = memory.frontmatter;
-  const currentState = resolveLifecycleState(frontmatter);
-  const heatScore = computeHeat(memory, now, signals);
-  const decayScore = computeDecay(memory, now, signals);
-  const protectedMemory = isProtectedMemory(frontmatter, mergedPolicy);
-  if (currentState === "archived") {
-    return {
-      currentState,
-      nextState: "archived",
-      heatScore,
-      decayScore,
-      changed: false,
-      reason: "archived_is_terminal"
-    };
-  }
-  if (frontmatter.verificationState === "disputed") {
-    const nextState = toTerminalDisputedState(currentState);
-    return {
-      currentState,
-      nextState,
-      heatScore,
-      decayScore,
-      changed: nextState !== currentState,
-      reason: "disputed_memories_do_not_promote_to_active"
-    };
-  }
-  if (decayScore >= mergedPolicy.archiveDecayThreshold && !protectedMemory) {
-    return {
-      currentState,
-      nextState: "archived",
-      heatScore,
-      decayScore,
-      changed: true,
-      reason: "decay_exceeded_archive_threshold"
-    };
-  }
-  if (decayScore >= mergedPolicy.staleDecayThreshold) {
-    return {
-      currentState,
-      nextState: "stale",
-      heatScore,
-      decayScore,
-      changed: currentState !== "stale",
-      reason: "decay_exceeded_stale_threshold"
-    };
-  }
-  if (heatScore >= mergedPolicy.promoteHeatThreshold) {
-    const nextState = isActiveEligible(frontmatter.verificationState) ? "active" : "validated";
-    return {
-      currentState,
-      nextState,
-      heatScore,
-      decayScore,
-      changed: currentState !== nextState,
-      reason: "heat_exceeded_promote_threshold"
-    };
-  }
-  return {
-    currentState,
-    nextState: currentState,
-    heatScore,
-    decayScore,
-    changed: false,
-    reason: "no_transition"
-  };
-}
-
 // src/temporal-index.ts
 import * as fs2 from "fs";
 import * as path16 from "path";
@@ -13121,6 +13137,154 @@ var RoutingRulesStore = class {
   }
 };
 
+// src/policy-runtime.ts
+import path26 from "path";
+import { mkdir as mkdir19, readFile as readFile18, rename as rename3, writeFile as writeFile17 } from "fs/promises";
+var RUNTIME_POLICY_VERSION = 1;
+var RUNTIME_POLICY_FILE = "policy-runtime.json";
+var RUNTIME_POLICY_PREV_FILE = "policy-runtime.prev.json";
+function sanitizeRuntimePolicyValues(values, options) {
+  const out = {};
+  if (typeof values.recencyWeight === "number") {
+    out.recencyWeight = clamp01(values.recencyWeight);
+  }
+  if (typeof values.lifecyclePromoteHeatThreshold === "number") {
+    out.lifecyclePromoteHeatThreshold = clampLifecycleThreshold(values.lifecyclePromoteHeatThreshold);
+  }
+  if (typeof values.lifecycleStaleDecayThreshold === "number") {
+    const staleDecayThreshold = clampLifecycleThreshold(values.lifecycleStaleDecayThreshold);
+    const maxStaleDecayThreshold = typeof options?.maxStaleDecayThreshold === "number" ? clampLifecycleThreshold(options.maxStaleDecayThreshold) : 1;
+    out.lifecycleStaleDecayThreshold = Math.min(staleDecayThreshold, maxStaleDecayThreshold);
+  }
+  if (typeof values.cronRecallInstructionHeavyTokenCap === "number") {
+    out.cronRecallInstructionHeavyTokenCap = clampInstructionHeavyTokenCap(
+      values.cronRecallInstructionHeavyTokenCap
+    );
+  }
+  return out;
+}
+function isRuntimeParameter(parameter) {
+  return parameter === "recencyWeight" || parameter === "lifecyclePromoteHeatThreshold" || parameter === "lifecycleStaleDecayThreshold" || parameter === "cronRecallInstructionHeavyTokenCap";
+}
+async function readSnapshot(filePath) {
+  try {
+    const raw = await readFile18(filePath, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed.version !== "number" || parsed.version < 1 || typeof parsed.updatedAt !== "string" || !parsed.values || typeof parsed.values !== "object" || typeof parsed.sourceAdjustmentCount !== "number" || parsed.sourceAdjustmentCount < 0) {
+      return null;
+    }
+    return {
+      version: parsed.version,
+      updatedAt: parsed.updatedAt,
+      values: sanitizeRuntimePolicyValues(parsed.values),
+      sourceAdjustmentCount: parsed.sourceAdjustmentCount
+    };
+  } catch {
+    return null;
+  }
+}
+async function writeSnapshotAtomic(filePath, snapshot) {
+  const tempPath = `${filePath}.tmp`;
+  await mkdir19(path26.dirname(filePath), { recursive: true });
+  await writeFile17(tempPath, `${JSON.stringify(snapshot, null, 2)}
+`, "utf-8");
+  await rename3(tempPath, filePath);
+}
+var PolicyRuntimeManager = class {
+  constructor(memoryDir, config) {
+    this.memoryDir = memoryDir;
+    this.config = config;
+    const stateDir2 = path26.join(memoryDir, "state");
+    this.runtimePath = path26.join(stateDir2, RUNTIME_POLICY_FILE);
+    this.runtimePrevPath = path26.join(stateDir2, RUNTIME_POLICY_PREV_FILE);
+  }
+  runtimePath;
+  runtimePrevPath;
+  async loadRuntimeValues() {
+    const snapshot = await readSnapshot(this.runtimePath);
+    if (!snapshot) return null;
+    return sanitizeRuntimePolicyValues(snapshot.values, {
+      maxStaleDecayThreshold: this.config.lifecycleArchiveDecayThreshold
+    });
+  }
+  async rollback() {
+    const previous = await readSnapshot(this.runtimePrevPath);
+    if (!previous) return false;
+    await writeSnapshotAtomic(this.runtimePath, {
+      ...previous,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    return true;
+  }
+  async applyFromBehaviorState(state) {
+    const adjustmentCount = state.adjustments.length;
+    if (adjustmentCount === 0) {
+      return { applied: false, rolledBack: false, values: await this.loadRuntimeValues(), reason: "no_adjustments" };
+    }
+    const protectedSet = /* @__PURE__ */ new Set([
+      ...this.config.behaviorLoopProtectedParams,
+      ...state.protectedParams
+    ]);
+    const existing = await readSnapshot(this.runtimePath);
+    const candidate = {
+      recencyWeight: existing?.values.recencyWeight ?? this.config.recencyWeight,
+      lifecyclePromoteHeatThreshold: existing?.values.lifecyclePromoteHeatThreshold ?? this.config.lifecyclePromoteHeatThreshold,
+      lifecycleStaleDecayThreshold: existing?.values.lifecycleStaleDecayThreshold ?? this.config.lifecycleStaleDecayThreshold,
+      cronRecallInstructionHeavyTokenCap: existing?.values.cronRecallInstructionHeavyTokenCap ?? this.config.cronRecallInstructionHeavyTokenCap
+    };
+    for (const adjustment of state.adjustments) {
+      if (!isRuntimeParameter(adjustment.parameter)) {
+        let rolledBack = false;
+        if (existing) {
+          await writeSnapshotAtomic(this.runtimePath, existing);
+          rolledBack = true;
+        } else {
+          rolledBack = await this.rollback();
+        }
+        return {
+          applied: false,
+          rolledBack,
+          values: await this.loadRuntimeValues(),
+          reason: `invalid_parameter:${adjustment.parameter}`
+        };
+      }
+      if (protectedSet.has(adjustment.parameter)) {
+        continue;
+      }
+      if (!Number.isFinite(adjustment.nextValue)) {
+        let rolledBack = false;
+        if (existing) {
+          await writeSnapshotAtomic(this.runtimePath, existing);
+          rolledBack = true;
+        } else {
+          rolledBack = await this.rollback();
+        }
+        return {
+          applied: false,
+          rolledBack,
+          values: await this.loadRuntimeValues(),
+          reason: `invalid_value:${adjustment.parameter}`
+        };
+      }
+      candidate[adjustment.parameter] = adjustment.nextValue;
+    }
+    const sanitized = sanitizeRuntimePolicyValues(candidate, {
+      maxStaleDecayThreshold: this.config.lifecycleArchiveDecayThreshold
+    });
+    if (existing) {
+      await writeSnapshotAtomic(this.runtimePrevPath, existing);
+    }
+    const nextSnapshot = {
+      version: RUNTIME_POLICY_VERSION,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      values: sanitized,
+      sourceAdjustmentCount: adjustmentCount
+    };
+    await writeSnapshotAtomic(this.runtimePath, nextSnapshot);
+    return { applied: true, rolledBack: false, values: sanitized, reason: "applied" };
+  }
+};
+
 // src/behavior-signals.ts
 import { createHash as createHash5 } from "crypto";
 function normalizeSignalText(input) {
@@ -13312,11 +13476,11 @@ function mergeGraphExpandedResults(primary, expanded) {
   return Array.from(mergedByPath.values());
 }
 function graphPathRelativeToStorage(storageDir, candidatePath) {
-  const absolutePath = path26.isAbsolute(candidatePath) ? candidatePath : path26.resolve(storageDir, candidatePath);
-  const rel = path26.relative(storageDir, absolutePath);
+  const absolutePath = path27.isAbsolute(candidatePath) ? candidatePath : path27.resolve(storageDir, candidatePath);
+  const rel = path27.relative(storageDir, absolutePath);
   if (!rel || rel === ".") return null;
   if (rel.startsWith("..")) return null;
-  return rel.split(path26.sep).join("/");
+  return rel.split(path27.sep).join("/");
 }
 function normalizeGraphActivationScore(score) {
   const bounded = Number.isFinite(score) && score > 0 ? score : 0;
@@ -13391,7 +13555,7 @@ function buildMemoryPathById(allMemsForGraph, storageDir) {
   for (const mem of allMemsForGraph ?? []) {
     const id = mem.frontmatter.id;
     if (!id) continue;
-    pathById.set(id, path26.relative(storageDir, mem.path));
+    pathById.set(id, path27.relative(storageDir, mem.path));
   }
   return pathById;
 }
@@ -13399,7 +13563,7 @@ function appendMemoryToGraphContext(options) {
   if (!Array.isArray(options.allMemsForGraph)) return;
   const nowIso = (/* @__PURE__ */ new Date()).toISOString();
   options.allMemsForGraph.push({
-    path: path26.join(options.storageDir, options.memoryRelPath),
+    path: path27.join(options.storageDir, options.memoryRelPath),
     content: options.content,
     frontmatter: {
       id: options.memoryId,
@@ -13419,15 +13583,15 @@ function resolvePersistedMemoryRelativePath(options) {
   const persisted = options.pathById.get(options.memoryId);
   if (persisted) return persisted;
   if (options.category === "correction") {
-    return path26.join("corrections", `${options.memoryId}.md`);
+    return path27.join("corrections", `${options.memoryId}.md`);
   }
   const idParts = options.memoryId.split("-");
   const maybeTimestamp = Number(idParts[1]);
   if (Number.isFinite(maybeTimestamp) && maybeTimestamp > 0) {
     const day = new Date(maybeTimestamp).toISOString().slice(0, 10);
-    return path26.join("facts", day, `${options.memoryId}.md`);
+    return path27.join("facts", day, `${options.memoryId}.md`);
   }
-  return path26.join("facts", `${options.memoryId}.md`);
+  return path27.join("facts", `${options.memoryId}.md`);
 }
 var Orchestrator = class _Orchestrator {
   storage;
@@ -13486,6 +13650,8 @@ var Orchestrator = class _Orchestrator {
   lastRecallFailureLogAtMs = 0;
   lastRecallFailureAtMs = 0;
   suppressedRecallFailures = 0;
+  policyRuntime;
+  runtimePolicyValues = null;
   // Initialization gate: recall() awaits this before proceeding
   initPromise = null;
   resolveInit = null;
@@ -13535,7 +13701,7 @@ var Orchestrator = class _Orchestrator {
     this.compounding = config.compoundingEnabled ? new CompoundingEngine(config) : void 0;
     this.buffer = new SmartBuffer(config, this.storage);
     this.transcript = new TranscriptManager(config);
-    this.conversationIndexDir = path26.join(config.memoryDir, "conversation-index", "chunks");
+    this.conversationIndexDir = path27.join(config.memoryDir, "conversation-index", "chunks");
     this.modelRegistry = new ModelRegistry(config.memoryDir);
     this.relevance = new RelevanceStore(config.memoryDir);
     this.negatives = new NegativeExampleStore(config.memoryDir);
@@ -13547,11 +13713,12 @@ var Orchestrator = class _Orchestrator {
       bands: config.sessionObserverBands ?? []
     });
     this.embeddingFallback = new EmbeddingFallback(config);
+    this.policyRuntime = new PolicyRuntimeManager(config.memoryDir, config);
     this.summarizer = new HourlySummarizer(config, config.gatewayConfig, this.modelRegistry, this.transcript);
     this.localLlm = new LocalLlmClient(config, this.modelRegistry);
     this.extraction = new ExtractionEngine(config, this.localLlm, config.gatewayConfig, this.modelRegistry);
     this.threading = new ThreadingManager(
-      path26.join(config.memoryDir, "threads"),
+      path27.join(config.memoryDir, "threads"),
       config.threadingGapMinutes
     );
     this.tmtBuilder = new TmtBuilder(config.memoryDir, {
@@ -13579,6 +13746,27 @@ var Orchestrator = class _Orchestrator {
     }
     return this.boxBuilders.get(dir);
   }
+  effectiveRecencyWeight() {
+    return applyRuntimeRetrievalPolicy(
+      { recencyWeight: this.config.recencyWeight },
+      this.runtimePolicyValues
+    ).recencyWeight;
+  }
+  effectiveCronRecallInstructionHeavyTokenCap() {
+    return this.runtimePolicyValues?.cronRecallInstructionHeavyTokenCap ?? this.config.cronRecallInstructionHeavyTokenCap;
+  }
+  effectiveLifecycleThresholds() {
+    const archiveDecayThreshold = this.config.lifecycleArchiveDecayThreshold;
+    const staleDecayThreshold = Math.min(
+      this.runtimePolicyValues?.lifecycleStaleDecayThreshold ?? this.config.lifecycleStaleDecayThreshold,
+      archiveDecayThreshold
+    );
+    return {
+      promoteHeatThreshold: this.runtimePolicyValues?.lifecyclePromoteHeatThreshold ?? this.config.lifecyclePromoteHeatThreshold,
+      staleDecayThreshold,
+      archiveDecayThreshold
+    };
+  }
   routeEngineOptions() {
     const allowedNamespaces = this.config.namespacesEnabled ? Array.from(
       /* @__PURE__ */ new Set([
@@ -13687,8 +13875,9 @@ var Orchestrator = class _Orchestrator {
     await this.lastRecall.load();
     await this.tierMigrationStatus.load();
     await this.sessionObserver.load();
+    this.runtimePolicyValues = await this.policyRuntime.loadRuntimeValues();
     if (this.config.factDeduplicationEnabled) {
-      const stateDir2 = path26.join(this.config.memoryDir, "state");
+      const stateDir2 = path27.join(this.config.memoryDir, "state");
       this.contentHashIndex = new ContentHashIndex(stateDir2);
       await this.contentHashIndex.load();
       log.info(`content-hash dedup: loaded ${this.contentHashIndex.size} hashes`);
@@ -13726,7 +13915,7 @@ var Orchestrator = class _Orchestrator {
       if (available) {
         log.info(`Conversation index QMD: available ${this.conversationQmd.debugStatus()}`);
         const collectionState = await this.conversationQmd.ensureCollection(
-          path26.join(this.config.memoryDir, "conversation-index")
+          path27.join(this.config.memoryDir, "conversation-index")
         );
         if (collectionState === "missing") {
           this.config.conversationIndexEnabled = false;
@@ -13762,6 +13951,16 @@ var Orchestrator = class _Orchestrator {
       this.resolveInit = null;
     }
   }
+  async applyBehaviorRuntimePolicy(state) {
+    const result = await this.policyRuntime.applyFromBehaviorState(state);
+    this.runtimePolicyValues = await this.policyRuntime.loadRuntimeValues();
+    return result;
+  }
+  async rollbackBehaviorRuntimePolicy() {
+    const rolledBack = await this.policyRuntime.rollback();
+    this.runtimePolicyValues = await this.policyRuntime.loadRuntimeValues();
+    return rolledBack;
+  }
   async maybeRunFileHygiene() {
     const hygiene = this.config.fileHygiene;
     if (!hygiene?.enabled) return;
@@ -13770,12 +13969,12 @@ var Orchestrator = class _Orchestrator {
     this.lastFileHygieneRunAtMs = now;
     if (hygiene.rotateEnabled) {
       for (const rel of hygiene.rotatePaths) {
-        const abs = path26.isAbsolute(rel) ? rel : path26.join(this.config.workspaceDir, rel);
+        const abs = path27.isAbsolute(rel) ? rel : path27.join(this.config.workspaceDir, rel);
         try {
-          const raw = await readFile18(abs, "utf-8");
+          const raw = await readFile19(abs, "utf-8");
           if (raw.length > hygiene.rotateMaxBytes) {
-            const archiveDir = path26.join(this.config.workspaceDir, hygiene.archiveDir);
-            const base = path26.basename(abs);
+            const archiveDir = path27.join(this.config.workspaceDir, hygiene.archiveDir);
+            const base = path27.basename(abs);
             const prefix = base.toUpperCase().replace(/\.MD$/i, "").replace(/[^A-Z0-9]+/g, "-") || "FILE";
             const { newContent } = await rotateMarkdownFileToArchive({
               filePath: abs,
@@ -13783,7 +13982,7 @@ var Orchestrator = class _Orchestrator {
               archivePrefix: prefix,
               keepTailChars: hygiene.rotateKeepTailChars
             });
-            await writeFile17(abs, newContent, "utf-8");
+            await writeFile18(abs, newContent, "utf-8");
           }
         } catch {
         }
@@ -13800,8 +13999,8 @@ var Orchestrator = class _Orchestrator {
         log.warn(w.message);
       }
       if (hygiene.warningsLogEnabled && warnings.length > 0) {
-        const fp = path26.join(this.config.memoryDir, hygiene.warningsLogPath);
-        await mkdir19(path26.dirname(fp), { recursive: true });
+        const fp = path27.join(this.config.memoryDir, hygiene.warningsLogPath);
+        await mkdir20(path27.dirname(fp), { recursive: true });
         const stamp = (/* @__PURE__ */ new Date()).toISOString();
         const block = `
 
@@ -13810,11 +14009,11 @@ var Orchestrator = class _Orchestrator {
 ` + warnings.map((w) => `- ${w.message}`).join("\n") + "\n";
         let existing = "";
         try {
-          existing = await readFile18(fp, "utf-8");
+          existing = await readFile19(fp, "utf-8");
         } catch {
           existing = "# Engram File Hygiene Warnings\n";
         }
-        await writeFile17(fp, existing + block, "utf-8");
+        await writeFile18(fp, existing + block, "utf-8");
       }
     }
   }
@@ -13890,9 +14089,9 @@ var Orchestrator = class _Orchestrator {
   }
   async getLastGraphRecallSnapshot(namespace) {
     const storage = await this.getStorage(namespace);
-    const snapshotPath = path26.join(storage.dir, "state", "last_graph_recall.json");
+    const snapshotPath = path27.join(storage.dir, "state", "last_graph_recall.json");
     try {
-      const raw = await readFile18(snapshotPath, "utf-8");
+      const raw = await readFile19(snapshotPath, "utf-8");
       const parsed = JSON.parse(raw);
       if (!parsed || typeof parsed !== "object") return null;
       return {
@@ -13961,7 +14160,7 @@ ${r.snippet.trim()}
       const entries = await readdir11(dir, { withFileTypes: true });
       let total = 0;
       for (const entry of entries) {
-        const fullPath = path26.join(dir, entry.name);
+        const fullPath = path27.join(dir, entry.name);
         if (entry.isDirectory()) {
           total += await this.countConversationChunkDocs(fullPath);
           continue;
@@ -14277,7 +14476,7 @@ ${r.snippet.trim()}
       const seedRelativePaths = seedCandidates.map((result) => graphPathRelativeToStorage(storage.dir, result.path)).filter((value) => typeof value === "string" && value.length > 0);
       if (seedRelativePaths.length === 0) continue;
       const seedRecallScore = seedCandidates.reduce((max, item) => Math.max(max, item.score), 0);
-      seedPaths.push(...seedRelativePaths.map((rel) => path26.join(storage.dir, rel)));
+      seedPaths.push(...seedRelativePaths.map((rel) => path27.join(storage.dir, rel)));
       const seedSet = new Set(seedRelativePaths);
       const expanded = await this.graphIndexFor(storage).spreadingActivation(
         seedRelativePaths,
@@ -14286,7 +14485,7 @@ ${r.snippet.trim()}
       if (expanded.length === 0) continue;
       for (const candidate of expanded.slice(0, perNamespaceExpandedCap)) {
         if (seedSet.has(candidate.path)) continue;
-        const memoryPath = path26.resolve(storage.dir, candidate.path);
+        const memoryPath = path27.resolve(storage.dir, candidate.path);
         const memory = await storage.readMemoryByPath(memoryPath);
         if (!memory) continue;
         if (isArtifactMemoryPath(memory.path)) continue;
@@ -14309,7 +14508,7 @@ ${r.snippet.trim()}
           path: memory.path,
           score,
           namespace,
-          seed: path26.resolve(storage.dir, candidate.seed),
+          seed: path27.resolve(storage.dir, candidate.seed),
           hopDepth: candidate.hopDepth,
           decayedWeight: candidate.decayedWeight,
           graphType: candidate.graphType
@@ -14324,8 +14523,8 @@ ${r.snippet.trim()}
   }
   async recordLastGraphRecallSnapshot(options) {
     try {
-      const snapshotPath = path26.join(options.storage.dir, "state", "last_graph_recall.json");
-      await mkdir19(path26.dirname(snapshotPath), { recursive: true });
+      const snapshotPath = path27.join(options.storage.dir, "state", "last_graph_recall.json");
+      await mkdir20(path27.dirname(snapshotPath), { recursive: true });
       const now = (/* @__PURE__ */ new Date()).toISOString();
       const totalSeedCount = options.seedPaths.length;
       const totalExpandedCount = options.expandedPaths.length;
@@ -14342,7 +14541,7 @@ ${r.snippet.trim()}
         seeds,
         expanded
       };
-      await writeFile17(snapshotPath, JSON.stringify(payload, null, 2), "utf-8");
+      await writeFile18(snapshotPath, JSON.stringify(payload, null, 2), "utf-8");
     } catch (err) {
       log.debug(`last graph recall write failed: ${err}`);
     }
@@ -14355,7 +14554,7 @@ ${r.snippet.trim()}
     const queryPolicy = buildRecallQueryPolicy(prompt, sessionKey, {
       cronRecallPolicyEnabled: this.config.cronRecallPolicyEnabled,
       cronRecallNormalizedQueryMaxChars: this.config.cronRecallNormalizedQueryMaxChars,
-      cronRecallInstructionHeavyTokenCap: this.config.cronRecallInstructionHeavyTokenCap,
+      cronRecallInstructionHeavyTokenCap: this.effectiveCronRecallInstructionHeavyTokenCap(),
       cronConversationRecallMode: this.config.cronConversationRecallMode
     });
     const retrievalQuery = queryPolicy.retrievalQuery || prompt;
@@ -15349,7 +15548,7 @@ _Context: ${topQuestion.context}_`);
     };
     this.tierMigrationInFlight = true;
     try {
-      const coldStorage = new StorageManager(path26.join(storage.dir, "cold"));
+      const coldStorage = new StorageManager(path27.join(storage.dir, "cold"));
       const [hotMemories, coldMemories] = await Promise.all([
         storage.readAllMemories(),
         coldStorage.readAllMemories()
@@ -15943,7 +16142,7 @@ _Context: ${topQuestion.context}_`);
         const allMems = allMemsForGraph ?? [];
         for (const m of allMems) {
           if (m.frontmatter.entityRef === entityRef) {
-            const rel = path26.relative(storage.dir, m.path);
+            const rel = path27.relative(storage.dir, m.path);
             if (rel !== memoryRelPath) entitySiblings.push(rel);
           }
         }
@@ -16445,10 +16644,11 @@ ${texts.map((t, i) => `[${i + 1}] ${t}`).join("\n\n")}`;
     let updatedCount = 0;
     let disputedCount = 0;
     let evaluatedCount = 0;
+    const thresholds = this.effectiveLifecycleThresholds();
     const policy = {
-      promoteHeatThreshold: this.config.lifecyclePromoteHeatThreshold,
-      staleDecayThreshold: this.config.lifecycleStaleDecayThreshold,
-      archiveDecayThreshold: this.config.lifecycleArchiveDecayThreshold,
+      promoteHeatThreshold: thresholds.promoteHeatThreshold,
+      staleDecayThreshold: thresholds.staleDecayThreshold,
+      archiveDecayThreshold: thresholds.archiveDecayThreshold,
       protectedCategories: this.config.lifecycleProtectedCategories
     };
     const actionPriors = await this.buildLifecycleActionPriors();
@@ -16494,15 +16694,15 @@ ${texts.map((t, i) => `[${i + 1}] ${t}`).join("\n\n")}`;
       staleRatio: total > 0 ? countsByState.stale / total : 0,
       disputedRatio: total > 0 ? disputedCount / total : 0,
       policy: {
-        promoteHeatThreshold: this.config.lifecyclePromoteHeatThreshold,
-        staleDecayThreshold: this.config.lifecycleStaleDecayThreshold,
-        archiveDecayThreshold: this.config.lifecycleArchiveDecayThreshold,
+        promoteHeatThreshold: thresholds.promoteHeatThreshold,
+        staleDecayThreshold: thresholds.staleDecayThreshold,
+        archiveDecayThreshold: thresholds.archiveDecayThreshold,
         protectedCategories: this.config.lifecycleProtectedCategories
       }
     };
-    const metricsPath = path26.join(this.storage.dir, "state", "lifecycle-metrics.json");
-    await mkdir19(path26.dirname(metricsPath), { recursive: true });
-    await writeFile17(metricsPath, JSON.stringify(metrics, null, 2), "utf-8");
+    const metricsPath = path27.join(this.storage.dir, "state", "lifecycle-metrics.json");
+    await mkdir20(path27.dirname(metricsPath), { recursive: true });
+    await writeFile18(metricsPath, JSON.stringify(metrics, null, 2), "utf-8");
   }
   /**
    * Archive old, low-importance, rarely-accessed facts (v6.0).
@@ -16768,7 +16968,7 @@ ${lines.join("\n\n")}`;
     if (hits.length === 0) return [];
     const results = [];
     for (const hit of hits) {
-      const fullPath = path26.isAbsolute(hit.path) ? hit.path : path26.join(this.config.memoryDir, hit.path);
+      const fullPath = path27.isAbsolute(hit.path) ? hit.path : path27.join(this.config.memoryDir, hit.path);
       const memory = await this.storage.readMemoryByPath(fullPath);
       if (!memory) continue;
       results.push({
@@ -17027,6 +17227,7 @@ ${lines.join("\n\n")}`;
     }
     let lifecycleFilteredCount = 0;
     const boosted = [];
+    const recencyWeight2 = this.effectiveRecencyWeight();
     for (const r of results) {
       const memory = memoryByPath.get(r.path);
       let score = r.score;
@@ -17038,13 +17239,13 @@ ${lines.join("\n\n")}`;
           lifecycleFilteredCount += 1;
           continue;
         }
-        if (this.config.recencyWeight > 0) {
+        if (recencyWeight2 > 0) {
           const createdAt = new Date(memory.frontmatter.created).getTime();
           const ageMs = now - createdAt;
           const ageDays = ageMs / (1e3 * 60 * 60 * 24);
           const halfLifeDays = 7;
           const recencyScore = Math.pow(0.5, ageDays / halfLifeDays);
-          score = score * (1 - this.config.recencyWeight) + recencyScore * this.config.recencyWeight;
+          score = score * (1 - recencyWeight2) + recencyScore * recencyWeight2;
         }
         if (this.config.boostAccessCount && memory.frontmatter.accessCount) {
           const accessBoost = Math.log10(memory.frontmatter.accessCount + 1) / 3;
@@ -17225,8 +17426,8 @@ ${lines.join("\n\n")}`;
   }
   namespaceFromStorageDir(storageDir) {
     if (!this.config.namespacesEnabled) return this.config.defaultNamespace;
-    const resolvedStorageDir = path26.resolve(storageDir);
-    const resolvedMemoryDir = path26.resolve(this.config.memoryDir);
+    const resolvedStorageDir = path27.resolve(storageDir);
+    const resolvedMemoryDir = path27.resolve(this.config.memoryDir);
     if (resolvedStorageDir === resolvedMemoryDir) return this.config.defaultNamespace;
     const m = resolvedStorageDir.match(/[\\/]namespaces[\\/]([^\\/]+)$/);
     return m && m[1] ? m[1] : this.config.defaultNamespace;
@@ -17254,14 +17455,14 @@ ${lines.join("\n\n")}`;
 };
 
 // src/tools.ts
-import path28 from "path";
+import path29 from "path";
 import { createHash as createHash7 } from "crypto";
 import { Type } from "@sinclair/typebox";
 
 // src/work/storage.ts
-import path27 from "path";
+import path28 from "path";
 import { randomUUID } from "crypto";
-import { mkdir as mkdir20, readdir as readdir12, readFile as readFile19, rm as rm3, writeFile as writeFile18 } from "fs/promises";
+import { mkdir as mkdir21, readdir as readdir12, readFile as readFile20, rm as rm3, writeFile as writeFile19 } from "fs/promises";
 var TASK_TRANSITIONS = {
   todo: /* @__PURE__ */ new Set(["in_progress", "blocked", "cancelled"]),
   in_progress: /* @__PURE__ */ new Set(["todo", "blocked", "done", "cancelled"]),
@@ -17336,22 +17537,22 @@ function ensureProjectStatus(value) {
 var WorkStorage = class {
   constructor(memoryDir) {
     this.memoryDir = memoryDir;
-    this.tasksDir = path27.join(memoryDir, "work", "tasks");
-    this.projectsDir = path27.join(memoryDir, "work", "projects");
+    this.tasksDir = path28.join(memoryDir, "work", "tasks");
+    this.projectsDir = path28.join(memoryDir, "work", "projects");
   }
   tasksDir;
   projectsDir;
   async ensureDirectories() {
-    await mkdir20(this.tasksDir, { recursive: true });
-    await mkdir20(this.projectsDir, { recursive: true });
+    await mkdir21(this.tasksDir, { recursive: true });
+    await mkdir21(this.projectsDir, { recursive: true });
   }
   taskPath(id) {
     assertValidWorkId(id, "task");
-    return path27.join(this.tasksDir, `${id}.md`);
+    return path28.join(this.tasksDir, `${id}.md`);
   }
   projectPath(id) {
     assertValidWorkId(id, "project");
-    return path27.join(this.projectsDir, `${id}.md`);
+    return path28.join(this.projectsDir, `${id}.md`);
   }
   serializeTask(task) {
     return `${serializeFrontmatter2(task)}
@@ -17423,7 +17624,7 @@ ${project.description}
         throw new Error(`project not found: ${task.projectId}`);
       }
     }
-    await writeFile18(this.taskPath(task.id), this.serializeTask(task), "utf-8");
+    await writeFile19(this.taskPath(task.id), this.serializeTask(task), "utf-8");
     if (task.projectId) {
       await this.addTaskIdToProject(task.projectId, task.id, now);
     }
@@ -17431,7 +17632,7 @@ ${project.description}
   }
   async getTask(id) {
     try {
-      const raw = await readFile19(this.taskPath(id), "utf-8");
+      const raw = await readFile20(this.taskPath(id), "utf-8");
       return this.parseTask(raw);
     } catch {
       return null;
@@ -17443,7 +17644,7 @@ ${project.description}
     const out = [];
     for (const entry of entries) {
       if (!entry.isFile() || !entry.name.endsWith(".md")) continue;
-      const raw = await readFile19(path27.join(this.tasksDir, entry.name), "utf-8");
+      const raw = await readFile20(path28.join(this.tasksDir, entry.name), "utf-8");
       const task = this.parseTask(raw);
       if (!task) continue;
       if (filter?.status && task.status !== filter.status) continue;
@@ -17485,7 +17686,7 @@ ${project.description}
       tags: patch.tags ?? existing.tags,
       updatedAt: now.toISOString()
     };
-    await writeFile18(this.taskPath(id), this.serializeTask(next), "utf-8");
+    await writeFile19(this.taskPath(id), this.serializeTask(next), "utf-8");
     return next;
   }
   async transitionTask(id, nextStatus, now = /* @__PURE__ */ new Date()) {
@@ -17525,12 +17726,12 @@ ${project.description}
       createdAt: timestamp,
       updatedAt: timestamp
     };
-    await writeFile18(this.projectPath(project.id), this.serializeProject(project), "utf-8");
+    await writeFile19(this.projectPath(project.id), this.serializeProject(project), "utf-8");
     return project;
   }
   async getProject(id) {
     try {
-      const raw = await readFile19(this.projectPath(id), "utf-8");
+      const raw = await readFile20(this.projectPath(id), "utf-8");
       return this.parseProject(raw);
     } catch {
       return null;
@@ -17542,7 +17743,7 @@ ${project.description}
     const out = [];
     for (const entry of entries) {
       if (!entry.isFile() || !entry.name.endsWith(".md")) continue;
-      const raw = await readFile19(path27.join(this.projectsDir, entry.name), "utf-8");
+      const raw = await readFile20(path28.join(this.projectsDir, entry.name), "utf-8");
       const project = this.parseProject(raw);
       if (project) out.push(project);
     }
@@ -17559,7 +17760,7 @@ ${project.description}
       taskIds: patch.taskIds ? [...patch.taskIds].sort() : existing.taskIds,
       updatedAt: now.toISOString()
     };
-    await writeFile18(this.projectPath(id), this.serializeProject(next), "utf-8");
+    await writeFile19(this.projectPath(id), this.serializeProject(next), "utf-8");
     return next;
   }
   async deleteProject(id) {
@@ -19098,7 +19299,7 @@ Best for:
 - Reviewing identity development over time`,
       parameters: Type.Object({}),
       async execute() {
-        const workspaceDir = path28.join(process.env.HOME ?? "~", ".openclaw", "workspace");
+        const workspaceDir = path29.join(process.env.HOME ?? "~", ".openclaw", "workspace");
         const identity = await orchestrator.storage.readIdentity(workspaceDir);
         if (!identity) {
           return toolResult("No identity file found. Identity reflections build automatically through conversations when identityEnabled is true.");
@@ -19607,12 +19808,12 @@ mistakes: ${res.mistakesCount} patterns`
 }
 
 // src/cli.ts
-import path44 from "path";
-import { access as access3, readFile as readFile30, readdir as readdir19, unlink as unlink5 } from "fs/promises";
+import path45 from "path";
+import { access as access3, readFile as readFile31, readdir as readdir19, unlink as unlink5 } from "fs/promises";
 
 // src/transfer/export-json.ts
-import path30 from "path";
-import { mkdir as mkdir22, readFile as readFile21 } from "fs/promises";
+import path31 from "path";
+import { mkdir as mkdir23, readFile as readFile22 } from "fs/promises";
 
 // src/transfer/constants.ts
 var EXPORT_FORMAT = "openclaw-engram-export";
@@ -19620,10 +19821,10 @@ var EXPORT_SCHEMA_VERSION = 1;
 
 // src/transfer/fs-utils.ts
 import { createHash as createHash8 } from "crypto";
-import { mkdir as mkdir21, readdir as readdir13, readFile as readFile20, stat as stat6, writeFile as writeFile19 } from "fs/promises";
-import path29 from "path";
+import { mkdir as mkdir22, readdir as readdir13, readFile as readFile21, stat as stat6, writeFile as writeFile20 } from "fs/promises";
+import path30 from "path";
 async function sha256File(filePath) {
-  const buf = await readFile20(filePath);
+  const buf = await readFile21(filePath);
   const sha256 = createHash8("sha256").update(buf).digest("hex");
   return { sha256, bytes: buf.byteLength };
 }
@@ -19633,11 +19834,11 @@ function sha256String(content) {
   return { sha256, bytes: buf.byteLength };
 }
 async function writeJsonFile(filePath, value) {
-  await mkdir21(path29.dirname(filePath), { recursive: true });
-  await writeFile19(filePath, JSON.stringify(value, null, 2) + "\n", "utf-8");
+  await mkdir22(path30.dirname(filePath), { recursive: true });
+  await writeFile20(filePath, JSON.stringify(value, null, 2) + "\n", "utf-8");
 }
 async function readJsonFile(filePath) {
-  const raw = await readFile20(filePath, "utf-8");
+  const raw = await readFile21(filePath, "utf-8");
   return JSON.parse(raw);
 }
 async function listFilesRecursive(rootDir) {
@@ -19645,7 +19846,7 @@ async function listFilesRecursive(rootDir) {
   async function walk(dir) {
     const entries = await readdir13(dir, { withFileTypes: true });
     for (const ent of entries) {
-      const fp = path29.join(dir, ent.name);
+      const fp = path30.join(dir, ent.name);
       if (ent.isDirectory()) {
         await walk(fp);
       } else if (ent.isFile()) {
@@ -19665,11 +19866,11 @@ async function fileExists(filePath) {
   }
 }
 function toPosixRelPath(absPath, rootDir) {
-  const rel = path29.relative(rootDir, absPath);
-  return rel.split(path29.sep).join("/");
+  const rel = path30.relative(rootDir, absPath);
+  return rel.split(path30.sep).join("/");
 }
 function fromPosixRelPath(relPath) {
-  return relPath.split("/").join(path29.sep);
+  return relPath.split("/").join(path30.sep);
 }
 
 // src/transfer/export-json.ts
@@ -19685,24 +19886,24 @@ function shouldExclude(relPosix, includeTranscripts) {
 }
 async function exportJsonBundle(opts) {
   const includeTranscripts = opts.includeTranscripts === true;
-  const outDirAbs = path30.resolve(opts.outDir);
-  await mkdir22(outDirAbs, { recursive: true });
-  const memoryDirAbs = path30.resolve(opts.memoryDir);
+  const outDirAbs = path31.resolve(opts.outDir);
+  await mkdir23(outDirAbs, { recursive: true });
+  const memoryDirAbs = path31.resolve(opts.memoryDir);
   const filesAbs = await listFilesRecursive(memoryDirAbs);
   const records = [];
   const manifestFiles = [];
   for (const abs of filesAbs) {
     const relPosix = toPosixRelPath(abs, memoryDirAbs);
     if (shouldExclude(relPosix, includeTranscripts)) continue;
-    const content = await readFile21(abs, "utf-8");
+    const content = await readFile22(abs, "utf-8");
     records.push({ path: relPosix, content });
     const { sha256, bytes } = await sha256File(abs);
     manifestFiles.push({ path: relPosix, sha256, bytes });
   }
   if (opts.includeWorkspaceIdentity !== false && opts.workspaceDir) {
-    const identityPath = path30.join(opts.workspaceDir, "IDENTITY.md");
+    const identityPath = path31.join(opts.workspaceDir, "IDENTITY.md");
     try {
-      const content = await readFile21(identityPath, "utf-8");
+      const content = await readFile22(identityPath, "utf-8");
       const relPath = "workspace/IDENTITY.md";
       records.push({ path: relPath, content });
       const { sha256, bytes } = sha256String(content);
@@ -19719,13 +19920,13 @@ async function exportJsonBundle(opts) {
     files: manifestFiles.sort((a, b) => a.path.localeCompare(b.path))
   };
   const bundle = { manifest, records };
-  await writeJsonFile(path30.join(outDirAbs, "manifest.json"), manifest);
-  await writeJsonFile(path30.join(outDirAbs, "bundle.json"), bundle);
+  await writeJsonFile(path31.join(outDirAbs, "manifest.json"), manifest);
+  await writeJsonFile(path31.join(outDirAbs, "bundle.json"), bundle);
 }
 
 // src/transfer/export-md.ts
-import path31 from "path";
-import { mkdir as mkdir23, readFile as readFile22, writeFile as writeFile20 } from "fs/promises";
+import path32 from "path";
+import { mkdir as mkdir24, readFile as readFile23, writeFile as writeFile21 } from "fs/promises";
 function shouldExclude2(relPosix, includeTranscripts) {
   const parts = relPosix.split("/");
   if (!includeTranscripts && parts[0] === "transcripts") return true;
@@ -19733,18 +19934,18 @@ function shouldExclude2(relPosix, includeTranscripts) {
 }
 async function exportMarkdownBundle(opts) {
   const includeTranscripts = opts.includeTranscripts === true;
-  const outDirAbs = path31.resolve(opts.outDir);
-  await mkdir23(outDirAbs, { recursive: true });
-  const memDirAbs = path31.resolve(opts.memoryDir);
+  const outDirAbs = path32.resolve(opts.outDir);
+  await mkdir24(outDirAbs, { recursive: true });
+  const memDirAbs = path32.resolve(opts.memoryDir);
   const filesAbs = await listFilesRecursive(memDirAbs);
   const manifestFiles = [];
   for (const abs of filesAbs) {
     const relPosix = toPosixRelPath(abs, memDirAbs);
     if (shouldExclude2(relPosix, includeTranscripts)) continue;
-    const dstAbs = path31.join(outDirAbs, ...relPosix.split("/"));
-    await mkdir23(path31.dirname(dstAbs), { recursive: true });
-    const content = await readFile22(abs);
-    await writeFile20(dstAbs, content);
+    const dstAbs = path32.join(outDirAbs, ...relPosix.split("/"));
+    await mkdir24(path32.dirname(dstAbs), { recursive: true });
+    const content = await readFile23(abs);
+    await writeFile21(dstAbs, content);
     const { sha256, bytes } = await sha256File(abs);
     manifestFiles.push({ path: relPosix, sha256, bytes });
   }
@@ -19756,12 +19957,12 @@ async function exportMarkdownBundle(opts) {
     includesTranscripts: includeTranscripts,
     files: manifestFiles.sort((a, b) => a.path.localeCompare(b.path))
   };
-  await writeJsonFile(path31.join(outDirAbs, "manifest.json"), manifest);
+  await writeJsonFile(path32.join(outDirAbs, "manifest.json"), manifest);
 }
 async function looksLikeEngramMdExport(fromDir) {
-  const dirAbs = path31.resolve(fromDir);
+  const dirAbs = path32.resolve(fromDir);
   try {
-    const raw = await readFile22(path31.join(dirAbs, "manifest.json"), "utf-8");
+    const raw = await readFile23(path32.join(dirAbs, "manifest.json"), "utf-8");
     const parsed = JSON.parse(raw);
     return parsed.format === EXPORT_FORMAT && parsed.schemaVersion === EXPORT_SCHEMA_VERSION;
   } catch {
@@ -19770,16 +19971,16 @@ async function looksLikeEngramMdExport(fromDir) {
 }
 
 // src/transfer/backup.ts
-import path32 from "path";
-import { mkdir as mkdir24, readdir as readdir14, rm as rm4 } from "fs/promises";
+import path33 from "path";
+import { mkdir as mkdir25, readdir as readdir14, rm as rm4 } from "fs/promises";
 function timestampDirName(now) {
   return now.toISOString().replace(/[:.]/g, "-");
 }
 async function backupMemoryDir(opts) {
-  const outDirAbs = path32.resolve(opts.outDir);
-  await mkdir24(outDirAbs, { recursive: true });
+  const outDirAbs = path33.resolve(opts.outDir);
+  await mkdir25(outDirAbs, { recursive: true });
   const ts = timestampDirName(/* @__PURE__ */ new Date());
-  const backupDir = path32.join(outDirAbs, ts);
+  const backupDir = path33.join(outDirAbs, ts);
   await exportMarkdownBundle({
     memoryDir: opts.memoryDir,
     outDir: backupDir,
@@ -19804,15 +20005,15 @@ async function enforceRetention(outDirAbs, retentionDays) {
     const tsMs = iso ? Date.parse(iso) : NaN;
     if (!Number.isFinite(tsMs)) continue;
     if (tsMs < cutoffMs) {
-      await rm4(path32.join(outDirAbs, name), { recursive: true, force: true });
+      await rm4(path33.join(outDirAbs, name), { recursive: true, force: true });
     }
   }
 }
 
 // src/transfer/export-sqlite.ts
-import path33 from "path";
+import path34 from "path";
 import Database from "better-sqlite3";
-import { readFile as readFile23 } from "fs/promises";
+import { readFile as readFile24 } from "fs/promises";
 
 // src/transfer/sqlite-schema.ts
 var SQLITE_SCHEMA_VERSION = 1;
@@ -19838,8 +20039,8 @@ function shouldExclude3(relPosix, includeTranscripts) {
 }
 async function exportSqlite(opts) {
   const includeTranscripts = opts.includeTranscripts === true;
-  const memDirAbs = path33.resolve(opts.memoryDir);
-  const outAbs = path33.resolve(opts.outFile);
+  const memDirAbs = path34.resolve(opts.memoryDir);
+  const outAbs = path34.resolve(opts.outFile);
   const filesAbs = await listFilesRecursive(memDirAbs);
   const db = new Database(outAbs);
   try {
@@ -19860,7 +20061,7 @@ async function exportSqlite(opts) {
     for (const abs of filesAbs) {
       const relPosix = toPosixRelPath(abs, memDirAbs);
       if (shouldExclude3(relPosix, includeTranscripts)) continue;
-      const content = await readFile23(abs, "utf-8");
+      const content = await readFile24(abs, "utf-8");
       const { sha256, bytes } = await sha256File(abs);
       rows.push({ rel: relPosix, bytes, sha256, content });
     }
@@ -19871,8 +20072,8 @@ async function exportSqlite(opts) {
 }
 
 // src/transfer/import-json.ts
-import path34 from "path";
-import { mkdir as mkdir25, writeFile as writeFile21 } from "fs/promises";
+import path35 from "path";
+import { mkdir as mkdir26, writeFile as writeFile22 } from "fs/promises";
 
 // src/transfer/types.ts
 import { z as z4 } from "zod";
@@ -19905,21 +20106,21 @@ function normalizeForDedupe(s) {
 }
 async function importJsonBundle(opts) {
   const conflict = opts.conflict ?? "skip";
-  const fromDirAbs = path34.resolve(opts.fromDir);
-  const bundlePath = path34.join(fromDirAbs, "bundle.json");
+  const fromDirAbs = path35.resolve(opts.fromDir);
+  const bundlePath = path35.join(fromDirAbs, "bundle.json");
   const bundle = ExportBundleV1Schema.parse(await readJsonFile(bundlePath));
-  const memDirAbs = path34.resolve(opts.targetMemoryDir);
+  const memDirAbs = path35.resolve(opts.targetMemoryDir);
   const written = [];
   let skipped = 0;
   for (const rec of bundle.records) {
     const isWorkspace = rec.path.startsWith("workspace/");
-    const targetBase = isWorkspace ? opts.workspaceDir ? path34.resolve(opts.workspaceDir) : null : memDirAbs;
+    const targetBase = isWorkspace ? opts.workspaceDir ? path35.resolve(opts.workspaceDir) : null : memDirAbs;
     if (isWorkspace && !targetBase) {
       skipped += 1;
       continue;
     }
     const relFs = fromPosixRelPath(isWorkspace ? rec.path.replace(/^workspace\//, "") : rec.path);
-    const absTarget = path34.join(targetBase, relFs);
+    const absTarget = path35.join(targetBase, relFs);
     const exists3 = await fileExists(absTarget);
     if (exists3) {
       if (conflict === "skip") {
@@ -19943,30 +20144,30 @@ async function importJsonBundle(opts) {
     return { written: 0, skipped };
   }
   for (const w of written) {
-    await mkdir25(path34.dirname(w.abs), { recursive: true });
-    await writeFile21(w.abs, w.content, "utf-8");
+    await mkdir26(path35.dirname(w.abs), { recursive: true });
+    await writeFile22(w.abs, w.content, "utf-8");
   }
   return { written: written.length, skipped };
 }
 function looksLikeEngramJsonExport(fromDir) {
-  const dir = path34.resolve(fromDir);
+  const dir = path35.resolve(fromDir);
   return Promise.all([
-    fileExists(path34.join(dir, "manifest.json")),
-    fileExists(path34.join(dir, "bundle.json"))
+    fileExists(path35.join(dir, "manifest.json")),
+    fileExists(path35.join(dir, "bundle.json"))
   ]).then(([m, b]) => m && b);
 }
 
 // src/transfer/import-sqlite.ts
-import path35 from "path";
+import path36 from "path";
 import Database2 from "better-sqlite3";
-import { mkdir as mkdir26, writeFile as writeFile22 } from "fs/promises";
+import { mkdir as mkdir27, writeFile as writeFile23 } from "fs/promises";
 function normalizeForDedupe2(s) {
   return s.replace(/\s+/g, " ").trim();
 }
 async function importSqlite(opts) {
   const conflict = opts.conflict ?? "skip";
-  const memDirAbs = path35.resolve(opts.targetMemoryDir);
-  const fromAbs = path35.resolve(opts.fromFile);
+  const memDirAbs = path36.resolve(opts.targetMemoryDir);
+  const fromAbs = path36.resolve(opts.fromFile);
   const db = new Database2(fromAbs, { readonly: true });
   const written = [];
   let skipped = 0;
@@ -19979,7 +20180,7 @@ async function importSqlite(opts) {
     const rows = db.prepare("SELECT path_rel, content FROM files").all();
     for (const r of rows) {
       const relFs = fromPosixRelPath(r.path_rel);
-      const absTarget = path35.join(memDirAbs, relFs);
+      const absTarget = path36.join(memDirAbs, relFs);
       const exists3 = await fileExists(absTarget);
       if (exists3) {
         if (conflict === "skip") {
@@ -20004,30 +20205,30 @@ async function importSqlite(opts) {
   }
   if (opts.dryRun) return { written: 0, skipped };
   for (const w of written) {
-    await mkdir26(path35.dirname(w.abs), { recursive: true });
-    await writeFile22(w.abs, w.content, "utf-8");
+    await mkdir27(path36.dirname(w.abs), { recursive: true });
+    await writeFile23(w.abs, w.content, "utf-8");
   }
   return { written: written.length, skipped };
 }
 
 // src/transfer/import-md.ts
-import path36 from "path";
-import { mkdir as mkdir27, readFile as readFile24, writeFile as writeFile23 } from "fs/promises";
+import path37 from "path";
+import { mkdir as mkdir28, readFile as readFile25, writeFile as writeFile24 } from "fs/promises";
 function normalizeForDedupe3(s) {
   return s.replace(/\s+/g, " ").trim();
 }
 async function importMarkdownBundle(opts) {
   const conflict = opts.conflict ?? "skip";
-  const fromAbs = path36.resolve(opts.fromDir);
-  const targetAbs = path36.resolve(opts.targetMemoryDir);
+  const fromAbs = path37.resolve(opts.fromDir);
+  const targetAbs = path37.resolve(opts.targetMemoryDir);
   const filesAbs = await listFilesRecursive(fromAbs);
   const writes = [];
   let skipped = 0;
   for (const abs of filesAbs) {
     const relPosix = toPosixRelPath(abs, fromAbs);
     if (relPosix === "manifest.json") continue;
-    const dstAbs = path36.join(targetAbs, fromPosixRelPath(relPosix));
-    const content = await readFile24(abs, "utf-8");
+    const dstAbs = path37.join(targetAbs, fromPosixRelPath(relPosix));
+    const content = await readFile25(abs, "utf-8");
     const exists3 = await fileExists(dstAbs);
     if (exists3) {
       if (conflict === "skip") {
@@ -20049,17 +20250,17 @@ async function importMarkdownBundle(opts) {
   }
   if (opts.dryRun) return { written: 0, skipped };
   for (const w of writes) {
-    await mkdir27(path36.dirname(w.abs), { recursive: true });
-    await writeFile23(w.abs, w.content, "utf-8");
+    await mkdir28(path37.dirname(w.abs), { recursive: true });
+    await writeFile24(w.abs, w.content, "utf-8");
   }
   return { written: writes.length, skipped };
 }
 
 // src/transfer/autodetect.ts
-import path37 from "path";
+import path38 from "path";
 import { stat as stat7 } from "fs/promises";
 async function detectImportFormat(fromPath) {
-  const abs = path37.resolve(fromPath);
+  const abs = path38.resolve(fromPath);
   let st;
   try {
     st = await stat7(abs);
@@ -20487,8 +20688,8 @@ function gatherCandidates(input, warnings) {
       const record = rec;
       const content = typeof record.content === "string" ? record.content : null;
       if (!content) continue;
-      const path46 = typeof record.path === "string" ? record.path : "";
-      if (!path46.startsWith("transcripts/") && !path46.includes("/transcripts/")) continue;
+      const path47 = typeof record.path === "string" ? record.path : "";
+      if (!path47.startsWith("transcripts/") && !path47.includes("/transcripts/")) continue;
       rows.push(...parseJsonl(content, warnings));
     }
     return rows;
@@ -20544,8 +20745,8 @@ var openclawReplayNormalizer = {
 };
 
 // src/maintenance/archive-observations.ts
-import path38 from "path";
-import { mkdir as mkdir28, readdir as readdir15, readFile as readFile25, unlink as unlink4, writeFile as writeFile24 } from "fs/promises";
+import path39 from "path";
+import { mkdir as mkdir29, readdir as readdir15, readFile as readFile26, unlink as unlink4, writeFile as writeFile25 } from "fs/promises";
 var DATE_FILE_PATTERN = /^(\d{4})-(\d{2})-(\d{2})\.(jsonl|md)$/;
 function normalizeRetentionDays(value) {
   if (!Number.isFinite(value)) return 30;
@@ -20571,8 +20772,8 @@ async function listFilesRecursive2(root, relPrefix = "") {
     return out;
   }
   for (const entry of entries) {
-    const rel = relPrefix ? path38.join(relPrefix, entry.name) : entry.name;
-    const full = path38.join(root, entry.name);
+    const rel = relPrefix ? path39.join(relPrefix, entry.name) : entry.name;
+    const full = path39.join(root, entry.name);
     if (entry.isDirectory()) {
       out.push(...await listFilesRecursive2(full, rel));
       continue;
@@ -20582,19 +20783,19 @@ async function listFilesRecursive2(root, relPrefix = "") {
   return out;
 }
 async function collectArchiveCandidates(memoryDir, cutoffTimeMs) {
-  const roots = ["transcripts", path38.join("state", "tool-usage"), path38.join("summaries", "hourly")];
+  const roots = ["transcripts", path39.join("state", "tool-usage"), path39.join("summaries", "hourly")];
   const out = [];
   for (const relRoot of roots) {
-    const absRoot = path38.join(memoryDir, relRoot);
+    const absRoot = path39.join(memoryDir, relRoot);
     const files = await listFilesRecursive2(absRoot);
     for (const fileRel of files) {
-      const filename = path38.basename(fileRel);
+      const filename = path39.basename(fileRel);
       const parsedDate = extractDateFromFilename(filename);
       if (!parsedDate) continue;
       if (parsedDate.getTime() >= cutoffTimeMs) continue;
       out.push({
-        absolutePath: path38.join(absRoot, fileRel),
-        relativePath: path38.join(relRoot, fileRel)
+        absolutePath: path39.join(absRoot, fileRel),
+        relativePath: path39.join(relRoot, fileRel)
       });
     }
   }
@@ -20609,7 +20810,7 @@ async function archiveObservations(options) {
     new Date(now.getTime() - retentionDays * 24 * 60 * 60 * 1e3)
   );
   const stamp = now.toISOString().replace(/[-:]/g, "").replace(/\.\d{3}Z$/, "Z");
-  const archiveRoot = path38.join(options.memoryDir, "archive", "observations", stamp);
+  const archiveRoot = path39.join(options.memoryDir, "archive", "observations", stamp);
   const candidates = retentionDays === 0 ? [] : await collectArchiveCandidates(
     options.memoryDir,
     cutoffDayStartUtc
@@ -20618,13 +20819,13 @@ async function archiveObservations(options) {
   let archivedBytes = 0;
   const archivedRelativePaths = [];
   if (!dryRun && candidates.length > 0) {
-    await mkdir28(archiveRoot, { recursive: true });
+    await mkdir29(archiveRoot, { recursive: true });
     for (const candidate of candidates) {
-      const archivePath = path38.join(archiveRoot, candidate.relativePath);
-      const archiveDir = path38.dirname(archivePath);
-      await mkdir28(archiveDir, { recursive: true });
-      const raw = await readFile25(candidate.absolutePath);
-      await writeFile24(archivePath, raw);
+      const archivePath = path39.join(archiveRoot, candidate.relativePath);
+      const archiveDir = path39.dirname(archivePath);
+      await mkdir29(archiveDir, { recursive: true });
+      const raw = await readFile26(candidate.absolutePath);
+      await writeFile25(archivePath, raw);
       await unlink4(candidate.absolutePath);
       archivedFiles += 1;
       archivedBytes += raw.byteLength;
@@ -20645,12 +20846,12 @@ async function archiveObservations(options) {
 }
 
 // src/maintenance/rebuild-observations.ts
-import path40 from "path";
-import { readdir as readdir16, readFile as readFile27 } from "fs/promises";
+import path41 from "path";
+import { readdir as readdir16, readFile as readFile28 } from "fs/promises";
 
 // src/maintenance/observation-ledger-utils.ts
-import path39 from "path";
-import { mkdir as mkdir29, readFile as readFile26, writeFile as writeFile25 } from "fs/promises";
+import path40 from "path";
+import { mkdir as mkdir30, readFile as readFile27, writeFile as writeFile26 } from "fs/promises";
 function toHourBucketIso(timestamp) {
   const normalized = /(?:Z|[+-]\d{2}:\d{2})$/u.test(timestamp) ? timestamp : `${timestamp}Z`;
   const ms = Date.parse(normalized);
@@ -20661,17 +20862,17 @@ function toHourBucketIso(timestamp) {
 }
 async function backupAndWriteRebuiltObservations(options) {
   const stamp = options.now.toISOString().replace(/[-:]/g, "").replace(/\.\d{3}Z$/, "Z");
-  const archiveRoot = path39.join(options.memoryDir, "archive", "observations", stamp);
-  let backupPath = path39.join(
+  const archiveRoot = path40.join(options.memoryDir, "archive", "observations", stamp);
+  let backupPath = path40.join(
     archiveRoot,
     "state",
     "observation-ledger",
     "rebuilt-observations.jsonl"
   );
   try {
-    const existing = await readFile26(options.outputPath, "utf-8");
-    await mkdir29(path39.dirname(backupPath), { recursive: true });
-    await writeFile25(backupPath, existing, "utf-8");
+    const existing = await readFile27(options.outputPath, "utf-8");
+    await mkdir30(path40.dirname(backupPath), { recursive: true });
+    await writeFile26(backupPath, existing, "utf-8");
   } catch (err) {
     const code = err.code;
     if (code && code === "ENOENT") {
@@ -20687,8 +20888,8 @@ async function backupAndWriteRebuiltObservations(options) {
       rebuiltAt
     })
   );
-  await mkdir29(path39.dirname(options.outputPath), { recursive: true });
-  await writeFile25(options.outputPath, lines.length > 0 ? `${lines.join("\n")}
+  await mkdir30(path40.dirname(options.outputPath), { recursive: true });
+  await writeFile26(options.outputPath, lines.length > 0 ? `${lines.join("\n")}
 ` : "", "utf-8");
   return backupPath;
 }
@@ -20710,7 +20911,7 @@ async function listTranscriptFiles(root) {
   for (const entry of entries) {
     if (entry.name === "." || entry.name === "..") continue;
     if (entry.isSymbolicLink()) continue;
-    const full = path40.join(root, entry.name);
+    const full = path41.join(root, entry.name);
     if (entry.isDirectory()) {
       out.push(...await listTranscriptFiles(full));
       continue;
@@ -20770,8 +20971,8 @@ function buildLedgerRows(linesByFile) {
 async function rebuildObservations(options) {
   const dryRun = options.dryRun !== false;
   const now = options.now ?? /* @__PURE__ */ new Date();
-  const transcriptsRoot = path40.join(options.memoryDir, "transcripts");
-  const outputPath = path40.join(
+  const transcriptsRoot = path41.join(options.memoryDir, "transcripts");
+  const outputPath = path41.join(
     options.memoryDir,
     "state",
     "observation-ledger",
@@ -20781,7 +20982,7 @@ async function rebuildObservations(options) {
   const contents = [];
   for (const file of transcriptFiles) {
     try {
-      contents.push(await readFile27(file, "utf-8"));
+      contents.push(await readFile28(file, "utf-8"));
     } catch {
     }
   }
@@ -20807,8 +21008,8 @@ async function rebuildObservations(options) {
 }
 
 // src/maintenance/migrate-observations.ts
-import path41 from "path";
-import { readdir as readdir17, readFile as readFile28 } from "fs/promises";
+import path42 from "path";
+import { readdir as readdir17, readFile as readFile29 } from "fs/promises";
 function toNonNegativeInt(value) {
   if (typeof value !== "number" || !Number.isFinite(value)) return null;
   const normalized = Math.floor(value);
@@ -20871,16 +21072,16 @@ async function listLegacyObservationFiles(root) {
 async function migrateObservations(options) {
   const dryRun = options.dryRun !== false;
   const now = options.now ?? /* @__PURE__ */ new Date();
-  const ledgerRoot = path41.join(options.memoryDir, "state", "observation-ledger");
-  const outputPath = path41.join(ledgerRoot, "rebuilt-observations.jsonl");
+  const ledgerRoot = path42.join(options.memoryDir, "state", "observation-ledger");
+  const outputPath = path42.join(ledgerRoot, "rebuilt-observations.jsonl");
   const legacyFiles = await listLegacyObservationFiles(ledgerRoot);
-  const sourceRelativePaths = legacyFiles.map((name) => path41.join("state", "observation-ledger", name));
+  const sourceRelativePaths = legacyFiles.map((name) => path42.join("state", "observation-ledger", name));
   const byKey = /* @__PURE__ */ new Map();
   let parsedRows = 0;
   let malformedLines = 0;
   for (const file of legacyFiles) {
-    const full = path41.join(ledgerRoot, file);
-    const raw = await readFile28(full, "utf-8");
+    const full = path42.join(ledgerRoot, file);
+    const raw = await readFile29(full, "utf-8");
     for (const line of raw.split("\n")) {
       if (!line.trim()) continue;
       let parsed;
@@ -21069,10 +21270,10 @@ var defaultCommandRunner = (command, args, options) => {
 
 // src/network/webdav.ts
 import { createReadStream } from "fs";
-import { mkdir as mkdir30, readdir as readdir18, realpath as realpath2, stat as stat9 } from "fs/promises";
+import { mkdir as mkdir31, readdir as readdir18, realpath as realpath2, stat as stat9 } from "fs/promises";
 import { createServer } from "http";
 import { timingSafeEqual } from "crypto";
-import path42 from "path";
+import path43 from "path";
 import { pipeline } from "stream/promises";
 import { URL as URL2 } from "url";
 function hostToUrlAuthority(host) {
@@ -21108,10 +21309,10 @@ var WebDavServer = class _WebDavServer {
     const allowedRoots = [];
     const aliasSet = /* @__PURE__ */ new Set();
     for (const dir of options.allowlistDirs) {
-      const resolved = path42.resolve(dir);
-      await mkdir30(resolved, { recursive: true });
+      const resolved = path43.resolve(dir);
+      await mkdir31(resolved, { recursive: true });
       const canonical = await realpath2(resolved);
-      const alias = path42.basename(canonical) || "root";
+      const alias = path43.basename(canonical) || "root";
       if (aliasSet.has(alias)) {
         throw new Error(`duplicate webdav allowlist alias: ${alias}`);
       }
@@ -21267,7 +21468,7 @@ var WebDavServer = class _WebDavServer {
     if (decodedPath.includes("\0")) {
       return { ok: false, code: 400, message: "invalid path" };
     }
-    const normalized = path42.posix.normalize(decodedPath);
+    const normalized = path43.posix.normalize(decodedPath);
     const segments = normalized.split("/").filter((segment) => segment.length > 0);
     if (segments.length === 0) {
       return { ok: false, code: 403, message: "root listing is not allowed" };
@@ -21281,7 +21482,7 @@ var WebDavServer = class _WebDavServer {
     if (relative.some((segment) => segment === ".." || segment.includes("\\"))) {
       return { ok: false, code: 403, message: "path traversal is not allowed" };
     }
-    const candidate = path42.resolve(root.absolute, ...relative);
+    const candidate = path43.resolve(root.absolute, ...relative);
     if (!this.isPathInside(root.absolute, candidate)) {
       return { ok: false, code: 403, message: "path escaped allowlist" };
     }
@@ -21359,10 +21560,10 @@ var WebDavServer = class _WebDavServer {
   }
   isPathInside(root, target) {
     if (target === root) return true;
-    if (root === path42.parse(root).root) {
+    if (root === path43.parse(root).root) {
       return target.startsWith(root);
     }
-    return target.startsWith(`${root}${path42.sep}`);
+    return target.startsWith(`${root}${path43.sep}`);
   }
 };
 function xmlEscape(value) {
@@ -21373,8 +21574,8 @@ function toEncodedHref(pathname) {
 }
 
 // src/compat/checks.ts
-import { access as access2, readFile as readFile29 } from "fs/promises";
-import path43 from "path";
+import { access as access2, readFile as readFile30 } from "fs/promises";
+import path44 from "path";
 import { spawn as spawn4 } from "child_process";
 var REQUIRED_HOOKS = ["before_agent_start", "agent_end"];
 function isSafeCommandToken(command) {
@@ -21556,13 +21757,13 @@ function compareVersions(a, b) {
 async function runCompatChecks(options) {
   const checks = [];
   const runner = options.runner ?? defaultRunner;
-  const pluginJsonPath = path43.join(options.repoRoot, "openclaw.plugin.json");
-  const packageJsonPath = path43.join(options.repoRoot, "package.json");
-  const indexPath = path43.join(options.repoRoot, "src", "index.ts");
+  const pluginJsonPath = path44.join(options.repoRoot, "openclaw.plugin.json");
+  const packageJsonPath = path44.join(options.repoRoot, "package.json");
+  const indexPath = path44.join(options.repoRoot, "src", "index.ts");
   let pluginRaw = "";
   let pluginManifestPresent = false;
   try {
-    pluginRaw = await readFile29(pluginJsonPath, "utf-8");
+    pluginRaw = await readFile30(pluginJsonPath, "utf-8");
     pluginManifestPresent = true;
     checks.push({
       id: "plugin-manifest-present",
@@ -21611,7 +21812,7 @@ async function runCompatChecks(options) {
   let packageRaw = "";
   let packageJsonPresent = false;
   try {
-    packageRaw = await readFile29(packageJsonPath, "utf-8");
+    packageRaw = await readFile30(packageJsonPath, "utf-8");
     packageJsonPresent = true;
   } catch {
     checks.push({
@@ -21682,7 +21883,7 @@ async function runCompatChecks(options) {
   }
   try {
     await access2(indexPath);
-    const indexRaw = await readFile29(indexPath, "utf-8");
+    const indexRaw = await readFile30(indexPath, "utf-8");
     const structuralSource = stripCommentsAndStrings(indexRaw);
     const hooks = parseHookRegistrations(indexRaw);
     const missingHooks = REQUIRED_HOOKS.filter((hook) => !hooks.has(hook));
@@ -22214,7 +22415,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 readFile30(options.inputPath, "utf-8");
+  const inputRaw = await readFile31(options.inputPath, "utf-8");
   const registry = buildReplayNormalizerRegistry([
     openclawReplayNormalizer,
     claudeReplayNormalizer,
@@ -22279,7 +22480,7 @@ async function runReplayCliCommand(orchestrator, options) {
 async function getPluginVersion() {
   try {
     const pkgPath = new URL("../package.json", import.meta.url);
-    const raw = await readFile30(pkgPath, "utf-8");
+    const raw = await readFile31(pkgPath, "utf-8");
     const parsed = JSON.parse(raw);
     return parsed.version ?? "unknown";
   } catch {
@@ -22298,14 +22499,14 @@ async function resolveMemoryDirForNamespace(orchestrator, namespace) {
   const ns = (namespace ?? "").trim();
   if (!ns) return orchestrator.config.memoryDir;
   if (!orchestrator.config.namespacesEnabled) return orchestrator.config.memoryDir;
-  const candidate = path44.join(orchestrator.config.memoryDir, "namespaces", ns);
+  const candidate = path45.join(orchestrator.config.memoryDir, "namespaces", ns);
   if (ns === orchestrator.config.defaultNamespace) {
     return await exists2(candidate) ? candidate : orchestrator.config.memoryDir;
   }
   return candidate;
 }
 async function readAllMemoryFiles(memoryDir) {
-  const roots = [path44.join(memoryDir, "facts"), path44.join(memoryDir, "corrections")];
+  const roots = [path45.join(memoryDir, "facts"), path45.join(memoryDir, "corrections")];
   const out = [];
   const walk = async (dir) => {
     let entries;
@@ -22316,14 +22517,14 @@ async function readAllMemoryFiles(memoryDir) {
     }
     for (const entry of entries) {
       const entryName = typeof entry.name === "string" ? entry.name : entry.name.toString("utf-8");
-      const fullPath = path44.join(dir, entryName);
+      const fullPath = path45.join(dir, entryName);
       if (entry.isDirectory()) {
         await walk(fullPath);
         continue;
       }
       if (!entry.isFile() || !entryName.endsWith(".md")) continue;
       try {
-        const raw = await readFile30(fullPath, "utf-8");
+        const raw = await readFile31(fullPath, "utf-8");
         const parsed = raw.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
         if (!parsed) continue;
         const fmRaw = parsed[1];
@@ -23131,7 +23332,7 @@ function registerCli(api, orchestrator) {
         }
       });
       cmd.command("identity").description("Show agent identity reflections").action(async () => {
-        const workspaceDir = path44.join(process.env.HOME ?? "~", ".openclaw", "workspace");
+        const workspaceDir = path45.join(process.env.HOME ?? "~", ".openclaw", "workspace");
         const identity = await orchestrator.storage.readIdentity(workspaceDir);
         if (!identity) {
           console.log("No identity file found.");
@@ -23354,8 +23555,8 @@ function registerCli(api, orchestrator) {
         const options = args[0] ?? {};
         const threadId = options.thread;
         const top = parseInt(options.top ?? "10", 10);
-        const memoryDir = path44.join(process.env.HOME ?? "~", ".openclaw", "workspace", "memory", "local");
-        const threading = new ThreadingManager(path44.join(memoryDir, "threads"));
+        const memoryDir = path45.join(process.env.HOME ?? "~", ".openclaw", "workspace", "memory", "local");
+        const threading = new ThreadingManager(path45.join(memoryDir, "threads"));
         if (threadId) {
           const thread = await threading.loadThread(threadId);
           if (!thread) {
@@ -23528,16 +23729,16 @@ function parseDuration(duration) {
 }
 
 // src/index.ts
-import { readFile as readFile31, writeFile as writeFile26 } from "fs/promises";
+import { readFile as readFile32, writeFile as writeFile27 } from "fs/promises";
 import { readFileSync as readFileSync4 } from "fs";
-import path45 from "path";
+import path46 from "path";
 import os5 from "os";
 var ENGRAM_REGISTERED_GUARD = "__openclawEngramRegistered";
 function loadPluginConfigFromFile() {
   try {
     const explicitConfigPath = process.env.OPENCLAW_ENGRAM_CONFIG_PATH || process.env.OPENCLAW_CONFIG_PATH;
     const homeDir = process.env.HOME ?? os5.homedir();
-    const configPath = explicitConfigPath && explicitConfigPath.length > 0 ? explicitConfigPath : path45.join(homeDir, ".openclaw", "openclaw.json");
+    const configPath = explicitConfigPath && explicitConfigPath.length > 0 ? explicitConfigPath : path46.join(homeDir, ".openclaw", "openclaw.json");
     const content = readFileSync4(configPath, "utf-8");
     const config = JSON.parse(content);
     const pluginEntry = config?.plugins?.entries?.["openclaw-engram"];
@@ -23745,11 +23946,11 @@ Use this context naturally when relevant. Never quote or expose this memory cont
     );
     async function ensureHourlySummaryCron(api2) {
       const jobId = "engram-hourly-summary";
-      const cronFilePath = path45.join(os5.homedir(), ".openclaw", "cron", "jobs.json");
+      const cronFilePath = path46.join(os5.homedir(), ".openclaw", "cron", "jobs.json");
       try {
         let jobsData = { version: 1, jobs: [] };
         try {
-          const content = await readFile31(cronFilePath, "utf-8");
+          const content = await readFile32(cronFilePath, "utf-8");
           jobsData = JSON.parse(content);
         } catch {
         }
@@ -23786,7 +23987,7 @@ Use this context naturally when relevant. Never quote or expose this memory cont
           state: {}
         };
         jobsData.jobs.push(newJob);
-        await writeFile26(cronFilePath, JSON.stringify(jobsData, null, 2), "utf-8");
+        await writeFile27(cronFilePath, JSON.stringify(jobsData, null, 2), "utf-8");
         log.info("auto-registered hourly summary cron job");
       } catch (err) {
         log.error("failed to auto-register hourly summary cron job:", err);