@joshuaswarren/openclaw-engram 8.3.80 → 8.3.81

package/dist/index.js

@@ -9137,6 +9137,7 @@ var LastRecallStore = class {
       queryHash,
       queryLen: opts.query.length,
       memoryIds: opts.memoryIds,
+      policyVersion: opts.policyVersion,
       identityInjectionMode: opts.identityInjection?.mode,
       identityInjectedChars: opts.identityInjection?.injectedChars,
       identityInjectionTruncated: opts.identityInjection?.truncated
@@ -13166,7 +13167,7 @@ function sanitizeRuntimePolicyValues(values, options) {
 function isRuntimeParameter(parameter) {
   return parameter === "recencyWeight" || parameter === "lifecyclePromoteHeatThreshold" || parameter === "lifecycleStaleDecayThreshold" || parameter === "cronRecallInstructionHeavyTokenCap";
 }
-async function readSnapshot(filePath) {
+async function readRuntimePolicySnapshot(filePath, options) {
   try {
     const raw = await readFile18(filePath, "utf-8");
     const parsed = JSON.parse(raw);
@@ -13176,7 +13177,9 @@ async function readSnapshot(filePath) {
     return {
       version: parsed.version,
       updatedAt: parsed.updatedAt,
-      values: sanitizeRuntimePolicyValues(parsed.values),
+      values: sanitizeRuntimePolicyValues(parsed.values, {
+        maxStaleDecayThreshold: options?.maxStaleDecayThreshold
+      }),
       sourceAdjustmentCount: parsed.sourceAdjustmentCount
     };
   } catch {
@@ -13201,14 +13204,16 @@ var PolicyRuntimeManager = class {
   runtimePath;
   runtimePrevPath;
   async loadRuntimeValues() {
-    const snapshot = await readSnapshot(this.runtimePath);
-    if (!snapshot) return null;
-    return sanitizeRuntimePolicyValues(snapshot.values, {
+    const snapshot = await readRuntimePolicySnapshot(this.runtimePath, {
       maxStaleDecayThreshold: this.config.lifecycleArchiveDecayThreshold
     });
+    if (!snapshot) return null;
+    return snapshot.values;
   }
   async rollback() {
-    const previous = await readSnapshot(this.runtimePrevPath);
+    const previous = await readRuntimePolicySnapshot(this.runtimePrevPath, {
+      maxStaleDecayThreshold: this.config.lifecycleArchiveDecayThreshold
+    });
     if (!previous) return false;
     await writeSnapshotAtomic(this.runtimePath, {
       ...previous,
@@ -13225,7 +13230,9 @@ var PolicyRuntimeManager = class {
       ...this.config.behaviorLoopProtectedParams,
       ...state.protectedParams
     ]);
-    const existing = await readSnapshot(this.runtimePath);
+    const existing = await readRuntimePolicySnapshot(this.runtimePath, {
+      maxStaleDecayThreshold: this.config.lifecycleArchiveDecayThreshold
+    });
     const candidate = {
       recencyWeight: existing?.values.recencyWeight ?? this.config.recencyWeight,
       lifecyclePromoteHeatThreshold: existing?.values.lifecyclePromoteHeatThreshold ?? this.config.lifecyclePromoteHeatThreshold,
@@ -13755,6 +13762,16 @@ var Orchestrator = class _Orchestrator {
   effectiveCronRecallInstructionHeavyTokenCap() {
     return this.runtimePolicyValues?.cronRecallInstructionHeavyTokenCap ?? this.config.cronRecallInstructionHeavyTokenCap;
   }
+  currentPolicyVersion() {
+    const thresholds = this.effectiveLifecycleThresholds();
+    const payload = {
+      recencyWeight: this.effectiveRecencyWeight(),
+      lifecyclePromoteHeatThreshold: thresholds.promoteHeatThreshold,
+      lifecycleStaleDecayThreshold: thresholds.staleDecayThreshold,
+      cronRecallInstructionHeavyTokenCap: this.effectiveCronRecallInstructionHeavyTokenCap()
+    };
+    return createHash6("sha256").update(JSON.stringify(payload)).digest("hex").slice(0, 12);
+  }
   effectiveLifecycleThresholds() {
     const archiveDecayThreshold = this.config.lifecycleArchiveDecayThreshold;
     const staleDecayThreshold = Math.min(
@@ -14559,6 +14576,7 @@ ${r.snippet.trim()}
     });
     const retrievalQuery = queryPolicy.retrievalQuery || prompt;
     const retrievalQueryHash = createHash6("sha256").update(retrievalQuery).digest("hex");
+    const policyVersion = this.currentPolicyVersion();
     let impressionRecorded = false;
     let recallSource = "none";
     let recalledMemoryCount = 0;
@@ -14609,6 +14627,7 @@ ${r.snippet.trim()}
         recalledMemoryCount,
         injected: false,
         contextChars: 0,
+        policyVersion,
         identityInjectionMode: identityInjectionModeUsed,
         identityInjectedChars,
         identityInjectionTruncated,
@@ -15180,6 +15199,7 @@ _Context: ${topQuestion.context}_`);
         sessionKey,
         query: retrievalQuery,
         memoryIds: [],
+        policyVersion,
         identityInjection: {
           mode: identityInjectionModeUsed,
           injectedChars: identityInjectedChars,
@@ -15206,6 +15226,7 @@ _Context: ${topQuestion.context}_`);
       recalledMemoryCount,
       injected: context.length > 0,
       contextChars: context.length,
+      policyVersion,
       identityInjectionMode: identityInjectionModeUsed,
       identityInjectedChars,
       identityInjectionTruncated,
@@ -16956,6 +16977,7 @@ ${lines.join("\n\n")}`;
         sessionKey: options.sessionKey,
         query: options.retrievalQuery,
         memoryIds: unique,
+        policyVersion: this.currentPolicyVersion(),
         identityInjection: options.identityInjection
       }).catch((err) => log.debug(`last recall record failed: ${err}`));
     }
@@ -19810,6 +19832,7 @@ mistakes: ${res.mistakesCount} patterns`
 // src/cli.ts
 import path45 from "path";
 import { access as access3, readFile as readFile31, readdir as readdir19, unlink as unlink5 } from "fs/promises";
+import { createHash as createHash9 } from "crypto";
 
 // src/transfer/export-json.ts
 import path31 from "path";
@@ -22099,6 +22122,171 @@ async function runTierMigrateCliCommand(orchestrator, options = {}) {
     limit: options.limit
   });
 }
+function effectivePolicyValuesForVersion(values, config) {
+  const candidate = {
+    recencyWeight: values.recencyWeight ?? config.recencyWeight,
+    lifecyclePromoteHeatThreshold: values.lifecyclePromoteHeatThreshold ?? config.lifecyclePromoteHeatThreshold,
+    lifecycleStaleDecayThreshold: values.lifecycleStaleDecayThreshold ?? config.lifecycleStaleDecayThreshold,
+    cronRecallInstructionHeavyTokenCap: values.cronRecallInstructionHeavyTokenCap ?? config.cronRecallInstructionHeavyTokenCap
+  };
+  const normalized = sanitizeRuntimePolicyValues(candidate, {
+    maxStaleDecayThreshold: config.lifecycleArchiveDecayThreshold
+  });
+  return {
+    recencyWeight: normalized.recencyWeight ?? config.recencyWeight,
+    lifecyclePromoteHeatThreshold: normalized.lifecyclePromoteHeatThreshold ?? config.lifecyclePromoteHeatThreshold,
+    lifecycleStaleDecayThreshold: normalized.lifecycleStaleDecayThreshold ?? config.lifecycleStaleDecayThreshold,
+    cronRecallInstructionHeavyTokenCap: normalized.cronRecallInstructionHeavyTokenCap ?? config.cronRecallInstructionHeavyTokenCap
+  };
+}
+function policyVersionForValues(values, config) {
+  const normalized = effectivePolicyValuesForVersion(values, config);
+  return createHash9("sha256").update(JSON.stringify(normalized)).digest("hex").slice(0, 12);
+}
+async function readRuntimePolicySnapshot2(config, fileName) {
+  const filePath = path45.join(config.memoryDir, "state", fileName);
+  const snapshot = await readRuntimePolicySnapshot(filePath, {
+    maxStaleDecayThreshold: config.lifecycleArchiveDecayThreshold
+  });
+  if (!snapshot) return null;
+  return {
+    version: snapshot.version,
+    updatedAt: snapshot.updatedAt,
+    values: snapshot.values,
+    sourceAdjustmentCount: Math.max(0, Math.floor(snapshot.sourceAdjustmentCount))
+  };
+}
+function parseSinceDurationMs(since) {
+  const trimmed = since.trim().toLowerCase();
+  const match = trimmed.match(/^(\d+)\s*([mhd])$/);
+  if (!match) {
+    throw new Error(`invalid --since value: ${since} (expected formats like 30m, 12h, 7d)`);
+  }
+  const amount = Number.parseInt(match[1] ?? "0", 10);
+  const unit = match[2];
+  if (!Number.isFinite(amount) || amount <= 0) {
+    throw new Error(`invalid --since value: ${since}`);
+  }
+  if (unit === "m") return amount * 60 * 1e3;
+  if (unit === "h") return amount * 60 * 60 * 1e3;
+  return amount * 24 * 60 * 60 * 1e3;
+}
+function resolvePolicySignalNamespaces(orchestrator) {
+  const names = /* @__PURE__ */ new Set([orchestrator.config.defaultNamespace]);
+  if (orchestrator.config.namespacesEnabled) {
+    names.add(orchestrator.config.sharedNamespace);
+    for (const policy of orchestrator.config.namespacePolicies) {
+      if (policy?.name) names.add(policy.name);
+    }
+  }
+  return [...names];
+}
+async function readBehaviorSignalsForNamespaces(orchestrator, limitPerNamespace) {
+  const namespaces = resolvePolicySignalNamespaces(orchestrator);
+  const merged = [];
+  for (const namespace of namespaces) {
+    const storage = await orchestrator.getStorage(namespace);
+    const events = await storage.readBehaviorSignals(limitPerNamespace);
+    merged.push(...events);
+  }
+  return merged;
+}
+function summarizeTopSignals(signals, cutoffIso, topN = 5) {
+  const cutoffMs = cutoffIso ? Date.parse(cutoffIso) : Number.NEGATIVE_INFINITY;
+  const grouped = /* @__PURE__ */ new Map();
+  for (const signal of signals) {
+    const ts = Date.parse(signal.timestamp);
+    if (Number.isFinite(cutoffMs) && (!Number.isFinite(ts) || ts < cutoffMs)) continue;
+    const key = `${signal.signalType}:${signal.direction}`;
+    const existing = grouped.get(key);
+    if (existing) {
+      existing.count += 1;
+      if (signal.timestamp > existing.lastSeenAt) {
+        existing.lastSeenAt = signal.timestamp;
+      }
+    } else {
+      grouped.set(key, {
+        signalType: signal.signalType,
+        direction: signal.direction,
+        count: 1,
+        lastSeenAt: signal.timestamp
+      });
+    }
+  }
+  return [...grouped.values()].sort((a, b) => b.count - a.count || b.lastSeenAt.localeCompare(a.lastSeenAt)).slice(0, Math.max(1, topN));
+}
+async function runPolicyStatusCliCommand(orchestrator) {
+  const now = /* @__PURE__ */ new Date();
+  const current = await readRuntimePolicySnapshot2(orchestrator.config, "policy-runtime.json");
+  const previous = await readRuntimePolicySnapshot2(orchestrator.config, "policy-runtime.prev.json");
+  const signals = await readBehaviorSignalsForNamespaces(orchestrator, 1e3);
+  const defaultWindowMs = Math.max(0, orchestrator.config.behaviorLoopLearningWindowDays) * 24 * 60 * 60 * 1e3;
+  const cutoffIso = defaultWindowMs > 0 ? new Date(now.getTime() - defaultWindowMs).toISOString() : void 0;
+  return {
+    generatedAt: now.toISOString(),
+    autoTuneEnabled: orchestrator.config.behaviorLoopAutoTuneEnabled,
+    current: current ? {
+      ...current,
+      policyVersion: policyVersionForValues(current.values, orchestrator.config)
+    } : null,
+    previous: previous ? {
+      ...previous,
+      policyVersion: policyVersionForValues(previous.values, orchestrator.config)
+    } : null,
+    topContributingSignals: summarizeTopSignals(signals, cutoffIso)
+  };
+}
+async function runPolicyDiffCliCommand(orchestrator, options = {}) {
+  const since = options.since?.trim() || "7d";
+  const sinceMs = parseSinceDurationMs(since);
+  const sinceIso = new Date(Date.now() - sinceMs).toISOString();
+  const current = await readRuntimePolicySnapshot2(orchestrator.config, "policy-runtime.json");
+  const previous = await readRuntimePolicySnapshot2(orchestrator.config, "policy-runtime.prev.json");
+  const currentValues = current?.values ?? {};
+  const previousValues = previous?.values ?? {};
+  const parameterKeys = /* @__PURE__ */ new Set([
+    ...Object.keys(currentValues),
+    ...Object.keys(previousValues)
+  ]);
+  const deltas = [];
+  for (const parameter of parameterKeys) {
+    const previousRaw = previousValues[parameter];
+    const nextRaw = currentValues[parameter];
+    const previousValue = typeof previousRaw === "number" ? previousRaw : null;
+    const nextValue = typeof nextRaw === "number" ? nextRaw : null;
+    if (previousValue === nextValue) continue;
+    deltas.push({
+      parameter,
+      previousValue,
+      nextValue,
+      delta: (nextValue ?? 0) - (previousValue ?? 0),
+      evidenceCount: current?.sourceAdjustmentCount ?? 0
+    });
+  }
+  deltas.sort((a, b) => Math.abs(b.delta) - Math.abs(a.delta) || a.parameter.localeCompare(b.parameter));
+  const signals = await readBehaviorSignalsForNamespaces(orchestrator, 1e3);
+  return {
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    since,
+    sinceIso,
+    currentPolicyVersion: current ? policyVersionForValues(current.values, orchestrator.config) : null,
+    previousPolicyVersion: previous ? policyVersionForValues(previous.values, orchestrator.config) : null,
+    deltas,
+    topContributingSignals: summarizeTopSignals(signals, sinceIso)
+  };
+}
+async function runPolicyRollbackCliCommand(orchestrator) {
+  const rolledBack = await orchestrator.rollbackBehaviorRuntimePolicy();
+  const current = await readRuntimePolicySnapshot2(orchestrator.config, "policy-runtime.json");
+  return {
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    rolledBack,
+    current: current ? {
+      ...current,
+      policyVersion: policyVersionForValues(current.values, orchestrator.config)
+    } : null
+  };
+}
 function incrementCounter(target, key) {
   const normalized = key && key.length > 0 ? key : "unknown";
   target[normalized] = (target[normalized] ?? 0) + 1;
@@ -22818,6 +23006,23 @@ function registerCli(api, orchestrator) {
         console.log(JSON.stringify(summary, null, 2));
         console.log("OK");
       });
+      cmd.command("policy-status").description("Show runtime behavior-loop policy status and top contributing signals").action(async () => {
+        const status = await runPolicyStatusCliCommand(orchestrator);
+        console.log(JSON.stringify(status, null, 2));
+        console.log("OK");
+      });
+      cmd.command("policy-diff").description("Show runtime policy deltas and evidence since a relative duration (default: 7d)").option("--since <window>", "Relative duration window like 30m, 12h, 7d", "7d").action(async (...args) => {
+        const options = args[0] ?? {};
+        const since = typeof options.since === "string" ? options.since : "7d";
+        const report = await runPolicyDiffCliCommand(orchestrator, { since });
+        console.log(JSON.stringify(report, null, 2));
+        console.log("OK");
+      });
+      cmd.command("policy-rollback").description("Roll back runtime behavior policy to the previous snapshot").action(async () => {
+        const report = await runPolicyRollbackCliCommand(orchestrator);
+        console.log(JSON.stringify(report, null, 2));
+        console.log("OK");
+      });
       cmd.command("action-audit").description("Show namespace-aware memory action policy outcomes").option("--namespace <name>", "Filter to a single namespace").option("--limit <n>", "Max events to read per namespace", "200").action(async (...args) => {
         const options = args[0] ?? {};
         const limitRaw = parseInt(String(options.limit ?? "200"), 10);