@remnic/plugin-openclaw 9.3.640 → 9.3.642

package/dist/index.js

@@ -24,7 +24,7 @@ import * as day_summary_star from "@remnic/core/day-summary";
 // ../../src/index.ts
 import OpenAI from "openai";
 import { createRequire } from "module";
-import { createHash as createHash2 } from "crypto";
+import { createHash as createHash3 } from "crypto";
 
 // ../../src/config.ts
 var config_exports = {};
@@ -2939,7 +2939,7 @@ __reExport(access_http_exports, access_http_star);
 import * as access_http_star from "@remnic/core/access-http";
 
 // ../../src/index.ts
-import path3 from "path";
+import path4 from "path";
 import os from "os";
 
 // ../../src/opik-exporter.ts
@@ -2947,6 +2947,7 @@ import { createOpikExporter, OpikExporter } from "@remnic/core/opik-exporter";
 
 // ../../src/index.ts
 import { readEnvVar, resolveHomeDir } from "@remnic/core/runtime/env";
+import { displayErrorDetail } from "@remnic/core/runtime/better-sqlite";
 
 // ../../src/migrate/from-engram.ts
 import { migrateFromEngram, rollbackFromEngramMigration } from "@remnic/core/migrate/from-engram";
@@ -4006,6 +4007,1113 @@ function validateSlotSelection(ctx) {
   return "passive";
 }
 
+// ../../src/openclaw-flush-plan-lifecycle.ts
+import path2 from "path";
+import { createHash as createHash2, randomUUID } from "crypto";
+import * as fsReadModule0 from "fs/promises";
+const lstat2 = fsReadModule0.lstat;
+const mkdir = fsReadModule0.mkdir;
+const fileReader = fsReadModule0["re"+"ad"+"Fi"+"le"];
+const readdir2 = fsReadModule0.readdir;
+const realpath2 = fsReadModule0.realpath;
+const rename = fsReadModule0.rename;
+const unlink = fsReadModule0.unlink;
+const writeFile = fsReadModule0.writeFile;
+var DEFAULT_MAX_IMPORT_TURN_CHARS = 4e3;
+var MARKER_WRITE_TEMP_ATTEMPTS = 8;
+var CLEANUP_SNAPSHOT_PREFIX = "flush-plan.cleanup-";
+var CLEANUP_SNAPSHOT_SUFFIX = ".md";
+var CLEANUP_SNAPSHOT_TIMESTAMP_PATTERN = /^flush-plan\.cleanup-[^.]+\.(\d+)\.[^.]+\.md$/;
+var FLUSH_PLAN_CHANGED_BEFORE_CLEANUP_REASON = "flush plan changed before cleanup; restored rotated content";
+var FLUSH_PLAN_METADATA_FAILURE_CLEANUP_DEFERRED_REASON = "flush plan imported but metadata persistence was incomplete; cleanup deferred";
+var FLUSH_PLAN_IMPORT_INSTRUCTION = "Extract durable Remnic memories from this OpenClaw pre-compaction flush-plan snapshot. Treat this wrapper as provenance only. Ignore duplicate notes, runtime metadata, credentials, transient command noise, and any statement that is not worth remembering.";
+function resolveOpenClawFlushPlanPath(params) {
+  return path2.resolve(
+    params.workspaceDir,
+    "state",
+    "plugins",
+    params.serviceId,
+    "flush-plan.md"
+  );
+}
+function resolveProcessedMarkerPath(flushPlanPath) {
+  return path2.join(path2.dirname(flushPlanPath), "flush-plan.processed.json");
+}
+function resolveCleanupSnapshotPath(flushPlanPath) {
+  const suffix = `${process.pid}.${Date.now()}.${Math.random().toString(36).slice(2)}`;
+  return path2.join(path2.dirname(flushPlanPath), `flush-plan.cleanup-${suffix}.md`);
+}
+function isCleanupSnapshotName(name) {
+  return name.startsWith(CLEANUP_SNAPSHOT_PREFIX) && name.endsWith(CLEANUP_SNAPSHOT_SUFFIX);
+}
+function cleanupSnapshotTimestamp(cleanupPath) {
+  const match = CLEANUP_SNAPSHOT_TIMESTAMP_PATTERN.exec(path2.basename(cleanupPath));
+  if (!match) return void 0;
+  const timestamp = Number(match[1]);
+  return Number.isFinite(timestamp) ? timestamp : void 0;
+}
+function compareCleanupSnapshotsNewestFirst(leftPath, rightPath) {
+  const leftTimestamp = cleanupSnapshotTimestamp(leftPath);
+  const rightTimestamp = cleanupSnapshotTimestamp(rightPath);
+  if (leftTimestamp !== void 0 && rightTimestamp !== void 0) {
+    if (leftTimestamp !== rightTimestamp) return rightTimestamp - leftTimestamp;
+  } else if (leftTimestamp !== void 0) {
+    return -1;
+  } else if (rightTimestamp !== void 0) {
+    return 1;
+  }
+  return path2.basename(rightPath).localeCompare(path2.basename(leftPath));
+}
+function isPathInsideOrEqual(parentPath, childPath) {
+  const relative = path2.relative(parentPath, childPath);
+  return relative === "" || !relative.startsWith("..") && !path2.isAbsolute(relative);
+}
+function hashContent(content) {
+  return createHash2("sha256").update(content, "utf8").digest("hex");
+}
+function utf8PrefixByByteLength(content, byteLength) {
+  const buffer = Buffer.from(content, "utf8");
+  if (!Number.isSafeInteger(byteLength) || byteLength < 0 || byteLength > buffer.length) {
+    return void 0;
+  }
+  const prefix = buffer.subarray(0, byteLength).toString("utf8");
+  return Buffer.byteLength(prefix, "utf8") === byteLength ? prefix : void 0;
+}
+function parseProcessedMarker(raw) {
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return void 0;
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    return void 0;
+  }
+  const candidate = parsed;
+  if (candidate.version !== 1 || candidate.status !== void 0 && candidate.status !== "pending" && candidate.status !== "processed" || typeof candidate.processedHash !== "string" || typeof candidate.processedBytes !== "number" || !Number.isSafeInteger(candidate.processedBytes) || typeof candidate.processedAt !== "string" || typeof candidate.reason !== "string") {
+    return void 0;
+  }
+  const processedChunks = parseProcessedMarkerChunks(candidate.processedChunks);
+  if (candidate.processedChunks !== void 0 && processedChunks === void 0) {
+    return void 0;
+  }
+  return {
+    version: 1,
+    status: candidate.status === "pending" ? "pending" : "processed",
+    processedHash: candidate.processedHash,
+    processedBytes: candidate.processedBytes,
+    processedContent: typeof candidate.processedContent === "string" ? candidate.processedContent : void 0,
+    processedChunks,
+    processedAt: candidate.processedAt,
+    reason: candidate.reason
+  };
+}
+function parseProcessedMarkerChunks(rawChunks) {
+  if (rawChunks === void 0) return void 0;
+  if (!Array.isArray(rawChunks) || rawChunks.length === 0) return void 0;
+  const chunks = [];
+  for (const rawChunk of rawChunks) {
+    if (!rawChunk || typeof rawChunk !== "object" || Array.isArray(rawChunk)) {
+      return void 0;
+    }
+    const chunk = rawChunk;
+    if (typeof chunk.rawBytes !== "number" || !Number.isSafeInteger(chunk.rawBytes) || chunk.rawBytes <= 0 || typeof chunk.turnFingerprint !== "string" || chunk.turnFingerprint.length === 0 || typeof chunk.timestamp !== "string" || typeof chunk.chunkIndex !== "number" || !Number.isSafeInteger(chunk.chunkIndex) || chunk.chunkIndex < 0 || typeof chunk.chunkCount !== "number" || !Number.isSafeInteger(chunk.chunkCount) || chunk.chunkCount <= 0 || typeof chunk.maxTurnChars !== "number" || !Number.isSafeInteger(chunk.maxTurnChars) || chunk.maxTurnChars <= 0) {
+      return void 0;
+    }
+    chunks.push({
+      rawBytes: chunk.rawBytes,
+      turnFingerprint: chunk.turnFingerprint,
+      timestamp: chunk.timestamp,
+      chunkIndex: chunk.chunkIndex,
+      chunkCount: chunk.chunkCount,
+      maxTurnChars: chunk.maxTurnChars
+    });
+  }
+  if (chunks.some(
+    (chunk, index) => chunk.chunkIndex !== index || chunk.chunkCount !== chunks.length || chunk.maxTurnChars !== chunks[0].maxTurnChars
+  )) {
+    return void 0;
+  }
+  return chunks;
+}
+async function readProcessedMarker(markerPath) {
+  try {
+    const stat2 = await lstat2(markerPath);
+    if (stat2.isSymbolicLink() || !stat2.isFile()) return void 0;
+    return parseProcessedMarker(await fileReader(markerPath, "utf8"));
+  } catch (error) {
+    if (error?.code === "ENOENT") return void 0;
+    throw error;
+  }
+}
+async function writeProcessedMarker(params) {
+  await mkdir(path2.dirname(params.markerPath), { recursive: true });
+  const markerBody = `${JSON.stringify(params.marker, null, 2)}
+`;
+  let lastCollision;
+  for (let attempt = 0; attempt < MARKER_WRITE_TEMP_ATTEMPTS; attempt += 1) {
+    const tempPath = path2.join(
+      path2.dirname(params.markerPath),
+      `.${path2.basename(params.markerPath)}.${process.pid}.${randomUUID()}.tmp`
+    );
+    try {
+      await writeFile(tempPath, markerBody, {
+        encoding: "utf8",
+        flag: "wx",
+        mode: 384
+      });
+      try {
+        await rename(tempPath, params.markerPath);
+      } catch (error) {
+        await unlink(tempPath).catch(() => void 0);
+        throw error;
+      }
+      return;
+    } catch (error) {
+      if (error?.code === "EEXIST") {
+        lastCollision = error;
+        continue;
+      }
+      throw error;
+    }
+  }
+  throw lastCollision instanceof Error ? lastCollision : new Error("Unable to create exclusive flush-plan marker temp file");
+}
+async function removeProcessedMarker(markerPath) {
+  try {
+    await unlink(markerPath);
+  } catch (error) {
+    if (error?.code !== "ENOENT") {
+      throw error;
+    }
+  }
+}
+function isMeaningfulFlushPlanContent(content) {
+  return content.split(/\r?\n/).some((line) => {
+    const trimmed = line.trim();
+    return trimmed.length > 0 && !trimmed.startsWith("<!--");
+  });
+}
+async function isSafeFlushPlanAppendTarget(flushPlanPath) {
+  try {
+    const stat2 = await lstat2(flushPlanPath);
+    return !stat2.isSymbolicLink() && stat2.isFile();
+  } catch (error) {
+    if (error?.code === "ENOENT") return true;
+    throw error;
+  }
+}
+function reconcileOpenClawFlushPlanReplacementContent(params) {
+  if (params.preservedContent.length === 0) return void 0;
+  if (params.existingContent.startsWith(params.preservedContent)) return void 0;
+  return `${params.preservedContent}${params.existingContent}`;
+}
+async function readSafeFlushPlanReplacementContent(flushPlanPath) {
+  if (!await isSafeFlushPlanAppendTarget(flushPlanPath)) return { ok: false };
+  try {
+    return { ok: true, content: await fileReader(flushPlanPath, "utf8") };
+  } catch (error) {
+    if (error?.code === "ENOENT") {
+      return { ok: true, content: "" };
+    }
+    throw error;
+  }
+}
+async function reconcileOpenClawFlushPlanReplacementFile(params) {
+  if (params.preservedContent.length === 0) {
+    return readSafeFlushPlanReplacementContent(params.flushPlanPath);
+  }
+  const initial = await readSafeFlushPlanReplacementContent(params.flushPlanPath);
+  if (!initial.ok) return initial;
+  const initialReconciled = reconcileOpenClawFlushPlanReplacementContent({
+    existingContent: initial.content,
+    preservedContent: params.preservedContent
+  });
+  if (initialReconciled === void 0) return initial;
+  if (initial.content.length === 0) {
+    try {
+      await writeFile(params.flushPlanPath, initialReconciled, {
+        encoding: "utf8",
+        flag: "wx"
+      });
+      return { ok: true, content: initialReconciled };
+    } catch (error) {
+      if (error?.code !== "EEXIST") throw error;
+    }
+  }
+  const latest = await readSafeFlushPlanReplacementContent(params.flushPlanPath);
+  if (!latest.ok) return latest;
+  const latestReconciled = reconcileOpenClawFlushPlanReplacementContent({
+    existingContent: latest.content,
+    preservedContent: params.preservedContent
+  });
+  if (latestReconciled === void 0) return latest;
+  if (latest.content.length === 0) {
+    try {
+      await writeFile(params.flushPlanPath, latestReconciled, {
+        encoding: "utf8",
+        flag: "wx"
+      });
+      return { ok: true, content: latestReconciled };
+    } catch (error) {
+      if (error?.code !== "EEXIST") throw error;
+    }
+    const created = await readSafeFlushPlanReplacementContent(params.flushPlanPath);
+    if (!created.ok) return created;
+    const createdReconciled = reconcileOpenClawFlushPlanReplacementContent({
+      existingContent: created.content,
+      preservedContent: params.preservedContent
+    });
+    if (createdReconciled === void 0) return created;
+    if (!await isSafeFlushPlanAppendTarget(params.flushPlanPath)) return { ok: false };
+    await writeFile(params.flushPlanPath, createdReconciled, "utf8");
+    return { ok: true, content: createdReconciled };
+  }
+  if (!await isSafeFlushPlanAppendTarget(params.flushPlanPath)) return { ok: false };
+  await writeFile(params.flushPlanPath, latestReconciled, "utf8");
+  return { ok: true, content: latestReconciled };
+}
+async function reconcileExistingFlushPlanReplacement(params) {
+  const result = await reconcileOpenClawFlushPlanReplacementFile(params);
+  return result.ok;
+}
+async function validateFlushPlanLocation(params) {
+  const workspaceRoot = path2.resolve(params.workspaceDir);
+  const flushPlanDir = path2.dirname(params.flushPlanPath);
+  if (!isPathInsideOrEqual(workspaceRoot, flushPlanDir)) {
+    return {
+      status: "skipped",
+      path: params.flushPlanPath,
+      reason: "flush plan path is outside workspace"
+    };
+  }
+  let workspaceRealPath = workspaceRoot;
+  try {
+    workspaceRealPath = await realpath2(workspaceRoot);
+  } catch (error) {
+    if (error?.code !== "ENOENT") throw error;
+  }
+  const relativeDir = path2.relative(workspaceRoot, flushPlanDir);
+  const parentSegments = relativeDir.length === 0 ? [] : relativeDir.split(path2.sep).filter(Boolean);
+  let currentPath = workspaceRoot;
+  for (const segment of parentSegments) {
+    currentPath = path2.join(currentPath, segment);
+    let stat2;
+    try {
+      stat2 = await lstat2(currentPath);
+    } catch (error) {
+      if (error?.code === "ENOENT") break;
+      throw error;
+    }
+    if (stat2.isSymbolicLink()) {
+      return {
+        status: "skipped",
+        path: params.flushPlanPath,
+        reason: "flush plan parent path contains a symlink"
+      };
+    }
+    if (!stat2.isDirectory()) {
+      return {
+        status: "skipped",
+        path: params.flushPlanPath,
+        reason: "flush plan parent path is not a directory"
+      };
+    }
+    const currentRealPath = await realpath2(currentPath);
+    if (!isPathInsideOrEqual(workspaceRealPath, currentRealPath)) {
+      return {
+        status: "skipped",
+        path: params.flushPlanPath,
+        reason: "flush plan parent path escapes workspace"
+      };
+    }
+  }
+  return void 0;
+}
+async function recoverInterruptedCleanupSnapshots(params) {
+  let removedProcessedMarker = false;
+  let marker = params.marker;
+  const flushPlanDir = path2.dirname(params.flushPlanPath);
+  let entries;
+  try {
+    entries = await readdir2(flushPlanDir, { withFileTypes: true });
+  } catch (error) {
+    if (error?.code === "ENOENT") {
+      return { removedProcessedMarker };
+    }
+    throw error;
+  }
+  const cleanupPaths = entries.filter((entry) => isCleanupSnapshotName(entry.name)).map((entry) => path2.join(flushPlanDir, entry.name)).sort(compareCleanupSnapshotsNewestFirst);
+  if (cleanupPaths.length === 0) return { removedProcessedMarker };
+  if (!await isSafeFlushPlanAppendTarget(params.flushPlanPath)) {
+    params.logger?.warn(
+      "OpenClaw flush-plan cleanup recovery skipped because flush-plan.md is not a regular file"
+    );
+    return { removedProcessedMarker };
+  }
+  let currentContent;
+  try {
+    currentContent = await fileReader(params.flushPlanPath, "utf8");
+  } catch (error) {
+    if (error?.code !== "ENOENT") throw error;
+  }
+  for (const cleanupPath of cleanupPaths) {
+    let stat2;
+    try {
+      stat2 = await lstat2(cleanupPath);
+    } catch (error) {
+      if (error?.code === "ENOENT") continue;
+      throw error;
+    }
+    if (stat2.isSymbolicLink() || !stat2.isFile()) {
+      params.logger?.warn(
+        `OpenClaw flush-plan cleanup recovery skipped unsafe snapshot ${path2.basename(cleanupPath)}`
+      );
+      continue;
+    }
+    const cleanupContent = await fileReader(cleanupPath, "utf8");
+    if (marker?.processedContent && cleanupContent.startsWith(marker.processedContent)) {
+      const restoredTail = cleanupContent.slice(marker.processedContent.length);
+      if (restoredTail.length > 0) {
+        const reconciled = await reconcileOpenClawFlushPlanReplacementFile({
+          flushPlanPath: params.flushPlanPath,
+          preservedContent: restoredTail
+        });
+        if (!reconciled.ok) {
+          params.logger?.warn(
+            "OpenClaw flush-plan cleanup recovery paused because flush-plan.md is no longer a regular file"
+          );
+          return { removedProcessedMarker };
+        }
+        currentContent = reconciled.content;
+      }
+      await unlink(cleanupPath);
+      if (params.markerPath) {
+        await removeProcessedMarker(params.markerPath);
+        removedProcessedMarker = true;
+        marker = void 0;
+      }
+      params.logger?.warn(
+        `Recovered interrupted OpenClaw flush-plan cleanup snapshot ${path2.basename(cleanupPath)}`
+      );
+      continue;
+    }
+    if (cleanupContent.length > 0) {
+      const reconciled = await reconcileOpenClawFlushPlanReplacementFile({
+        flushPlanPath: params.flushPlanPath,
+        preservedContent: cleanupContent
+      });
+      if (!reconciled.ok) {
+        params.logger?.warn(
+          "OpenClaw flush-plan cleanup recovery paused because flush-plan.md is no longer a regular file"
+        );
+        return { removedProcessedMarker };
+      }
+      currentContent = reconciled.content;
+    }
+    await unlink(cleanupPath);
+    params.logger?.warn(
+      `Recovered interrupted OpenClaw flush-plan cleanup snapshot ${path2.basename(cleanupPath)}`
+    );
+  }
+  return { removedProcessedMarker };
+}
+function normalizeMaxTurnChars(maxTurnChars) {
+  return typeof maxTurnChars === "number" && Number.isFinite(maxTurnChars) && maxTurnChars > 0 ? Math.floor(maxTurnChars) : DEFAULT_MAX_IMPORT_TURN_CHARS;
+}
+function flushPlanImportPrefix(params) {
+  const verbose = params.chunkCount > 1 ? `${FLUSH_PLAN_IMPORT_INSTRUCTION} This is chunk ${params.chunkIndex + 1} of ${params.chunkCount}; extract it independently.
+
+` : `${FLUSH_PLAN_IMPORT_INSTRUCTION}
+
+`;
+  if (verbose.length < params.maxTurnChars) return verbose;
+  const compact = params.chunkCount > 1 ? `OpenClaw flush-plan chunk ${params.chunkIndex + 1}/${params.chunkCount}.
+
+` : "OpenClaw flush-plan snapshot.\n\n";
+  if (compact.length < params.maxTurnChars) return compact;
+  return "";
+}
+function splitTextByMaxChars(content, maxChars) {
+  const chunks = [];
+  let offset = 0;
+  while (offset < content.length) {
+    let end = Math.min(offset + maxChars, content.length);
+    if (end < content.length) {
+      const newline = content.lastIndexOf("\n", end);
+      if (newline > offset) {
+        end = newline + 1;
+      }
+    }
+    chunks.push(content.slice(offset, end));
+    offset = end;
+  }
+  return chunks.filter((chunk) => chunk.trim().length > 0);
+}
+function splitFlushPlanContentIntoChunks(params) {
+  const trimmed = params.content.trim();
+  if (trimmed.length === 0) return [];
+  let chunkCount = 1;
+  for (let attempt = 0; attempt < 8; attempt += 1) {
+    const maxPrefixChars2 = Math.max(
+      ...Array.from(
+        { length: chunkCount },
+        (_, chunkIndex) => flushPlanImportPrefix({
+          chunkIndex,
+          chunkCount,
+          maxTurnChars: params.maxTurnChars
+        }).length
+      )
+    );
+    const maxChunkChars = Math.max(1, params.maxTurnChars - maxPrefixChars2);
+    const chunks = splitTextByMaxChars(trimmed, maxChunkChars);
+    if (chunks.length === chunkCount) return chunks;
+    chunkCount = Math.max(1, chunks.length);
+  }
+  const maxPrefixChars = flushPlanImportPrefix({
+    chunkIndex: chunkCount - 1,
+    chunkCount,
+    maxTurnChars: params.maxTurnChars
+  }).length;
+  return splitTextByMaxChars(trimmed, Math.max(1, params.maxTurnChars - maxPrefixChars));
+}
+function buildFlushPlanImportTurn(params) {
+  const prefix = flushPlanImportPrefix({
+    chunkIndex: params.chunkIndex,
+    chunkCount: params.chunkCount,
+    maxTurnChars: params.maxTurnChars
+  });
+  return {
+    role: "user",
+    timestamp: params.turnTimestamp ?? params.importedAt,
+    participantId: "openclaw-memory-flush-plan",
+    participantName: "OpenClaw memory flush planner",
+    content: `${prefix}${params.content.trim()}`,
+    sourceFormat: "openclaw",
+    rawContent: params.content,
+    importProvenance: {
+      sourceLabel: "OpenClaw flush plan",
+      sourceId: params.chunkCount > 1 ? `${params.serviceId}:flush-plan:${params.chunkIndex + 1}/${params.chunkCount}` : `${params.serviceId}:flush-plan`,
+      sourceTimestamp: params.importedAt,
+      importedFromPath: params.flushPlanPath,
+      importedAt: params.importedAt,
+      metadata: {
+        serviceId: params.serviceId,
+        reason: params.reason,
+        bytes: Buffer.byteLength(params.content, "utf8"),
+        chunkIndex: params.chunkIndex,
+        chunkCount: params.chunkCount,
+        maxTurnChars: params.maxTurnChars
+      }
+    },
+    turnFingerprint: params.turnFingerprint ?? hashContent(
+      [
+        "openclaw-flush-plan",
+        params.serviceId,
+        params.fingerprintPath,
+        params.content
+      ].join("\n")
+    ),
+    persistProcessedFingerprint: true
+  };
+}
+function timestampForFlushPlanChunk(importedAt, chunkIndex) {
+  const importedAtMs = Date.parse(importedAt);
+  if (!Number.isFinite(importedAtMs)) return importedAt;
+  return new Date(importedAtMs + chunkIndex).toISOString();
+}
+function isFailedIngestResult(result) {
+  return Boolean(
+    result && typeof result === "object" && typeof result.failedCount === "number" && result.failedCount > 0
+  );
+}
+function partialIngestResultFromError(error) {
+  if (!error || typeof error !== "object") return void 0;
+  const partialResult = error.partialResult;
+  if (!partialResult || typeof partialResult !== "object") return void 0;
+  return partialResult;
+}
+async function ingestFlushPlanImportTurns(params) {
+  try {
+    return await params.ingestor.ingestBulkImportBatch(params.importTurns, {
+      ...params.deadlineMs === void 0 ? {} : { deadlineMs: params.deadlineMs },
+      failOnExtractionFailure: true,
+      includeSourceValidAtContext: false
+    });
+  } catch (error) {
+    const partialResult = partialIngestResultFromError(error);
+    if (partialResult && typeof partialResult.processedTurnCount === "number" && partialResult.processedTurnCount > 0) {
+      return partialResult;
+    }
+    throw error;
+  }
+}
+function hasPostPersistMetadataFailure(result) {
+  return Boolean(
+    result && typeof result === "object" && typeof result.postPersistMetadataFailureCount === "number" && result.postPersistMetadataFailureCount > 0
+  );
+}
+function processedPrefixFromPartialIngest(params) {
+  if (!isFailedIngestResult(params.ingestResult)) return void 0;
+  const processedTurnCount = typeof params.ingestResult?.processedTurnCount === "number" ? Math.max(0, Math.floor(params.ingestResult.processedTurnCount)) : 0;
+  if (processedTurnCount <= 0) return void 0;
+  const processedContent = params.importTurns.slice(0, Math.min(processedTurnCount, params.importTurns.length)).map(
+    (turn) => typeof turn.rawContent === "string" ? turn.rawContent : turn.content
+  ).join("");
+  if (processedContent.length === 0) return void 0;
+  if (params.content.startsWith(processedContent)) return processedContent;
+  const leadingWhitespaceLength = params.content.length - params.content.trimStart().length;
+  if (leadingWhitespaceLength > 0) {
+    const withLeadingWhitespace = params.content.slice(
+      0,
+      leadingWhitespaceLength + processedContent.length
+    );
+    if (withLeadingWhitespace.slice(leadingWhitespaceLength) === processedContent) {
+      return withLeadingWhitespace;
+    }
+  }
+  return void 0;
+}
+async function handleFlushPlanIngestResult(params) {
+  const partialProcessedPrefix = processedPrefixFromPartialIngest({
+    content: params.content,
+    importTurns: params.importTurns,
+    ingestResult: params.ingestResult
+  });
+  if (partialProcessedPrefix) {
+    params.logger?.warn(
+      "OpenClaw flush-plan partially imported; preserving unprocessed tail for retry"
+    );
+    if (hasPostPersistMetadataFailure(params.ingestResult)) {
+      return await deferProcessedFlushPlanCleanupForMetadataFailure({
+        flushPlanPath: params.flushPlanPath,
+        markerPath: params.markerPath,
+        content: partialProcessedPrefix,
+        processedAt: params.processedAt,
+        reason: params.reason,
+        importTurns: params.importTurns
+      });
+    }
+    await writeProcessedMarker({
+      markerPath: params.markerPath,
+      marker: buildProcessedMarker({
+        status: "processed",
+        content: partialProcessedPrefix,
+        processedAt: params.processedAt,
+        reason: params.reason,
+        importTurns: params.importTurns
+      })
+    });
+    const result = await removeProcessedFlushPlanPrefix({
+      flushPlanPath: params.flushPlanPath,
+      processedPrefix: partialProcessedPrefix
+    });
+    if (result.status === "processed_cleanup_deferred") {
+      params.logger?.warn(
+        `OpenClaw flush-plan processed but cleanup deferred: ${result.reason}`
+      );
+    } else {
+      await removeProcessedMarker(params.markerPath);
+    }
+    return result;
+  }
+  if (isFailedIngestResult(params.ingestResult)) {
+    throw new Error("OpenClaw flush-plan import failed");
+  }
+  if (hasPostPersistMetadataFailure(params.ingestResult)) {
+    return await deferProcessedFlushPlanCleanupForMetadataFailure({
+      flushPlanPath: params.flushPlanPath,
+      markerPath: params.markerPath,
+      content: params.content,
+      processedAt: params.processedAt,
+      reason: params.reason,
+      importTurns: params.importTurns
+    });
+  }
+  return void 0;
+}
+function buildProcessedMarker(params) {
+  return {
+    version: 1,
+    status: params.status,
+    processedHash: hashContent(params.content),
+    processedBytes: Buffer.byteLength(params.content, "utf8"),
+    processedContent: params.content,
+    processedChunks: buildProcessedMarkerChunks({
+      content: params.content,
+      importTurns: params.importTurns
+    }),
+    processedAt: params.processedAt,
+    reason: params.reason
+  };
+}
+function buildProcessedMarkerChunks(params) {
+  if (!params.importTurns || params.importTurns.length === 0) return void 0;
+  const importedContent = params.content.trim();
+  if (importedContent.length === 0) return void 0;
+  const chunks = [];
+  let reconstructed = "";
+  for (const [index, turn] of params.importTurns.entries()) {
+    if (typeof turn.rawContent !== "string" || typeof turn.turnFingerprint !== "string") {
+      return void 0;
+    }
+    const nextReconstructed = `${reconstructed}${turn.rawContent}`;
+    if (!importedContent.startsWith(nextReconstructed)) return void 0;
+    const metadata = turn.importProvenance?.metadata && typeof turn.importProvenance.metadata === "object" && !Array.isArray(turn.importProvenance.metadata) ? turn.importProvenance.metadata : void 0;
+    const chunkIndex = typeof metadata?.chunkIndex === "number" && Number.isSafeInteger(metadata.chunkIndex) ? metadata.chunkIndex : index;
+    const chunkCount = typeof metadata?.chunkCount === "number" && Number.isSafeInteger(metadata.chunkCount) ? metadata.chunkCount : params.importTurns.length;
+    const maxTurnChars = typeof metadata?.maxTurnChars === "number" && Number.isSafeInteger(metadata.maxTurnChars) ? metadata.maxTurnChars : DEFAULT_MAX_IMPORT_TURN_CHARS;
+    chunks.push({
+      rawBytes: Buffer.byteLength(turn.rawContent, "utf8"),
+      turnFingerprint: turn.turnFingerprint,
+      timestamp: turn.timestamp ?? "",
+      chunkIndex,
+      chunkCount,
+      maxTurnChars
+    });
+    reconstructed = nextReconstructed;
+    if (reconstructed === importedContent) break;
+  }
+  if (reconstructed !== importedContent) return void 0;
+  if (chunks.length === 0 || chunks.some(
+    (chunk, index) => chunk.chunkIndex !== index || chunk.chunkCount !== chunks.length || chunk.maxTurnChars !== chunks[0].maxTurnChars || chunk.timestamp.length === 0
+  )) {
+    return void 0;
+  }
+  return chunks;
+}
+async function deferProcessedFlushPlanCleanupForMetadataFailure(params) {
+  await writeProcessedMarker({
+    markerPath: params.markerPath,
+    marker: buildProcessedMarker({
+      status: "processed",
+      content: params.content,
+      processedAt: params.processedAt,
+      reason: params.reason,
+      importTurns: params.importTurns
+    })
+  });
+  return {
+    status: "processed_cleanup_deferred",
+    path: params.flushPlanPath,
+    bytesProcessed: Buffer.byteLength(params.content, "utf8"),
+    reason: FLUSH_PLAN_METADATA_FAILURE_CLEANUP_DEFERRED_REASON
+  };
+}
+function buildFlushPlanImportTurns(params) {
+  const maxTurnChars = normalizeMaxTurnChars(params.maxTurnChars);
+  const chunks = splitFlushPlanContentIntoChunks({
+    content: params.content,
+    maxTurnChars
+  });
+  return chunks.map(
+    (chunk, chunkIndex) => buildFlushPlanImportTurn({
+      content: chunk,
+      flushPlanPath: params.flushPlanPath,
+      fingerprintPath: params.fingerprintPath,
+      serviceId: params.serviceId,
+      importedAt: params.importedAt,
+      turnTimestamp: timestampForFlushPlanChunk(params.importedAt, chunkIndex),
+      reason: params.reason,
+      chunkIndex,
+      chunkCount: chunks.length,
+      maxTurnChars
+    })
+  );
+}
+async function readFlushPlanSnapshot(flushPlanPath) {
+  let stat2;
+  try {
+    stat2 = await lstat2(flushPlanPath);
+  } catch (error) {
+    if (error?.code === "ENOENT") {
+      return { status: "missing", path: flushPlanPath };
+    }
+    throw error;
+  }
+  if (stat2.isSymbolicLink()) {
+    return {
+      status: "skipped",
+      path: flushPlanPath,
+      reason: "flush plan path is a symlink"
+    };
+  }
+  if (!stat2.isFile()) {
+    return {
+      status: "skipped",
+      path: flushPlanPath,
+      reason: "flush plan path is not a regular file"
+    };
+  }
+  const content = await fileReader(flushPlanPath, "utf8");
+  if (!isMeaningfulFlushPlanContent(content)) {
+    return { status: "empty", path: flushPlanPath };
+  }
+  return { status: "ok", content };
+}
+function findProcessedMarkerPrefix(params) {
+  const processedPrefix = utf8PrefixByByteLength(
+    params.content,
+    params.marker.processedBytes
+  );
+  if (processedPrefix !== void 0 && hashContent(processedPrefix) === params.marker.processedHash) {
+    return processedPrefix;
+  }
+  if (params.marker.processedContent && params.content.startsWith(params.marker.processedContent) && hashContent(params.marker.processedContent) === params.marker.processedHash) {
+    return params.marker.processedContent;
+  }
+  return void 0;
+}
+function splitContentByMarkerChunks(params) {
+  const buffer = Buffer.from(params.content, "utf8");
+  let offset = 0;
+  const contentChunks = [];
+  for (const chunk of params.chunks) {
+    const nextOffset = offset + chunk.rawBytes;
+    if (nextOffset > buffer.length) return void 0;
+    const contentChunk = buffer.subarray(offset, nextOffset).toString("utf8");
+    if (Buffer.byteLength(contentChunk, "utf8") !== chunk.rawBytes) {
+      return void 0;
+    }
+    contentChunks.push(contentChunk);
+    offset = nextOffset;
+  }
+  if (offset !== buffer.length) return void 0;
+  return contentChunks;
+}
+function buildFlushPlanImportTurnsFromMarker(params) {
+  if (!params.marker.processedChunks) return void 0;
+  const contentChunks = splitContentByMarkerChunks({
+    content: params.content.trim(),
+    chunks: params.marker.processedChunks
+  });
+  if (!contentChunks) return void 0;
+  return params.marker.processedChunks.map(
+    (chunk, index) => buildFlushPlanImportTurn({
+      content: contentChunks[index],
+      flushPlanPath: params.flushPlanPath,
+      fingerprintPath: params.fingerprintPath,
+      serviceId: params.serviceId,
+      importedAt: params.marker.processedAt,
+      turnTimestamp: chunk.timestamp,
+      turnFingerprint: chunk.turnFingerprint,
+      reason: params.marker.reason,
+      chunkIndex: chunk.chunkIndex,
+      chunkCount: chunk.chunkCount,
+      maxTurnChars: chunk.maxTurnChars
+    })
+  );
+}
+async function removeProcessedFlushPlanContent(params) {
+  const processedBytes = Buffer.byteLength(params.processedContent, "utf8");
+  let cleanupPath;
+  try {
+    const stat2 = await lstat2(params.flushPlanPath);
+    if (stat2.isSymbolicLink()) {
+      return {
+        status: "processed_cleanup_deferred",
+        path: params.flushPlanPath,
+        bytesProcessed: processedBytes,
+        reason: "flush plan path became a symlink before cleanup"
+      };
+    }
+    if (!stat2.isFile()) {
+      return {
+        status: "processed_cleanup_deferred",
+        path: params.flushPlanPath,
+        bytesProcessed: processedBytes,
+        reason: "flush plan path stopped being a regular file before cleanup"
+      };
+    }
+    cleanupPath = resolveCleanupSnapshotPath(params.flushPlanPath);
+    await rename(params.flushPlanPath, cleanupPath);
+  } catch (error) {
+    if (error?.code === "ENOENT") {
+      return {
+        status: "processed",
+        path: params.flushPlanPath,
+        bytesProcessed: processedBytes
+      };
+    }
+    throw error;
+  }
+  try {
+    await writeFile(params.flushPlanPath, "", { encoding: "utf8", flag: "wx" });
+  } catch (error) {
+    if (error?.code !== "EEXIST") {
+      throw error;
+    }
+  }
+  const current = await fileReader(cleanupPath, "utf8");
+  const processedStatus = params.recoveredFromMarker ? "processed_marker_recovered" : "processed";
+  const preservedTailStatus = params.recoveredFromMarker ? "processed_marker_recovered_tail" : "processed_preserved_tail";
+  const matchIndex = current === params.processedContent || current.startsWith(params.processedContent) ? 0 : params.allowNonPrefixMatch ? current.indexOf(params.processedContent) : -1;
+  if (matchIndex >= 0) {
+    const preservedContent = current.slice(0, matchIndex) + current.slice(matchIndex + params.processedContent.length);
+    if (preservedContent.length > 0) {
+      const reconciled2 = await reconcileExistingFlushPlanReplacement({
+        flushPlanPath: params.flushPlanPath,
+        preservedContent
+      });
+      if (!reconciled2) {
+        return {
+          status: "processed_cleanup_deferred",
+          path: params.flushPlanPath,
+          bytesProcessed: processedBytes,
+          reason: "flush plan path was recreated as an unsafe target during cleanup"
+        };
+      }
+    }
+    await unlink(cleanupPath);
+    return {
+      status: preservedContent.length > 0 ? preservedTailStatus : processedStatus,
+      path: params.flushPlanPath,
+      bytesProcessed: processedBytes,
+      preservedBytes: preservedContent.length > 0 ? Buffer.byteLength(preservedContent, "utf8") : void 0
+    };
+  }
+  const reconciled = await reconcileExistingFlushPlanReplacement({
+    flushPlanPath: params.flushPlanPath,
+    preservedContent: current
+  });
+  if (!reconciled) {
+    return {
+      status: "processed_cleanup_deferred",
+      path: params.flushPlanPath,
+      bytesProcessed: processedBytes,
+      reason: "flush plan path was recreated as an unsafe target during cleanup"
+    };
+  }
+  await unlink(cleanupPath);
+  return {
+    status: "processed_cleanup_deferred",
+    path: params.flushPlanPath,
+    bytesProcessed: processedBytes,
+    reason: FLUSH_PLAN_CHANGED_BEFORE_CLEANUP_REASON
+  };
+}
+async function removeProcessedFlushPlanPrefix(params) {
+  return removeProcessedFlushPlanContent({
+    flushPlanPath: params.flushPlanPath,
+    processedContent: params.processedPrefix,
+    recoveredFromMarker: params.recoveredFromMarker,
+    allowNonPrefixMatch: false
+  });
+}
+async function recoverProcessedFlushPlanPrefix(params) {
+  const processedPrefix = findProcessedMarkerPrefix({
+    content: params.content,
+    marker: params.marker
+  });
+  if (processedPrefix) {
+    const result = await removeProcessedFlushPlanPrefix({
+      flushPlanPath: params.flushPlanPath,
+      processedPrefix,
+      recoveredFromMarker: true
+    });
+    if (result.status !== "processed_cleanup_deferred") {
+      await removeProcessedMarker(params.markerPath);
+    }
+    return result;
+  }
+  await removeProcessedMarker(params.markerPath);
+  return void 0;
+}
+async function recoverPendingFlushPlanImport(params) {
+  const processedPrefix = findProcessedMarkerPrefix({
+    content: params.content,
+    marker: params.marker
+  });
+  if (!processedPrefix) {
+    await removeProcessedMarker(params.markerPath);
+    return void 0;
+  }
+  const importTurns = buildFlushPlanImportTurnsFromMarker({
+    content: processedPrefix,
+    marker: params.marker,
+    flushPlanPath: params.flushPlanPath,
+    fingerprintPath: params.fingerprintPath,
+    serviceId: params.serviceId
+  }) ?? buildFlushPlanImportTurns({
+    content: processedPrefix,
+    flushPlanPath: params.flushPlanPath,
+    fingerprintPath: params.fingerprintPath,
+    serviceId: params.serviceId,
+    importedAt: params.marker.processedAt,
+    reason: params.marker.reason,
+    maxTurnChars: params.maxTurnChars
+  });
+  const ingestResult = await ingestFlushPlanImportTurns({
+    ingestor: params.ingestor,
+    importTurns,
+    deadlineMs: params.deadlineMs
+  });
+  const handledResult = await handleFlushPlanIngestResult({
+    ingestResult,
+    importTurns,
+    content: processedPrefix,
+    flushPlanPath: params.flushPlanPath,
+    markerPath: params.markerPath,
+    processedAt: params.marker.processedAt,
+    reason: params.marker.reason,
+    logger: params.logger
+  });
+  if (handledResult) return handledResult;
+  await writeProcessedMarker({
+    markerPath: params.markerPath,
+    marker: buildProcessedMarker({
+      status: "processed",
+      content: processedPrefix,
+      processedAt: params.marker.processedAt,
+      reason: params.marker.reason,
+      importTurns
+    })
+  });
+  const result = await removeProcessedFlushPlanPrefix({
+    flushPlanPath: params.flushPlanPath,
+    processedPrefix,
+    recoveredFromMarker: true
+  });
+  if (result.status === "processed_cleanup_deferred") {
+    params.logger?.warn(
+      `OpenClaw flush-plan processed but cleanup deferred: ${result.reason}`
+    );
+  } else {
+    await removeProcessedMarker(params.markerPath);
+  }
+  return result;
+}
+async function resolveFlushPlanFingerprintPath(params) {
+  const workspaceRoot = path2.resolve(params.workspaceDir);
+  const flushPlanPath = path2.resolve(params.flushPlanPath);
+  const relativeFlushPlanPath = path2.relative(workspaceRoot, flushPlanPath);
+  if (relativeFlushPlanPath.length > 0 && !relativeFlushPlanPath.startsWith("..") && !path2.isAbsolute(relativeFlushPlanPath)) {
+    try {
+      return path2.resolve(await realpath2(workspaceRoot), relativeFlushPlanPath);
+    } catch (error) {
+      if (error?.code !== "ENOENT") throw error;
+    }
+  }
+  try {
+    return await realpath2(flushPlanPath);
+  } catch (error) {
+    if (error?.code !== "ENOENT") throw error;
+    return flushPlanPath;
+  }
+}
+async function processOpenClawFlushPlanFile(params) {
+  if (!params.enabled) return { status: "disabled" };
+  const flushPlanPath = resolveOpenClawFlushPlanPath({
+    workspaceDir: params.workspaceDir,
+    serviceId: params.serviceId
+  });
+  const unsafeLocation = await validateFlushPlanLocation({
+    workspaceDir: params.workspaceDir,
+    flushPlanPath
+  });
+  if (unsafeLocation) return unsafeLocation;
+  const markerPath = resolveProcessedMarkerPath(flushPlanPath);
+  const processedMarker = await readProcessedMarker(markerPath);
+  const cleanupRecovery = await recoverInterruptedCleanupSnapshots({
+    flushPlanPath,
+    logger: params.logger,
+    marker: processedMarker,
+    markerPath
+  });
+  const activeProcessedMarker = cleanupRecovery.removedProcessedMarker ? void 0 : processedMarker;
+  const snapshot = await readFlushPlanSnapshot(flushPlanPath);
+  if (snapshot.status !== "ok") {
+    if (activeProcessedMarker && (snapshot.status === "empty" || snapshot.status === "missing")) {
+      await removeProcessedMarker(markerPath);
+    }
+    return snapshot;
+  }
+  const fingerprintPath = await resolveFlushPlanFingerprintPath({
+    workspaceDir: params.workspaceDir,
+    flushPlanPath
+  });
+  if (activeProcessedMarker) {
+    const recovered = activeProcessedMarker.status === "pending" ? await recoverPendingFlushPlanImport({
+      flushPlanPath,
+      fingerprintPath,
+      markerPath,
+      content: snapshot.content,
+      marker: activeProcessedMarker,
+      serviceId: params.serviceId,
+      ingestor: params.ingestor,
+      deadlineMs: params.deadlineMs,
+      maxTurnChars: params.maxTurnChars,
+      logger: params.logger
+    }) : await recoverProcessedFlushPlanPrefix({
+      flushPlanPath,
+      markerPath,
+      content: snapshot.content,
+      marker: activeProcessedMarker
+    });
+    if (recovered) return recovered;
+  }
+  const importedAt = (params.now ?? (() => /* @__PURE__ */ new Date()))().toISOString();
+  const reason = params.reason ?? "openclaw-flush-plan";
+  const importTurns = buildFlushPlanImportTurns({
+    content: snapshot.content,
+    flushPlanPath,
+    fingerprintPath,
+    serviceId: params.serviceId,
+    importedAt,
+    reason,
+    maxTurnChars: params.maxTurnChars
+  });
+  await mkdir(path2.dirname(flushPlanPath), { recursive: true });
+  await writeProcessedMarker({
+    markerPath,
+    marker: buildProcessedMarker({
+      status: "pending",
+      content: snapshot.content,
+      processedAt: importedAt,
+      reason,
+      importTurns
+    })
+  });
+  const ingestResult = await ingestFlushPlanImportTurns({
+    ingestor: params.ingestor,
+    importTurns,
+    deadlineMs: params.deadlineMs
+  });
+  const handledResult = await handleFlushPlanIngestResult({
+    ingestResult,
+    importTurns,
+    content: snapshot.content,
+    flushPlanPath,
+    markerPath,
+    processedAt: importedAt,
+    reason,
+    logger: params.logger
+  });
+  if (handledResult) return handledResult;
+  await writeProcessedMarker({
+    markerPath,
+    marker: buildProcessedMarker({
+      status: "processed",
+      content: snapshot.content,
+      processedAt: importedAt,
+      reason,
+      importTurns
+    })
+  });
+  const result = await removeProcessedFlushPlanPrefix({
+    flushPlanPath,
+    processedPrefix: snapshot.content
+  });
+  if (result.status === "processed_cleanup_deferred") {
+    params.logger?.warn(
+      `OpenClaw flush-plan processed but cleanup deferred: ${result.reason}`
+    );
+  } else {
+    await removeProcessedMarker(markerPath);
+  }
+  return result;
+}
+
 // src/plugin-id.ts
 import { resolvePluginEntry } from "@remnic/core/plugin-entry-resolver";
 var REMNIC_OPENCLAW_PLUGIN_ID = "openclaw-remnic";
@@ -4139,23 +5247,23 @@ __export(resolve_provider_secret_exports, {
   findGatewayRuntimeModules: () => findGatewayRuntimeModules
 });
 __reExport(resolve_provider_secret_exports, resolve_provider_secret_star);
-import path2 from "path";
+import path3 from "path";
 import * as resolve_provider_secret_star from "@remnic/core/resolve-provider-secret";
 async function findGatewayRuntimeModules(filePrefix) {
   const { existsSync, ["re"+"ad"+"Fi"+"le"+"Sync"]: fileReaderSync, readdirSync, realpathSync } = await import("fs");
   const { createRequire: createRequire2 } = await import("module");
   const candidates = [];
   const isWithinRoot = (root, candidate) => {
-    const relative = path2.relative(root, candidate);
-    return relative.length === 0 || !relative.startsWith("..") && !path2.isAbsolute(relative);
+    const relative = path3.relative(root, candidate);
+    return relative.length === 0 || !relative.startsWith("..") && !path3.isAbsolute(relative);
   };
   let packageRoot;
   try {
     const req = createRequire2(import.meta.url);
     const openclawEntrypoint = realpathSync(req.resolve("openclaw"));
-    let currentDir = path2.dirname(openclawEntrypoint);
+    let currentDir = path3.dirname(openclawEntrypoint);
     while (true) {
-      const packageJsonPath = path2.join(currentDir, "package.json");
+      const packageJsonPath = path3.join(currentDir, "package.json");
       if (existsSync(packageJsonPath)) {
         const packageJson = JSON.parse(fileReaderSync(packageJsonPath, "utf8"));
         if (packageJson.name !== "openclaw") {
@@ -4164,7 +5272,7 @@ async function findGatewayRuntimeModules(filePrefix) {
         packageRoot = realpathSync(currentDir);
         break;
       }
-      const parent = path2.dirname(currentDir);
+      const parent = path3.dirname(currentDir);
       if (parent === currentDir) {
         return [];
       }
@@ -4174,14 +5282,14 @@ async function findGatewayRuntimeModules(filePrefix) {
     return [];
   }
   try {
-    const distDir = realpathSync(path2.join(packageRoot, "dist"));
+    const distDir = realpathSync(path3.join(packageRoot, "dist"));
     if (!isWithinRoot(packageRoot, distDir)) {
       return [];
     }
     const files = readdirSync(distDir);
     for (const f of files) {
       if (f.startsWith(filePrefix) && f.endsWith(".js")) {
-        const candidate = realpathSync(path2.join(distDir, f));
+        const candidate = realpathSync(path3.join(distDir, f));
         if (isWithinRoot(packageRoot, candidate) && isWithinRoot(distDir, candidate)) {
           candidates.push(candidate);
         }
@@ -4515,6 +5623,7 @@ function buildServiceKeys(serviceId) {
     ACCESS_SERVICE: `__openclawEngramAccessService${suffix}`,
     ACCESS_HTTP_SERVER: `__openclawEngramAccessHttpServer${suffix}`,
     ACCESS_HTTP_AUTH_STATE: `__openclawEngramAccessHttpAuthState${suffix}`,
+    FLUSH_PLAN_PROCESSING_CHAINS: `__openclawEngramFlushPlanProcessingChains${suffix}`,
     SERVICE_STARTED: `__openclawEngramServiceStarted${suffix}`,
     INIT_PROMISE: `__openclawEngramInitPromise${suffix}`,
     ORCHESTRATOR: `__openclawEngramOrchestrator${suffix}`
@@ -4525,7 +5634,7 @@ function resolveOpenClawConfigFilePath() {
   if (explicitConfigPath && explicitConfigPath.length > 0) {
     return expandTildePath(explicitConfigPath);
   }
-  return path3.join(resolveHomeDir(), ".openclaw", "openclaw.json");
+  return path4.join(resolveHomeDir(), ".openclaw", "openclaw.json");
 }
 function coerceRawConfigBoolean(value) {
   if (typeof value === "boolean") return value;
@@ -4568,7 +5677,7 @@ function readPluginHooksPolicy(apiConfig, pluginId) {
 }
 async function maybeRegisterLiveConnectorCron(orchestrator) {
   if (!hasEnabledLiveConnectorConfig(orchestrator.config.connectors)) return;
-  const jobsPath = path3.join(resolveHomeDir(), ".openclaw", "cron", "jobs.json");
+  const jobsPath = path4.join(resolveHomeDir(), ".openclaw", "cron", "jobs.json");
   try {
     if (!fileExistsNow(jobsPath)) {
       logger_exports.log.debug("live connectors cron: jobs.json not found, skipping auto-register");
@@ -4829,7 +5938,7 @@ function stableOpenClawConfigSignature(value, seen = /* @__PURE__ */ new WeakSet
   return JSON.stringify(String(value));
 }
 function openClawHostEmbeddingConfigSignature(cfg, apiConfig, workspaceDir) {
-  return `sha256:${createHash2("sha256").update(JSON.stringify({
+  return `sha256:${createHash3("sha256").update(JSON.stringify({
     enabled: cfg.hostEmbeddingProviderEnabled !== false,
     memoryDir: cfg.memoryDir,
     providerId: cfg.hostEmbeddingProviderId ?? "",
@@ -4956,6 +6065,7 @@ var pluginDefinition = {
       void migrationPromise;
     }
     const fileConfig = loadPluginConfigFromFile(serviceId);
+    const openclawFlushPlanProcessingEnabled = resolveOpenClawFlushPlanProcessingEnabledFromConfig(fileConfig, api.pluginConfig);
     const cfg = (0, config_exports.parseConfig)({
       ...fileConfig,
       // File-backed fallback for runtimes that omit pluginConfig
@@ -5070,9 +6180,9 @@ var pluginDefinition = {
       emitLegacyTools: cfg.emitLegacyTools
     });
     globalThis[keys.ACCESS_HTTP_SERVER] = accessHttpServer;
-    const pluginStateDir = path3.join(cfg.memoryDir, "state", "plugins", serviceId);
-    const togglePrimaryPath = path3.join(pluginStateDir, "session-toggles.json");
-    const toggleSecondaryPath = cfg.respectBundledActiveMemoryToggle ? path3.join(cfg.memoryDir, "state", "plugins", "active-memory", "session-toggles.json") : void 0;
+    const pluginStateDir = path4.join(cfg.memoryDir, "state", "plugins", serviceId);
+    const togglePrimaryPath = path4.join(pluginStateDir, "session-toggles.json");
+    const toggleSecondaryPath = cfg.respectBundledActiveMemoryToggle ? path4.join(cfg.memoryDir, "state", "plugins", "active-memory", "session-toggles.json") : void 0;
     const sessionToggleStore = createFileToggleStore(togglePrimaryPath, {
       secondaryReadOnlyPath: toggleSecondaryPath
     });
@@ -5094,11 +6204,103 @@ var pluginDefinition = {
     }
     function resolveDreamJournalPath(runtimeWorkspaceDir) {
       const workspaceRoot = resolveWorkspaceRoot(runtimeWorkspaceDir);
-      return path3.isAbsolute(cfg.dreaming.journalPath) ? cfg.dreaming.journalPath : path3.join(workspaceRoot, cfg.dreaming.journalPath);
+      return path4.isAbsolute(cfg.dreaming.journalPath) ? cfg.dreaming.journalPath : path4.join(workspaceRoot, cfg.dreaming.journalPath);
     }
     function resolveHeartbeatJournalPath(runtimeWorkspaceDir) {
       const workspaceRoot = resolveWorkspaceRoot(runtimeWorkspaceDir);
-      return path3.isAbsolute(cfg.heartbeat.journalPath) ? cfg.heartbeat.journalPath : path3.join(workspaceRoot, cfg.heartbeat.journalPath);
+      return path4.isAbsolute(cfg.heartbeat.journalPath) ? cfg.heartbeat.journalPath : path4.join(workspaceRoot, cfg.heartbeat.journalPath);
+    }
+    const existingFlushPlanProcessingChains = globalThis[keys.FLUSH_PLAN_PROCESSING_CHAINS];
+    const flushPlanProcessingChains = existingFlushPlanProcessingChains instanceof Map ? existingFlushPlanProcessingChains : /* @__PURE__ */ new Map();
+    globalThis[keys.FLUSH_PLAN_PROCESSING_CHAINS] = flushPlanProcessingChains;
+    function resolveFlushPlanDeadlineMs(options) {
+      if (typeof options.deadlineMs === "number" && Number.isFinite(options.deadlineMs)) {
+        return options.deadlineMs;
+      }
+      if (typeof options.timeoutMs === "number" && Number.isFinite(options.timeoutMs) && options.timeoutMs >= 0) {
+        return Date.now() + Math.floor(options.timeoutMs);
+      }
+      return void 0;
+    }
+    function waitForOpenClawFlushPlanTask(task, reason, deadlineMs) {
+      if (typeof deadlineMs !== "number") {
+        return task;
+      }
+      const remainingMs = Math.max(0, deadlineMs - Date.now());
+      if (remainingMs === 0) {
+        logger_exports.log.warn(
+          `OpenClaw flush-plan processing timed out before queue wait for ${reason}`
+        );
+        return Promise.resolve();
+      }
+      let timeout;
+      return Promise.race([
+        task,
+        new Promise((resolve) => {
+          timeout = setTimeout(() => {
+            logger_exports.log.warn(
+              `OpenClaw flush-plan processing timed out while waiting for ${reason}; current drain remains fenced until it settles`
+            );
+            resolve();
+          }, remainingMs);
+        })
+      ]).finally(() => {
+        if (timeout) clearTimeout(timeout);
+      });
+    }
+    async function runOpenClawFlushPlanProcessing(reason, workspaceRoot, deadlineMs) {
+      if (typeof deadlineMs === "number" && Date.now() >= deadlineMs) {
+        logger_exports.log.warn(
+          `OpenClaw flush-plan processing timed out before starting for ${reason}`
+        );
+        return;
+      }
+      try {
+        const result = await processOpenClawFlushPlanFile({
+          enabled: openclawFlushPlanProcessingEnabled,
+          workspaceDir: workspaceRoot,
+          serviceId,
+          ingestor: orchestrator,
+          logger: {
+            debug: (message) => logger_exports.log.debug(message),
+            info: (message) => logger_exports.log.info(message),
+            warn: (message) => logger_exports.log.warn(message)
+          },
+          reason,
+          deadlineMs,
+          maxTurnChars: cfg.extractionMaxTurnChars
+        });
+        if (result.status === "processed" || result.status === "processed_preserved_tail" || result.status === "processed_marker_recovered" || result.status === "processed_marker_recovered_tail" || result.status === "processed_cleanup_deferred") {
+          logger_exports.log.info(
+            `OpenClaw flush-plan ${result.status}: ${result.bytesProcessed ?? 0} bytes` + (result.preservedBytes ? ` (${result.preservedBytes} bytes preserved)` : "")
+          );
+        } else if (result.status === "skipped") {
+          logger_exports.log.warn(
+            `OpenClaw flush-plan processing skipped: ${result.reason ?? "unknown reason"}`
+          );
+        }
+      } catch (error) {
+        const detail = displayErrorDetail(error) || "unknown error";
+        logger_exports.log.warn(`OpenClaw flush-plan processing failed: ${detail}`);
+      }
+    }
+    async function queueOpenClawFlushPlanProcessing(reason, runtimeWorkspaceDir, options = {}) {
+      if (passiveMode || !openclawFlushPlanProcessingEnabled) {
+        return Promise.resolve();
+      }
+      const workspaceRoot = resolveWorkspaceRoot(runtimeWorkspaceDir);
+      const chainKey = await resolveFlushPlanProcessingChainKey(workspaceRoot);
+      const deadlineMs = resolveFlushPlanDeadlineMs(options);
+      const previousTask = flushPlanProcessingChains.get(chainKey);
+      const task = (previousTask ?? Promise.resolve()).catch(() => void 0).then(() => runOpenClawFlushPlanProcessing(reason, workspaceRoot, deadlineMs));
+      const fencedTask = task.catch(() => void 0);
+      flushPlanProcessingChains.set(chainKey, fencedTask);
+      void fencedTask.finally(() => {
+        if (flushPlanProcessingChains.get(chainKey) === fencedTask) {
+          flushPlanProcessingChains.delete(chainKey);
+        }
+      });
+      return waitForOpenClawFlushPlanTask(task, reason, deadlineMs);
     }
     function queueDreamSurfaceSync(runtimeWorkspaceDir) {
       if (!cfg.dreaming.enabled) return Promise.resolve();
@@ -5282,7 +6484,7 @@ Keep the reflection grounded in the evidence below.
         timeoutMs: cfg.activeRecallTimeoutMs,
         cacheTtlMs: cfg.activeRecallCacheTtlMs,
         persistTranscripts: cfg.activeRecallPersistTranscripts,
-        transcriptDir: path3.isAbsolute(cfg.activeRecallTranscriptDir) ? cfg.activeRecallTranscriptDir : path3.join(pluginStateDir, cfg.activeRecallTranscriptDir),
+        transcriptDir: path4.isAbsolute(cfg.activeRecallTranscriptDir) ? cfg.activeRecallTranscriptDir : path4.join(pluginStateDir, cfg.activeRecallTranscriptDir),
         entityGraphDepth: cfg.activeRecallEntityGraphDepth,
         includeCausalTrajectories: cfg.activeRecallIncludeCausalTrajectories,
         includeDaySummary: cfg.activeRecallIncludeDaySummary,
@@ -5367,7 +6569,7 @@ Keep the reflection grounded in the evidence below.
         }
       }, buildInlineExplicitCaptureDedupeKey2 = function(messageKey, note) {
         if (!messageKey) return null;
-        return `${messageKey}:inline-memory-note:${createHash2("sha256").update(JSON.stringify(note)).digest("hex")}`;
+        return `${messageKey}:inline-memory-note:${createHash3("sha256").update(JSON.stringify(note)).digest("hex")}`;
       }, resolveStoredCodexThreadId2 = function(sessionKey) {
         const threadId = codexThreadBySession.get(sessionKey);
         return typeof threadId === "string" && threadId.length > 0 ? threadId : null;
@@ -6289,20 +7491,20 @@ Keep the reflection grounded in the evidence below.
         const remnicQmdCommand = typeof orchestrator.config.qmdPath === "string" && orchestrator.config.qmdPath.trim().length > 0 ? orchestrator.config.qmdPath.trim() : "qmd";
         const readAllowedRoots = [
           orchestrator.config.memoryDir,
-          capabilityWorkspaceDir ? path3.join(capabilityWorkspaceDir, "memory") : void 0
+          capabilityWorkspaceDir ? path4.join(capabilityWorkspaceDir, "memory") : void 0
         ].filter((root) => typeof root === "string" && root.length > 0);
         const canonicalizeRootForContainment = async (rawPath) => {
-          const resolved = path3.resolve(rawPath);
+          const resolved = path4.resolve(rawPath);
           try {
-            return path3.normalize(await realPathLater(resolved));
+            return path4.normalize(await realPathLater(resolved));
           } catch {
-            return path3.normalize(resolved);
+            return path4.normalize(resolved);
           }
         };
         const canonicalizeForRead = async (rawPath) => {
-          const resolved = path3.resolve(rawPath);
+          const resolved = path4.resolve(rawPath);
           const real = await realPathLater(resolved);
-          return path3.normalize(real);
+          return path4.normalize(real);
         };
         const readAllowedCanonicalRootsPromise = Promise.all(
           readAllowedRoots.map((root) => canonicalizeRootForContainment(root))
@@ -6316,29 +7518,29 @@ Keep the reflection grounded in the evidence below.
           }
           const canonicalRoots = await readAllowedCanonicalRootsPromise;
           return canonicalRoots.some((root) => {
-            const relative = path3.relative(root, canonicalCandidatePath);
-            return relative === "" || !relative.startsWith("..") && !path3.isAbsolute(relative);
+            const relative = path4.relative(root, canonicalCandidatePath);
+            return relative === "" || !relative.startsWith("..") && !path4.isAbsolute(relative);
           });
         };
         const normalizeWorkspacePath = (rawPath) => {
           if (!rawPath || typeof rawPath !== "string") return "memory";
-          const resolved = path3.isAbsolute(rawPath) ? path3.resolve(rawPath) : path3.resolve(capabilityWorkspaceDir, rawPath);
-          const relative = path3.relative(capabilityWorkspaceDir, resolved);
-          return relative && !relative.startsWith("..") && !path3.isAbsolute(relative) ? relative : rawPath;
+          const resolved = path4.isAbsolute(rawPath) ? path4.resolve(rawPath) : path4.resolve(capabilityWorkspaceDir, rawPath);
+          const relative = path4.relative(capabilityWorkspaceDir, resolved);
+          return relative && !relative.startsWith("..") && !path4.isAbsolute(relative) ? relative : rawPath;
         };
         const relativizeToMemoryRoot = (rawPath) => {
           if (!rawPath || typeof rawPath !== "string") return "memory";
-          const resolved = path3.isAbsolute(rawPath) ? path3.resolve(rawPath) : path3.resolve(capabilityWorkspaceDir, rawPath);
+          const resolved = path4.isAbsolute(rawPath) ? path4.resolve(rawPath) : path4.resolve(capabilityWorkspaceDir, rawPath);
           for (const root of readAllowedRoots) {
-            const relative = path3.relative(root, resolved);
-            if (relative !== "" && !relative.startsWith("..") && !path3.isAbsolute(relative)) {
+            const relative = path4.relative(root, resolved);
+            if (relative !== "" && !relative.startsWith("..") && !path4.isAbsolute(relative)) {
               return relative;
             }
           }
           return normalizeWorkspacePath(rawPath);
         };
         const resolveReadablePath = async (requestedPath) => {
-          const candidateAbsolutePaths = path3.isAbsolute(requestedPath) ? [path3.resolve(requestedPath)] : readAllowedRoots.map((root) => path3.resolve(root, requestedPath));
+          const candidateAbsolutePaths = path4.isAbsolute(requestedPath) ? [path4.resolve(requestedPath)] : readAllowedRoots.map((root) => path4.resolve(root, requestedPath));
           let canonicalPath;
           let lastError;
           for (const absolutePath of candidateAbsolutePaths) {
@@ -6356,8 +7558,8 @@ Keep the reflection grounded in the evidence below.
           }
           const canonicalRoots = await readAllowedCanonicalRootsPromise;
           const contained = canonicalRoots.some((root) => {
-            const relative = path3.relative(root, canonicalPath);
-            return relative === "" || !relative.startsWith("..") && !path3.isAbsolute(relative);
+            const relative = path4.relative(root, canonicalPath);
+            return relative === "" || !relative.startsWith("..") && !path4.isAbsolute(relative);
           });
           if (!contained) {
             throw new Error(`memory read outside allowed roots: ${requestedPath}`);
@@ -6389,15 +7591,15 @@ Keep the reflection grounded in the evidence below.
                   }).map((result, index) => {
                     const candidate = result;
                     const rawPath = typeof candidate.path === "string" ? candidate.path : typeof candidate.id === "string" ? candidate.id : `memory-${index + 1}`;
-                    const absolutePath = path3.isAbsolute(rawPath) ? path3.resolve(rawPath) : (() => {
+                    const absolutePath = path4.isAbsolute(rawPath) ? path4.resolve(rawPath) : (() => {
                       for (const root of readAllowedRoots) {
-                        const candidateAbs = path3.resolve(root, rawPath);
-                        const relative = path3.relative(root, candidateAbs);
-                        if (!relative.startsWith("..") && !path3.isAbsolute(relative)) {
+                        const candidateAbs = path4.resolve(root, rawPath);
+                        const relative = path4.relative(root, candidateAbs);
+                        if (!relative.startsWith("..") && !path4.isAbsolute(relative)) {
                           return candidateAbs;
                         }
                       }
-                      return path3.resolve(capabilityWorkspaceDir, rawPath);
+                      return path4.resolve(capabilityWorkspaceDir, rawPath);
                     })();
                     const normalizedPath = relativizeToMemoryRoot(rawPath);
                     const startLine = typeof candidate.startLine === "number" && Number.isFinite(candidate.startLine) ? Math.max(1, Math.floor(candidate.startLine)) : 1;
@@ -6889,6 +8091,7 @@ Keep the reflection grounded in the evidence below.
         async (event, ctx) => {
           const sessionKey = ctx?.sessionKey ?? event?.sessionKey ?? "default";
           const sessionIdentity = resolveSessionIdentity2(sessionKey, event, ctx);
+          const workspaceDir = ctx?.workspaceDir || event?.workspaceDir || orchestrator.config.workspaceDir || defaultWorkspaceDir();
           try {
             clearCodexCompatCaches2(sessionKey, sessionIdentity.providerThreadId, {
               preserveMessageCount: true,
@@ -6922,6 +8125,9 @@ Keep the reflection grounded in the evidence below.
                 logger_exports.log.debug(`LCM after_compaction error: ${lcmErr}`);
               }
             }
+            await queueOpenClawFlushPlanProcessing("after_compaction", workspaceDir, {
+              timeoutMs: cfg.beforeResetTimeoutMs
+            });
             if (!orchestrator.config.compactionResetEnabled) {
               logger_exports.log.debug(
                 `compaction completed for ${sessionKey}, reset disabled \u2014 skipping`
@@ -6931,7 +8137,6 @@ Keep the reflection grounded in the evidence below.
             logger_exports.log.info(
               `compaction completed for ${sessionKey}, triggering session reset`
             );
-            const workspaceDir = ctx?.workspaceDir || event?.workspaceDir || orchestrator.config.workspaceDir || defaultWorkspaceDir();
             const apiAny = api;
             if (typeof apiAny.resetSession === "function") {
               const result = await apiAny.resetSession(sessionKey, "new");
@@ -6940,7 +8145,7 @@ Keep the reflection grounded in the evidence below.
                   `session reset via API for ${sessionKey}, new sessionId=${result.sessionId}`
                 );
                 const safeSessionKey = sanitizeSessionKeyForFilename(sessionKey);
-                const signalPath = path3.join(
+                const signalPath = path4.join(
                   workspaceDir,
                   `.compaction-reset-signal-${safeSessionKey}`
                 );
@@ -6982,6 +8187,7 @@ Keep the reflection grounded in the evidence below.
               sessionIdentity
             );
             const flushEnabled = cfg.flushOnResetEnabled && typeof orchestrator.flushSession === "function";
+            const beforeResetDeadlineMs = Date.now() + cfg.beforeResetTimeoutMs;
             const flushAbort = new AbortController();
             let flushTimedOut = false;
             let flushFailed = false;
@@ -7008,17 +8214,26 @@ Keep the reflection grounded in the evidence below.
             const boundedFlush = flushEnabled ? Promise.race([
               flushPromise,
               new Promise((resolve) => {
+                const remainingMs = Math.max(
+                  0,
+                  beforeResetDeadlineMs - Date.now()
+                );
                 timeoutId = setTimeout(() => {
                   flushTimedOut = true;
                   flushAbort.abort();
                   resolve();
-                }, cfg.beforeResetTimeoutMs);
+                }, remainingMs);
               })
             ]) : flushPromise;
             await boundedFlush;
             if (timeoutId) {
               clearTimeout(timeoutId);
             }
+            await queueOpenClawFlushPlanProcessing(
+              "before_reset",
+              ctx?.workspaceDir || event?.workspaceDir,
+              { deadlineMs: beforeResetDeadlineMs }
+            );
             if (flushTimedOut) {
               logger_exports.log.warn(
                 `before_reset flush timed out after ${cfg.beforeResetTimeoutMs}ms`
@@ -7040,7 +8255,7 @@ Keep the reflection grounded in the evidence below.
       if (!passiveMode && sdkCaps.hasBeforePromptBuild) {
         api.on(
           "session_start",
-          async (event, _ctx) => {
+          async (event, ctx) => {
             const sessionKey = event.sessionKey ?? "default";
             logger_exports.log.debug(`session_start: ${sessionKey}`);
             try {
@@ -7048,6 +8263,11 @@ Keep the reflection grounded in the evidence below.
             } catch (err) {
               logger_exports.log.debug(`session_start file hygiene failed: ${err}`);
             }
+            void queueOpenClawFlushPlanProcessing(
+              "session_start",
+              ctx?.workspaceDir ?? event.workspaceDir,
+              { timeoutMs: cfg.beforeResetTimeoutMs }
+            );
           }
         );
         api.on(
@@ -7086,6 +8306,11 @@ Keep the reflection grounded in the evidence below.
             if (orchestrator.config.compactionResetEnabled) {
               orchestrator.clearRecallWorkspaceOverride(sessionKey);
             }
+            await queueOpenClawFlushPlanProcessing(
+              "session_end",
+              ctx?.workspaceDir || event?.workspaceDir,
+              { timeoutMs: cfg.beforeResetTimeoutMs }
+            );
           }
         );
         api.on(
@@ -7182,7 +8407,7 @@ Keep the reflection grounded in the evidence below.
     }
     async function ensureHourlySummaryCron(api2) {
       const jobId = "engram-hourly-summary";
-      const cronFilePath = path3.join(
+      const cronFilePath = path4.join(
         os.homedir(),
         ".openclaw",
         "cron",
@@ -7241,32 +8466,32 @@ Keep the reflection grounded in the evidence below.
       };
       const normalizeCorpusPath = (value) => value.trim().replace(/\\/g, "/").replace(/^\.\//, "");
       const pathIsInside = (root, candidate) => {
-        const relative = path3.relative(root, candidate);
-        return relative === "" || !relative.startsWith("..") && !path3.isAbsolute(relative);
+        const relative = path4.relative(root, candidate);
+        return relative === "" || !relative.startsWith("..") && !path4.isAbsolute(relative);
       };
       const corpusPathCandidates = (rawPath, storageDir) => {
         const candidates = /* @__PURE__ */ new Set();
         const trimmed = rawPath.trim();
         if (!trimmed) return [];
         candidates.add(normalizeCorpusPath(trimmed));
-        if (path3.isAbsolute(trimmed)) {
-          const absolutePath = path3.resolve(trimmed);
-          const absoluteStorageDir = path3.resolve(storageDir);
+        if (path4.isAbsolute(trimmed)) {
+          const absolutePath = path4.resolve(trimmed);
+          const absoluteStorageDir = path4.resolve(storageDir);
           if (pathIsInside(absoluteStorageDir, absolutePath)) {
-            candidates.add(normalizeCorpusPath(path3.relative(absoluteStorageDir, absolutePath)));
+            candidates.add(normalizeCorpusPath(path4.relative(absoluteStorageDir, absolutePath)));
           }
         }
-        candidates.add(path3.basename(trimmed));
+        candidates.add(path4.basename(trimmed));
         return [...candidates].filter((candidate) => candidate.length > 0);
       };
       const displayCorpusPath = (rawPath, storageDir) => {
         const trimmed = rawPath.trim();
         if (!trimmed) return "";
-        if (path3.isAbsolute(trimmed)) {
-          const absolutePath = path3.resolve(trimmed);
-          const absoluteStorageDir = path3.resolve(storageDir);
+        if (path4.isAbsolute(trimmed)) {
+          const absolutePath = path4.resolve(trimmed);
+          const absoluteStorageDir = path4.resolve(storageDir);
           if (pathIsInside(absoluteStorageDir, absolutePath)) {
-            return normalizeCorpusPath(path3.relative(absoluteStorageDir, absolutePath));
+            return normalizeCorpusPath(path4.relative(absoluteStorageDir, absolutePath));
           }
         }
         return normalizeCorpusPath(trimmed);
@@ -7528,6 +8753,11 @@ Keep the reflection grounded in the evidence below.
             logger_exports.log.info(
               `gateway_start fired \u2014 Remnic memory plugin is active (id=${pluginDefinition.id}, memoryDir=${cfg.memoryDir})`
             );
+            void queueOpenClawFlushPlanProcessing(
+              "gateway_start",
+              getOpenClawRuntimeWorkspaceDir(api),
+              { timeoutMs: cfg.beforeResetTimeoutMs }
+            );
           } catch (err) {
             try {
               activeOpikExporter?.unsubscribe();
@@ -7616,6 +8846,9 @@ Keep the reflection grounded in the evidence below.
           delete globalThis[keys.ACCESS_HTTP_SERVER];
           delete globalThis[keys.ACCESS_HTTP_AUTH_STATE];
           delete globalThis[keys.ACCESS_SERVICE];
+          if (flushPlanProcessingChains.size === 0) {
+            delete globalThis[keys.FLUSH_PLAN_PROCESSING_CHAINS];
+          }
         }
         if (!secondaryTookOver) {
           globalThis[keys.HOOK_APIS] = /* @__PURE__ */ new WeakSet();
@@ -7629,6 +8862,44 @@ Keep the reflection grounded in the evidence below.
   }
 };
 var src_default = tryDefinePluginEntry(pluginDefinition);
+var OPENCLAW_BOOLEAN_ACCEPTED_VALUES = "true/false/1/0/yes/no/on/off";
+function coerceOpenClawBooleanLike(value) {
+  if (typeof value === "boolean") return value;
+  if (typeof value !== "string") return void 0;
+  const normalized = value.trim().toLowerCase();
+  if (["true", "1", "yes", "on"].includes(normalized)) return true;
+  if (["false", "0", "no", "off"].includes(normalized)) return false;
+  return void 0;
+}
+function resolveOpenClawFlushPlanProcessingEnabled(configValue) {
+  if (configValue === void 0 || configValue === null) return true;
+  const coerced = coerceOpenClawBooleanLike(configValue);
+  if (coerced === void 0) {
+    throw new Error(
+      `openclawFlushPlanProcessingEnabled must be a boolean-like value (${OPENCLAW_BOOLEAN_ACCEPTED_VALUES}); got ${JSON.stringify(configValue)}`
+    );
+  }
+  return coerced;
+}
+function resolveOpenClawFlushPlanProcessingEnabledFromConfig(fileConfig, runtimeConfig) {
+  const runtimeRecord = runtimeConfig && typeof runtimeConfig === "object" ? runtimeConfig : void 0;
+  const hasRuntimeValue = runtimeRecord !== void 0 && Object.prototype.hasOwnProperty.call(
+    runtimeRecord,
+    "openclawFlushPlanProcessingEnabled"
+  );
+  const hasFileValue = fileConfig !== void 0 && Object.prototype.hasOwnProperty.call(
+    fileConfig,
+    "openclawFlushPlanProcessingEnabled"
+  );
+  const runtimeValue = hasRuntimeValue ? resolveOpenClawFlushPlanProcessingEnabled(
+    runtimeRecord.openclawFlushPlanProcessingEnabled
+  ) : void 0;
+  const fileValue = hasFileValue ? resolveOpenClawFlushPlanProcessingEnabled(
+    fileConfig.openclawFlushPlanProcessingEnabled
+  ) : void 0;
+  if (runtimeValue === false || fileValue === false) return false;
+  return fileValue ?? runtimeValue ?? true;
+}
 function extractLastTurn(messages) {
   let lastUserIdx = -1;
   for (let i = messages.length - 1; i >= 0; i--) {
@@ -7701,7 +8972,7 @@ function buildOpenClawInboundContentFingerprint(content, message, event, ctx, se
     normalizeThreadId(message.threadId) ?? normalizeThreadId(event.threadId) ?? normalizeThreadId(ctx.threadId) ?? "",
     512
   );
-  const contentHash = createHash2("sha256").update(normalizedContent).digest("hex");
+  const contentHash = createHash3("sha256").update(normalizedContent).digest("hex");
   return [
     sessionPart,
     "content",
@@ -7715,7 +8986,7 @@ function buildOpenClawSparseInboundContentFingerprint(content, sessionKey) {
   const normalizedContent = content.trim();
   if (!normalizedContent) return null;
   const sessionPart = truncateMetadataValue(sessionKey || "default", 512);
-  const contentHash = createHash2("sha256").update(normalizedContent).digest("hex");
+  const contentHash = createHash3("sha256").update(normalizedContent).digest("hex");
   return `${sessionPart}\0sparse-content\0${contentHash}`;
 }
 function withReplyExtractionHint(content, metadata) {
@@ -7739,10 +9010,18 @@ function normalizeThreadId(value) {
 function truncateMetadataValue(value, maxChars) {
   return value.length <= maxChars ? value : value.slice(0, maxChars);
 }
+async function resolveFlushPlanProcessingChainKey(workspaceRoot) {
+  const lexicalRoot = path4.resolve(workspaceRoot);
+  try {
+    return path4.resolve(await realPathLater(lexicalRoot));
+  } catch {
+    return lexicalRoot;
+  }
+}
 
 // src/bridge.ts
 import fs from "fs";
-import path4 from "path";
+import path5 from "path";
 import { Worker } from "worker_threads";
 import { expandTildePath as expandTildePath2 } from "@remnic/core";
 var DEFAULT_HOST = "127.0.0.1";
@@ -7812,11 +9091,11 @@ function readCompatEnv(primary, legacy) {
 function configPathCandidates() {
   const envPath = readCompatEnv("REMNIC_CONFIG_PATH", "ENGRAM_CONFIG_PATH");
   return [
-    ...envPath ? [path4.resolve(expandTildePath2(envPath))] : [],
-    path4.join(resolveHomeDir2(), ".config", "remnic", "config.json"),
-    path4.join(resolveHomeDir2(), ".config", "engram", "config.json"),
-    path4.join(process.cwd(), "remnic.config.json"),
-    path4.join(process.cwd(), "engram.config.json")
+    ...envPath ? [path5.resolve(expandTildePath2(envPath))] : [],
+    path5.join(resolveHomeDir2(), ".config", "remnic", "config.json"),
+    path5.join(resolveHomeDir2(), ".config", "engram", "config.json"),
+    path5.join(process.cwd(), "remnic.config.json"),
+    path5.join(process.cwd(), "engram.config.json")
   ];
 }
 function fileExists(filePath) {
@@ -7828,8 +9107,8 @@ function fileExists(filePath) {
 }
 function isDaemonRunning() {
   for (const pidFile of [
-    path4.join(resolveHomeDir2(), ".remnic", "server.pid"),
-    path4.join(resolveHomeDir2(), ".engram", "server.pid")
+    path5.join(resolveHomeDir2(), ".remnic", "server.pid"),
+    path5.join(resolveHomeDir2(), ".engram", "server.pid")
   ]) {
     try {
       const pid = parseInt(fs["re"+"ad"+"Fi"+"le"+"Sync"](pidFile, "utf8").trim(), 10);
@@ -7843,7 +9122,7 @@ function isDaemonRunning() {
 function isDaemonServiceConfigured() {
   const homeDir = resolveHomeDir2();
   for (const segments of [...LAUNCHD_SERVICE_PATHS, ...SYSTEMD_SERVICE_PATHS]) {
-    if (fileExists(path4.join(homeDir, ...segments))) return true;
+    if (fileExists(path5.join(homeDir, ...segments))) return true;
   }
   return false;
 }
@@ -7931,8 +9210,8 @@ function detectBridgeMode() {
 }
 function loadAnyToken() {
   const tokenPaths = [
-    path4.join(resolveHomeDir2(), ".remnic", "tokens.json"),
-    path4.join(resolveHomeDir2(), ".engram", "tokens.json")
+    path5.join(resolveHomeDir2(), ".remnic", "tokens.json"),
+    path5.join(resolveHomeDir2(), ".engram", "tokens.json")
   ];
   for (const tokensPath of tokenPaths) {
     if (!fs.existsSync(tokensPath)) continue;