@runfusion/fusion 0.43.1 → 0.45.0

package/dist/chunk-2JI3F6MG.js

@@ -0,0 +1,948 @@
+import {
+  isEphemeralAgent
+} from "./chunk-AWKNRUOR.js";
+
+// ../core/dist/memory-dreams.js
+import { appendFile, mkdir as mkdir2, readFile as readFile2, readdir as readdir2, stat as stat2, writeFile as writeFile2 } from "fs/promises";
+import { existsSync as existsSync2 } from "fs";
+import { join as join2 } from "path";
+
+// ../core/dist/memory-backend.js
+import { readFile, writeFile, mkdir, access, constants, readdir, stat } from "fs/promises";
+import { existsSync } from "fs";
+import { basename, dirname, isAbsolute, join, normalize, relative, resolve, sep } from "path";
+import { createHash } from "crypto";
+var MEMORY_WORKSPACE_PATH = ".fusion/memory";
+var MEMORY_LONG_TERM_FILENAME = "MEMORY.md";
+var MEMORY_DREAMS_FILENAME = "DREAMS.md";
+var QMD_INSTALL_COMMAND = "bun install -g @tobilu/qmd";
+var QMD_REFRESH_INTERVAL_MS = 5 * 60 * 1e3;
+var DAILY_MEMORY_RE = /^\d{4}-\d{2}-\d{2}\.md$/;
+var MAX_MEMORY_SNIPPET_CHARS = 700;
+var DEFAULT_MEMORY_GET_LINES = 120;
+var MAX_MEMORY_GET_LINES = 400;
+var QMD_COLLECTION_PREFIX = "fusion-memory";
+var qmdRefreshState = /* @__PURE__ */ new Map();
+var qmdAgentRefreshState = /* @__PURE__ */ new Map();
+var qmdInstallPromise = null;
+function shouldSkipBackgroundQmdRefresh() {
+  return (process.env.VITEST === "true" || process.env.NODE_ENV === "test") && process.env.FUSION_ENABLE_QMD_REFRESH_IN_TESTS !== "1";
+}
+var MemoryBackendError = class extends Error {
+  code;
+  backend;
+  constructor(code, message, backend) {
+    super(message);
+    this.name = "MemoryBackendError";
+    this.code = code;
+    this.backend = backend;
+  }
+};
+var backendRegistry = /* @__PURE__ */ new Map();
+var FileMemoryBackend = class {
+  type = "file";
+  name = "File (.fusion/memory/MEMORY.md)";
+  capabilities = {
+    readable: true,
+    writable: true,
+    supportsAtomicWrite: true,
+    hasConflictResolution: false,
+    persistent: true
+  };
+  getLongTermPath(rootDir) {
+    return join(rootDir, MEMORY_WORKSPACE_PATH, MEMORY_LONG_TERM_FILENAME);
+  }
+  async read(rootDir) {
+    const filePath = this.getLongTermPath(rootDir);
+    try {
+      const content = await readFile(filePath, "utf-8");
+      return {
+        content,
+        exists: true,
+        backend: this.type
+      };
+    } catch (err) {
+      if (err.code === "ENOENT") {
+        return {
+          content: "",
+          exists: false,
+          backend: this.type
+        };
+      }
+      throw new MemoryBackendError("READ_FAILED", `Failed to read memory file: ${err.message}`, this.type);
+    }
+  }
+  async write(rootDir, content) {
+    const filePath = this.getLongTermPath(rootDir);
+    const dir = join(rootDir, MEMORY_WORKSPACE_PATH);
+    try {
+      if (!existsSync(dir)) {
+        await mkdir(dir, { recursive: true });
+      }
+      const tmpPath = filePath + ".tmp";
+      await writeFile(tmpPath, content, "utf-8");
+      const { rename } = await import("fs/promises");
+      await rename(tmpPath, filePath);
+      return {
+        success: true,
+        backend: this.type
+      };
+    } catch (err) {
+      throw new MemoryBackendError("WRITE_FAILED", `Failed to write memory file: ${err.message}`, this.type);
+    }
+  }
+  async exists(rootDir) {
+    try {
+      await access(this.getLongTermPath(rootDir), constants.R_OK);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async get(rootDir, options) {
+    return getMemoryFile(rootDir, options, this.type);
+  }
+  async search(rootDir, options) {
+    return searchMemoryFiles(rootDir, options, this.type);
+  }
+};
+var ReadOnlyMemoryBackend = class {
+  type = "readonly";
+  name = "Read-Only";
+  capabilities = {
+    readable: true,
+    writable: false,
+    supportsAtomicWrite: false,
+    hasConflictResolution: false,
+    persistent: false
+  };
+  async read(_rootDir) {
+    return {
+      content: "",
+      exists: false,
+      backend: this.type
+    };
+  }
+  async write(_rootDir, _content) {
+    throw new MemoryBackendError("READ_ONLY", "This backend is read-only and cannot write memory", this.type);
+  }
+  async get(_rootDir, options) {
+    throw new MemoryBackendError("NOT_FOUND", `Memory path '${options.path}' not found`, this.type);
+  }
+  async search(_rootDir, _options) {
+    return [];
+  }
+};
+var QmdMemoryBackend = class {
+  type = "qmd";
+  name = "QMD (qmd index/query integration)";
+  capabilities = {
+    readable: true,
+    writable: true,
+    supportsAtomicWrite: false,
+    hasConflictResolution: false,
+    persistent: true
+  };
+  /** Delegate file backend for actual I/O operations */
+  fileBackend = new FileMemoryBackend();
+  /**
+   * Read memory content from the filesystem.
+   *
+   * @param rootDir - The project root directory
+   * @returns Promise resolving to memory read result
+   */
+  async read(rootDir) {
+    const result = await this.fileBackend.read(rootDir);
+    return {
+      ...result,
+      backend: this.type
+    };
+  }
+  /**
+   * Write memory content to the filesystem.
+   *
+   * @param rootDir - The project root directory
+   * @param content - The content to write
+   * @returns Promise resolving to write result
+   */
+  async write(rootDir, content) {
+    const result = await this.fileBackend.write(rootDir, content);
+    scheduleQmdProjectMemoryRefresh(rootDir);
+    return {
+      ...result,
+      backend: this.type
+    };
+  }
+  /**
+   * Check if memory file exists.
+   *
+   * @param rootDir - The project root directory
+   * @returns Promise resolving to true if memory exists
+   */
+  async exists(rootDir) {
+    return this.fileBackend.exists(rootDir);
+  }
+  async get(rootDir, options) {
+    return getMemoryFile(rootDir, options, this.type);
+  }
+  async search(rootDir, options) {
+    const qmdResults = await searchWithQmd(rootDir, options);
+    if (qmdResults.length > 0) {
+      return qmdResults.map((result) => ({ ...result, backend: this.type }));
+    }
+    return searchMemoryFiles(rootDir, options, this.type);
+  }
+};
+function memoryWorkspacePath(rootDir) {
+  return join(rootDir, MEMORY_WORKSPACE_PATH);
+}
+function memoryLongTermPath(rootDir) {
+  return join(memoryWorkspacePath(rootDir), MEMORY_LONG_TERM_FILENAME);
+}
+function memoryDreamsPath(rootDir) {
+  return join(memoryWorkspacePath(rootDir), MEMORY_DREAMS_FILENAME);
+}
+function qmdMemoryCollectionName(rootDir) {
+  const absoluteRoot = resolve(rootDir);
+  const slug = basename(absoluteRoot).toLowerCase().replace(/[^a-z0-9_-]+/g, "-").replace(/^-+|-+$/g, "") || "project";
+  const hash = createHash("sha1").update(absoluteRoot).digest("hex").slice(0, 12);
+  return `${QMD_COLLECTION_PREFIX}-${slug}-${hash}`;
+}
+function buildQmdSearchArgs(rootDir, options) {
+  const limit = Math.max(1, Math.min(options.limit ?? 5, 20));
+  return [
+    "search",
+    options.query,
+    "--json",
+    "--collection",
+    qmdMemoryCollectionName(rootDir),
+    "-n",
+    String(limit)
+  ];
+}
+function buildQmdCollectionAddArgs(rootDir) {
+  return [
+    "collection",
+    "add",
+    memoryWorkspacePath(rootDir),
+    "--name",
+    qmdMemoryCollectionName(rootDir),
+    "--mask",
+    "**/*.md"
+  ];
+}
+function qmdAgentMemoryCollectionName(rootDir, agentId) {
+  const absoluteRoot = resolve(rootDir);
+  const safeAgentId = agentId.trim().replace(/[^a-zA-Z0-9._-]+/g, "-").replace(/^-+|-+$/g, "") || "agent";
+  const hash = createHash("sha1").update(`${absoluteRoot}:${agentId}`).digest("hex").slice(0, 12);
+  return `fusion-agent-memory-${safeAgentId.toLowerCase()}-${hash}`;
+}
+function dailyMemoryPath(rootDir, date = /* @__PURE__ */ new Date()) {
+  return join(memoryWorkspacePath(rootDir), `${date.toISOString().slice(0, 10)}.md`);
+}
+function getDefaultLongTermMemoryScaffold() {
+  return `# Project Memory
+
+<!-- Curated long-term memory. Store durable decisions, conventions, preferences, and pitfalls. -->
+
+## Decisions
+
+## Conventions
+
+## Pitfalls
+
+## Context
+`;
+}
+function getDefaultDailyMemoryScaffold(date = /* @__PURE__ */ new Date()) {
+  return `# Daily Memory ${date.toISOString().slice(0, 10)}
+
+<!-- Append running observations, open loops, and day-to-day notes here. Promote evergreen facts to MEMORY.md. -->
+`;
+}
+function getDefaultDreamsScaffold() {
+  return `# Memory Dreams
+
+<!-- Periodic synthesized patterns from daily notes. Promote durable lessons to MEMORY.md. -->
+`;
+}
+async function ensureOpenClawMemoryFiles(rootDir, date = /* @__PURE__ */ new Date()) {
+  const workspacePath = memoryWorkspacePath(rootDir);
+  await mkdir(workspacePath, { recursive: true });
+  const longTermPath = memoryLongTermPath(rootDir);
+  let longTermCreated = false;
+  if (!existsSync(longTermPath)) {
+    await writeFile(longTermPath, getDefaultLongTermMemoryScaffold(), "utf-8");
+    longTermCreated = true;
+  }
+  const todayPath = dailyMemoryPath(rootDir, date);
+  let dailyCreated = false;
+  if (!existsSync(todayPath)) {
+    await writeFile(todayPath, getDefaultDailyMemoryScaffold(date), "utf-8");
+    dailyCreated = true;
+  }
+  const dreamsPath = memoryDreamsPath(rootDir);
+  if (!existsSync(dreamsPath)) {
+    await writeFile(dreamsPath, getDefaultDreamsScaffold(), "utf-8");
+  }
+  return { longTermCreated, dailyCreated };
+}
+function isPathTraversal(path) {
+  return path.split(/[\\/]+/).includes("..");
+}
+function normalizeMemoryRequestPath(rawPath) {
+  const trimmed = rawPath.trim();
+  if (!trimmed) {
+    throw new MemoryBackendError("NOT_FOUND", "Memory path is required", "memory");
+  }
+  if (isAbsolute(trimmed) || isPathTraversal(trimmed)) {
+    throw new MemoryBackendError("UNSUPPORTED", "Memory paths must be workspace-relative", "memory");
+  }
+  const normalized = normalize(trimmed).replace(/\\/g, "/");
+  if (normalized === MEMORY_LONG_TERM_FILENAME || normalized === MEMORY_DREAMS_FILENAME || normalized === `memory/${MEMORY_LONG_TERM_FILENAME}` || normalized === `memory/${MEMORY_DREAMS_FILENAME}`) {
+    return `${MEMORY_WORKSPACE_PATH}/${basename(normalized)}`;
+  }
+  if (DAILY_MEMORY_RE.test(basename(normalized)) && (normalized === basename(normalized) || normalized.startsWith("memory/"))) {
+    return `${MEMORY_WORKSPACE_PATH}/${basename(normalized)}`;
+  }
+  if (normalized.startsWith(`${MEMORY_WORKSPACE_PATH}/`)) {
+    const file = basename(normalized);
+    if (file === MEMORY_LONG_TERM_FILENAME || file === MEMORY_DREAMS_FILENAME || DAILY_MEMORY_RE.test(file)) {
+      return `${MEMORY_WORKSPACE_PATH}/${file}`;
+    }
+  }
+  throw new MemoryBackendError("UNSUPPORTED", `Memory path '${rawPath}' is outside allowed files: .fusion/memory/MEMORY.md, .fusion/memory/DREAMS.md, .fusion/memory/YYYY-MM-DD.md`, "memory");
+}
+function resolveMemoryFilePath(rootDir, requestedPath) {
+  const displayPath = normalizeMemoryRequestPath(requestedPath);
+  const absPath = resolve(rootDir, displayPath);
+  const rel = relative(rootDir, absPath);
+  if (!rel || rel.startsWith(`..${sep}`) || rel === ".." || isAbsolute(rel)) {
+    throw new MemoryBackendError("UNSUPPORTED", "Memory path escapes project root", "memory");
+  }
+  return { absPath, displayPath };
+}
+async function getMemoryFile(rootDir, options, backend) {
+  const { absPath, displayPath } = resolveMemoryFilePath(rootDir, options.path);
+  let content;
+  try {
+    content = await readFile(absPath, "utf-8");
+  } catch (err) {
+    if (err.code === "ENOENT") {
+      throw new MemoryBackendError("NOT_FOUND", `Memory path '${options.path}' not found`, backend);
+    }
+    throw new MemoryBackendError("READ_FAILED", `Failed to read memory path '${options.path}': ${err.message}`, backend);
+  }
+  const lines = content.split("\n");
+  const startLine = Math.max(1, Math.floor(options.startLine ?? 1));
+  const requestedCount = Math.max(1, Math.floor(options.lineCount ?? DEFAULT_MEMORY_GET_LINES));
+  const lineCount = Math.min(requestedCount, MAX_MEMORY_GET_LINES);
+  const startIndex = Math.min(startLine - 1, lines.length);
+  const endIndex = Math.min(startIndex + lineCount, lines.length);
+  return {
+    path: displayPath,
+    content: lines.slice(startIndex, endIndex).join("\n"),
+    startLine,
+    endLine: endIndex,
+    totalLines: lines.length,
+    backend
+  };
+}
+async function listMemoryFiles(rootDir) {
+  const files = [];
+  const workspacePath = memoryWorkspacePath(rootDir);
+  const longTerm = memoryLongTermPath(rootDir);
+  if (existsSync(longTerm)) {
+    files.push({ absPath: longTerm, displayPath: `${MEMORY_WORKSPACE_PATH}/${MEMORY_LONG_TERM_FILENAME}` });
+  }
+  const dreams = memoryDreamsPath(rootDir);
+  if (existsSync(dreams)) {
+    files.push({ absPath: dreams, displayPath: `${MEMORY_WORKSPACE_PATH}/${MEMORY_DREAMS_FILENAME}` });
+  }
+  if (existsSync(workspacePath)) {
+    for (const entry of await readdir(workspacePath)) {
+      if (!DAILY_MEMORY_RE.test(entry))
+        continue;
+      const absPath = join(workspacePath, entry);
+      const fileStat = await stat(absPath);
+      if (fileStat.isFile()) {
+        files.push({ absPath, displayPath: `${MEMORY_WORKSPACE_PATH}/${entry}` });
+      }
+    }
+  }
+  return files;
+}
+function scoreSnippet(snippet, queryTerms) {
+  const normalized = snippet.toLowerCase();
+  return queryTerms.reduce((score, term) => score + (normalized.includes(term) ? 1 : 0), 0);
+}
+async function searchMemoryFiles(rootDir, options, backend) {
+  const queryTerms = options.query.toLowerCase().split(/[^a-z0-9_-]+/i).map((term) => term.trim()).filter((term) => term.length >= 2);
+  if (queryTerms.length === 0) {
+    return [];
+  }
+  const limit = Math.max(1, Math.min(options.limit ?? 5, 20));
+  const results = [];
+  for (const file of await listMemoryFiles(rootDir)) {
+    const lines = (await readFile(file.absPath, "utf-8")).split("\n");
+    for (let index = 0; index < lines.length; index += 8) {
+      const chunkLines = lines.slice(index, index + 12);
+      const snippet = chunkLines.join("\n").trim();
+      if (!snippet)
+        continue;
+      const score = scoreSnippet(snippet, queryTerms);
+      if (score === 0)
+        continue;
+      results.push({
+        path: file.displayPath,
+        lineStart: index + 1,
+        lineEnd: Math.min(index + chunkLines.length, lines.length),
+        snippet: snippet.slice(0, MAX_MEMORY_SNIPPET_CHARS),
+        score,
+        backend
+      });
+    }
+  }
+  return results.sort((a, b) => b.score - a.score || a.path.localeCompare(b.path)).slice(0, limit);
+}
+function normalizeQmdSearchResultPath(rootDir, rawPath) {
+  const original = String(rawPath ?? "").trim();
+  if (!original) {
+    return "";
+  }
+  let candidate = original.replace(/\\/g, "/");
+  const uriMatch = candidate.match(/^qmd:\/\/[^/]+\/(.+)$/i);
+  if (uriMatch?.[1]) {
+    candidate = uriMatch[1];
+  }
+  candidate = candidate.split("?")[0]?.split("#")[0] ?? "";
+  candidate = candidate.replace(/^\.\/+/, "");
+  if (isAbsolute(candidate)) {
+    const rel = relative(resolve(rootDir), resolve(candidate)).replace(/\\/g, "/");
+    if (rel && rel !== "." && rel !== ".." && !rel.startsWith("../") && !isAbsolute(rel)) {
+      candidate = rel;
+    }
+  }
+  const lowerCandidate = candidate.toLowerCase();
+  const normalizedBaseName = basename(candidate).toLowerCase();
+  const normalizedDirName = dirname(lowerCandidate).replace(/\\/g, "/");
+  if (normalizedBaseName === "memory.md" && (normalizedDirName === ".fusion" || normalizedDirName.endsWith("/.fusion"))) {
+    return `${MEMORY_WORKSPACE_PATH}/${MEMORY_LONG_TERM_FILENAME}`;
+  }
+  if (normalizedBaseName === MEMORY_LONG_TERM_FILENAME.toLowerCase()) {
+    return `${MEMORY_WORKSPACE_PATH}/${MEMORY_LONG_TERM_FILENAME}`;
+  }
+  if (normalizedBaseName === MEMORY_DREAMS_FILENAME.toLowerCase()) {
+    return `${MEMORY_WORKSPACE_PATH}/${MEMORY_DREAMS_FILENAME}`;
+  }
+  if (DAILY_MEMORY_RE.test(normalizedBaseName)) {
+    return `${MEMORY_WORKSPACE_PATH}/${normalizedBaseName}`;
+  }
+  try {
+    return normalizeMemoryRequestPath(candidate);
+  } catch {
+    return original;
+  }
+}
+async function searchWithQmd(rootDir, options) {
+  if (shouldSkipBackgroundQmdRefresh()) {
+    return [];
+  }
+  const command = "qmd";
+  const limit = Math.max(1, Math.min(options.limit ?? 5, 20));
+  try {
+    const { execFile } = await import("child_process");
+    const { promisify } = await import("util");
+    const execFileAsync = promisify(execFile);
+    await ensureQmdProjectMemoryCollection(rootDir, execFileAsync);
+    scheduleQmdProjectMemoryRefresh(rootDir);
+    const args = buildQmdSearchArgs(rootDir, options);
+    const { stdout } = await execFileAsync(command, args, {
+      cwd: rootDir,
+      timeout: 4e3,
+      maxBuffer: 1024 * 1024
+    });
+    const parsed = JSON.parse(stdout);
+    const rawResults = Array.isArray(parsed) ? parsed : Array.isArray(parsed?.results) ? parsed.results : [];
+    return rawResults.slice(0, limit).map((result, index) => {
+      const rawPath = result.path ?? result.file ?? `qmd/result-${index + 1}`;
+      return {
+        path: normalizeQmdSearchResultPath(rootDir, rawPath) || String(rawPath),
+        lineStart: Number(result.lineStart ?? result.startLine ?? 1),
+        lineEnd: Number(result.lineEnd ?? result.endLine ?? result.startLine ?? 1),
+        snippet: String(result.snippet ?? result.text ?? result.content ?? "").slice(0, MAX_MEMORY_SNIPPET_CHARS),
+        score: Number(result.score ?? 1),
+        backend: "qmd"
+      };
+    }).filter((result) => result.snippet.trim().length > 0);
+  } catch {
+    return [];
+  }
+}
+async function ensureQmdProjectMemoryCollection(rootDir, execFileAsync) {
+  const collectionName = qmdMemoryCollectionName(rootDir);
+  const memoryDir = memoryWorkspacePath(rootDir);
+  await mkdir(memoryDir, { recursive: true });
+  try {
+    await execFileAsync("qmd", buildQmdCollectionAddArgs(rootDir), {
+      cwd: rootDir,
+      timeout: 4e3,
+      maxBuffer: 512 * 1024
+    });
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    const stderr = typeof err === "object" && err && "stderr" in err ? String(err.stderr ?? "") : "";
+    if (!/already exists|exists/i.test(`${message}
+${stderr}`)) {
+      throw err;
+    }
+  }
+  return collectionName;
+}
+async function getDefaultExecFileAsync() {
+  const { execFile } = await import("child_process");
+  const { promisify } = await import("util");
+  return promisify(execFile);
+}
+async function refreshQmdProjectMemoryIndex(rootDir, options) {
+  const key = resolve(rootDir);
+  const now = Date.now();
+  const current = qmdRefreshState.get(key);
+  if (!options?.force) {
+    if (current?.inFlight) {
+      return current.inFlight;
+    }
+    if (current && now - current.lastStartedAt < QMD_REFRESH_INTERVAL_MS) {
+      return;
+    }
+  }
+  const promise = (async () => {
+    const execFileAsync = options?.execFileAsync ?? await getDefaultExecFileAsync();
+    await ensureQmdProjectMemoryCollection(rootDir, execFileAsync);
+    await execFileAsync("qmd", ["update"], {
+      cwd: rootDir,
+      timeout: 3e4,
+      maxBuffer: 1024 * 1024
+    });
+    await execFileAsync("qmd", ["embed"], {
+      cwd: rootDir,
+      timeout: 12e4,
+      maxBuffer: 1024 * 1024
+    });
+  })();
+  qmdRefreshState.set(key, { lastStartedAt: now, inFlight: promise });
+  try {
+    await promise;
+  } finally {
+    const latest = qmdRefreshState.get(key);
+    if (latest?.inFlight === promise) {
+      qmdRefreshState.set(key, { lastStartedAt: latest.lastStartedAt });
+    }
+  }
+}
+function scheduleQmdProjectMemoryRefresh(rootDir) {
+  if (shouldSkipBackgroundQmdRefresh()) {
+    return;
+  }
+  void refreshQmdProjectMemoryIndex(rootDir).catch(() => {
+  });
+}
+async function refreshQmdAgentMemoryIndex(rootDir, agentId, options) {
+  const key = `${resolve(rootDir)}:${agentId}`;
+  const now = Date.now();
+  const current = qmdAgentRefreshState.get(key);
+  if (!options?.force) {
+    if (current?.inFlight) {
+      return current.inFlight;
+    }
+    if (current && now - current.lastStartedAt < QMD_REFRESH_INTERVAL_MS) {
+      return;
+    }
+  }
+  const promise = (async () => {
+    const execFileAsync = options?.execFileAsync ?? await getDefaultExecFileAsync();
+    const { agentMemoryWorkspacePath: agentMemoryWorkspacePath2 } = await import("./memory-dreams-PBPISUDD.js");
+    const workspacePath = agentMemoryWorkspacePath2(rootDir, agentId);
+    await mkdir(workspacePath, { recursive: true });
+    try {
+      await execFileAsync("qmd", ["collection", "add", workspacePath, "--name", qmdAgentMemoryCollectionName(rootDir, agentId), "--mask", "**/*.md"], {
+        cwd: rootDir,
+        timeout: 4e3,
+        maxBuffer: 512 * 1024
+      });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      const stderr = typeof err === "object" && err && "stderr" in err ? String(err.stderr ?? "") : "";
+      if (!/already exists|exists/i.test(`${message}
+${stderr}`)) {
+        throw err;
+      }
+    }
+    await execFileAsync("qmd", ["update"], { cwd: rootDir, timeout: 3e4, maxBuffer: 1024 * 1024 });
+    await execFileAsync("qmd", ["embed"], { cwd: rootDir, timeout: 12e4, maxBuffer: 1024 * 1024 });
+  })();
+  qmdAgentRefreshState.set(key, { lastStartedAt: now, inFlight: promise });
+  try {
+    await promise;
+  } finally {
+    const latest = qmdAgentRefreshState.get(key);
+    if (latest?.inFlight === promise) {
+      qmdAgentRefreshState.set(key, { lastStartedAt: latest.lastStartedAt });
+    }
+  }
+}
+function scheduleQmdAgentMemoryRefresh(rootDir, agentId) {
+  if (shouldSkipBackgroundQmdRefresh()) {
+    return;
+  }
+  void refreshQmdAgentMemoryIndex(rootDir, agentId).catch(() => {
+  });
+}
+async function isQmdAvailable() {
+  try {
+    const execFileAsync = await getDefaultExecFileAsync();
+    await execFileAsync("qmd", ["--help"], {
+      timeout: 3e3,
+      maxBuffer: 128 * 1024
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function installQmd(options) {
+  const execFileAsync = options?.execFileAsync ?? await getDefaultExecFileAsync();
+  const [command, ...args] = QMD_INSTALL_COMMAND.split(" ");
+  if (!command || args.length === 0) {
+    throw new MemoryBackendError("BACKEND_UNAVAILABLE", "qmd install command is not configured", "qmd");
+  }
+  await execFileAsync(command, args, {
+    timeout: 12e4,
+    maxBuffer: 1024 * 1024
+  });
+  return true;
+}
+async function ensureQmdInstalled(options) {
+  const checkAvailable = options?.isAvailable ?? isQmdAvailable;
+  if (await checkAvailable()) {
+    return true;
+  }
+  if (!qmdInstallPromise) {
+    qmdInstallPromise = installQmd({ execFileAsync: options?.execFileAsync }).then(async () => checkAvailable()).finally(() => {
+      qmdInstallPromise = null;
+    });
+  }
+  return qmdInstallPromise;
+}
+async function ensureQmdInstalledAndRefresh(rootDir) {
+  const available = await ensureQmdInstalled();
+  if (available) {
+    await refreshQmdProjectMemoryIndex(rootDir, { force: true });
+  }
+}
+function scheduleQmdInstallAndRefresh(rootDir) {
+  if (shouldSkipBackgroundQmdRefresh()) {
+    return;
+  }
+  void ensureQmdInstalledAndRefresh(rootDir).catch(() => {
+  });
+}
+var fileBackendInstance = new FileMemoryBackend();
+backendRegistry.set("file", fileBackendInstance);
+backendRegistry.set("readonly", new ReadOnlyMemoryBackend());
+backendRegistry.set("qmd", new QmdMemoryBackend());
+var MEMORY_BACKEND_SETTINGS_KEYS = {
+  /** Backend type to use (default: "file") */
+  MEMORY_BACKEND_TYPE: "memoryBackendType"
+};
+var DEFAULT_MEMORY_BACKEND = "qmd";
+function resolveMemoryBackend(settings) {
+  const backendType = settings?.[MEMORY_BACKEND_SETTINGS_KEYS.MEMORY_BACKEND_TYPE] || DEFAULT_MEMORY_BACKEND;
+  const backend = backendRegistry.get(backendType);
+  if (backend) {
+    return backend;
+  }
+  return backendRegistry.get(DEFAULT_MEMORY_BACKEND);
+}
+
+// ../core/dist/memory-dreams.js
+var MEMORY_DREAMS_SCHEDULE_NAME = "Memory Dreams";
+var DEFAULT_MEMORY_DREAMS_SCHEDULE = "0 4 * * *";
+var AGENT_MEMORY_ROOT = ".fusion/agent-memory";
+var AGENT_MEMORY_FILENAME = "MEMORY.md";
+var AGENT_DREAMS_FILENAME = "DREAMS.md";
+var DAILY_AGENT_MEMORY_RE = /^\d{4}-\d{2}-\d{2}\.md$/;
+function agentMemoryWorkspacePath(rootDir, agentId) {
+  const safeAgentId = agentId.trim().replace(/[^a-zA-Z0-9._-]+/g, "-").replace(/^-+|-+$/g, "") || "agent";
+  return join2(rootDir, AGENT_MEMORY_ROOT, safeAgentId);
+}
+function agentMemoryLongTermPath(rootDir, agentId) {
+  return join2(agentMemoryWorkspacePath(rootDir, agentId), AGENT_MEMORY_FILENAME);
+}
+function agentMemoryDreamsPath(rootDir, agentId) {
+  return join2(agentMemoryWorkspacePath(rootDir, agentId), AGENT_DREAMS_FILENAME);
+}
+function agentDailyMemoryPath(rootDir, agentId, date = /* @__PURE__ */ new Date()) {
+  return join2(agentMemoryWorkspacePath(rootDir, agentId), `${date.toISOString().slice(0, 10)}.md`);
+}
+async function ensureAgentMemoryFiles(rootDir, agent, date = /* @__PURE__ */ new Date()) {
+  const workspacePath = agentMemoryWorkspacePath(rootDir, agent.id);
+  await mkdir2(workspacePath, { recursive: true });
+  const longTermPath = agentMemoryLongTermPath(rootDir, agent.id);
+  if (!existsSync2(longTermPath)) {
+    const title = agent.name?.trim() ? `# Agent Memory: ${agent.name.trim()}` : "# Agent Memory";
+    await writeFile2(longTermPath, `${title}
+
+<!-- Per-agent memory. Keep separate from workspace Project Memory. -->
+
+${agent.memory?.trim() ?? ""}
+`, "utf-8");
+  }
+  const dreamsPath = agentMemoryDreamsPath(rootDir, agent.id);
+  if (!existsSync2(dreamsPath)) {
+    await writeFile2(dreamsPath, "# Agent Memory Dreams\n\n<!-- Synthesized patterns from this agent's daily notes. -->\n", "utf-8");
+  }
+  const dailyPath = agentDailyMemoryPath(rootDir, agent.id, date);
+  if (!existsSync2(dailyPath)) {
+    await writeFile2(dailyPath, `# Agent Daily Memory ${date.toISOString().slice(0, 10)}
+
+<!-- Running observations for this agent. -->
+`, "utf-8");
+  }
+}
+function buildDreamProcessingPrompt(input) {
+  return `You are processing project memory in an OpenClaw-style memory system.
+
+Read today's daily notes and existing long-term memory. Produce:
+1. DREAMS: synthesized patterns, open loops, contradictions, and emerging themes.
+2. LONG_TERM_UPDATES: only durable conventions, decisions, pitfalls, or constraints worth keeping.
+
+Rules:
+- Do not copy task logs or changelog entries.
+- Do not invent facts not present in the input.
+- Keep output concise and actionable.
+- Return exactly these Markdown headings:
+
+## DREAMS
+
+## LONG_TERM_UPDATES
+
+Date: ${input.date}
+
+## Existing Long-Term Memory
+
+${input.longTermMemory || "(empty)"}
+
+## Previous Dreams
+
+${input.previousDreams || "(empty)"}
+
+## Daily Notes
+
+${input.dailyMemory || "(empty)"}
+`;
+}
+function extractDreamProcessorResult(output) {
+  const text = typeof output === "string" ? output : "";
+  const dreamsMatch = text.match(/## DREAMS\s*([\s\S]*?)(?=## LONG_TERM_UPDATES|$)/i);
+  const updatesMatch = text.match(/## LONG_TERM_UPDATES\s*([\s\S]*?)$/i);
+  return {
+    dreams: dreamsMatch?.[1]?.trim() ?? "",
+    longTermUpdates: updatesMatch?.[1]?.trim() ?? ""
+  };
+}
+async function readIfExists(path) {
+  if (!existsSync2(path)) {
+    return "";
+  }
+  return readFile2(path, "utf-8");
+}
+async function processMemoryDreams(rootDir, executePrompt, date = /* @__PURE__ */ new Date()) {
+  await ensureOpenClawMemoryFiles(rootDir, date);
+  const dateKey = date.toISOString().slice(0, 10);
+  const longTermPath = memoryLongTermPath(rootDir);
+  const dreamsPath = memoryDreamsPath(rootDir);
+  const dailyPath = dailyMemoryPath(rootDir, date);
+  const prompt = buildDreamProcessingPrompt({
+    date: dateKey,
+    longTermMemory: await readIfExists(longTermPath),
+    previousDreams: await readIfExists(dreamsPath),
+    dailyMemory: await readIfExists(dailyPath)
+  });
+  const result = extractDreamProcessorResult(await executePrompt(prompt));
+  if (result.dreams) {
+    await appendFile(dreamsPath, `
+## ${dateKey}
+
+${result.dreams}
+`, "utf-8");
+  }
+  if (result.longTermUpdates) {
+    await appendFile(longTermPath, `
+## Dream Updates ${dateKey}
+
+${result.longTermUpdates}
+`, "utf-8");
+  }
+  await writeFile2(dailyPath, `# Daily Memory ${dateKey}
+
+<!-- Processed into dreams on ${(/* @__PURE__ */ new Date()).toISOString()} -->
+`, "utf-8");
+  return result;
+}
+async function readAgentDailyNotes(rootDir, agentId, date) {
+  const workspacePath = agentMemoryWorkspacePath(rootDir, agentId);
+  const dateKey = date.toISOString().slice(0, 10);
+  const dailyPath = agentDailyMemoryPath(rootDir, agentId, date);
+  if (existsSync2(dailyPath)) {
+    return readFile2(dailyPath, "utf-8");
+  }
+  const files = await readdir2(workspacePath).catch(() => []);
+  const chunks = [];
+  for (const file of files) {
+    if (!DAILY_AGENT_MEMORY_RE.test(file))
+      continue;
+    if (!file.startsWith(dateKey))
+      continue;
+    const absPath = join2(workspacePath, file);
+    if ((await stat2(absPath)).isFile()) {
+      chunks.push(await readFile2(absPath, "utf-8"));
+    }
+  }
+  return chunks.join("\n\n");
+}
+async function processAgentMemoryDreams(rootDir, agents, executePrompt, date = /* @__PURE__ */ new Date(), settings) {
+  const dateKey = date.toISOString().slice(0, 10);
+  const results = [];
+  for (const agent of agents) {
+    if (isEphemeralAgent(agent)) {
+      continue;
+    }
+    await ensureAgentMemoryFiles(rootDir, agent, date);
+    const longTermPath = agentMemoryLongTermPath(rootDir, agent.id);
+    const dreamsPath = agentMemoryDreamsPath(rootDir, agent.id);
+    const dailyPath = agentDailyMemoryPath(rootDir, agent.id, date);
+    const prompt = buildDreamProcessingPrompt({
+      date: dateKey,
+      longTermMemory: await readIfExists(longTermPath),
+      previousDreams: await readIfExists(dreamsPath),
+      dailyMemory: await readAgentDailyNotes(rootDir, agent.id, date)
+    }).replace("You are processing project memory in an OpenClaw-style memory system.", `You are processing private memory for agent ${agent.name} (${agent.id}) in an OpenClaw-style memory system.`);
+    const result = extractDreamProcessorResult(await executePrompt(prompt));
+    if (result.dreams) {
+      await appendFile(dreamsPath, `
+## ${dateKey}
+
+${result.dreams}
+`, "utf-8");
+    }
+    if (result.longTermUpdates) {
+      await appendFile(longTermPath, `
+## Dream Updates ${dateKey}
+
+${result.longTermUpdates}
+`, "utf-8");
+    }
+    await writeFile2(dailyPath, `# Agent Daily Memory ${dateKey}
+
+<!-- Processed into dreams on ${(/* @__PURE__ */ new Date()).toISOString()} -->
+`, "utf-8");
+    results.push({ agentId: agent.id, ...result });
+    if (resolveMemoryBackend(settings).type === "qmd") {
+      scheduleQmdAgentMemoryRefresh(rootDir, agent.id);
+    }
+  }
+  return results;
+}
+function createMemoryDreamsAutomation(settings, modelProvider, modelId) {
+  const schedule = settings.memoryDreamsSchedule ?? DEFAULT_MEMORY_DREAMS_SCHEDULE;
+  const prompt = `You are the Memory Dream Processor for an OpenClaw-style project memory system.
+
+## Your Task
+
+1. Read today's daily notes from \`.fusion/memory/YYYY-MM-DD.md\`.
+2. Read existing dreams from \`.fusion/memory/DREAMS.md\`.
+3. Read long-term memory from \`.fusion/memory/MEMORY.md\`.
+4. Append a dated synthesis to \`.fusion/memory/DREAMS.md\` with patterns, open loops, contradictions, and emerging themes.
+5. Append only durable conventions, decisions, pitfalls, or constraints to \`.fusion/memory/MEMORY.md\`.
+6. Reset today's daily note to a short processed marker after successful synthesis.
+7. For every persisted non-ephemeral agent in \`.fusion/agents/*.json\`, repeat the same process for that agent's private memory workspace at \`.fusion/agent-memory/{agentId}/\`:
+   - Read \`MEMORY.md\`, \`DREAMS.md\`, and today's \`YYYY-MM-DD.md\`.
+   - If the agent workspace is missing, create it and seed \`MEMORY.md\` from the agent JSON \`memory\` field when present.
+   - Append agent-specific synthesis to that agent's \`DREAMS.md\`.
+   - Promote only durable agent-specific operating preferences, habits, or constraints to that agent's \`MEMORY.md\`.
+   - Reset that agent's daily note after successful synthesis.
+
+## Rules
+
+- Do not copy task logs or changelog entries into long-term memory.
+- Do not invent facts.
+- Keep dreams useful for future agents, not a transcript of the day.
+- Preserve the three-layer model for both workspace and agent memory: daily notes are raw, DREAMS.md is synthesis, MEMORY.md is curated durable knowledge.
+- Keep agent memory separate from workspace memory. Do not promote private agent operating notes into project memory unless they are useful to every agent in the workspace.`;
+  return {
+    name: MEMORY_DREAMS_SCHEDULE_NAME,
+    description: "Synthesizes daily memory notes into dreams and promotes durable lessons to long-term memory",
+    scheduleType: "custom",
+    cronExpression: schedule,
+    command: "",
+    enabled: true,
+    steps: [
+      {
+        id: "memory-dream-processor",
+        type: "ai-prompt",
+        name: "Process Memory Dreams",
+        prompt,
+        ...modelProvider && modelId ? { modelProvider, modelId } : {},
+        timeoutMs: 12e4
+      }
+    ]
+  };
+}
+async function syncMemoryDreamsAutomation(automationStore, settings) {
+  const { AutomationStore } = await import("./automation-store-RDDYZFUJ.js");
+  const schedules = await automationStore.listSchedules();
+  const existingSchedule = schedules.find((schedule2) => schedule2.name === MEMORY_DREAMS_SCHEDULE_NAME);
+  if (!settings.memoryDreamsEnabled) {
+    if (existingSchedule) {
+      await automationStore.deleteSchedule(existingSchedule.id);
+    }
+    return void 0;
+  }
+  const schedule = settings.memoryDreamsSchedule ?? DEFAULT_MEMORY_DREAMS_SCHEDULE;
+  if (!AutomationStore.isValidCron(schedule)) {
+    throw new Error(`Invalid memory dreams schedule: ${schedule}`);
+  }
+  const input = createMemoryDreamsAutomation(settings);
+  if (existingSchedule) {
+    return automationStore.updateSchedule(existingSchedule.id, {
+      scheduleType: "custom",
+      cronExpression: schedule,
+      command: input.command,
+      steps: input.steps,
+      enabled: true
+    });
+  }
+  return automationStore.createSchedule(input);
+}
+
+export {
+  MEMORY_DREAMS_SCHEDULE_NAME,
+  DEFAULT_MEMORY_DREAMS_SCHEDULE,
+  agentMemoryWorkspacePath,
+  agentMemoryLongTermPath,
+  agentMemoryDreamsPath,
+  agentDailyMemoryPath,
+  ensureAgentMemoryFiles,
+  buildDreamProcessingPrompt,
+  extractDreamProcessorResult,
+  processMemoryDreams,
+  processAgentMemoryDreams,
+  createMemoryDreamsAutomation,
+  syncMemoryDreamsAutomation,
+  ensureOpenClawMemoryFiles,
+  scheduleQmdInstallAndRefresh,
+  MEMORY_BACKEND_SETTINGS_KEYS,
+  DEFAULT_MEMORY_BACKEND,
+  resolveMemoryBackend
+};