@joshuaswarren/openclaw-engram 9.0.29 → 9.0.31

package/dist/index.js

@@ -299,6 +299,7 @@ function parseConfig(raw) {
     trustZonesEnabled: cfg.trustZonesEnabled === true,
     quarantinePromotionEnabled: cfg.quarantinePromotionEnabled === true,
     trustZoneStoreDir: typeof cfg.trustZoneStoreDir === "string" && cfg.trustZoneStoreDir.trim().length > 0 ? cfg.trustZoneStoreDir.trim() : path.join(memoryDir, "state", "trust-zones"),
+    trustZoneRecallEnabled: cfg.trustZoneRecallEnabled === true,
     // Local LLM Provider (v2.1)
     localLlmEnabled: cfg.localLlmEnabled === true || cfg.localLlmEnabled === "true",
     // default: false
@@ -569,6 +570,12 @@ function buildDefaultRecallPipeline(cfg) {
       maxResults: 3,
       maxChars: 2200
     },
+    {
+      id: "trust-zones",
+      enabled: cfg.trustZoneRecallEnabled === true,
+      maxResults: 3,
+      maxChars: 1800
+    },
     {
       id: "memories",
       enabled: true,
@@ -616,10 +623,10 @@ function buildRecallPipelineConfig(cfg) {
 }
 
 // src/orchestrator.ts
-import path33 from "path";
+import path34 from "path";
 import os5 from "os";
 import { createHash as createHash6 } from "crypto";
-import { mkdir as mkdir23, readdir as readdir16, readFile as readFile23, stat as stat7, unlink as unlink5, writeFile as writeFile23 } from "fs/promises";
+import { mkdir as mkdir24, readdir as readdir16, readFile as readFile23, stat as stat7, unlink as unlink5, writeFile as writeFile24 } from "fs/promises";
 
 // src/signal.ts
 var BUILTIN_HIGH_PATTERNS = [
@@ -14196,6 +14203,33 @@ function recencyWindowFromPrompt(prompt, nowMs = Date.now()) {
 import path22 from "path";
 import { mkdir as mkdir15, writeFile as writeFile16 } from "fs/promises";
 
+// src/recall-tokenization.ts
+function normalizeRecallTokens(value, extraStopWords = []) {
+  const stopWords = /* @__PURE__ */ new Set([
+    "the",
+    "and",
+    "for",
+    "with",
+    "from",
+    "into",
+    "that",
+    "this",
+    "why",
+    "did",
+    ...extraStopWords
+  ]);
+  return value.toLowerCase().split(/[^a-z0-9]+/).map((token) => token.trim()).filter((token) => token.length >= 3 && !stopWords.has(token));
+}
+function countRecallTokenOverlap(queryTokens, value, extraStopWords = []) {
+  if (!value) return 0;
+  const tokens = new Set(normalizeRecallTokens(value, extraStopWords));
+  let matches = 0;
+  for (const token of queryTokens) {
+    if (tokens.has(token)) matches += 1;
+  }
+  return matches;
+}
+
 // src/store-contract.ts
 function isRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -14323,19 +14357,6 @@ async function getCausalTrajectoryStoreStatus(options) {
     invalidTrajectories
   };
 }
-function normalizeTokens(value) {
-  const stopWords = /* @__PURE__ */ new Set(["the", "and", "for", "with", "from", "into", "that", "this", "why", "did", "make"]);
-  return value.toLowerCase().split(/[^a-z0-9]+/).map((token) => token.trim()).filter((token) => token.length >= 3 && !stopWords.has(token));
-}
-function countOverlap(queryTokens, value) {
-  if (!value) return 0;
-  const tokens = new Set(normalizeTokens(value));
-  let matches = 0;
-  for (const token of queryTokens) {
-    if (tokens.has(token)) matches += 1;
-  }
-  return matches;
-}
 function lexicalScoreCausalTrajectoryRecord(record, queryTokens) {
   const weightedFields = [
     ["goal", record.goal, 4],
@@ -14351,7 +14372,7 @@ function lexicalScoreCausalTrajectoryRecord(record, queryTokens) {
   let score = 0;
   const matchedFields = [];
   for (const [field, value, weight] of weightedFields) {
-    const matches = countOverlap(queryTokens, value);
+    const matches = countRecallTokenOverlap(queryTokens, value, ["make"]);
     if (matches > 0) matchedFields.push(field);
     score += matches * weight;
   }
@@ -14372,7 +14393,7 @@ async function searchCausalTrajectories(options) {
   if (maxResults === 0) return [];
   const { trajectories } = await readCausalTrajectoryRecords(options);
   if (trajectories.length === 0) return [];
-  const queryTokens = new Set(normalizeTokens(options.query));
+  const queryTokens = new Set(normalizeRecallTokens(options.query, ["make"]));
   if (queryTokens.size === 0) return [];
   const scored = trajectories.map((record) => {
     const lexical = lexicalScoreCausalTrajectoryRecord(record, queryTokens);
@@ -14515,12 +14536,12 @@ async function readObjectiveStateSnapshots(options) {
   }
   return { files, snapshots, invalidSnapshots };
 }
-function normalizeTokens2(value) {
+function normalizeTokens(value) {
   return value.toLowerCase().split(/[^a-z0-9]+/).map((token) => token.trim()).filter((token) => token.length >= 2);
 }
 function overlapScore(queryTokens, value, weight) {
   if (!value) return 0;
-  const tokens = new Set(normalizeTokens2(value));
+  const tokens = new Set(normalizeTokens(value));
   let matches = 0;
   for (const token of queryTokens) {
     if (tokens.has(token)) matches += 1;
@@ -14555,7 +14576,7 @@ async function searchObjectiveStateSnapshots(options) {
   if (maxResults === 0) return [];
   const { snapshots } = await readObjectiveStateSnapshots(options);
   if (snapshots.length === 0) return [];
-  const queryTokens = new Set(normalizeTokens2(options.query));
+  const queryTokens = new Set(normalizeTokens(options.query));
   const scored = snapshots.map((snapshot) => {
     const lexicalScore = lexicalScoreObjectiveStateSnapshot(snapshot, queryTokens);
     return {
@@ -14572,6 +14593,302 @@ async function searchObjectiveStateSnapshots(options) {
   return filtered.slice(0, maxResults);
 }
 
+// src/trust-zones.ts
+import path24 from "path";
+import { mkdir as mkdir17, writeFile as writeFile18 } from "fs/promises";
+function validateMetadata3(raw) {
+  return validateStringRecord(raw, "metadata");
+}
+function validateZone(raw, field) {
+  const value = assertString2(raw, field);
+  if (!["quarantine", "working", "trusted"].includes(value)) {
+    throw new Error(`${field} must be one of quarantine|working|trusted`);
+  }
+  return value;
+}
+function validateKind(raw) {
+  const value = assertString2(raw, "kind");
+  if (!["memory", "artifact", "state", "trajectory", "external"].includes(value)) {
+    throw new Error("kind must be one of memory|artifact|state|trajectory|external");
+  }
+  return value;
+}
+function validateProvenance(raw) {
+  if (!isRecord2(raw)) throw new Error("provenance must be an object");
+  const sourceClass = assertString2(raw.sourceClass, "provenance.sourceClass");
+  if (!["tool_output", "web_content", "subagent_trace", "system_memory", "user_input", "manual"].includes(sourceClass)) {
+    throw new Error("provenance.sourceClass must be one of tool_output|web_content|subagent_trace|system_memory|user_input|manual");
+  }
+  return {
+    sourceClass,
+    observedAt: assertIsoRecordedAt(assertString2(raw.observedAt, "provenance.observedAt"), "provenance.observedAt"),
+    sessionKey: optionalString(raw.sessionKey),
+    sourceId: optionalString(raw.sourceId),
+    evidenceHash: optionalString(raw.evidenceHash)
+  };
+}
+function resolveTrustZoneStoreDir(memoryDir, overrideDir) {
+  if (typeof overrideDir === "string" && overrideDir.trim().length > 0) {
+    return overrideDir.trim();
+  }
+  return path24.join(memoryDir, "state", "trust-zones");
+}
+function validateTrustZoneRecord(raw) {
+  if (!isRecord2(raw)) throw new Error("trust-zone record must be an object");
+  if (raw.schemaVersion !== 1) throw new Error("schemaVersion must be 1");
+  return {
+    schemaVersion: 1,
+    recordId: assertSafePathSegment(assertString2(raw.recordId, "recordId"), "recordId"),
+    zone: validateZone(raw.zone, "zone"),
+    recordedAt: assertIsoRecordedAt(assertString2(raw.recordedAt, "recordedAt")),
+    kind: validateKind(raw.kind),
+    summary: assertString2(raw.summary, "summary"),
+    provenance: validateProvenance(raw.provenance),
+    promotedFromZone: raw.promotedFromZone === void 0 ? void 0 : validateZone(raw.promotedFromZone, "promotedFromZone"),
+    entityRefs: optionalStringArray2(raw.entityRefs, "entityRefs"),
+    tags: optionalStringArray2(raw.tags, "tags"),
+    metadata: validateMetadata3(raw.metadata)
+  };
+}
+async function recordTrustZoneRecord(options) {
+  const rootDir = resolveTrustZoneStoreDir(options.memoryDir, options.trustZoneStoreDir);
+  const validated = validateTrustZoneRecord(options.record);
+  const day = recordStoreDay(validated.recordedAt);
+  const zoneDir = path24.join(rootDir, "zones", validated.zone, day);
+  const filePath = path24.join(zoneDir, `${validated.recordId}.json`);
+  await mkdir17(zoneDir, { recursive: true });
+  await writeFile18(filePath, JSON.stringify(validated, null, 2), "utf8");
+  return filePath;
+}
+function hasAnchoredProvenance(record) {
+  return Boolean(record.provenance.sourceId && record.provenance.evidenceHash);
+}
+function buildPromotionRecordId(sourceRecordId, targetZone, recordedAt) {
+  const suffix = recordedAt.replace(/[^0-9]/g, "").slice(0, 14);
+  return `${sourceRecordId}-${targetZone}-${suffix}`;
+}
+function dedupeStrings(values) {
+  const out = values.filter((value) => typeof value === "string" && value.length > 0);
+  if (out.length === 0) return void 0;
+  return [...new Set(out)];
+}
+function planTrustZonePromotion(options) {
+  const { record, targetZone } = options;
+  const reasons = [];
+  const provenanceAnchored = hasAnchoredProvenance(record);
+  if (record.zone === targetZone) {
+    reasons.push(`record is already in the ${targetZone} zone`);
+  }
+  if (record.zone === "trusted") {
+    reasons.push("trusted records are terminal and cannot be promoted again");
+  }
+  if (record.zone === "quarantine" && targetZone === "trusted") {
+    reasons.push("quarantine records must pass through working before trusted promotion");
+  }
+  if (record.zone === "working" && targetZone === "quarantine") {
+    reasons.push("working records cannot be demoted back into quarantine in this promotion path");
+  }
+  if (record.zone === "quarantine" && targetZone !== "working") {
+    reasons.push("quarantine promotions only support the working zone");
+  }
+  if (record.zone === "working" && targetZone !== "trusted") {
+    reasons.push("working promotions only support the trusted zone");
+  }
+  if (targetZone === "trusted" && ["tool_output", "web_content", "subagent_trace"].includes(record.provenance.sourceClass) && provenanceAnchored !== true) {
+    reasons.push("trusted promotion for external/tool-derived provenance requires both provenance.sourceId and provenance.evidenceHash");
+  }
+  return {
+    allowed: reasons.length === 0,
+    reasons,
+    sourceRecordId: record.recordId,
+    sourceZone: record.zone,
+    targetZone,
+    provenanceAnchored
+  };
+}
+async function findTrustZoneRecordById(options) {
+  const { records } = await readTrustZoneRecords(options);
+  records.sort((a, b) => b.recordedAt.localeCompare(a.recordedAt));
+  return records.find((record) => record.recordId === options.recordId) ?? null;
+}
+async function promoteTrustZoneRecord(options) {
+  if (options.enabled !== true) {
+    throw new Error("trust zone promotion requires trustZonesEnabled=true");
+  }
+  if (options.promotionEnabled !== true) {
+    throw new Error("trust zone promotion requires quarantinePromotionEnabled=true");
+  }
+  const sourceRecord = await findTrustZoneRecordById({
+    memoryDir: options.memoryDir,
+    trustZoneStoreDir: options.trustZoneStoreDir,
+    recordId: assertSafePathSegment(assertString2(options.sourceRecordId, "sourceRecordId"), "sourceRecordId")
+  });
+  if (!sourceRecord) {
+    throw new Error(`source trust-zone record not found: ${options.sourceRecordId}`);
+  }
+  const plan = planTrustZonePromotion({
+    record: sourceRecord,
+    targetZone: options.targetZone
+  });
+  if (!plan.allowed) {
+    throw new Error(`trust-zone promotion denied: ${plan.reasons.join("; ")}`);
+  }
+  const recordedAt = assertIsoRecordedAt(assertString2(options.recordedAt, "recordedAt"));
+  const promotionReason = assertString2(options.promotionReason, "promotionReason");
+  const nextRecord = {
+    schemaVersion: 1,
+    recordId: buildPromotionRecordId(sourceRecord.recordId, options.targetZone, recordedAt),
+    zone: options.targetZone,
+    recordedAt,
+    kind: sourceRecord.kind,
+    summary: optionalString(options.summary) ?? sourceRecord.summary,
+    provenance: sourceRecord.provenance,
+    promotedFromZone: sourceRecord.zone,
+    entityRefs: sourceRecord.entityRefs,
+    tags: dedupeStrings([...sourceRecord.tags ?? [], "promotion"]),
+    metadata: {
+      ...sourceRecord.metadata ?? {},
+      sourceRecordId: sourceRecord.recordId,
+      promotionReason
+    }
+  };
+  if (options.dryRun === true) {
+    return {
+      plan,
+      wroteRecord: false,
+      record: nextRecord,
+      sourceRecord
+    };
+  }
+  const filePath = await recordTrustZoneRecord({
+    memoryDir: options.memoryDir,
+    trustZoneStoreDir: options.trustZoneStoreDir,
+    record: nextRecord
+  });
+  return {
+    plan,
+    wroteRecord: true,
+    record: nextRecord,
+    filePath,
+    sourceRecord
+  };
+}
+async function readTrustZoneRecords(options) {
+  const rootDir = resolveTrustZoneStoreDir(options.memoryDir, options.trustZoneStoreDir);
+  const files = await listJsonFiles(path24.join(rootDir, "zones"));
+  const records = [];
+  const invalidRecords = [];
+  for (const filePath of files) {
+    try {
+      records.push(validateTrustZoneRecord(await readJsonFile(filePath)));
+    } catch (error) {
+      invalidRecords.push({
+        path: filePath,
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+  return { files, records, invalidRecords };
+}
+function lexicalScoreTrustZoneRecord(record, queryTokens) {
+  const weightedFields = [
+    ["summary", record.summary, 4],
+    ["kind", record.kind, 1],
+    ["zone", record.zone, 1],
+    ["sourceClass", record.provenance.sourceClass, 1],
+    ["entityRefs", record.entityRefs?.join(" "), 2],
+    ["tags", record.tags?.join(" "), 2],
+    ["metadata", record.metadata ? Object.values(record.metadata).join(" ") : void 0, 1]
+  ];
+  let score = 0;
+  const matchedFields = [];
+  for (const [field, value, weight] of weightedFields) {
+    const matches = countRecallTokenOverlap(queryTokens, value, ["what"]);
+    if (matches > 0) matchedFields.push(field);
+    score += matches * weight;
+  }
+  return { score, matchedFields };
+}
+function zonePriority(zone) {
+  switch (zone) {
+    case "trusted":
+      return 3;
+    case "working":
+      return 2;
+    case "quarantine":
+      return 1;
+  }
+}
+function scoreTrustZoneRecord(record, lexicalScore, sessionKey) {
+  let score = lexicalScore;
+  score += zonePriority(record.zone);
+  if (sessionKey && record.provenance.sessionKey === sessionKey) score += 1;
+  const recordedAtMs = Date.parse(record.recordedAt);
+  if (Number.isFinite(recordedAtMs)) {
+    const ageHours = Math.max(0, (Date.now() - recordedAtMs) / 36e5);
+    score += 1 / (1 + ageHours);
+  }
+  return score;
+}
+async function searchTrustZoneRecords(options) {
+  const maxResults = Math.max(0, Math.floor(options.maxResults));
+  if (maxResults === 0) return [];
+  const { records } = await readTrustZoneRecords(options);
+  const candidates = records.filter((record) => record.zone !== "quarantine");
+  if (candidates.length === 0) return [];
+  const queryTokens = new Set(normalizeRecallTokens(options.query, ["what"]));
+  if (queryTokens.size === 0) return [];
+  const scored = candidates.map((record) => {
+    const lexical = lexicalScoreTrustZoneRecord(record, queryTokens);
+    return {
+      record,
+      matchedFields: lexical.matchedFields,
+      lexicalScore: lexical.score,
+      score: scoreTrustZoneRecord(record, lexical.score, options.sessionKey)
+    };
+  });
+  const filtered = scored.filter((result) => result.lexicalScore > 0);
+  filtered.sort((left, right) => {
+    if (right.score !== left.score) return right.score - left.score;
+    return right.record.recordedAt.localeCompare(left.record.recordedAt);
+  });
+  return filtered.slice(0, maxResults).map(({ record, score, matchedFields }) => ({
+    record,
+    score,
+    matchedFields
+  }));
+}
+async function getTrustZoneStoreStatus(options) {
+  const rootDir = resolveTrustZoneStoreDir(options.memoryDir, options.trustZoneStoreDir);
+  const zonesDir = path24.join(rootDir, "zones");
+  const { files, records, invalidRecords } = await readTrustZoneRecords(options);
+  records.sort((a, b) => b.recordedAt.localeCompare(a.recordedAt));
+  const byZone = {};
+  const byKind = {};
+  for (const record of records) {
+    byZone[record.zone] = (byZone[record.zone] ?? 0) + 1;
+    byKind[record.kind] = (byKind[record.kind] ?? 0) + 1;
+  }
+  return {
+    enabled: options.enabled,
+    promotionEnabled: options.promotionEnabled,
+    rootDir,
+    zonesDir,
+    records: {
+      total: files.length,
+      valid: records.length,
+      invalid: invalidRecords.length,
+      byZone,
+      byKind,
+      latestRecordId: records[0]?.recordId,
+      latestRecordedAt: records[0]?.recordedAt,
+      latestZone: records[0]?.zone
+    },
+    latestRecord: records[0],
+    invalidRecords
+  };
+}
+
 // src/replay/types.ts
 var VALID_SOURCES = /* @__PURE__ */ new Set(["openclaw", "claude", "chatgpt"]);
 var VALID_ROLES = /* @__PURE__ */ new Set(["user", "assistant"]);
@@ -14680,8 +14997,8 @@ function chunkTranscriptEntries(sessionKey, entries, opts) {
 }
 
 // src/conversation-index/indexer.ts
-import { mkdir as mkdir17, writeFile as writeFile18 } from "fs/promises";
-import path24 from "path";
+import { mkdir as mkdir18, writeFile as writeFile19 } from "fs/promises";
+import path25 from "path";
 function sanitizeSessionKey(sessionKey) {
   const raw = typeof sessionKey === "string" && sessionKey.trim().length > 0 ? sessionKey : "unknown-session";
   return raw.toLowerCase().replace(/[^a-z0-9._-]+/g, "_").slice(0, 200);
@@ -14691,9 +15008,9 @@ async function writeConversationChunks(rootDir, chunks) {
   for (const c of chunks) {
     const safe = sanitizeSessionKey(c.sessionKey);
     const date = c.startTs.slice(0, 10);
-    const dir = path24.join(rootDir, safe, date);
-    await mkdir17(dir, { recursive: true });
-    const fp = path24.join(dir, `${c.id}.md`);
+    const dir = path25.join(rootDir, safe, date);
+    await mkdir18(dir, { recursive: true });
+    const fp = path25.join(dir, `${c.id}.md`);
     const content = `---
 kind: conversation_chunk
 sessionKey: ${c.sessionKey}
@@ -14702,7 +15019,7 @@ endTs: ${c.endTs}
 ---
 
 ` + c.text + "\n";
-    await writeFile18(fp, content, "utf-8");
+    await writeFile19(fp, content, "utf-8");
     written.push(fp);
   }
   return written;
@@ -14722,7 +15039,7 @@ async function upsertConversationChunksFailOpen(adapter, chunks) {
 
 // src/conversation-index/cleanup.ts
 import { readdir as readdir13, rm as rm2 } from "fs/promises";
-import path25 from "path";
+import path26 from "path";
 async function cleanupConversationChunks(rootDir, retentionDays) {
   if (!Number.isFinite(retentionDays) || retentionDays <= 0) return;
   const cutoffMs = Date.now() - retentionDays * 24 * 60 * 60 * 1e3;
@@ -14730,7 +15047,7 @@ async function cleanupConversationChunks(rootDir, retentionDays) {
     const sessions = await readdir13(rootDir, { withFileTypes: true });
     for (const s of sessions) {
       if (!s.isDirectory()) continue;
-      const sessionDir = path25.join(rootDir, s.name);
+      const sessionDir = path26.join(rootDir, s.name);
       const dayDirs = await readdir13(sessionDir, { withFileTypes: true });
       for (const d of dayDirs) {
         if (!d.isDirectory()) continue;
@@ -14738,7 +15055,7 @@ async function cleanupConversationChunks(rootDir, retentionDays) {
         const dayMs = (/* @__PURE__ */ new Date(d.name + "T00:00:00.000Z")).getTime();
         if (!Number.isFinite(dayMs)) continue;
         if (dayMs < cutoffMs) {
-          await rm2(path25.join(sessionDir, d.name), { recursive: true, force: true });
+          await rm2(path26.join(sessionDir, d.name), { recursive: true, force: true });
         }
       }
       try {
@@ -14757,7 +15074,7 @@ async function cleanupConversationChunks(rootDir, retentionDays) {
 // src/conversation-index/faiss-adapter.ts
 import * as childProcess from "child_process";
 import { fileURLToPath } from "url";
-import path26 from "path";
+import path27 from "path";
 var FaissAdapterError = class extends Error {
   constructor(message, code) {
     super(message);
@@ -14767,18 +15084,18 @@ var FaissAdapterError = class extends Error {
 };
 function resolveDefaultFaissScriptPath(fromModuleUrl = import.meta.url) {
   const currentFile = fileURLToPath(fromModuleUrl);
-  const moduleDir = path26.dirname(currentFile);
-  if (moduleDir.endsWith(`${path26.sep}conversation-index`)) {
-    return path26.resolve(moduleDir, "..", "..", "scripts", "faiss_index.py");
+  const moduleDir = path27.dirname(currentFile);
+  if (moduleDir.endsWith(`${path27.sep}conversation-index`)) {
+    return path27.resolve(moduleDir, "..", "..", "scripts", "faiss_index.py");
   }
-  return path26.resolve(moduleDir, "..", "scripts", "faiss_index.py");
+  return path27.resolve(moduleDir, "..", "scripts", "faiss_index.py");
 }
 var FaissConversationIndexAdapter = class {
   constructor(config) {
     this.config = config;
     this.pythonBin = config.pythonBin && config.pythonBin.trim().length > 0 ? config.pythonBin.trim() : "python3";
     this.scriptPath = config.scriptPath && config.scriptPath.trim().length > 0 ? config.scriptPath.trim() : resolveDefaultFaissScriptPath();
-    this.indexPath = path26.isAbsolute(config.indexDir) ? config.indexDir : path26.join(config.memoryDir, config.indexDir);
+    this.indexPath = path27.isAbsolute(config.indexDir) ? config.indexDir : path27.join(config.memoryDir, config.indexDir);
     this.spawnFn = config.spawnFn ?? childProcess.spawn;
   }
   pythonBin;
@@ -14959,7 +15276,7 @@ async function searchConversationIndexFaissFailOpen(adapter, query, maxResults)
 }
 
 // src/namespaces/storage.ts
-import path27 from "path";
+import path28 from "path";
 import { access } from "fs/promises";
 async function exists(p) {
   try {
@@ -14981,7 +15298,7 @@ var NamespaceStorageRouter = class {
       this.defaultNsRootResolved = this.config.memoryDir;
       return this.defaultNsRootResolved;
     }
-    const nsDir = path27.join(this.config.memoryDir, "namespaces", this.config.defaultNamespace);
+    const nsDir = path28.join(this.config.memoryDir, "namespaces", this.config.defaultNamespace);
     this.defaultNsRootResolved = await exists(nsDir) ? nsDir : this.config.memoryDir;
     return this.defaultNsRootResolved;
   }
@@ -14990,7 +15307,7 @@ var NamespaceStorageRouter = class {
     if (namespace === this.config.defaultNamespace) {
       return this.defaultNsRootResolved ?? this.config.memoryDir;
     }
-    return path27.join(this.config.memoryDir, "namespaces", namespace);
+    return path28.join(this.config.memoryDir, "namespaces", namespace);
   }
   async storageFor(namespace) {
     const ns = namespace || this.config.defaultNamespace;
@@ -15066,8 +15383,8 @@ function recallNamespacesForPrincipal(principal, config) {
 }
 
 // src/shared-context/manager.ts
-import { mkdir as mkdir18, readFile as readFile19, readdir as readdir14, appendFile as appendFile4, writeFile as writeFile19, stat as stat5 } from "fs/promises";
-import path28 from "path";
+import { mkdir as mkdir19, readFile as readFile19, readdir as readdir14, appendFile as appendFile4, writeFile as writeFile20, stat as stat5 } from "fs/promises";
+import path29 from "path";
 import os3 from "os";
 import { z as z3 } from "zod";
 var SharedFeedbackEntrySchema = z3.object({
@@ -15263,15 +15580,15 @@ async function computeSemanticOverlapsWithTimeout(sources, timeoutMs, maxCandida
 var SharedContextManager = class {
   constructor(config) {
     this.config = config;
-    const base = typeof config.sharedContextDir === "string" && config.sharedContextDir.length > 0 ? config.sharedContextDir : path28.join(os3.homedir(), ".openclaw", "workspace", "shared-context");
+    const base = typeof config.sharedContextDir === "string" && config.sharedContextDir.length > 0 ? config.sharedContextDir : path29.join(os3.homedir(), ".openclaw", "workspace", "shared-context");
     this.dir = base;
-    this.prioritiesPath = path28.join(base, "priorities.md");
-    this.prioritiesInboxPath = path28.join(base, "priorities.inbox.md");
-    this.outputsDir = path28.join(base, "agent-outputs");
-    this.roundtableDir = path28.join(base, "roundtable");
-    this.feedbackDir = path28.join(base, "feedback");
-    this.feedbackInboxPath = path28.join(this.feedbackDir, "inbox.jsonl");
-    this.crossSignalsDir = path28.join(base, "cross-signals");
+    this.prioritiesPath = path29.join(base, "priorities.md");
+    this.prioritiesInboxPath = path29.join(base, "priorities.inbox.md");
+    this.outputsDir = path29.join(base, "agent-outputs");
+    this.roundtableDir = path29.join(base, "roundtable");
+    this.feedbackDir = path29.join(base, "feedback");
+    this.feedbackInboxPath = path29.join(this.feedbackDir, "inbox.jsonl");
+    this.crossSignalsDir = path29.join(base, "cross-signals");
   }
   dir;
   prioritiesPath;
@@ -15282,15 +15599,15 @@ var SharedContextManager = class {
   feedbackInboxPath;
   crossSignalsDir;
   async ensureStructure() {
-    await mkdir18(this.dir, { recursive: true });
-    await mkdir18(this.outputsDir, { recursive: true });
-    await mkdir18(this.roundtableDir, { recursive: true });
-    await mkdir18(this.feedbackDir, { recursive: true });
-    await mkdir18(this.crossSignalsDir, { recursive: true });
-    await mkdir18(path28.join(this.dir, "staging"), { recursive: true });
-    await mkdir18(path28.join(this.dir, "kpis"), { recursive: true });
-    await mkdir18(path28.join(this.dir, "calendar"), { recursive: true });
-    await mkdir18(path28.join(this.dir, "content-calendar"), { recursive: true });
+    await mkdir19(this.dir, { recursive: true });
+    await mkdir19(this.outputsDir, { recursive: true });
+    await mkdir19(this.roundtableDir, { recursive: true });
+    await mkdir19(this.feedbackDir, { recursive: true });
+    await mkdir19(this.crossSignalsDir, { recursive: true });
+    await mkdir19(path29.join(this.dir, "staging"), { recursive: true });
+    await mkdir19(path29.join(this.dir, "kpis"), { recursive: true });
+    await mkdir19(path29.join(this.dir, "calendar"), { recursive: true });
+    await mkdir19(path29.join(this.dir, "content-calendar"), { recursive: true });
     await this.ensureFile(
       this.prioritiesPath,
       [
@@ -15321,7 +15638,7 @@ var SharedContextManager = class {
     try {
       await stat5(fp);
     } catch {
-      await writeFile19(fp, content, "utf-8");
+      await writeFile20(fp, content, "utf-8");
     }
   }
   async readPriorities() {
@@ -15334,7 +15651,7 @@ var SharedContextManager = class {
   async readLatestRoundtable() {
     try {
       const files = (await readdir14(this.roundtableDir)).filter((f) => f.endsWith(".md")).sort().reverse();
-      const fp = files[0] ? path28.join(this.roundtableDir, files[0]) : null;
+      const fp = files[0] ? path29.join(this.roundtableDir, files[0]) : null;
       if (!fp) return "";
       return await readFile19(fp, "utf-8");
     } catch {
@@ -15346,9 +15663,9 @@ var SharedContextManager = class {
     const date = ymd(createdAt);
     const time = createdAt.toISOString().slice(11, 19).replace(/:/g, "");
     const slug = safeSlug(opts.title);
-    const dir = path28.join(this.outputsDir, opts.agentId, date);
-    await mkdir18(dir, { recursive: true });
-    const fp = path28.join(dir, `${time}-${slug}.md`);
+    const dir = path29.join(this.outputsDir, opts.agentId, date);
+    await mkdir19(dir, { recursive: true });
+    const fp = path29.join(dir, `${time}-${slug}.md`);
     const body = `---
 kind: agent_output
 agent: ${opts.agentId}
@@ -15357,7 +15674,7 @@ title: ${opts.title.replace(/\n/g, " ").slice(0, 200)}
 ---
 
 ` + opts.content.trimEnd() + "\n";
-    await writeFile19(fp, body, "utf-8");
+    await writeFile20(fp, body, "utf-8");
     return fp;
   }
   async appendFeedback(entry) {
@@ -15383,11 +15700,11 @@ title: ${opts.title.replace(/\n/g, " ").slice(0, 200)}
       const agents = await readdir14(this.outputsDir, { withFileTypes: true });
       for (const a of agents) {
         if (!a.isDirectory()) continue;
-        const dayDir = path28.join(this.outputsDir, a.name, date);
+        const dayDir = path29.join(this.outputsDir, a.name, date);
         try {
           const files = (await readdir14(dayDir)).filter((f) => f.endsWith(".md")).sort();
           for (const f of files) {
-            const p = path28.join(dayDir, f);
+            const p = path29.join(dayDir, f);
             const raw = await readFile19(p, "utf-8");
             const title = (raw.match(/^title:\s*(.+)$/m)?.[1] ?? f).trim();
             outputs.push({ agent: a.name, path: p, title, raw });
@@ -15494,8 +15811,8 @@ ${body}`)
         addedOverlapCount: semanticAddedOverlapCount
       }
     };
-    const crossSignalsPath = path28.join(this.crossSignalsDir, `${date}.json`);
-    await writeFile19(crossSignalsPath, `${JSON.stringify(crossSignalReport, null, 2)}
+    const crossSignalsPath = path29.join(this.crossSignalsDir, `${date}.json`);
+    await writeFile20(crossSignalsPath, `${JSON.stringify(crossSignalReport, null, 2)}
 `, "utf-8");
     const overlapBullets = mergedOverlaps.length === 0 ? ["- No multi-agent topic overlap detected."] : mergedOverlaps.slice(0, 8).map((entry) => `- \`${entry.token}\` (${entry.agentCount} agents: ${entry.agents.join(", ")})`);
     const md = [
@@ -15518,8 +15835,8 @@ ${body}`)
     ];
     const out = md.join("\n");
     const trimmed = out.length > maxChars ? out.slice(0, maxChars) + "\n\n...(trimmed)\n" : out;
-    const roundtablePath = path28.join(this.roundtableDir, `${date}.md`);
-    await writeFile19(roundtablePath, trimmed, "utf-8");
+    const roundtablePath = path29.join(this.roundtableDir, `${date}.md`);
+    await writeFile20(roundtablePath, trimmed, "utf-8");
     log.info(`shared-context curated daily roundtable: ${roundtablePath}`);
     return {
       date,
@@ -15531,8 +15848,8 @@ ${body}`)
 };
 
 // src/compounding/engine.ts
-import { mkdir as mkdir19, readFile as readFile20, readdir as readdir15, writeFile as writeFile20 } from "fs/promises";
-import path29 from "path";
+import { mkdir as mkdir20, readFile as readFile20, readdir as readdir15, writeFile as writeFile21 } from "fs/promises";
+import path30 from "path";
 import os4 from "os";
 function defaultTierMigrationCycleBudget(config, trigger) {
   if (trigger === "extraction") {
@@ -15579,7 +15896,7 @@ function sharedContextDir(config) {
   if (typeof config.sharedContextDir === "string" && config.sharedContextDir.length > 0) {
     return config.sharedContextDir;
   }
-  return path29.join(os4.homedir(), ".openclaw", "workspace", "shared-context");
+  return path30.join(os4.homedir(), ".openclaw", "workspace", "shared-context");
 }
 function cadenceStaleWindowMs(cadence) {
   switch (cadence) {
@@ -15598,16 +15915,16 @@ function cadenceStaleWindowMs(cadence) {
 var CompoundingEngine = class {
   constructor(config) {
     this.config = config;
-    this.weeklyDir = path29.join(config.memoryDir, "compounding", "weekly");
-    this.rubricsPath = path29.join(config.memoryDir, "compounding", "rubrics.md");
-    this.mistakesPath = path29.join(config.memoryDir, "compounding", "mistakes.json");
-    this.feedbackInboxPath = path29.join(sharedContextDir(config), "feedback", "inbox.jsonl");
-    this.identityAnchorPath = path29.join(config.memoryDir, "identity", "identity-anchor.md");
-    this.identityIncidentsDir = path29.join(config.memoryDir, "identity", "incidents");
-    this.identityAuditWeeklyDir = path29.join(config.memoryDir, "identity", "audits", "weekly");
-    this.identityAuditMonthlyDir = path29.join(config.memoryDir, "identity", "audits", "monthly");
-    this.identityImprovementLoopsPath = path29.join(config.memoryDir, "identity", "improvement-loops.md");
-    this.memoryActionEventsPath = path29.join(config.memoryDir, "state", "memory-actions.jsonl");
+    this.weeklyDir = path30.join(config.memoryDir, "compounding", "weekly");
+    this.rubricsPath = path30.join(config.memoryDir, "compounding", "rubrics.md");
+    this.mistakesPath = path30.join(config.memoryDir, "compounding", "mistakes.json");
+    this.feedbackInboxPath = path30.join(sharedContextDir(config), "feedback", "inbox.jsonl");
+    this.identityAnchorPath = path30.join(config.memoryDir, "identity", "identity-anchor.md");
+    this.identityIncidentsDir = path30.join(config.memoryDir, "identity", "incidents");
+    this.identityAuditWeeklyDir = path30.join(config.memoryDir, "identity", "audits", "weekly");
+    this.identityAuditMonthlyDir = path30.join(config.memoryDir, "identity", "audits", "monthly");
+    this.identityImprovementLoopsPath = path30.join(config.memoryDir, "identity", "improvement-loops.md");
+    this.memoryActionEventsPath = path30.join(config.memoryDir, "state", "memory-actions.jsonl");
   }
   weeklyDir;
   rubricsPath;
@@ -15620,9 +15937,9 @@ var CompoundingEngine = class {
   identityImprovementLoopsPath;
   memoryActionEventsPath;
   async ensureDirs() {
-    await mkdir19(this.weeklyDir, { recursive: true });
-    await mkdir19(path29.dirname(this.mistakesPath), { recursive: true });
-    await mkdir19(path29.dirname(this.rubricsPath), { recursive: true });
+    await mkdir20(this.weeklyDir, { recursive: true });
+    await mkdir20(path30.dirname(this.mistakesPath), { recursive: true });
+    await mkdir20(path30.dirname(this.rubricsPath), { recursive: true });
   }
   async synthesizeWeekly(opts) {
     await this.ensureDirs();
@@ -15633,12 +15950,12 @@ var CompoundingEngine = class {
     const promotionCandidates = this.config.compoundingSemanticEnabled ? this.derivePromotionCandidates(outcomeSummary) : [];
     const mistakes = this.buildMistakes(entries, actionPatterns);
     const continuity = this.config.continuityAuditEnabled ? await this.readContinuityAuditReferences(weekId) : { monthId: monthIdFromIsoWeek(weekId), weeklyPath: null, monthlyPath: null };
-    const reportPath = path29.join(this.weeklyDir, `${weekId}.md`);
+    const reportPath = path30.join(this.weeklyDir, `${weekId}.md`);
     const md = this.formatWeeklyReport(weekId, entries, mistakes.patterns, mistakes.details, continuity, outcomeSummary, promotionCandidates);
-    await writeFile20(reportPath, md, "utf-8");
+    await writeFile21(reportPath, md, "utf-8");
     const rubrics = this.formatRubrics(entries, outcomeSummary);
-    await writeFile20(this.rubricsPath, rubrics, "utf-8");
-    await writeFile20(
+    await writeFile21(this.rubricsPath, rubrics, "utf-8");
+    await writeFile21(
       this.mistakesPath,
       JSON.stringify({ updatedAt: mistakes.updatedAt, patterns: mistakes.patterns }, null, 2) + "\n",
       "utf-8"
@@ -15718,9 +16035,9 @@ var CompoundingEngine = class {
       ""
     ];
     const dir = period === "weekly" ? this.identityAuditWeeklyDir : this.identityAuditMonthlyDir;
-    await mkdir19(dir, { recursive: true });
-    const reportPath = path29.join(dir, `${key}.md`);
-    await writeFile20(reportPath, lines.join("\n"), "utf-8");
+    await mkdir20(dir, { recursive: true });
+    const reportPath = path30.join(dir, `${key}.md`);
+    await writeFile21(reportPath, lines.join("\n"), "utf-8");
     return { period, key, reportPath };
   }
   async readMistakes() {
@@ -15819,7 +16136,7 @@ var CompoundingEngine = class {
       else if (event.outcome === "skipped") acc.counts.skipped += 1;
       else if (event.outcome === "failed") acc.counts.failed += 1;
       else acc.counts.unknown += 1;
-      acc.provenance.add(`${path29.basename(this.memoryActionEventsPath)}:L${event.line}`);
+      acc.provenance.add(`${path30.basename(this.memoryActionEventsPath)}:L${event.line}`);
       byAction.set(key, acc);
     }
     const out = [];
@@ -15857,7 +16174,7 @@ var CompoundingEngine = class {
     const patterns = [];
     for (const wrapped of entries) {
       const e = wrapped.entry;
-      const provenance = [`${path29.basename(wrapped.sourcePath)}:L${wrapped.sourceLine}#${wrapped.entryId}`];
+      const provenance = [`${path30.basename(wrapped.sourcePath)}:L${wrapped.sourceLine}#${wrapped.entryId}`];
       if (e.learning && e.learning.trim().length > 0) {
         patterns.push({ pattern: `${e.agent}: ${e.learning.trim()}`, provenance });
         continue;
@@ -15867,7 +16184,7 @@ var CompoundingEngine = class {
       }
     }
     for (const p of actionPatterns) {
-      patterns.push({ pattern: p, provenance: [`${path29.basename(this.memoryActionEventsPath)}:*`] });
+      patterns.push({ pattern: p, provenance: [`${path30.basename(this.memoryActionEventsPath)}:*`] });
     }
     const byPattern = /* @__PURE__ */ new Map();
     for (const p of patterns) {
@@ -15907,7 +16224,7 @@ var CompoundingEngine = class {
         lines.push(`- approved: ${approved}`);
         lines.push(`- approved_with_feedback: ${awf}`);
         lines.push(`- rejected: ${rejected}`);
-        const provenance = list.slice(0, 3).map((e) => `${path29.basename(e.sourcePath)}:L${e.sourceLine}#${e.entryId}`);
+        const provenance = list.slice(0, 3).map((e) => `${path30.basename(e.sourcePath)}:L${e.sourceLine}#${e.entryId}`);
         if (provenance.length > 0) {
           lines.push(`- provenance: ${provenance.join(", ")}`);
         }
@@ -15998,7 +16315,7 @@ var CompoundingEngine = class {
         } else {
           for (const item of learnings) {
             const note = (item.entry.learning && item.entry.learning.trim().length > 0 ? item.entry.learning : item.entry.reason).trim();
-            lines.push(`- ${note} _(source: ${path29.basename(item.sourcePath)}:L${item.sourceLine}#${item.entryId})_`);
+            lines.push(`- ${note} _(source: ${path30.basename(item.sourcePath)}:L${item.sourceLine}#${item.entryId})_`);
           }
         }
         lines.push("");
@@ -16043,7 +16360,7 @@ var CompoundingEngine = class {
       const files = names.filter((n) => n.endsWith(".md")).sort().reverse();
       for (const file of files) {
         if (incidents.length >= cappedLimit) break;
-        const filePath = path29.join(this.identityIncidentsDir, file);
+        const filePath = path30.join(this.identityIncidentsDir, file);
         try {
           const raw = await readFile20(filePath, "utf-8");
           const parsed = parseContinuityIncident(raw);
@@ -16059,8 +16376,8 @@ var CompoundingEngine = class {
   }
   async readContinuityAuditReferences(weekId) {
     const monthId = monthIdFromIsoWeek(weekId);
-    const weeklyPath = path29.join(this.identityAuditWeeklyDir, `${weekId}.md`);
-    const monthlyPath = path29.join(this.identityAuditMonthlyDir, `${monthId}.md`);
+    const weeklyPath = path30.join(this.identityAuditWeeklyDir, `${weekId}.md`);
+    const monthlyPath = path30.join(this.identityAuditMonthlyDir, `${monthId}.md`);
     const weeklyExists = await this.readNonEmptyFile(weeklyPath);
     const monthlyExists = await this.readNonEmptyFile(monthlyPath);
     return {
@@ -16073,8 +16390,8 @@ var CompoundingEngine = class {
 };
 
 // src/tier-migration.ts
-import { appendFile as appendFile5, mkdir as mkdir20 } from "fs/promises";
-import path30 from "path";
+import { appendFile as appendFile5, mkdir as mkdir21 } from "fs/promises";
+import path31 from "path";
 var TierMigrationExecutor = class {
   storage;
   qmd;
@@ -16088,7 +16405,7 @@ var TierMigrationExecutor = class {
     this.hotCollection = options.hotCollection;
     this.coldCollection = options.coldCollection;
     this.autoEmbed = options.autoEmbed === true;
-    this.journalPath = options.journalPath ?? path30.join(this.storage.dir, "state", "tier-migration-journal.jsonl");
+    this.journalPath = options.journalPath ?? path31.join(this.storage.dir, "state", "tier-migration-journal.jsonl");
   }
   async migrateMemory(request) {
     const { memory, fromTier, toTier, reason } = request;
@@ -16141,7 +16458,7 @@ var TierMigrationExecutor = class {
       reason: result.reason,
       targetPath: result.targetPath
     };
-    await mkdir20(path30.dirname(this.journalPath), { recursive: true });
+    await mkdir21(path31.dirname(this.journalPath), { recursive: true });
     await appendFile5(this.journalPath, `${JSON.stringify(entry)}
 `, "utf-8");
   }
@@ -16308,8 +16625,8 @@ function selectRouteRule(text, rules, options) {
 }
 
 // src/routing/store.ts
-import { lstat, mkdir as mkdir21, readFile as readFile21, realpath, rename as rename2, rm as rm3, stat as stat6, writeFile as writeFile21 } from "fs/promises";
-import path31 from "path";
+import { lstat, mkdir as mkdir22, readFile as readFile21, realpath, rename as rename2, rm as rm3, stat as stat6, writeFile as writeFile22 } from "fs/promises";
+import path32 from "path";
 import { createHash as createHash4 } from "crypto";
 function defaultState() {
   return {
@@ -16328,14 +16645,14 @@ function stableRuleId(rule) {
   return `route-${createHash4("sha256").update(seed).digest("hex").slice(0, 12)}`;
 }
 function resolveStatePath(memoryDir, stateFile) {
-  const root = path31.resolve(memoryDir);
-  const defaultPath = path31.join(root, "state", "routing-rules.json");
-  if (path31.isAbsolute(stateFile)) {
-    const absolute = path31.resolve(stateFile);
-    return absolute.startsWith(root + path31.sep) ? absolute : defaultPath;
+  const root = path32.resolve(memoryDir);
+  const defaultPath = path32.join(root, "state", "routing-rules.json");
+  if (path32.isAbsolute(stateFile)) {
+    const absolute = path32.resolve(stateFile);
+    return absolute.startsWith(root + path32.sep) ? absolute : defaultPath;
   }
-  const resolved = path31.resolve(root, stateFile);
-  return resolved.startsWith(root + path31.sep) ? resolved : defaultPath;
+  const resolved = path32.resolve(root, stateFile);
+  return resolved.startsWith(root + path32.sep) ? resolved : defaultPath;
 }
 function normalizeRule(rule, options) {
   if (!rule || typeof rule !== "object") return null;
@@ -16368,7 +16685,7 @@ var RoutingRulesStore = class {
   lockPath;
   writeQueue = Promise.resolve();
   constructor(memoryDir, stateFile = "state/routing-rules.json") {
-    this.memoryRoot = path31.resolve(memoryDir);
+    this.memoryRoot = path32.resolve(memoryDir);
     this.statePath = resolveStatePath(memoryDir, stateFile);
     this.lockPath = `${this.statePath}.lock`;
   }
@@ -16406,7 +16723,7 @@ var RoutingRulesStore = class {
     await this.withWriteLock(async () => {
       const payload = defaultState();
       await this.assertStatePathScoped();
-      await writeFile21(this.statePath, JSON.stringify(payload, null, 2), "utf-8");
+      await writeFile22(this.statePath, JSON.stringify(payload, null, 2), "utf-8");
     });
   }
   dedupeById(rules) {
@@ -16440,7 +16757,7 @@ var RoutingRulesStore = class {
     const tmpPath = `${this.statePath}.tmp-${process.pid}-${Date.now()}`;
     try {
       await this.assertStatePathScoped();
-      await writeFile21(tmpPath, JSON.stringify(payload, null, 2), "utf-8");
+      await writeFile22(tmpPath, JSON.stringify(payload, null, 2), "utf-8");
       await rename2(tmpPath, this.statePath);
     } catch (err) {
       log.debug(`routing rules write failed: ${err}`);
@@ -16474,10 +16791,10 @@ var RoutingRulesStore = class {
     const timeoutMs = 5e3;
     let unexpectedLockError = null;
     await this.assertStatePathScoped();
-    await mkdir21(path31.dirname(this.lockPath), { recursive: true });
+    await mkdir22(path32.dirname(this.lockPath), { recursive: true });
     while (Date.now() - start < timeoutMs) {
       try {
-        await mkdir21(this.lockPath);
+        await mkdir22(this.lockPath);
         return async () => {
           try {
             await rm3(this.lockPath, { recursive: true, force: true });
@@ -16507,14 +16824,14 @@ var RoutingRulesStore = class {
     throw new Error(`routing rules lock acquisition timed out after ${timeoutMs}ms`);
   }
   async assertStatePathScoped() {
-    await mkdir21(this.memoryRoot, { recursive: true });
+    await mkdir22(this.memoryRoot, { recursive: true });
     const canonicalRoot = await realpath(this.memoryRoot);
-    const canonicalParent = await this.canonicalizePathWithoutCreating(path31.dirname(this.statePath));
-    const canonicalStatePath = path31.join(canonicalParent, path31.basename(this.statePath));
+    const canonicalParent = await this.canonicalizePathWithoutCreating(path32.dirname(this.statePath));
+    const canonicalStatePath = path32.join(canonicalParent, path32.basename(this.statePath));
     if (!this.isPathInside(canonicalRoot, canonicalStatePath)) {
       throw new Error(`routing rules state path escaped memoryDir: ${canonicalStatePath}`);
     }
-    await mkdir21(path31.dirname(this.statePath), { recursive: true });
+    await mkdir22(path32.dirname(this.statePath), { recursive: true });
     try {
       const stateStats = await lstat(this.statePath);
       if (stateStats.isSymbolicLink()) {
@@ -16531,28 +16848,28 @@ var RoutingRulesStore = class {
     }
   }
   isPathInside(root, candidate) {
-    const normalizedRoot = path31.resolve(root);
-    const normalizedCandidate = path31.resolve(candidate);
+    const normalizedRoot = path32.resolve(root);
+    const normalizedCandidate = path32.resolve(candidate);
     if (normalizedCandidate === normalizedRoot) return true;
-    if (normalizedRoot === path31.parse(normalizedRoot).root) {
+    if (normalizedRoot === path32.parse(normalizedRoot).root) {
       return normalizedCandidate.startsWith(normalizedRoot);
     }
-    return normalizedCandidate.startsWith(`${normalizedRoot}${path31.sep}`);
+    return normalizedCandidate.startsWith(`${normalizedRoot}${path32.sep}`);
   }
   async canonicalizePathWithoutCreating(targetPath) {
-    const absoluteTarget = path31.resolve(targetPath);
+    const absoluteTarget = path32.resolve(targetPath);
     let probe = absoluteTarget;
     while (true) {
       try {
         const canonicalProbe = await realpath(probe);
-        const remainder = path31.relative(probe, absoluteTarget);
-        return path31.resolve(canonicalProbe, remainder);
+        const remainder = path32.relative(probe, absoluteTarget);
+        return path32.resolve(canonicalProbe, remainder);
       } catch (err) {
         const code = err.code;
         if (code !== "ENOENT") {
           throw err;
         }
-        const parent = path31.dirname(probe);
+        const parent = path32.dirname(probe);
         if (parent === probe) {
           return absoluteTarget;
         }
@@ -16563,8 +16880,8 @@ var RoutingRulesStore = class {
 };
 
 // src/policy-runtime.ts
-import path32 from "path";
-import { mkdir as mkdir22, readFile as readFile22, rename as rename3, writeFile as writeFile22 } from "fs/promises";
+import path33 from "path";
+import { mkdir as mkdir23, readFile as readFile22, rename as rename3, writeFile as writeFile23 } from "fs/promises";
 var RUNTIME_POLICY_VERSION = 1;
 var RUNTIME_POLICY_FILE = "policy-runtime.json";
 var RUNTIME_POLICY_PREV_FILE = "policy-runtime.prev.json";
@@ -16612,8 +16929,8 @@ async function readRuntimePolicySnapshot(filePath, options) {
 }
 async function writeSnapshotAtomic(filePath, snapshot) {
   const tempPath = `${filePath}.tmp`;
-  await mkdir22(path32.dirname(filePath), { recursive: true });
-  await writeFile22(tempPath, `${JSON.stringify(snapshot, null, 2)}
+  await mkdir23(path33.dirname(filePath), { recursive: true });
+  await writeFile23(tempPath, `${JSON.stringify(snapshot, null, 2)}
 `, "utf-8");
   await rename3(tempPath, filePath);
 }
@@ -16621,9 +16938,9 @@ var PolicyRuntimeManager = class {
   constructor(memoryDir, config) {
     this.memoryDir = memoryDir;
     this.config = config;
-    const stateDir2 = path32.join(memoryDir, "state");
-    this.runtimePath = path32.join(stateDir2, RUNTIME_POLICY_FILE);
-    this.runtimePrevPath = path32.join(stateDir2, RUNTIME_POLICY_PREV_FILE);
+    const stateDir2 = path33.join(memoryDir, "state");
+    this.runtimePath = path33.join(stateDir2, RUNTIME_POLICY_FILE);
+    this.runtimePrevPath = path33.join(stateDir2, RUNTIME_POLICY_PREV_FILE);
   }
   runtimePath;
   runtimePrevPath;
@@ -16776,7 +17093,7 @@ function dedupeBehaviorSignalsByMemoryAndHash(signals) {
 // src/orchestrator.ts
 var COMPACTION_SIGNAL_MAX_AGE_MS = 60 * 60 * 1e3;
 function defaultWorkspaceDir() {
-  return path33.join(os5.homedir(), ".openclaw", "workspace");
+  return path34.join(os5.homedir(), ".openclaw", "workspace");
 }
 function sanitizeSessionKeyForFilename(sessionKey) {
   const readable = sessionKey.replace(/[^a-zA-Z0-9._-]/g, "_");
@@ -16916,11 +17233,11 @@ function mergeGraphExpandedResults(primary, expanded) {
   return Array.from(mergedByPath.values());
 }
 function graphPathRelativeToStorage(storageDir, candidatePath) {
-  const absolutePath = path33.isAbsolute(candidatePath) ? candidatePath : path33.resolve(storageDir, candidatePath);
-  const rel = path33.relative(storageDir, absolutePath);
+  const absolutePath = path34.isAbsolute(candidatePath) ? candidatePath : path34.resolve(storageDir, candidatePath);
+  const rel = path34.relative(storageDir, absolutePath);
   if (!rel || rel === ".") return null;
   if (rel.startsWith("..")) return null;
-  return rel.split(path33.sep).join("/");
+  return rel.split(path34.sep).join("/");
 }
 function normalizeGraphActivationScore(score) {
   const bounded = Number.isFinite(score) && score > 0 ? score : 0;
@@ -16995,7 +17312,7 @@ function buildMemoryPathById(allMemsForGraph, storageDir) {
   for (const mem of allMemsForGraph ?? []) {
     const id = mem.frontmatter.id;
     if (!id) continue;
-    pathById.set(id, path33.relative(storageDir, mem.path));
+    pathById.set(id, path34.relative(storageDir, mem.path));
   }
   return pathById;
 }
@@ -17003,7 +17320,7 @@ function appendMemoryToGraphContext(options) {
   if (!Array.isArray(options.allMemsForGraph)) return;
   const nowIso = (/* @__PURE__ */ new Date()).toISOString();
   options.allMemsForGraph.push({
-    path: path33.join(options.storageDir, options.memoryRelPath),
+    path: path34.join(options.storageDir, options.memoryRelPath),
     content: options.content,
     frontmatter: {
       id: options.memoryId,
@@ -17023,15 +17340,15 @@ function resolvePersistedMemoryRelativePath(options) {
   const persisted = options.pathById.get(options.memoryId);
   if (persisted) return persisted;
   if (options.category === "correction") {
-    return path33.join("corrections", `${options.memoryId}.md`);
+    return path34.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 path33.join("facts", day, `${options.memoryId}.md`);
+    return path34.join("facts", day, `${options.memoryId}.md`);
   }
-  return path33.join("facts", `${options.memoryId}.md`);
+  return path34.join("facts", `${options.memoryId}.md`);
 }
 function shouldRejectLowConfidenceRecall(results, threshold) {
   if (results.length === 0) return false;
@@ -17139,7 +17456,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 = path33.join(config.memoryDir, "conversation-index", "chunks");
+    this.conversationIndexDir = path34.join(config.memoryDir, "conversation-index", "chunks");
     this.modelRegistry = new ModelRegistry(config.memoryDir);
     this.relevance = new RelevanceStore(config.memoryDir);
     this.negatives = new NegativeExampleStore(config.memoryDir);
@@ -17164,7 +17481,7 @@ var Orchestrator = class _Orchestrator {
     })() : this.localLlm;
     this.extraction = new ExtractionEngine(config, this.localLlm, config.gatewayConfig, this.modelRegistry);
     this.threading = new ThreadingManager(
-      path33.join(config.memoryDir, "threads"),
+      path34.join(config.memoryDir, "threads"),
       config.threadingGapMinutes
     );
     this.tmtBuilder = new TmtBuilder(config.memoryDir, {
@@ -17333,7 +17650,7 @@ var Orchestrator = class _Orchestrator {
     await this.sessionObserver.load();
     this.runtimePolicyValues = await this.policyRuntime.loadRuntimeValues();
     if (this.config.factDeduplicationEnabled) {
-      const stateDir2 = path33.join(this.config.memoryDir, "state");
+      const stateDir2 = path34.join(this.config.memoryDir, "state");
       this.contentHashIndex = new ContentHashIndex(stateDir2);
       await this.contentHashIndex.load();
       log.info(`content-hash dedup: loaded ${this.contentHashIndex.size} hashes`);
@@ -17372,7 +17689,7 @@ var Orchestrator = class _Orchestrator {
       if (available) {
         log.info(`Conversation index QMD: available ${this.conversationQmd.debugStatus()}`);
         const collectionState = await this.conversationQmd.ensureCollection(
-          path33.join(this.config.memoryDir, "conversation-index")
+          path34.join(this.config.memoryDir, "conversation-index")
         );
         if (collectionState === "missing") {
           this.config.conversationIndexEnabled = false;
@@ -17408,7 +17725,7 @@ var Orchestrator = class _Orchestrator {
         const files = await readdir16(wsDir).catch(() => []);
         for (const f of files) {
           if (!f.startsWith(".compaction-reset-signal-")) continue;
-          const fp = path33.join(wsDir, f);
+          const fp = path34.join(wsDir, f);
           const s = await stat7(fp).catch(() => null);
           if (s && Date.now() - s.mtimeMs >= COMPACTION_SIGNAL_MAX_AGE_MS) {
             await unlink5(fp).catch(() => {
@@ -17444,12 +17761,12 @@ var Orchestrator = class _Orchestrator {
     this.lastFileHygieneRunAtMs = now;
     if (hygiene.rotateEnabled) {
       for (const rel of hygiene.rotatePaths) {
-        const abs = path33.isAbsolute(rel) ? rel : path33.join(this.config.workspaceDir, rel);
+        const abs = path34.isAbsolute(rel) ? rel : path34.join(this.config.workspaceDir, rel);
         try {
           const raw = await readFile23(abs, "utf-8");
           if (raw.length > hygiene.rotateMaxBytes) {
-            const archiveDir = path33.join(this.config.workspaceDir, hygiene.archiveDir);
-            const base = path33.basename(abs);
+            const archiveDir = path34.join(this.config.workspaceDir, hygiene.archiveDir);
+            const base = path34.basename(abs);
             const prefix = base.toUpperCase().replace(/\.MD$/i, "").replace(/[^A-Z0-9]+/g, "-") || "FILE";
             const { newContent } = await rotateMarkdownFileToArchive({
               filePath: abs,
@@ -17457,7 +17774,7 @@ var Orchestrator = class _Orchestrator {
               archivePrefix: prefix,
               keepTailChars: hygiene.rotateKeepTailChars
             });
-            await writeFile23(abs, newContent, "utf-8");
+            await writeFile24(abs, newContent, "utf-8");
           }
         } catch {
         }
@@ -17474,8 +17791,8 @@ var Orchestrator = class _Orchestrator {
         log.warn(w.message);
       }
       if (hygiene.warningsLogEnabled && warnings.length > 0) {
-        const fp = path33.join(this.config.memoryDir, hygiene.warningsLogPath);
-        await mkdir23(path33.dirname(fp), { recursive: true });
+        const fp = path34.join(this.config.memoryDir, hygiene.warningsLogPath);
+        await mkdir24(path34.dirname(fp), { recursive: true });
         const stamp = (/* @__PURE__ */ new Date()).toISOString();
         const block = `
 
@@ -17488,7 +17805,7 @@ var Orchestrator = class _Orchestrator {
         } catch {
           existing = "# Engram File Hygiene Warnings\n";
         }
-        await writeFile23(fp, existing + block, "utf-8");
+        await writeFile24(fp, existing + block, "utf-8");
       }
     }
   }
@@ -17564,7 +17881,7 @@ var Orchestrator = class _Orchestrator {
   }
   async getLastGraphRecallSnapshot(namespace) {
     const storage = await this.getStorage(namespace);
-    const snapshotPath = path33.join(storage.dir, "state", "last_graph_recall.json");
+    const snapshotPath = path34.join(storage.dir, "state", "last_graph_recall.json");
     try {
       const raw = await readFile23(snapshotPath, "utf-8");
       const parsed = JSON.parse(raw);
@@ -17635,7 +17952,7 @@ ${r.snippet.trim()}
       const entries = await readdir16(dir, { withFileTypes: true });
       let total = 0;
       for (const entry of entries) {
-        const fullPath = path33.join(dir, entry.name);
+        const fullPath = path34.join(dir, entry.name);
         if (entry.isDirectory()) {
           total += await this.countConversationChunkDocs(fullPath);
           continue;
@@ -17960,7 +18277,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) => path33.join(storage.dir, rel)));
+      seedPaths.push(...seedRelativePaths.map((rel) => path34.join(storage.dir, rel)));
       const seedSet = new Set(seedRelativePaths);
       const expanded = await this.graphIndexFor(storage).spreadingActivation(
         seedRelativePaths,
@@ -17969,7 +18286,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 = path33.resolve(storage.dir, candidate.path);
+        const memoryPath = path34.resolve(storage.dir, candidate.path);
         const memory = await storage.readMemoryByPath(memoryPath);
         if (!memory) continue;
         if (isArtifactMemoryPath(memory.path)) continue;
@@ -17992,7 +18309,7 @@ ${r.snippet.trim()}
           path: memory.path,
           score,
           namespace,
-          seed: path33.resolve(storage.dir, candidate.seed),
+          seed: path34.resolve(storage.dir, candidate.seed),
           hopDepth: candidate.hopDepth,
           decayedWeight: candidate.decayedWeight,
           graphType: candidate.graphType
@@ -18007,8 +18324,8 @@ ${r.snippet.trim()}
   }
   async recordLastGraphRecallSnapshot(options) {
     try {
-      const snapshotPath = path33.join(options.storage.dir, "state", "last_graph_recall.json");
-      await mkdir23(path33.dirname(snapshotPath), { recursive: true });
+      const snapshotPath = path34.join(options.storage.dir, "state", "last_graph_recall.json");
+      await mkdir24(path34.dirname(snapshotPath), { recursive: true });
       const now = (/* @__PURE__ */ new Date()).toISOString();
       const totalSeedCount = options.seedPaths.length;
       const totalExpandedCount = options.expandedPaths.length;
@@ -18025,7 +18342,7 @@ ${r.snippet.trim()}
         seeds,
         expanded
       };
-      await writeFile23(snapshotPath, JSON.stringify(payload, null, 2), "utf-8");
+      await writeFile24(snapshotPath, JSON.stringify(payload, null, 2), "utf-8");
     } catch (err) {
       log.debug(`last graph recall write failed: ${err}`);
     }
@@ -18313,6 +18630,27 @@ ${r.snippet.trim()}
       timings.causalTrajectories = `${Date.now() - t0}ms`;
       return results.length > 0 ? this.formatCausalTrajectoryResults(results) : null;
     })();
+    const trustZonePromise = (async () => {
+      const t0 = Date.now();
+      if (!this.config.trustZonesEnabled || !this.config.trustZoneRecallEnabled || !this.isRecallSectionEnabled("trust-zones", this.config.trustZoneRecallEnabled === true)) {
+        timings.trustZones = "skip";
+        return null;
+      }
+      const maxResults = this.getRecallSectionNumber("trust-zones", "maxResults") ?? 3;
+      if (maxResults <= 0) {
+        timings.trustZones = "skip(limit=0)";
+        return null;
+      }
+      const results = await searchTrustZoneRecords({
+        memoryDir: this.config.memoryDir,
+        trustZoneStoreDir: this.config.trustZoneStoreDir,
+        query: retrievalQuery,
+        maxResults,
+        sessionKey
+      });
+      timings.trustZones = `${Date.now() - t0}ms`;
+      return results.length > 0 ? this.formatTrustZoneResults(results) : null;
+    })();
     const qmdPromise = (async () => {
       if (recallResultLimit <= 0) {
         timings.qmd = "skip(limit=0)";
@@ -18386,8 +18724,8 @@ ${formatted}`;
       if (!this.config.compactionResetEnabled) return null;
       const workspaceDir = compactionWorkspaceDir || this.config.workspaceDir || defaultWorkspaceDir();
       const safeSessionKey = sanitizeSessionKeyForFilename(effectiveSessionKey);
-      const signalPath = path33.join(workspaceDir, `.compaction-reset-signal-${safeSessionKey}`);
-      const bootPath = path33.join(workspaceDir, "BOOT.md");
+      const signalPath = path34.join(workspaceDir, `.compaction-reset-signal-${safeSessionKey}`);
+      const bootPath = path34.join(workspaceDir, "BOOT.md");
       try {
         const signalStat = await stat7(signalPath).catch(() => null);
         if (!signalStat) return null;
@@ -18518,6 +18856,7 @@ ${formatted}`;
       artifacts,
       objectiveStateSection,
       causalTrajectorySection,
+      trustZoneSection,
       qmdResult,
       transcriptSection,
       compactionSection,
@@ -18532,6 +18871,7 @@ ${formatted}`;
       artifactsPromise,
       objectiveStatePromise,
       causalTrajectoryPromise,
+      trustZonePromise,
       qmdPromise,
       transcriptPromise,
       compactionPromise,
@@ -18592,6 +18932,9 @@ ${tmtNode.summary}`);
     if (causalTrajectorySection) {
       this.appendRecallSection(sectionBuckets, "causal-trajectories", causalTrajectorySection);
     }
+    if (trustZoneSection) {
+      this.appendRecallSection(sectionBuckets, "trust-zones", trustZoneSection);
+    }
     if (qmdResult) {
       const t0 = Date.now();
       const { memoryResultsLists, globalResults } = qmdResult;
@@ -19385,7 +19728,7 @@ _Context: ${topQuestion.context}_`
     };
     this.tierMigrationInFlight = true;
     try {
-      const coldStorage = new StorageManager(path33.join(storage.dir, "cold"));
+      const coldStorage = new StorageManager(path34.join(storage.dir, "cold"));
       const [hotMemories, coldMemories] = await Promise.all([
         storage.readAllMemories(),
         coldStorage.readAllMemories()
@@ -19979,7 +20322,7 @@ _Context: ${topQuestion.context}_`
         const allMems = allMemsForGraph ?? [];
         for (const m of allMems) {
           if (m.frontmatter.entityRef === entityRef) {
-            const rel = path33.relative(storage.dir, m.path);
+            const rel = path34.relative(storage.dir, m.path);
             if (rel !== memoryRelPath) entitySiblings.push(rel);
           }
         }
@@ -20543,9 +20886,9 @@ ${texts.map((t, i) => `[${i + 1}] ${t}`).join("\n\n")}`;
         protectedCategories: this.config.lifecycleProtectedCategories
       }
     };
-    const metricsPath = path33.join(this.storage.dir, "state", "lifecycle-metrics.json");
-    await mkdir23(path33.dirname(metricsPath), { recursive: true });
-    await writeFile23(metricsPath, JSON.stringify(metrics, null, 2), "utf-8");
+    const metricsPath = path34.join(this.storage.dir, "state", "lifecycle-metrics.json");
+    await mkdir24(path34.dirname(metricsPath), { recursive: true });
+    await writeFile24(metricsPath, JSON.stringify(metrics, null, 2), "utf-8");
   }
   /**
    * Archive old, low-importance, rarely-accessed facts (v6.0).
@@ -20740,6 +21083,33 @@ ${details.join("\n")}`;
     });
     return `## Causal Trajectories
 
+${lines.join("\n\n")}`;
+  }
+  formatTrustZoneResults(results) {
+    const lines = results.map(({ record, matchedFields }, index) => {
+      const header = [
+        `[${index + 1}] ${record.recordedAt.replace("T", " ").slice(0, 16)}`,
+        record.zone,
+        record.kind
+      ].join(" | ");
+      const details = [
+        record.summary,
+        `provenance: ${record.provenance.sourceClass}`
+      ];
+      if (record.entityRefs && record.entityRefs.length > 0) {
+        details.push(`entities: ${record.entityRefs.join(", ")}`);
+      }
+      if (record.tags && record.tags.length > 0) {
+        details.push(`tags: ${record.tags.join(", ")}`);
+      }
+      if (matchedFields.length > 0) {
+        details.push(`matched: ${matchedFields.join(", ")}`);
+      }
+      return `${header}
+${details.join("\n")}`;
+    });
+    return `## Trust Zones
+
 ${lines.join("\n\n")}`;
   }
   summarizeIdentityText(raw, maxLines, maxChars) {
@@ -20873,7 +21243,7 @@ ${lines.join("\n\n")}`;
     if (hits.length === 0) return [];
     const results = [];
     for (const hit of hits) {
-      const fullPath = path33.isAbsolute(hit.path) ? hit.path : path33.join(this.config.memoryDir, hit.path);
+      const fullPath = path34.isAbsolute(hit.path) ? hit.path : path34.join(this.config.memoryDir, hit.path);
       const memory = await this.storage.readMemoryByPath(fullPath);
       if (!memory) continue;
       results.push({
@@ -21331,8 +21701,8 @@ ${lines.join("\n\n")}`;
   }
   namespaceFromStorageDir(storageDir) {
     if (!this.config.namespacesEnabled) return this.config.defaultNamespace;
-    const resolvedStorageDir = path33.resolve(storageDir);
-    const resolvedMemoryDir = path33.resolve(this.config.memoryDir);
+    const resolvedStorageDir = path34.resolve(storageDir);
+    const resolvedMemoryDir = path34.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;
@@ -21360,14 +21730,14 @@ ${lines.join("\n\n")}`;
 };
 
 // src/tools.ts
-import path35 from "path";
+import path36 from "path";
 import { createHash as createHash7 } from "crypto";
 import { Type } from "@sinclair/typebox";
 
 // src/work/storage.ts
-import path34 from "path";
+import path35 from "path";
 import { randomUUID } from "crypto";
-import { mkdir as mkdir24, readdir as readdir17, readFile as readFile24, rm as rm4, writeFile as writeFile24 } from "fs/promises";
+import { mkdir as mkdir25, readdir as readdir17, readFile as readFile24, rm as rm4, writeFile as writeFile25 } from "fs/promises";
 var TASK_TRANSITIONS = {
   todo: /* @__PURE__ */ new Set(["in_progress", "blocked", "cancelled"]),
   in_progress: /* @__PURE__ */ new Set(["todo", "blocked", "done", "cancelled"]),
@@ -21442,22 +21812,22 @@ function ensureProjectStatus(value) {
 var WorkStorage = class {
   constructor(memoryDir) {
     this.memoryDir = memoryDir;
-    this.tasksDir = path34.join(memoryDir, "work", "tasks");
-    this.projectsDir = path34.join(memoryDir, "work", "projects");
+    this.tasksDir = path35.join(memoryDir, "work", "tasks");
+    this.projectsDir = path35.join(memoryDir, "work", "projects");
   }
   tasksDir;
   projectsDir;
   async ensureDirectories() {
-    await mkdir24(this.tasksDir, { recursive: true });
-    await mkdir24(this.projectsDir, { recursive: true });
+    await mkdir25(this.tasksDir, { recursive: true });
+    await mkdir25(this.projectsDir, { recursive: true });
   }
   taskPath(id) {
     assertValidWorkId(id, "task");
-    return path34.join(this.tasksDir, `${id}.md`);
+    return path35.join(this.tasksDir, `${id}.md`);
   }
   projectPath(id) {
     assertValidWorkId(id, "project");
-    return path34.join(this.projectsDir, `${id}.md`);
+    return path35.join(this.projectsDir, `${id}.md`);
   }
   serializeTask(task) {
     return `${serializeFrontmatter2(task)}
@@ -21529,7 +21899,7 @@ ${project.description}
         throw new Error(`project not found: ${task.projectId}`);
       }
     }
-    await writeFile24(this.taskPath(task.id), this.serializeTask(task), "utf-8");
+    await writeFile25(this.taskPath(task.id), this.serializeTask(task), "utf-8");
     if (task.projectId) {
       await this.addTaskIdToProject(task.projectId, task.id, now);
     }
@@ -21549,7 +21919,7 @@ ${project.description}
     const out = [];
     for (const entry of entries) {
       if (!entry.isFile() || !entry.name.endsWith(".md")) continue;
-      const raw = await readFile24(path34.join(this.tasksDir, entry.name), "utf-8");
+      const raw = await readFile24(path35.join(this.tasksDir, entry.name), "utf-8");
       const task = this.parseTask(raw);
       if (!task) continue;
       if (filter?.status && task.status !== filter.status) continue;
@@ -21591,7 +21961,7 @@ ${project.description}
       tags: patch.tags ?? existing.tags,
       updatedAt: now.toISOString()
     };
-    await writeFile24(this.taskPath(id), this.serializeTask(next), "utf-8");
+    await writeFile25(this.taskPath(id), this.serializeTask(next), "utf-8");
     return next;
   }
   async transitionTask(id, nextStatus, now = /* @__PURE__ */ new Date()) {
@@ -21631,7 +22001,7 @@ ${project.description}
       createdAt: timestamp,
       updatedAt: timestamp
     };
-    await writeFile24(this.projectPath(project.id), this.serializeProject(project), "utf-8");
+    await writeFile25(this.projectPath(project.id), this.serializeProject(project), "utf-8");
     return project;
   }
   async getProject(id) {
@@ -21648,7 +22018,7 @@ ${project.description}
     const out = [];
     for (const entry of entries) {
       if (!entry.isFile() || !entry.name.endsWith(".md")) continue;
-      const raw = await readFile24(path34.join(this.projectsDir, entry.name), "utf-8");
+      const raw = await readFile24(path35.join(this.projectsDir, entry.name), "utf-8");
       const project = this.parseProject(raw);
       if (project) out.push(project);
     }
@@ -21665,7 +22035,7 @@ ${project.description}
       taskIds: patch.taskIds ? [...patch.taskIds].sort() : existing.taskIds,
       updatedAt: now.toISOString()
     };
-    await writeFile24(this.projectPath(id), this.serializeProject(next), "utf-8");
+    await writeFile25(this.projectPath(id), this.serializeProject(next), "utf-8");
     return next;
   }
   async deleteProject(id) {
@@ -23204,7 +23574,7 @@ Best for:
 - Reviewing identity development over time`,
       parameters: Type.Object({}),
       async execute() {
-        const workspaceDir = path35.join(process.env.HOME ?? "~", ".openclaw", "workspace");
+        const workspaceDir = path36.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.");
@@ -23726,8 +24096,8 @@ import { access as access3, readFile as readFile37, readdir as readdir24, unlink
 import { createHash as createHash10 } from "crypto";
 
 // src/transfer/export-json.ts
-import path37 from "path";
-import { mkdir as mkdir26, readFile as readFile26 } from "fs/promises";
+import path38 from "path";
+import { mkdir as mkdir27, readFile as readFile26 } from "fs/promises";
 
 // src/transfer/constants.ts
 var EXPORT_FORMAT = "openclaw-engram-export";
@@ -23735,8 +24105,8 @@ var EXPORT_SCHEMA_VERSION = 1;
 
 // src/transfer/fs-utils.ts
 import { createHash as createHash8 } from "crypto";
-import { mkdir as mkdir25, readdir as readdir18, readFile as readFile25, stat as stat8, writeFile as writeFile25 } from "fs/promises";
-import path36 from "path";
+import { mkdir as mkdir26, readdir as readdir18, readFile as readFile25, stat as stat8, writeFile as writeFile26 } from "fs/promises";
+import path37 from "path";
 async function sha256File(filePath) {
   const buf = await readFile25(filePath);
   const sha256 = createHash8("sha256").update(buf).digest("hex");
@@ -23748,8 +24118,8 @@ function sha256String(content) {
   return { sha256, bytes: buf.byteLength };
 }
 async function writeJsonFile(filePath, value) {
-  await mkdir25(path36.dirname(filePath), { recursive: true });
-  await writeFile25(filePath, JSON.stringify(value, null, 2) + "\n", "utf-8");
+  await mkdir26(path37.dirname(filePath), { recursive: true });
+  await writeFile26(filePath, JSON.stringify(value, null, 2) + "\n", "utf-8");
 }
 async function readJsonFile2(filePath) {
   const raw = await readFile25(filePath, "utf-8");
@@ -23760,7 +24130,7 @@ async function listFilesRecursive(rootDir) {
   async function walk(dir) {
     const entries = await readdir18(dir, { withFileTypes: true });
     for (const ent of entries) {
-      const fp = path36.join(dir, ent.name);
+      const fp = path37.join(dir, ent.name);
       if (ent.isDirectory()) {
         await walk(fp);
       } else if (ent.isFile()) {
@@ -23780,11 +24150,11 @@ async function fileExists(filePath) {
   }
 }
 function toPosixRelPath(absPath, rootDir) {
-  const rel = path36.relative(rootDir, absPath);
-  return rel.split(path36.sep).join("/");
+  const rel = path37.relative(rootDir, absPath);
+  return rel.split(path37.sep).join("/");
 }
 function fromPosixRelPath(relPath) {
-  return relPath.split("/").join(path36.sep);
+  return relPath.split("/").join(path37.sep);
 }
 
 // src/transfer/export-json.ts
@@ -23800,9 +24170,9 @@ function shouldExclude(relPosix, includeTranscripts) {
 }
 async function exportJsonBundle(opts) {
   const includeTranscripts = opts.includeTranscripts === true;
-  const outDirAbs = path37.resolve(opts.outDir);
-  await mkdir26(outDirAbs, { recursive: true });
-  const memoryDirAbs = path37.resolve(opts.memoryDir);
+  const outDirAbs = path38.resolve(opts.outDir);
+  await mkdir27(outDirAbs, { recursive: true });
+  const memoryDirAbs = path38.resolve(opts.memoryDir);
   const filesAbs = await listFilesRecursive(memoryDirAbs);
   const records = [];
   const manifestFiles = [];
@@ -23815,7 +24185,7 @@ async function exportJsonBundle(opts) {
     manifestFiles.push({ path: relPosix, sha256, bytes });
   }
   if (opts.includeWorkspaceIdentity !== false && opts.workspaceDir) {
-    const identityPath = path37.join(opts.workspaceDir, "IDENTITY.md");
+    const identityPath = path38.join(opts.workspaceDir, "IDENTITY.md");
     try {
       const content = await readFile26(identityPath, "utf-8");
       const relPath = "workspace/IDENTITY.md";
@@ -23834,13 +24204,13 @@ async function exportJsonBundle(opts) {
     files: manifestFiles.sort((a, b) => a.path.localeCompare(b.path))
   };
   const bundle = { manifest, records };
-  await writeJsonFile(path37.join(outDirAbs, "manifest.json"), manifest);
-  await writeJsonFile(path37.join(outDirAbs, "bundle.json"), bundle);
+  await writeJsonFile(path38.join(outDirAbs, "manifest.json"), manifest);
+  await writeJsonFile(path38.join(outDirAbs, "bundle.json"), bundle);
 }
 
 // src/transfer/export-md.ts
-import path38 from "path";
-import { mkdir as mkdir27, readFile as readFile27, writeFile as writeFile26 } from "fs/promises";
+import path39 from "path";
+import { mkdir as mkdir28, readFile as readFile27, writeFile as writeFile27 } from "fs/promises";
 function shouldExclude2(relPosix, includeTranscripts) {
   const parts = relPosix.split("/");
   if (!includeTranscripts && parts[0] === "transcripts") return true;
@@ -23848,18 +24218,18 @@ function shouldExclude2(relPosix, includeTranscripts) {
 }
 async function exportMarkdownBundle(opts) {
   const includeTranscripts = opts.includeTranscripts === true;
-  const outDirAbs = path38.resolve(opts.outDir);
-  await mkdir27(outDirAbs, { recursive: true });
-  const memDirAbs = path38.resolve(opts.memoryDir);
+  const outDirAbs = path39.resolve(opts.outDir);
+  await mkdir28(outDirAbs, { recursive: true });
+  const memDirAbs = path39.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 = path38.join(outDirAbs, ...relPosix.split("/"));
-    await mkdir27(path38.dirname(dstAbs), { recursive: true });
+    const dstAbs = path39.join(outDirAbs, ...relPosix.split("/"));
+    await mkdir28(path39.dirname(dstAbs), { recursive: true });
     const content = await readFile27(abs);
-    await writeFile26(dstAbs, content);
+    await writeFile27(dstAbs, content);
     const { sha256, bytes } = await sha256File(abs);
     manifestFiles.push({ path: relPosix, sha256, bytes });
   }
@@ -23871,12 +24241,12 @@ async function exportMarkdownBundle(opts) {
     includesTranscripts: includeTranscripts,
     files: manifestFiles.sort((a, b) => a.path.localeCompare(b.path))
   };
-  await writeJsonFile(path38.join(outDirAbs, "manifest.json"), manifest);
+  await writeJsonFile(path39.join(outDirAbs, "manifest.json"), manifest);
 }
 async function looksLikeEngramMdExport(fromDir) {
-  const dirAbs = path38.resolve(fromDir);
+  const dirAbs = path39.resolve(fromDir);
   try {
-    const raw = await readFile27(path38.join(dirAbs, "manifest.json"), "utf-8");
+    const raw = await readFile27(path39.join(dirAbs, "manifest.json"), "utf-8");
     const parsed = JSON.parse(raw);
     return parsed.format === EXPORT_FORMAT && parsed.schemaVersion === EXPORT_SCHEMA_VERSION;
   } catch {
@@ -23885,16 +24255,16 @@ async function looksLikeEngramMdExport(fromDir) {
 }
 
 // src/transfer/backup.ts
-import path39 from "path";
-import { mkdir as mkdir28, readdir as readdir19, rm as rm5 } from "fs/promises";
+import path40 from "path";
+import { mkdir as mkdir29, readdir as readdir19, rm as rm5 } from "fs/promises";
 function timestampDirName(now) {
   return now.toISOString().replace(/[:.]/g, "-");
 }
 async function backupMemoryDir(opts) {
-  const outDirAbs = path39.resolve(opts.outDir);
-  await mkdir28(outDirAbs, { recursive: true });
+  const outDirAbs = path40.resolve(opts.outDir);
+  await mkdir29(outDirAbs, { recursive: true });
   const ts = timestampDirName(/* @__PURE__ */ new Date());
-  const backupDir = path39.join(outDirAbs, ts);
+  const backupDir = path40.join(outDirAbs, ts);
   await exportMarkdownBundle({
     memoryDir: opts.memoryDir,
     outDir: backupDir,
@@ -23919,13 +24289,13 @@ async function enforceRetention(outDirAbs, retentionDays) {
     const tsMs = iso ? Date.parse(iso) : NaN;
     if (!Number.isFinite(tsMs)) continue;
     if (tsMs < cutoffMs) {
-      await rm5(path39.join(outDirAbs, name), { recursive: true, force: true });
+      await rm5(path40.join(outDirAbs, name), { recursive: true, force: true });
     }
   }
 }
 
 // src/transfer/export-sqlite.ts
-import path40 from "path";
+import path41 from "path";
 import Database from "better-sqlite3";
 import { readFile as readFile28 } from "fs/promises";
 
@@ -23953,8 +24323,8 @@ function shouldExclude3(relPosix, includeTranscripts) {
 }
 async function exportSqlite(opts) {
   const includeTranscripts = opts.includeTranscripts === true;
-  const memDirAbs = path40.resolve(opts.memoryDir);
-  const outAbs = path40.resolve(opts.outFile);
+  const memDirAbs = path41.resolve(opts.memoryDir);
+  const outAbs = path41.resolve(opts.outFile);
   const filesAbs = await listFilesRecursive(memDirAbs);
   const db = new Database(outAbs);
   try {
@@ -23986,8 +24356,8 @@ async function exportSqlite(opts) {
 }
 
 // src/transfer/import-json.ts
-import path41 from "path";
-import { mkdir as mkdir29, writeFile as writeFile27 } from "fs/promises";
+import path42 from "path";
+import { mkdir as mkdir30, writeFile as writeFile28 } from "fs/promises";
 
 // src/transfer/types.ts
 import { z as z4 } from "zod";
@@ -24020,21 +24390,21 @@ function normalizeForDedupe(s) {
 }
 async function importJsonBundle(opts) {
   const conflict = opts.conflict ?? "skip";
-  const fromDirAbs = path41.resolve(opts.fromDir);
-  const bundlePath = path41.join(fromDirAbs, "bundle.json");
+  const fromDirAbs = path42.resolve(opts.fromDir);
+  const bundlePath = path42.join(fromDirAbs, "bundle.json");
   const bundle = ExportBundleV1Schema.parse(await readJsonFile2(bundlePath));
-  const memDirAbs = path41.resolve(opts.targetMemoryDir);
+  const memDirAbs = path42.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 ? path41.resolve(opts.workspaceDir) : null : memDirAbs;
+    const targetBase = isWorkspace ? opts.workspaceDir ? path42.resolve(opts.workspaceDir) : null : memDirAbs;
     if (isWorkspace && !targetBase) {
       skipped += 1;
       continue;
     }
     const relFs = fromPosixRelPath(isWorkspace ? rec.path.replace(/^workspace\//, "") : rec.path);
-    const absTarget = path41.join(targetBase, relFs);
+    const absTarget = path42.join(targetBase, relFs);
     const exists3 = await fileExists(absTarget);
     if (exists3) {
       if (conflict === "skip") {
@@ -24058,30 +24428,30 @@ async function importJsonBundle(opts) {
     return { written: 0, skipped };
   }
   for (const w of written) {
-    await mkdir29(path41.dirname(w.abs), { recursive: true });
-    await writeFile27(w.abs, w.content, "utf-8");
+    await mkdir30(path42.dirname(w.abs), { recursive: true });
+    await writeFile28(w.abs, w.content, "utf-8");
   }
   return { written: written.length, skipped };
 }
 function looksLikeEngramJsonExport(fromDir) {
-  const dir = path41.resolve(fromDir);
+  const dir = path42.resolve(fromDir);
   return Promise.all([
-    fileExists(path41.join(dir, "manifest.json")),
-    fileExists(path41.join(dir, "bundle.json"))
+    fileExists(path42.join(dir, "manifest.json")),
+    fileExists(path42.join(dir, "bundle.json"))
   ]).then(([m, b]) => m && b);
 }
 
 // src/transfer/import-sqlite.ts
-import path42 from "path";
+import path43 from "path";
 import Database2 from "better-sqlite3";
-import { mkdir as mkdir30, writeFile as writeFile28 } from "fs/promises";
+import { mkdir as mkdir31, writeFile as writeFile29 } from "fs/promises";
 function normalizeForDedupe2(s) {
   return s.replace(/\s+/g, " ").trim();
 }
 async function importSqlite(opts) {
   const conflict = opts.conflict ?? "skip";
-  const memDirAbs = path42.resolve(opts.targetMemoryDir);
-  const fromAbs = path42.resolve(opts.fromFile);
+  const memDirAbs = path43.resolve(opts.targetMemoryDir);
+  const fromAbs = path43.resolve(opts.fromFile);
   const db = new Database2(fromAbs, { readonly: true });
   const written = [];
   let skipped = 0;
@@ -24094,7 +24464,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 = path42.join(memDirAbs, relFs);
+      const absTarget = path43.join(memDirAbs, relFs);
       const exists3 = await fileExists(absTarget);
       if (exists3) {
         if (conflict === "skip") {
@@ -24119,29 +24489,29 @@ async function importSqlite(opts) {
   }
   if (opts.dryRun) return { written: 0, skipped };
   for (const w of written) {
-    await mkdir30(path42.dirname(w.abs), { recursive: true });
-    await writeFile28(w.abs, w.content, "utf-8");
+    await mkdir31(path43.dirname(w.abs), { recursive: true });
+    await writeFile29(w.abs, w.content, "utf-8");
   }
   return { written: written.length, skipped };
 }
 
 // src/transfer/import-md.ts
-import path43 from "path";
-import { mkdir as mkdir31, readFile as readFile29, writeFile as writeFile29 } from "fs/promises";
+import path44 from "path";
+import { mkdir as mkdir32, readFile as readFile29, writeFile as writeFile30 } from "fs/promises";
 function normalizeForDedupe3(s) {
   return s.replace(/\s+/g, " ").trim();
 }
 async function importMarkdownBundle(opts) {
   const conflict = opts.conflict ?? "skip";
-  const fromAbs = path43.resolve(opts.fromDir);
-  const targetAbs = path43.resolve(opts.targetMemoryDir);
+  const fromAbs = path44.resolve(opts.fromDir);
+  const targetAbs = path44.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 = path43.join(targetAbs, fromPosixRelPath(relPosix));
+    const dstAbs = path44.join(targetAbs, fromPosixRelPath(relPosix));
     const content = await readFile29(abs, "utf-8");
     const exists3 = await fileExists(dstAbs);
     if (exists3) {
@@ -24164,17 +24534,17 @@ async function importMarkdownBundle(opts) {
   }
   if (opts.dryRun) return { written: 0, skipped };
   for (const w of writes) {
-    await mkdir31(path43.dirname(w.abs), { recursive: true });
-    await writeFile29(w.abs, w.content, "utf-8");
+    await mkdir32(path44.dirname(w.abs), { recursive: true });
+    await writeFile30(w.abs, w.content, "utf-8");
   }
   return { written: writes.length, skipped };
 }
 
 // src/transfer/autodetect.ts
-import path44 from "path";
+import path45 from "path";
 import { stat as stat9 } from "fs/promises";
 async function detectImportFormat(fromPath) {
-  const abs = path44.resolve(fromPath);
+  const abs = path45.resolve(fromPath);
   let st;
   try {
     st = await stat9(abs);
@@ -24659,8 +25029,8 @@ var openclawReplayNormalizer = {
 };
 
 // src/maintenance/archive-observations.ts
-import path45 from "path";
-import { mkdir as mkdir32, readdir as readdir20, readFile as readFile30, unlink as unlink6, writeFile as writeFile30 } from "fs/promises";
+import path46 from "path";
+import { mkdir as mkdir33, readdir as readdir20, readFile as readFile30, unlink as unlink6, writeFile as writeFile31 } from "fs/promises";
 var DATE_FILE_PATTERN = /^(\d{4})-(\d{2})-(\d{2})\.(jsonl|md)$/;
 function normalizeRetentionDays(value) {
   if (!Number.isFinite(value)) return 30;
@@ -24686,8 +25056,8 @@ async function listFilesRecursive2(root, relPrefix = "") {
     return out;
   }
   for (const entry of entries) {
-    const rel = relPrefix ? path45.join(relPrefix, entry.name) : entry.name;
-    const full = path45.join(root, entry.name);
+    const rel = relPrefix ? path46.join(relPrefix, entry.name) : entry.name;
+    const full = path46.join(root, entry.name);
     if (entry.isDirectory()) {
       out.push(...await listFilesRecursive2(full, rel));
       continue;
@@ -24697,19 +25067,19 @@ async function listFilesRecursive2(root, relPrefix = "") {
   return out;
 }
 async function collectArchiveCandidates(memoryDir, cutoffTimeMs) {
-  const roots = ["transcripts", path45.join("state", "tool-usage"), path45.join("summaries", "hourly")];
+  const roots = ["transcripts", path46.join("state", "tool-usage"), path46.join("summaries", "hourly")];
   const out = [];
   for (const relRoot of roots) {
-    const absRoot = path45.join(memoryDir, relRoot);
+    const absRoot = path46.join(memoryDir, relRoot);
     const files = await listFilesRecursive2(absRoot);
     for (const fileRel of files) {
-      const filename = path45.basename(fileRel);
+      const filename = path46.basename(fileRel);
       const parsedDate = extractDateFromFilename(filename);
       if (!parsedDate) continue;
       if (parsedDate.getTime() >= cutoffTimeMs) continue;
       out.push({
-        absolutePath: path45.join(absRoot, fileRel),
-        relativePath: path45.join(relRoot, fileRel)
+        absolutePath: path46.join(absRoot, fileRel),
+        relativePath: path46.join(relRoot, fileRel)
       });
     }
   }
@@ -24724,7 +25094,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 = path45.join(options.memoryDir, "archive", "observations", stamp);
+  const archiveRoot = path46.join(options.memoryDir, "archive", "observations", stamp);
   const candidates = retentionDays === 0 ? [] : await collectArchiveCandidates(
     options.memoryDir,
     cutoffDayStartUtc
@@ -24733,13 +25103,13 @@ async function archiveObservations(options) {
   let archivedBytes = 0;
   const archivedRelativePaths = [];
   if (!dryRun && candidates.length > 0) {
-    await mkdir32(archiveRoot, { recursive: true });
+    await mkdir33(archiveRoot, { recursive: true });
     for (const candidate of candidates) {
-      const archivePath = path45.join(archiveRoot, candidate.relativePath);
-      const archiveDir = path45.dirname(archivePath);
-      await mkdir32(archiveDir, { recursive: true });
+      const archivePath = path46.join(archiveRoot, candidate.relativePath);
+      const archiveDir = path46.dirname(archivePath);
+      await mkdir33(archiveDir, { recursive: true });
       const raw = await readFile30(candidate.absolutePath);
-      await writeFile30(archivePath, raw);
+      await writeFile31(archivePath, raw);
       await unlink6(candidate.absolutePath);
       archivedFiles += 1;
       archivedBytes += raw.byteLength;
@@ -24760,12 +25130,12 @@ async function archiveObservations(options) {
 }
 
 // src/maintenance/rebuild-observations.ts
-import path47 from "path";
+import path48 from "path";
 import { readdir as readdir21, readFile as readFile32 } from "fs/promises";
 
 // src/maintenance/observation-ledger-utils.ts
-import path46 from "path";
-import { mkdir as mkdir33, readFile as readFile31, writeFile as writeFile31 } from "fs/promises";
+import path47 from "path";
+import { mkdir as mkdir34, readFile as readFile31, writeFile as writeFile32 } from "fs/promises";
 function toHourBucketIso(timestamp) {
   const normalized = /(?:Z|[+-]\d{2}:\d{2})$/u.test(timestamp) ? timestamp : `${timestamp}Z`;
   const ms = Date.parse(normalized);
@@ -24776,8 +25146,8 @@ function toHourBucketIso(timestamp) {
 }
 async function backupAndWriteRebuiltObservations(options) {
   const stamp = options.now.toISOString().replace(/[-:]/g, "").replace(/\.\d{3}Z$/, "Z");
-  const archiveRoot = path46.join(options.memoryDir, "archive", "observations", stamp);
-  let backupPath = path46.join(
+  const archiveRoot = path47.join(options.memoryDir, "archive", "observations", stamp);
+  let backupPath = path47.join(
     archiveRoot,
     "state",
     "observation-ledger",
@@ -24785,8 +25155,8 @@ async function backupAndWriteRebuiltObservations(options) {
   );
   try {
     const existing = await readFile31(options.outputPath, "utf-8");
-    await mkdir33(path46.dirname(backupPath), { recursive: true });
-    await writeFile31(backupPath, existing, "utf-8");
+    await mkdir34(path47.dirname(backupPath), { recursive: true });
+    await writeFile32(backupPath, existing, "utf-8");
   } catch (err) {
     const code = err.code;
     if (code && code === "ENOENT") {
@@ -24802,8 +25172,8 @@ async function backupAndWriteRebuiltObservations(options) {
       rebuiltAt
     })
   );
-  await mkdir33(path46.dirname(options.outputPath), { recursive: true });
-  await writeFile31(options.outputPath, lines.length > 0 ? `${lines.join("\n")}
+  await mkdir34(path47.dirname(options.outputPath), { recursive: true });
+  await writeFile32(options.outputPath, lines.length > 0 ? `${lines.join("\n")}
 ` : "", "utf-8");
   return backupPath;
 }
@@ -24825,7 +25195,7 @@ async function listTranscriptFiles2(root) {
   for (const entry of entries) {
     if (entry.name === "." || entry.name === "..") continue;
     if (entry.isSymbolicLink()) continue;
-    const full = path47.join(root, entry.name);
+    const full = path48.join(root, entry.name);
     if (entry.isDirectory()) {
       out.push(...await listTranscriptFiles2(full));
       continue;
@@ -24885,8 +25255,8 @@ function buildLedgerRows(linesByFile) {
 async function rebuildObservations(options) {
   const dryRun = options.dryRun !== false;
   const now = options.now ?? /* @__PURE__ */ new Date();
-  const transcriptsRoot = path47.join(options.memoryDir, "transcripts");
-  const outputPath = path47.join(
+  const transcriptsRoot = path48.join(options.memoryDir, "transcripts");
+  const outputPath = path48.join(
     options.memoryDir,
     "state",
     "observation-ledger",
@@ -24922,7 +25292,7 @@ async function rebuildObservations(options) {
 }
 
 // src/maintenance/migrate-observations.ts
-import path48 from "path";
+import path49 from "path";
 import { readdir as readdir22, readFile as readFile33 } from "fs/promises";
 function toNonNegativeInt(value) {
   if (typeof value !== "number" || !Number.isFinite(value)) return null;
@@ -24986,15 +25356,15 @@ async function listLegacyObservationFiles(root) {
 async function migrateObservations(options) {
   const dryRun = options.dryRun !== false;
   const now = options.now ?? /* @__PURE__ */ new Date();
-  const ledgerRoot = path48.join(options.memoryDir, "state", "observation-ledger");
-  const outputPath = path48.join(ledgerRoot, "rebuilt-observations.jsonl");
+  const ledgerRoot = path49.join(options.memoryDir, "state", "observation-ledger");
+  const outputPath = path49.join(ledgerRoot, "rebuilt-observations.jsonl");
   const legacyFiles = await listLegacyObservationFiles(ledgerRoot);
-  const sourceRelativePaths = legacyFiles.map((name) => path48.join("state", "observation-ledger", name));
+  const sourceRelativePaths = legacyFiles.map((name) => path49.join("state", "observation-ledger", name));
   const byKey = /* @__PURE__ */ new Map();
   let parsedRows = 0;
   let malformedLines = 0;
   for (const file of legacyFiles) {
-    const full = path48.join(ledgerRoot, file);
+    const full = path49.join(ledgerRoot, file);
     const raw = await readFile33(full, "utf-8");
     for (const line of raw.split("\n")) {
       if (!line.trim()) continue;
@@ -25184,10 +25554,10 @@ var defaultCommandRunner = (command, args, options) => {
 
 // src/network/webdav.ts
 import { createReadStream } from "fs";
-import { mkdir as mkdir34, readdir as readdir23, realpath as realpath2, stat as stat11 } from "fs/promises";
+import { mkdir as mkdir35, readdir as readdir23, realpath as realpath2, stat as stat11 } from "fs/promises";
 import { createServer } from "http";
 import { timingSafeEqual } from "crypto";
-import path49 from "path";
+import path50 from "path";
 import { pipeline } from "stream/promises";
 import { URL as URL2 } from "url";
 function hostToUrlAuthority(host) {
@@ -25223,10 +25593,10 @@ var WebDavServer = class _WebDavServer {
     const allowedRoots = [];
     const aliasSet = /* @__PURE__ */ new Set();
     for (const dir of options.allowlistDirs) {
-      const resolved = path49.resolve(dir);
-      await mkdir34(resolved, { recursive: true });
+      const resolved = path50.resolve(dir);
+      await mkdir35(resolved, { recursive: true });
       const canonical = await realpath2(resolved);
-      const alias = path49.basename(canonical) || "root";
+      const alias = path50.basename(canonical) || "root";
       if (aliasSet.has(alias)) {
         throw new Error(`duplicate webdav allowlist alias: ${alias}`);
       }
@@ -25382,7 +25752,7 @@ var WebDavServer = class _WebDavServer {
     if (decodedPath.includes("\0")) {
       return { ok: false, code: 400, message: "invalid path" };
     }
-    const normalized = path49.posix.normalize(decodedPath);
+    const normalized = path50.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" };
@@ -25396,7 +25766,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 = path49.resolve(root.absolute, ...relative);
+    const candidate = path50.resolve(root.absolute, ...relative);
     if (!this.isPathInside(root.absolute, candidate)) {
       return { ok: false, code: 403, message: "path escaped allowlist" };
     }
@@ -25474,10 +25844,10 @@ var WebDavServer = class _WebDavServer {
   }
   isPathInside(root, target) {
     if (target === root) return true;
-    if (root === path49.parse(root).root) {
+    if (root === path50.parse(root).root) {
       return target.startsWith(root);
     }
-    return target.startsWith(`${root}${path49.sep}`);
+    return target.startsWith(`${root}${path50.sep}`);
   }
 };
 function xmlEscape(value) {
@@ -25492,10 +25862,10 @@ import { createHash as createHash9 } from "crypto";
 import { createServer as createServer2 } from "http";
 import { watch } from "fs";
 import { readFile as readFile35 } from "fs/promises";
-import path51 from "path";
+import path52 from "path";
 
 // src/graph-dashboard-parser.ts
-import path50 from "path";
+import path51 from "path";
 import { readFile as readFile34 } from "fs/promises";
 
 // src/graph-dashboard-key.ts
@@ -25506,7 +25876,7 @@ function graphEdgeKey(edge) {
 // src/graph-dashboard-parser.ts
 var GRAPH_TYPES = ["entity", "time", "causal"];
 function graphFile(memoryDir, type) {
-  return path50.join(memoryDir, "state", "graphs", `${type}.jsonl`);
+  return path51.join(memoryDir, "state", "graphs", `${type}.jsonl`);
 }
 function isGraphEdge(raw, expectedType) {
   if (!raw || typeof raw !== "object") return false;
@@ -25633,7 +26003,7 @@ var GraphDashboardServer = class {
     this.memoryDir = options.memoryDir;
     this.host = options.host?.trim() || "127.0.0.1";
     this.requestedPort = Number.isFinite(options.port) ? Math.max(0, Math.floor(options.port ?? 0)) : 0;
-    this.publicDir = options.publicDir ?? path51.join(process.cwd(), "dashboard", "public");
+    this.publicDir = options.publicDir ?? path52.join(process.cwd(), "dashboard", "public");
     this.watchDebounceMs = Math.max(50, Math.floor(options.watchDebounceMs ?? 300));
   }
   async start() {
@@ -25732,11 +26102,11 @@ var GraphDashboardServer = class {
       return;
     }
     if (req.method === "GET" && url === "/app.js") {
-      await this.respondStatic(res, path51.join(this.publicDir, "app.js"), "application/javascript; charset=utf-8");
+      await this.respondStatic(res, path52.join(this.publicDir, "app.js"), "application/javascript; charset=utf-8");
       return;
     }
     if (req.method === "GET" && (url === "/" || url === "/index.html")) {
-      await this.respondStatic(res, path51.join(this.publicDir, "index.html"), "text/html; charset=utf-8");
+      await this.respondStatic(res, path52.join(this.publicDir, "index.html"), "text/html; charset=utf-8");
       return;
     }
     this.respondJson(res, 404, { error: "Not found" });
@@ -25822,7 +26192,7 @@ var GraphDashboardServer = class {
     }
   }
   startWatcher() {
-    const graphDir = path51.join(this.memoryDir, "state", "graphs");
+    const graphDir = path52.join(this.memoryDir, "state", "graphs");
     try {
       this.watcher = watch(graphDir, { persistent: false }, () => {
         this.scheduleRebuild();
@@ -25868,7 +26238,7 @@ var GraphDashboardServer = class {
 
 // src/compat/checks.ts
 import { access as access2, readFile as readFile36 } from "fs/promises";
-import path52 from "path";
+import path53 from "path";
 import { spawn as spawn4 } from "child_process";
 var REQUIRED_HOOKS = ["before_agent_start", "agent_end"];
 function isSafeCommandToken(command) {
@@ -26050,9 +26420,9 @@ function compareVersions(a, b) {
 async function runCompatChecks(options) {
   const checks = [];
   const runner = options.runner ?? defaultRunner;
-  const pluginJsonPath = path52.join(options.repoRoot, "openclaw.plugin.json");
-  const packageJsonPath = path52.join(options.repoRoot, "package.json");
-  const indexPath = path52.join(options.repoRoot, "src", "index.ts");
+  const pluginJsonPath = path53.join(options.repoRoot, "openclaw.plugin.json");
+  const packageJsonPath = path53.join(options.repoRoot, "package.json");
+  const indexPath = path53.join(options.repoRoot, "src", "index.ts");
   let pluginRaw = "";
   let pluginManifestPresent = false;
   try {
@@ -26237,111 +26607,6 @@ async function runCompatChecks(options) {
   };
 }
 
-// src/trust-zones.ts
-import path53 from "path";
-import { mkdir as mkdir35, writeFile as writeFile32 } from "fs/promises";
-function validateMetadata3(raw) {
-  return validateStringRecord(raw, "metadata");
-}
-function validateZone(raw, field) {
-  const value = assertString2(raw, field);
-  if (!["quarantine", "working", "trusted"].includes(value)) {
-    throw new Error(`${field} must be one of quarantine|working|trusted`);
-  }
-  return value;
-}
-function validateKind(raw) {
-  const value = assertString2(raw, "kind");
-  if (!["memory", "artifact", "state", "trajectory", "external"].includes(value)) {
-    throw new Error("kind must be one of memory|artifact|state|trajectory|external");
-  }
-  return value;
-}
-function validateProvenance(raw) {
-  if (!isRecord2(raw)) throw new Error("provenance must be an object");
-  const sourceClass = assertString2(raw.sourceClass, "provenance.sourceClass");
-  if (!["tool_output", "web_content", "subagent_trace", "system_memory", "user_input", "manual"].includes(sourceClass)) {
-    throw new Error("provenance.sourceClass must be one of tool_output|web_content|subagent_trace|system_memory|user_input|manual");
-  }
-  return {
-    sourceClass,
-    observedAt: assertIsoRecordedAt(assertString2(raw.observedAt, "provenance.observedAt"), "provenance.observedAt"),
-    sessionKey: optionalString(raw.sessionKey),
-    sourceId: optionalString(raw.sourceId),
-    evidenceHash: optionalString(raw.evidenceHash)
-  };
-}
-function resolveTrustZoneStoreDir(memoryDir, overrideDir) {
-  if (typeof overrideDir === "string" && overrideDir.trim().length > 0) {
-    return overrideDir.trim();
-  }
-  return path53.join(memoryDir, "state", "trust-zones");
-}
-function validateTrustZoneRecord(raw) {
-  if (!isRecord2(raw)) throw new Error("trust-zone record must be an object");
-  if (raw.schemaVersion !== 1) throw new Error("schemaVersion must be 1");
-  return {
-    schemaVersion: 1,
-    recordId: assertSafePathSegment(assertString2(raw.recordId, "recordId"), "recordId"),
-    zone: validateZone(raw.zone, "zone"),
-    recordedAt: assertIsoRecordedAt(assertString2(raw.recordedAt, "recordedAt")),
-    kind: validateKind(raw.kind),
-    summary: assertString2(raw.summary, "summary"),
-    provenance: validateProvenance(raw.provenance),
-    promotedFromZone: raw.promotedFromZone === void 0 ? void 0 : validateZone(raw.promotedFromZone, "promotedFromZone"),
-    entityRefs: optionalStringArray2(raw.entityRefs, "entityRefs"),
-    tags: optionalStringArray2(raw.tags, "tags"),
-    metadata: validateMetadata3(raw.metadata)
-  };
-}
-async function readTrustZoneRecords(options) {
-  const rootDir = resolveTrustZoneStoreDir(options.memoryDir, options.trustZoneStoreDir);
-  const files = await listJsonFiles(path53.join(rootDir, "zones"));
-  const records = [];
-  const invalidRecords = [];
-  for (const filePath of files) {
-    try {
-      records.push(validateTrustZoneRecord(await readJsonFile(filePath)));
-    } catch (error) {
-      invalidRecords.push({
-        path: filePath,
-        error: error instanceof Error ? error.message : String(error)
-      });
-    }
-  }
-  return { files, records, invalidRecords };
-}
-async function getTrustZoneStoreStatus(options) {
-  const rootDir = resolveTrustZoneStoreDir(options.memoryDir, options.trustZoneStoreDir);
-  const zonesDir = path53.join(rootDir, "zones");
-  const { files, records, invalidRecords } = await readTrustZoneRecords(options);
-  records.sort((a, b) => b.recordedAt.localeCompare(a.recordedAt));
-  const byZone = {};
-  const byKind = {};
-  for (const record of records) {
-    byZone[record.zone] = (byZone[record.zone] ?? 0) + 1;
-    byKind[record.kind] = (byKind[record.kind] ?? 0) + 1;
-  }
-  return {
-    enabled: options.enabled,
-    promotionEnabled: options.promotionEnabled,
-    rootDir,
-    zonesDir,
-    records: {
-      total: files.length,
-      valid: records.length,
-      invalid: invalidRecords.length,
-      byZone,
-      byKind,
-      latestRecordId: records[0]?.recordId,
-      latestRecordedAt: records[0]?.recordedAt,
-      latestZone: records[0]?.zone
-    },
-    latestRecord: records[0],
-    invalidRecords
-  };
-}
-
 // src/cli.ts
 function rankCandidateForKeep(a, b) {
   const aConfidence = typeof a.frontmatter.confidence === "number" ? a.frontmatter.confidence : 0;
@@ -26546,6 +26811,24 @@ async function runTrustZoneStatusCliCommand(options) {
     promotionEnabled: options.quarantinePromotionEnabled
   });
 }
+async function runTrustZonePromoteCliCommand(options) {
+  const result = await promoteTrustZoneRecord({
+    memoryDir: options.memoryDir,
+    trustZoneStoreDir: options.trustZoneStoreDir,
+    enabled: options.trustZonesEnabled,
+    promotionEnabled: options.quarantinePromotionEnabled,
+    sourceRecordId: options.sourceRecordId,
+    targetZone: options.targetZone,
+    recordedAt: options.recordedAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+    promotionReason: options.promotionReason,
+    summary: options.summary,
+    dryRun: options.dryRun === true
+  });
+  return {
+    ...result,
+    dryRun: options.dryRun === true
+  };
+}
 async function runSessionCheckCliCommand(options) {
   return analyzeSessionIntegrity({ memoryDir: options.memoryDir });
 }
@@ -27714,6 +27997,23 @@ function registerCli(api, orchestrator) {
         console.log(JSON.stringify(status, null, 2));
         console.log("OK");
       });
+      cmd.command("trust-zone-promote").description("Dry-run or apply a trust-zone promotion with provenance enforcement").requiredOption("--record-id <recordId>", "Source trust-zone record id").requiredOption("--target-zone <targetZone>", "Promotion target zone (working|trusted)").requiredOption("--reason <reason>", "Human-readable promotion reason").option("--recorded-at <isoTimestamp>", "Promotion timestamp (defaults to now)").option("--summary <summary>", "Optional replacement summary for the promoted record").option("--dry-run", "Show the promotion plan without writing the promoted record").action(async (...args) => {
+        const options = args[0] ?? {};
+        const result = await runTrustZonePromoteCliCommand({
+          memoryDir: orchestrator.config.memoryDir,
+          trustZoneStoreDir: orchestrator.config.trustZoneStoreDir,
+          trustZonesEnabled: orchestrator.config.trustZonesEnabled,
+          quarantinePromotionEnabled: orchestrator.config.quarantinePromotionEnabled,
+          sourceRecordId: String(options.recordId ?? ""),
+          targetZone: String(options.targetZone ?? ""),
+          promotionReason: String(options.reason ?? ""),
+          recordedAt: typeof options.recordedAt === "string" ? options.recordedAt : void 0,
+          summary: typeof options.summary === "string" ? options.summary : void 0,
+          dryRun: options.dryRun === true
+        });
+        console.log(JSON.stringify(result, null, 2));
+        console.log("OK");
+      });
       cmd.command("conversation-index-health").description("Show conversation index backend health and index stats").action(async () => {
         const health = await runConversationIndexHealthCliCommand(orchestrator);
         console.log(JSON.stringify(health, null, 2));