@ai-setting/roy-agent-core 1.4.11 → 1.4.12

package/dist/env/memory/index.js

@@ -0,0 +1,2171 @@
+// @bun
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toCommonJS = (from) => {
+  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+  }
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __moduleCache;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __legacyDecorateClassTS = function(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+    r = Reflect.decorate(decorators, target, key, desc);
+  else
+    for (var i = decorators.length - 1;i >= 0; i--)
+      if (d = decorators[i])
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = import.meta.require;
+
+// packages/core/src/env/log-trace/span-storage.ts
+var exports_span_storage = {};
+__export(exports_span_storage, {
+  SQLiteSpanStorage: () => SQLiteSpanStorage
+});
+
+class SQLiteSpanStorage {
+  db = null;
+  dbPath;
+  initialized = false;
+  constructor(dbPath) {
+    if (!dbPath) {
+      throw new Error("SQLiteSpanStorage requires a valid dbPath parameter");
+    }
+    if (dbPath === ":memory:") {
+      throw new Error("SQLiteSpanStorage does not support :memory: mode. Use a file path instead.");
+    }
+    this.dbPath = dbPath;
+  }
+  async initialize() {
+    if (this.initialized)
+      return;
+    const { Database } = __require("bun:sqlite");
+    const fs = __require("fs");
+    const path = __require("path");
+    const dir = path.dirname(this.dbPath);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+    this.db = new Database(this.dbPath);
+    this.db.run("PRAGMA journal_mode=WAL");
+    this.db.run("PRAGMA busy_timeout=5000");
+    this.db.run("PRAGMA synchronous=NORMAL");
+    this.db.run(`
+      CREATE TABLE IF NOT EXISTS span (
+        span_id TEXT PRIMARY KEY,
+        trace_id TEXT NOT NULL,
+        parent_span_id TEXT,
+        name TEXT NOT NULL,
+        kind TEXT NOT NULL,
+        status TEXT NOT NULL,
+        start_time INTEGER NOT NULL,
+        end_time INTEGER,
+        attributes TEXT,
+        result TEXT,
+        error TEXT,
+        time_created INTEGER NOT NULL
+      )
+    `);
+    this.db.run("CREATE INDEX IF NOT EXISTS idx_span_trace ON span(trace_id)");
+    this.db.run("CREATE INDEX IF NOT EXISTS idx_span_parent ON span(parent_span_id)");
+    this.initialized = true;
+  }
+  save(span) {
+    if (!this.db)
+      return;
+    const stmt = this.db.prepare(`
+      INSERT OR REPLACE INTO span 
+      (span_id, trace_id, parent_span_id, name, kind, status, start_time, end_time, attributes, result, error, time_created)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+    const resultValue = span.result !== undefined && span.result !== null ? typeof span.result === "string" ? span.result : JSON.stringify(span.result) : null;
+    stmt.run(span.spanId, span.traceId, span.parentSpanId || null, span.name, span.kind, span.status, span.startTime, span.endTime || null, JSON.stringify(span.attributes), resultValue, span.error || null, Date.now());
+  }
+  saveBatch(spans) {
+    for (const span of spans) {
+      this.save(span);
+    }
+  }
+  findByTraceId(traceId) {
+    if (!this.db)
+      return [];
+    const rows = this.db.prepare("SELECT * FROM span WHERE trace_id = ?").all(traceId);
+    return this.buildTree(rows.map(this.rowToSpan));
+  }
+  findBySpanId(spanId) {
+    if (!this.db)
+      return;
+    const row = this.db.prepare("SELECT * FROM span WHERE span_id = ?").get(spanId);
+    return row ? this.rowToSpan(row) : undefined;
+  }
+  listTraces(limit = 10) {
+    if (!this.db)
+      return [];
+    const rows = this.db.prepare(`
+      SELECT trace_id, 
+             MIN(start_time) as start_time,
+             MAX(end_time) as end_time,
+             COUNT(*) as span_count
+      FROM span 
+      GROUP BY trace_id 
+      ORDER BY start_time DESC 
+      LIMIT ?
+    `).all(limit);
+    return rows.map((row) => ({
+      traceId: row.trace_id,
+      rootSpanName: "unknown",
+      startTime: row.start_time,
+      endTime: row.end_time,
+      duration: row.end_time - row.start_time,
+      spanCount: row.span_count,
+      status: "ok"
+    }));
+  }
+  deleteByTraceId(traceId) {
+    if (this.db) {
+      this.db.prepare("DELETE FROM span WHERE trace_id = ?").run(traceId);
+    }
+  }
+  close() {
+    if (this.db) {
+      this.db.close();
+      this.db = null;
+    }
+  }
+  rowToSpan(row) {
+    return {
+      traceId: row.trace_id,
+      spanId: row.span_id,
+      parentSpanId: row.parent_span_id,
+      name: row.name,
+      kind: row.kind,
+      status: row.status,
+      startTime: row.start_time,
+      endTime: row.end_time,
+      attributes: row.attributes ? JSON.parse(row.attributes) : {},
+      result: row.result || undefined,
+      error: row.error || undefined
+    };
+  }
+  buildTree(spans) {
+    const spanMap = new Map;
+    const roots = [];
+    for (const span of spans) {
+      spanMap.set(span.spanId, { ...span, children: [] });
+    }
+    for (const span of spanMap.values()) {
+      if (span.parentSpanId) {
+        const parent = spanMap.get(span.parentSpanId);
+        if (parent) {
+          parent.children.push(span);
+        } else {
+          roots.push(span);
+        }
+      } else {
+        roots.push(span);
+      }
+    }
+    return roots;
+  }
+}
+
+// packages/core/src/env/log-trace/opentelemetry/propagation.ts
+function padLeft(str, length) {
+  return str.padStart(length, "0");
+}
+function isValidHex(str) {
+  return /^[0-9a-f]+$/i.test(str);
+}
+function serialize(context) {
+  const traceId = padLeft(context.traceId.toLowerCase(), TRACE_ID_LENGTH);
+  const spanId = padLeft(context.spanId.toLowerCase(), PARENT_SPAN_ID_LENGTH);
+  const parts = [
+    TRACE_CONTEXT_VERSION,
+    traceId,
+    spanId,
+    TRACE_FLAGS_SAMPLED
+  ];
+  return parts.join("-");
+}
+function parse(traceparent) {
+  if (!traceparent || typeof traceparent !== "string") {
+    return;
+  }
+  const trimmed = traceparent.trim();
+  const parts = trimmed.split("-");
+  if (parts.length !== 4) {
+    return;
+  }
+  const [version, traceId, senderSpanId, flags] = parts;
+  if (version !== TRACE_CONTEXT_VERSION) {
+    if (version > TRACE_CONTEXT_VERSION) {
+      return;
+    }
+  }
+  if (traceId.length !== TRACE_ID_LENGTH || !isValidHex(traceId)) {
+    return;
+  }
+  if (senderSpanId.length !== PARENT_SPAN_ID_LENGTH || !isValidHex(senderSpanId)) {
+    return;
+  }
+  if (flags.length !== FLAGS_LENGTH || !isValidHex(flags)) {
+    return;
+  }
+  return {
+    traceId: traceId.toLowerCase(),
+    spanId: senderSpanId.toLowerCase()
+  };
+}
+var TRACE_CONTEXT_VERSION = "00", TRACE_FLAGS_SAMPLED = "01", TRACEPARENT_HEADER = "TRACEPARENT", TRACE_ID_LENGTH = 32, PARENT_SPAN_ID_LENGTH = 16, FLAGS_LENGTH = 2, propagation;
+var init_propagation = __esm(() => {
+  propagation = {
+    inject(carrier, context) {
+      carrier[TRACEPARENT_HEADER] = serialize(context);
+    },
+    extract(carrier) {
+      const traceparent = carrier[TRACEPARENT_HEADER];
+      if (!traceparent) {
+        return;
+      }
+      return parse(traceparent);
+    },
+    getTraceparentHeader() {
+      return TRACEPARENT_HEADER;
+    }
+  };
+});
+
+// packages/core/src/env/log-trace/types.ts
+var SpanKind, SpanStatus;
+var init_types = __esm(() => {
+  ((SpanKind2) => {
+    SpanKind2["CLIENT"] = "client";
+    SpanKind2["SERVER"] = "server";
+    SpanKind2["INTERNAL"] = "internal";
+  })(SpanKind ||= {});
+  ((SpanStatus2) => {
+    SpanStatus2["OK"] = "ok";
+    SpanStatus2["ERROR"] = "error";
+  })(SpanStatus ||= {});
+});
+
+// packages/core/src/env/log-trace/opentelemetry/tracer-provider.ts
+var exports_tracer_provider = {};
+__export(exports_tracer_provider, {
+  resetTracerProvider: () => resetTracerProvider,
+  getTracerProvider: () => getTracerProvider,
+  OTelTracerProvider: () => OTelTracerProvider
+});
+
+class OTelSpanImpl {
+  name;
+  kind;
+  spanContext;
+  attributes = {};
+  startTime;
+  endTime;
+  error;
+  storage;
+  parentSpanContext;
+  onEnd;
+  constructor(name, spanContext, storage, parentSpanContext, onEnd) {
+    this.name = name;
+    this.kind = "internal";
+    this.spanContext = spanContext;
+    this.parentSpanContext = parentSpanContext;
+    this.startTime = Date.now();
+    this.storage = storage;
+    this.onEnd = onEnd;
+  }
+  setAttribute(key, value) {
+    this.attributes[key] = value;
+  }
+  addEvent(name, attributes) {
+    const events = this.attributes._events || [];
+    events.push({ name, attributes });
+    this.attributes._events = events;
+  }
+  end(result, error) {
+    this.endTime = Date.now();
+    if (error) {
+      this.error = error.message;
+    }
+    this.storage.save({
+      traceId: this.spanContext.traceId,
+      spanId: this.spanContext.spanId,
+      parentSpanId: this.spanContext.parentSpanId,
+      name: this.name,
+      kind: this.kind,
+      status: error ? "error" /* ERROR */ : "ok" /* OK */,
+      startTime: this.startTime,
+      endTime: this.endTime,
+      attributes: this.attributes,
+      result,
+      error: this.error
+    });
+    this.onEnd?.();
+  }
+}
+
+class OTelTracerImpl {
+  name;
+  version;
+  storage;
+  currentContext;
+  activeSpans = new Map;
+  onSpanEndCallback;
+  provider;
+  constructor(name, version, storage, provider) {
+    this.name = name;
+    this.version = version;
+    this.storage = storage;
+    this.provider = provider;
+  }
+  setOnSpanEndCallback(callback) {
+    this.onSpanEndCallback = callback;
+  }
+  getActiveSpanCount() {
+    return this.activeSpans.size;
+  }
+  startSpan(name, options) {
+    const parentFromOptions = options?.parent;
+    const hasExplicitParent = options && "parent" in options;
+    const globalContext = this.provider.getGlobalContext();
+    let effectiveParentContext;
+    if (hasExplicitParent) {
+      effectiveParentContext = parentFromOptions;
+    } else if (this.currentContext) {
+      effectiveParentContext = this.currentContext;
+    } else if (globalContext) {
+      effectiveParentContext = globalContext;
+    }
+    const traceId = effectiveParentContext?.traceId || this.generateTraceId();
+    const spanId = this.generateSpanId();
+    let parentSpanId;
+    if (hasExplicitParent && parentFromOptions) {
+      parentSpanId = parentFromOptions.parentSpanId || parentFromOptions.spanId;
+    } else if (this.currentContext) {
+      parentSpanId = this.currentContext.spanId;
+    } else if (globalContext) {
+      parentSpanId = globalContext.spanId;
+    }
+    const spanContext = {
+      traceId,
+      spanId,
+      parentSpanId
+    };
+    this.currentContext = {
+      traceId,
+      spanId,
+      parentSpanId
+    };
+    const span = new OTelSpanImpl(name, spanContext, this.storage, effectiveParentContext, () => this.handleSpanEnd(spanContext.spanId, effectiveParentContext?.spanId));
+    if (options?.attributes) {
+      for (const [key, value] of Object.entries(options.attributes)) {
+        span.setAttribute(key, value);
+      }
+    }
+    this.activeSpans.set(spanId, span);
+    return span;
+  }
+  injectToEnv(env) {
+    if (this.currentContext) {
+      propagation.inject(env, this.currentContext);
+    }
+  }
+  getCurrentContext() {
+    return this.currentContext;
+  }
+  setCurrentContext(context) {
+    this.currentContext = context;
+  }
+  endSpan(span) {
+    const spanContext = span.spanContext;
+    this.activeSpans.delete(spanContext.spanId);
+    const currentTraceId = this.currentContext?.traceId;
+    if (spanContext.parentSpanId) {
+      const parentSpan = this.activeSpans.get(spanContext.parentSpanId);
+      if (parentSpan) {
+        const parentContext = {
+          traceId: spanContext.traceId,
+          spanId: parentSpan.spanContext.spanId,
+          parentSpanId: parentSpan.spanContext.parentSpanId
+        };
+        this.currentContext = parentContext;
+        return parentContext;
+      }
+      if (currentTraceId) {
+        const parentContext = {
+          traceId: currentTraceId,
+          spanId: spanContext.parentSpanId,
+          parentSpanId: undefined
+        };
+        this.currentContext = parentContext;
+        return parentContext;
+      }
+    }
+    this.currentContext = undefined;
+    return;
+  }
+  generateTraceId() {
+    const timestamp = Date.now().toString(16).padStart(12, "0");
+    const random = Array.from({ length: 5 }, () => Math.floor(Math.random() * 4294967295).toString(16).padStart(8, "0")).join("");
+    return (timestamp + random).slice(0, 32).padStart(32, "0");
+  }
+  generateSpanId() {
+    return Math.floor(Math.random() * 18446744073709552000).toString(16).padStart(16, "0");
+  }
+  handleSpanEnd(spanId, parentSpanId) {
+    this.activeSpans.delete(spanId);
+    const currentTraceId = this.currentContext?.traceId;
+    if (parentSpanId) {
+      const parentSpan = this.activeSpans.get(parentSpanId);
+      if (parentSpan) {
+        this.currentContext = {
+          traceId: parentSpan.spanContext.traceId,
+          spanId: parentSpan.spanContext.spanId,
+          parentSpanId: parentSpan.spanContext.parentSpanId
+        };
+        return;
+      }
+      if (currentTraceId) {
+        this.currentContext = {
+          traceId: currentTraceId,
+          spanId: parentSpanId,
+          parentSpanId: undefined
+        };
+        return;
+      }
+    }
+    this.currentContext = undefined;
+  }
+}
+
+class OTelTracerProvider {
+  tracers = new Map;
+  storage;
+  initialized = false;
+  globalContext;
+  constructor(storage, dbPath) {
+    this.storage = storage || new SQLiteSpanStorage(dbPath || getDefaultDbPath());
+  }
+  async initialize() {
+    if (this.initialized)
+      return;
+    await this.storage.initialize();
+    this.initialized = true;
+  }
+  isInitialized() {
+    return this.initialized;
+  }
+  getGlobalContext() {
+    return this.globalContext;
+  }
+  setGlobalContext(context) {
+    this.globalContext = context;
+  }
+  getTracer(name, version) {
+    const key = `${name}@${version || "0.0.0"}`;
+    let tracer = this.tracers.get(key);
+    if (!tracer) {
+      tracer = new OTelTracerImpl(name, version, this.storage, this);
+      this.tracers.set(key, tracer);
+      if (this.initialized) {
+        this.restoreFromEnv(tracer);
+      }
+    }
+    return tracer;
+  }
+  restoreFromEnv(tracer) {
+    const extracted = propagation.extract(process.env);
+    if (extracted) {
+      tracer.setCurrentContext({
+        traceId: extracted.traceId,
+        spanId: extracted.spanId,
+        parentSpanId: undefined
+      });
+    }
+  }
+  shutdown() {
+    for (const tracer of this.tracers.values()) {}
+    this.tracers.clear();
+    this.storage.close();
+    this.initialized = false;
+    this.globalContext = undefined;
+    delete process.env["TRACEPARENT"];
+    delete process.env["TRACE_ID"];
+    delete process.env["LOG_TRACE_REQUEST_ID"];
+  }
+  getStorage() {
+    return this.storage;
+  }
+}
+function getTracerProvider() {
+  if (!providerInstance) {
+    providerInstance = new OTelTracerProvider;
+  }
+  return providerInstance;
+}
+function resetTracerProvider() {
+  if (providerInstance) {
+    providerInstance.shutdown();
+    providerInstance = null;
+  }
+}
+function getDefaultDbPath() {
+  const os = __require("os");
+  const path = __require("path");
+  const home = os.homedir();
+  const dataHome = process.env.XDG_DATA_HOME || path.join(home, ".local", "share");
+  return path.join(dataHome, "roy-agent", "traces.db");
+}
+var providerInstance = null;
+var init_tracer_provider = __esm(() => {
+  init_propagation();
+  init_types();
+});
+
+// packages/core/src/env/log-trace/logger.ts
+import { appendFileSync, existsSync, mkdirSync } from "fs";
+import { join } from "path";
+function simplifyFilePath(fullPath) {
+  let path = fullPath.replace(/\\/g, "/");
+  const bunfsMatch = path.match(/\/\$bunfs\/root\/(.+)$/);
+  if (bunfsMatch) {
+    const virtualPath = bunfsMatch[1];
+    const packagesMatch = virtualPath.match(/(packages\/[^/]+\/src\/[^/]+\/.+)$/);
+    if (packagesMatch) {
+      return packagesMatch[1];
+    }
+    return virtualPath;
+  }
+  const fileProtocolMatch = path.match(/@roy-agent\+core@file\+([^/]+)\/node_modules\/@roy-agent\/core\/(.+)$/);
+  if (fileProtocolMatch) {
+    const rootPkg = fileProtocolMatch[1].replace(/\+/g, "/");
+    const remaining = fileProtocolMatch[2];
+    const prefix = rootPkg;
+    const suffix = remaining.startsWith("src/") ? remaining : `src/${remaining}`;
+    return `${prefix}/${suffix}`;
+  }
+  const packagesRootMatch = path.match(/(packages\/[^/]+\/src\/[^/]+\/.+)$/);
+  if (packagesRootMatch) {
+    return packagesRootMatch[1];
+  }
+  const rootMarkers = ["packages/core/src", "packages/core", "packages"];
+  for (const marker of rootMarkers) {
+    const idx = path.indexOf(marker);
+    if (idx !== -1) {
+      return path.substring(idx);
+    }
+  }
+  return path;
+}
+function getDefaultLogDir() {
+  const home = process.env.HOME || process.env.USERPROFILE || "/tmp";
+  try {
+    const xdg = __require("xdg-basedir");
+    if (xdg.xdgData) {
+      return join(xdg.xdgData, "roy-agent", "logs");
+    }
+  } catch {}
+  return join(home, ".local", "share", "roy-agent", "logs");
+}
+function isQuietMode() {
+  return quietMode;
+}
+function setQuietMode(enabled) {
+  quietMode = enabled;
+}
+function setConfigComponent(component) {
+  configComponentInstance = component;
+}
+function getLogLevel() {
+  if (configComponentInstance) {
+    const level = configComponentInstance.get("log_trace.logging.level");
+    if (level && ["debug", "info", "warn", "error"].includes(level)) {
+      return level;
+    }
+  }
+  const envLevel = process.env.LOG_LEVEL;
+  if (envLevel && ["debug", "info", "warn", "error"].includes(envLevel)) {
+    return envLevel;
+  }
+  return "info";
+}
+function getCategoryLogLevel(category) {
+  if (configComponentInstance) {
+    const levels = configComponentInstance.get("log_trace.logging.levels");
+    if (levels && typeof levels === "object") {
+      const categoryLevel = levels[category];
+      if (categoryLevel && ["debug", "info", "warn", "error"].includes(categoryLevel)) {
+        return categoryLevel;
+      }
+    }
+    const directLevel = configComponentInstance.get(`log_trace.logging.levels.${category}`);
+    if (directLevel && ["debug", "info", "warn", "error"].includes(directLevel)) {
+      return directLevel;
+    }
+  }
+  const envKey = `LOG_LEVEL_${category.toUpperCase().replace(/:/g, "_")}`;
+  const envLevel = process.env[envKey];
+  if (envLevel && ["debug", "info", "warn", "error"].includes(envLevel)) {
+    return envLevel;
+  }
+  return getLogLevel();
+}
+function isAbsolutePath(path) {
+  if (path.startsWith("/")) {
+    return true;
+  }
+  if (/^[a-zA-Z]:[/\\]/.test(path)) {
+    return true;
+  }
+  return false;
+}
+function expandHomeDir(path) {
+  if (path.startsWith("~")) {
+    const home = process.env.HOME || process.env.USERPROFILE || "/tmp";
+    return join(home, path.slice(1));
+  }
+  return path;
+}
+function getLogFile() {
+  if (configComponentInstance) {
+    const file = configComponentInstance.get("log_trace.logging.file");
+    if (file) {
+      return file;
+    }
+  }
+  return "app.log";
+}
+function getLogDir() {
+  if (configComponentInstance) {
+    const dir = configComponentInstance.get("log_trace.logging.dir");
+    if (dir) {
+      return dir;
+    }
+  }
+  return getDefaultLogDir();
+}
+function getMaxOutput() {
+  if (configComponentInstance) {
+    const maxOutput = configComponentInstance.get("log-trace.logging.maxOutput");
+    if (typeof maxOutput === "number") {
+      return maxOutput;
+    }
+  }
+  return;
+}
+function setLogDirOverride(dir) {
+  logDirOverride = dir;
+}
+function getLogDirOverride() {
+  return logDirOverride;
+}
+
+class Logger {
+  prefix;
+  constructor(prefix) {
+    this.prefix = prefix;
+  }
+  shouldLog(level) {
+    const categoryLevel = getCategoryLogLevel(this.prefix);
+    return levelPriority[level] >= levelPriority[categoryLevel];
+  }
+  ensureLogDirectory(dir) {
+    if (!existsSync(dir)) {
+      try {
+        mkdirSync(dir, { recursive: true });
+      } catch (err) {
+        console.error("[Logger] Failed to create log directory:", dir, err);
+      }
+    }
+  }
+  getCallerLocation() {
+    const originalLimit = Error.stackTraceLimit;
+    Error.stackTraceLimit = 10;
+    const err = new Error;
+    Error.captureStackTrace(err, this.formatMessage);
+    const stack = err.stack?.split(`
+`) || [];
+    Error.stackTraceLimit = originalLimit;
+    for (let i = 1;i < stack.length; i++) {
+      const line = stack[i];
+      if (line.includes("at ") && !line.includes("logger.ts") && !line.includes("formatMessage")) {
+        const match = line.match(/at\s+.+\s+\((.+):(\d+):\d+\)/) || line.match(/at\s+(.+):(\d+):\d+/);
+        if (match) {
+          const filePath = match[1];
+          const relativePath = this.getRelativePath(filePath);
+          return {
+            file: relativePath,
+            line: parseInt(match[2], 10)
+          };
+        }
+      }
+    }
+    return null;
+  }
+  getRelativePath(fullPath) {
+    return simplifyFilePath(fullPath);
+  }
+  formatMessage(level, message, data) {
+    const now = new Date;
+    const timestamp = now.toLocaleString("zh-CN", {
+      timeZone: "Asia/Shanghai",
+      year: "numeric",
+      month: "2-digit",
+      day: "2-digit",
+      hour: "2-digit",
+      minute: "2-digit",
+      second: "2-digit",
+      hour12: false
+    }).replace(/\//g, "-") + "." + String(now.getMilliseconds()).padStart(3, "0");
+    const prefix = this.prefix ? `[${this.prefix}]` : "";
+    let traceIdStr = "";
+    try {
+      const provider = getTracerProvider();
+      const tracer = provider.getTracer("roy-tracer");
+      const context = tracer.getCurrentContext();
+      if (context?.traceId) {
+        traceIdStr = `[traceId=${context.traceId}]`;
+      }
+    } catch {}
+    let locationStr = "";
+    if (data && typeof data === "object" && "callerLocation" in data) {
+      const logData = data;
+      locationStr = logData.callerLocation ? ` [${logData.callerLocation}]` : "";
+      const { callerLocation: _callerLocation, ...rest } = logData;
+      data = Object.keys(rest).length > 0 ? rest : undefined;
+    } else {
+      const location = this.getCallerLocation();
+      if (location) {
+        locationStr = ` [${location.file}:${location.line}]`;
+      }
+    }
+    let formatted = `${timestamp} [${level.toUpperCase()}]${traceIdStr}${locationStr}${prefix} ${message}`;
+    if (data !== undefined) {
+      if (typeof data === "object") {
+        formatted += " " + JSON.stringify(data).replace(/\n/g, "");
+      } else {
+        formatted += " " + String(data);
+      }
+    }
+    const maxOutput = getMaxOutput();
+    if (maxOutput && maxOutput > 0 && formatted.length > maxOutput) {
+      formatted = formatted.substring(0, maxOutput) + " [TRUNCATED]";
+    }
+    return formatted;
+  }
+  writeToFile(message) {
+    try {
+      const dir = getLogDir();
+      const filename = getLogFile();
+      const expandedDir = expandHomeDir(dir);
+      const resolvedDir = isAbsolutePath(expandedDir) ? expandedDir : join(process.cwd(), expandedDir);
+      this.ensureLogDirectory(resolvedDir);
+      const logFile = join(resolvedDir, filename);
+      appendFileSync(logFile, message + `
+`, "utf-8");
+    } catch (err) {
+      console.error("[Logger] Failed to write to log file:", err);
+    }
+  }
+  log(level, message, data) {
+    if (!this.shouldLog(level))
+      return;
+    const formatted = this.formatMessage(level, message, data);
+    this.writeToFile(formatted);
+    if (!isQuietMode()) {
+      const consoleMethod = level === "error" ? console.error : level === "warn" ? console.warn : level === "info" ? console.log : console.debug;
+      consoleMethod(formatted);
+    }
+  }
+  debug(message, data) {
+    this.log("debug", message, data);
+  }
+  info(message, data) {
+    this.log("info", message, data);
+  }
+  warn(message, data) {
+    this.log("warn", message, data);
+  }
+  error(message, data) {
+    this.log("error", message, data);
+  }
+}
+function createLogger(prefix) {
+  if (!loggerCache.has(prefix)) {
+    loggerCache.set(prefix, new Logger(prefix));
+  }
+  return loggerCache.get(prefix);
+}
+function getLogLevels() {
+  return ["debug", "info", "warn", "error"];
+}
+var configComponentInstance = null, quietMode = false, logDirOverride, levelPriority, loggerCache;
+var init_logger = __esm(() => {
+  init_tracer_provider();
+  levelPriority = {
+    debug: 0,
+    info: 1,
+    warn: 2,
+    error: 3
+  };
+  loggerCache = new Map;
+});
+
+// packages/core/src/env/hook/types.ts
+function createHook(meta, fn) {
+  return {
+    ...meta,
+    execute: fn
+  };
+}
+function createPriorityHook(name, fn, priority) {
+  return createHook({ name, priority }, fn);
+}
+// packages/core/src/env/hook/hook-manager.ts
+class HookManager {
+  _hooks = new Map;
+  componentName;
+  componentVersion;
+  defaultPriority;
+  constructor(options = {}) {
+    this.componentName = options.componentName ?? "unknown";
+    this.componentVersion = options.componentVersion ?? "0.0.0";
+    this.defaultPriority = options.defaultPriority ?? 0;
+  }
+  register(hookPoint, hook) {
+    const hooks = this.getOrCreateHooks(hookPoint);
+    hooks.push(hook);
+  }
+  registerMany(hookPoint, hooks) {
+    const hookList = this.getOrCreateHooks(hookPoint);
+    hookList.push(...hooks);
+  }
+  unregister(hookPoint, name) {
+    const hooks = this._hooks.get(hookPoint);
+    if (!hooks)
+      return false;
+    const index = hooks.findIndex((h) => h.name === name);
+    if (index === -1)
+      return false;
+    hooks.splice(index, 1);
+    return true;
+  }
+  unregisterAll(hookPoint) {
+    this._hooks.delete(hookPoint);
+  }
+  async execute(hookPoint, data, metadata = {}) {
+    const hooks = this._hooks.get(hookPoint);
+    if (!hooks || hooks.length === 0)
+      return;
+    const sortedHooks = this.sortHooks(hooks);
+    const ctx = this.createContext(hookPoint, data, metadata, "before");
+    for (const hook of sortedHooks) {
+      await this.safeExecute(hook, ctx);
+    }
+  }
+  async executeAndCollect(hookPoint, data, metadata = {}) {
+    const hooks = this._hooks.get(hookPoint);
+    if (!hooks || hooks.length === 0)
+      return [];
+    const sortedHooks = this.sortHooks(hooks);
+    const ctx = this.createContext(hookPoint, data, metadata, "before");
+    const results = [];
+    for (const hook of sortedHooks) {
+      const result = await this.safeExecuteAndReturn(hook, ctx);
+      if (result !== undefined) {
+        results.push(result);
+      }
+    }
+    return results;
+  }
+  count(hookPoint) {
+    return this._hooks.get(hookPoint)?.length ?? 0;
+  }
+  clear() {
+    this._hooks.clear();
+  }
+  getHookPoints() {
+    return Array.from(this._hooks.keys());
+  }
+  hasHooks(hookPoint) {
+    return this.count(hookPoint) > 0;
+  }
+  setComponentInfo(name, version) {
+    this.componentName = name;
+    this.componentVersion = version;
+  }
+  get hooks() {
+    return this._hooks;
+  }
+  async executeWithIntervention(hookPoint, data, metadata = {}) {
+    const hooks = this._hooks.get(hookPoint);
+    if (!hooks || hooks.length === 0) {
+      return { stopped: false, results: [] };
+    }
+    const sortedHooks = this.sortHooks(hooks);
+    const ctx = this.createContext(hookPoint, data, metadata, "before");
+    const results = [];
+    let stopped = false;
+    let action;
+    for (const hook of sortedHooks) {
+      if (stopped)
+        break;
+      const result = await this.safeExecuteAndReturn(hook, ctx);
+      results.push(result);
+      if (result && typeof result === "object" && "stopped" in result) {
+        const hookResult = result;
+        if (hookResult.stopped) {
+          stopped = true;
+          action = hookResult.action;
+        }
+      }
+    }
+    return { stopped, action, results };
+  }
+  getOrCreateHooks(hookPoint) {
+    let hooks = this._hooks.get(hookPoint);
+    if (!hooks) {
+      hooks = [];
+      this._hooks.set(hookPoint, hooks);
+    }
+    return hooks;
+  }
+  sortHooks(hooks) {
+    return [...hooks].sort((a, b) => {
+      const priorityA = a.priority ?? this.defaultPriority;
+      const priorityB = b.priority ?? this.defaultPriority;
+      return priorityA - priorityB;
+    });
+  }
+  createContext(hookPoint, data, metadata, phase) {
+    return {
+      component: {
+        name: this.componentName,
+        version: this.componentVersion
+      },
+      data,
+      metadata,
+      phase,
+      hookPoint
+    };
+  }
+  async safeExecute(hook, ctx) {
+    try {
+      await hook.execute(ctx);
+    } catch (error) {
+      console.error(`Hook "${hook.name}" failed:`, error);
+    }
+  }
+  async safeExecuteAndReturn(hook, ctx) {
+    try {
+      return await hook.execute(ctx);
+    } catch (error) {
+      console.error(`Hook "${hook.name}" failed:`, error);
+      return;
+    }
+  }
+}
+// packages/core/src/env/hook/global-hook-manager.ts
+var globalHookManager = new HookManager;
+var AgentHookPoints = {
+  BEFORE_START: "agent:before.start",
+  BEFORE_LLM: "agent:before.llm",
+  AFTER_LLM: "agent:after.llm",
+  BEFORE_TOOL: "agent:before.tool",
+  AFTER_TOOL: "agent:after.tool",
+  ON_ITERATION: "agent:on.iteration",
+  ON_THRESHOLD: "agent:on.threshold",
+  AFTER_COMPLETE: "agent:after.complete",
+  ON_ERROR: "agent:on.error"
+};
+var LLMHookPoints = {
+  BEFORE_INVOKE: "llm:before.invoke",
+  AFTER_INVOKE: "llm:after.invoke",
+  ON_STREAM: "llm:on.stream"
+};
+var ToolHookPoints = {
+  BEFORE_EXECUTE: "tool:before.execute",
+  AFTER_EXECUTE: "tool:after.execute",
+  BEFORE_REGISTER: "tool:before.register",
+  AFTER_REGISTER: "tool:after.register",
+  ON_ERROR: "tool:on.error"
+};
+var hookPointAliases = {
+  "before.tool": "tool:before.execute",
+  "after.tool": "tool:after.execute",
+  "llm.before-invoke": "llm:before.invoke",
+  "llm.after-invoke": "llm:after.invoke",
+  "llm.stream": "llm:on.stream"
+};
+function setupAliasHooks() {
+  const originalRegister = globalHookManager.register.bind(globalHookManager);
+  globalHookManager.register = function(hookPoint, hook) {
+    originalRegister(hookPoint, hook);
+    const alias = hookPointAliases[hookPoint];
+    if (alias) {
+      originalRegister(alias, hook);
+    }
+  };
+}
+setupAliasHooks();
+async function executeAgentHook(hookPoint, data, metadata = {}) {
+  await globalHookManager.execute(hookPoint, data, metadata);
+}
+async function executeAgentHookWithIntervention(hookPoint, data, metadata = {}) {
+  return globalHookManager.executeWithIntervention(hookPoint, data, metadata);
+}
+async function executeLLMHook(hookPoint, data, metadata = {}) {
+  await globalHookManager.execute(hookPoint, data, metadata);
+}
+async function executeToolHook(hookPoint, data, metadata = {}) {
+  await globalHookManager.execute(hookPoint, data, metadata);
+}
+// packages/core/src/env/memory/built-in/record-memory.ts
+import { z } from "zod";
+var RecordMemorySchema = z.object({
+  scope: z.enum(["project", "global"]).describe("\u4F5C\u7528\u57DF: project/global"),
+  mode: z.enum(["append", "prepend", "overwrite", "delete"]).describe("\u6A21\u5F0F: append(\u8FFD\u52A0)/prepend(\u63D2\u5165)/overwrite(\u8986\u76D6)/delete(\u5220\u9664)"),
+  content: z.string().optional().describe("\u8BB0\u5FC6\u5185\u5BB9"),
+  title: z.string().optional().describe("\u7AE0\u8282\u6807\u9898")
+});
+function createRecordMemoryTool(recordMemory, getMemoryPaths, getMemoryFile) {
+  return {
+    name: "record_memory",
+    description: buildDescription(getMemoryPaths, getMemoryFile),
+    parameters: RecordMemorySchema,
+    execute: async (args, _ctx) => {
+      const params = RecordMemorySchema.parse(args);
+      const startTime = Date.now();
+      try {
+        const result = await recordMemory({
+          scope: params.scope,
+          mode: params.mode,
+          content: params.content,
+          title: params.title
+        });
+        if (!result) {
+          return {
+            success: false,
+            output: "",
+            error: "\u672A\u914D\u7F6E memory \u8DEF\u5F84\uFF0C\u65E0\u6CD5\u8BB0\u5F55\u8BB0\u5FC6",
+            metadata: { execution_time_ms: Date.now() - startTime }
+          };
+        }
+        const actionMessages = {
+          created: "\u5DF2\u521B\u5EFA\u8BB0\u5FC6\u6587\u4EF6",
+          overwrite: "\u5DF2\u8986\u76D6\u8BB0\u5FC6\u6587\u4EF6",
+          append: "\u5DF2\u8FFD\u52A0\u5185\u5BB9\u5230\u8BB0\u5FC6\u6587\u4EF6",
+          prepend: "\u5DF2\u63D2\u5165\u5185\u5BB9\u5230\u8BB0\u5FC6\u6587\u4EF6\u5F00\u5934",
+          delete: "\u5DF2\u5220\u9664\u8BB0\u5FC6\u6587\u4EF6"
+        };
+        return {
+          success: true,
+          output: `${actionMessages[result.action]}: ${result.path}`,
+          metadata: {
+            execution_time_ms: Date.now() - startTime,
+            path: result.path,
+            action: result.action
+          }
+        };
+      } catch (error) {
+        return {
+          success: false,
+          output: "",
+          error: error instanceof Error ? error.message : String(error),
+          metadata: { execution_time_ms: Date.now() - startTime }
+        };
+      }
+    }
+  };
+}
+function buildDescription(getMemoryPaths, getMemoryFile) {
+  const paths = getMemoryPaths();
+  const memoryFile = getMemoryFile();
+  const lines = [
+    `# Record Memory Tool`,
+    "",
+    `Record memory to file. Writes to the memory.md file in the specified scope.`,
+    "",
+    `## Modes`,
+    "",
+    "| Mode | Description |",
+    "|------|-------------|",
+    "| **append** | \u8FFD\u52A0\u5185\u5BB9\u5230 ${memoryFile} \u5C3E\u90E8 |",
+    "| **prepend** | \u63D2\u5165\u5185\u5BB9\u5230 ${memoryFile} \u5F00\u5934 |",
+    "| **overwrite** | \u8986\u76D6 ${memoryFile} |",
+    "| **delete** | \u5220\u9664 ${memoryFile} |",
+    "",
+    `## Parameters`,
+    "",
+    "- **scope** (required): \u4F5C\u7528\u57DF - project \u6216 global",
+    "- **mode** (required): \u64CD\u4F5C\u6A21\u5F0F",
+    "- **content** (optional): \u8BB0\u5FC6\u5185\u5BB9",
+    "- **title** (optional): \u7AE0\u8282\u6807\u9898",
+    "",
+    `## Memory Paths`,
+    ""
+  ];
+  if (paths.length === 0) {
+    lines.push("No memory paths configured.");
+  } else {
+    lines.push("Files will be written to:");
+    for (const p of paths) {
+      lines.push(`- **[${p.type}]** ${p.path}/${memoryFile}`);
+    }
+  }
+  return lines.join(`
+`);
+}
+
+// packages/core/src/env/memory/built-in/recall-memory.ts
+import { z as z2 } from "zod";
+var RecallMemorySchema = z2.object({
+  scope: z2.enum(["project", "global"]).optional().describe("\u4F5C\u7528\u57DF\uFF08\u53EF\u9009\uFF0C\u4E0D\u4F20\u5219\u8BFB\u53D6\u6240\u6709\uFF09")
+});
+function createRecallMemoryTool(recallMemory, getMemoryPaths, getMemoryFile) {
+  return {
+    name: "recall_memory",
+    description: buildDescription2(getMemoryPaths, getMemoryFile),
+    parameters: RecallMemorySchema,
+    execute: async (args, _ctx) => {
+      const params = RecallMemorySchema.parse(args);
+      const startTime = Date.now();
+      try {
+        const content = await recallMemory(params.scope);
+        if (!content) {
+          return {
+            success: true,
+            output: "(No memory files found)",
+            metadata: { execution_time_ms: Date.now() - startTime }
+          };
+        }
+        return {
+          success: true,
+          output: content,
+          metadata: { execution_time_ms: Date.now() - startTime }
+        };
+      } catch (error) {
+        return {
+          success: false,
+          output: "",
+          error: error instanceof Error ? error.message : String(error),
+          metadata: { execution_time_ms: Date.now() - startTime }
+        };
+      }
+    }
+  };
+}
+function buildDescription2(getMemoryPaths, getMemoryFile) {
+  const paths = getMemoryPaths();
+  const memoryFile = getMemoryFile();
+  const lines = [
+    `# Recall Memory Tool`,
+    "",
+    `Recall memory from memory files. Reads from the memory.md file in the specified scope.`,
+    "",
+    `## Parameters`,
+    "",
+    "- **scope** (optional): \u4F5C\u7528\u57DF - project \u6216 global\uFF08\u4E0D\u4F20\u5219\u8BFB\u53D6\u6240\u6709\uFF09",
+    "",
+    `## Memory Files`,
+    ""
+  ];
+  if (paths.length === 0) {
+    lines.push("No memory paths configured.");
+  } else {
+    lines.push("Files will be read from:");
+    for (const p of paths) {
+      lines.push(`- **[${p.type}]** ${p.path}/${memoryFile}`);
+    }
+  }
+  return lines.join(`
+`);
+}
+
+// packages/core/src/env/memory/built-in/index.ts
+function createMemoryTools(recordMemory, recallMemory, config) {
+  return [
+    createRecordMemoryTool(recordMemory, config.getMemoryPaths, config.getMemoryFile),
+    createRecallMemoryTool(recallMemory, config.getMemoryPaths, config.getMemoryFile)
+  ];
+}
+
+// packages/core/src/env/memory/plugin/memory-manager.ts
+init_logger();
+var logger = createLogger("MemoryManagerV3");
+function generateTaskId() {
+  return `task_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+}
+
+class MemoryManager {
+  static MAX_QUEUE_SIZE = 100;
+  queue = [];
+  processing = false;
+  shuttingDown = false;
+  config;
+  processingPromise = null;
+  resolveProcessing = null;
+  constructor(config = {}) {
+    this.config = config;
+  }
+  updateConfig(config) {
+    this.config = { ...this.config, ...config };
+  }
+  enqueue(task) {
+    if (this.shuttingDown) {
+      logger.debug("MemoryManager is shutting down, ignoring new task");
+      return;
+    }
+    const fullTask = {
+      ...task,
+      id: generateTaskId()
+    };
+    if (this.queue.length >= MemoryManager.MAX_QUEUE_SIZE) {
+      const dropped = this.queue.shift();
+      logger.warn(`Queue full (${MemoryManager.MAX_QUEUE_SIZE}), dropping oldest task: ${dropped?.id}`);
+    }
+    this.queue.push(fullTask);
+    logger.debug(`Task enqueued: ${task.type}, queue size: ${this.queue.length}`);
+    if (!this.processing) {
+      this.startProcessingLoop();
+    }
+  }
+  startProcessingLoop() {
+    const runLoop = async () => {
+      while (this.queue.length > 0 && !this.shuttingDown) {
+        const task = this.queue.shift();
+        try {
+          await this.processTask(task);
+        } catch (error) {
+          logger.error(`Task ${task.id} failed:`, error);
+        }
+      }
+      this.processing = false;
+      if (this.resolveProcessing) {
+        this.resolveProcessing();
+        this.resolveProcessing = null;
+        this.processingPromise = null;
+      }
+    };
+    this.processing = true;
+    this.processingPromise = new Promise((resolve) => {
+      this.resolveProcessing = resolve;
+    });
+    setImmediate(() => {
+      runLoop().catch((error) => {
+        logger.error("Processing loop error:", error);
+        this.processing = false;
+      });
+    });
+  }
+  hasPendingTasks() {
+    return this.queue.length > 0 || this.processing;
+  }
+  async waitForCompletion() {
+    if (this.queue.length === 0 && !this.processing) {
+      return;
+    }
+    if (this.processingPromise) {
+      await this.processingPromise;
+    }
+  }
+  prepareShutdown() {
+    this.shuttingDown = true;
+    logger.info("MemoryManager preparing for shutdown");
+  }
+  async dispose() {
+    await this.waitForCompletion();
+    this.queue = [];
+    logger.info("MemoryManager disposed");
+  }
+  async processTask(task) {
+    logger.debug(`Processing task: ${task.type}`);
+    switch (task.type) {
+      case "extract_memory":
+        await this.handleExtractMemory(task.payload);
+        break;
+      default:
+        logger.warn(`Unknown task type: ${task.type}`);
+    }
+  }
+  async handleExtractMemory(payload) {
+    const messageCount = payload.messages?.length || 0;
+    logger.info(`Extracting memory from ${messageCount} messages`);
+    if (this.config.onExtractMemory) {
+      try {
+        await this.config.onExtractMemory(payload);
+      } catch (error) {
+        logger.error("Memory extraction failed", { error });
+      }
+    }
+  }
+}
+// packages/core/src/env/memory/plugin/types.ts
+var DEFAULT_MEMORY_PLUGIN_CONFIG = {
+  enabled: true
+};
+
+// packages/core/src/env/memory/plugin/memory-plugin.ts
+init_logger();
+import path from "path";
+import os from "os";
+var logger2 = createLogger("MemoryPlugin");
+
+class MemoryPlugin {
+  config;
+  disposed = false;
+  initialized = false;
+  projectBaseDir = "";
+  globalBaseDir = "";
+  workDir = "";
+  agentComponent = null;
+  constructor(baseDir, config = {}) {
+    this.config = { ...DEFAULT_MEMORY_PLUGIN_CONFIG, ...config };
+    this.workDir = baseDir;
+    this.projectBaseDir = path.join(baseDir, ".roy", "memory");
+    this.globalBaseDir = path.join(os.homedir(), ".config", "roy-agent", "memory");
+    logger2.info("MemoryPlugin (simplified) created", { baseDir, config: this.config });
+  }
+  get name() {
+    return "MemoryPlugin";
+  }
+  get hookPoint() {
+    return "agent:after.react";
+  }
+  get priority() {
+    return 50;
+  }
+  get description() {
+    return "Memory management plugin. Use 'roy memory recall --extract' to extract memories.";
+  }
+  get hooks() {
+    return [
+      {
+        point: this.hookPoint,
+        priority: this.priority
+      }
+    ];
+  }
+  async initialize() {
+    if (this.initialized) {
+      return;
+    }
+    this.initialized = true;
+    logger2.info("MemoryPlugin (simplified) initialized");
+  }
+  async execute(ctx) {
+    if (this.disposed || !this.config.enabled || !this.initialized) {
+      return;
+    }
+    logger2.debug("MemoryPlugin hook executed. Use 'roy memory recall --extract' for memory extraction.");
+  }
+  prepareShutdown() {}
+  hasPendingTasks() {
+    return false;
+  }
+  async waitForCompletion() {}
+  async dispose() {
+    if (this.disposed) {
+      return;
+    }
+    this.disposed = true;
+    logger2.info("MemoryPlugin (simplified) disposed");
+  }
+  getProjectBaseDir() {
+    return this.projectBaseDir;
+  }
+  getGlobalBaseDir() {
+    return this.globalBaseDir;
+  }
+}
+function createMemoryPlugin(baseDir, config) {
+  return new MemoryPlugin(baseDir, config);
+}
+// packages/core/src/env/memory/plugin/recall-memory.ts
+import fs from "fs/promises";
+import path2 from "path";
+async function recallMemory(memoryPaths) {
+  const results = [];
+  for (const memoryPath of memoryPaths) {
+    const scope = memoryPath.type;
+    const baseDir = memoryPath.path;
+    try {
+      const memoryFile = path2.join(baseDir, "memory.md");
+      try {
+        const content = await fs.readFile(memoryFile, "utf-8");
+        if (content.trim()) {
+          results.push(`## [${scope}] memory.md
+${content}`);
+        }
+      } catch {}
+    } catch (error) {
+      console.error(`Error processing memory path ${baseDir}:`, error);
+    }
+  }
+  if (results.length === 0) {
+    return "(No memory files found)";
+  }
+  return results.join(`
+
+`);
+}
+// packages/core/src/env/memory/plugin/memory-agent.ts
+var PROJECT_MEMORY_AGENT_PROMPT = `\u4F60\u662F\u9879\u76EE\u7EA7 Memory Agent\uFF0C\u8D1F\u8D23\u6574\u7406\u548C\u66F4\u65B0\u5F53\u524D\u9879\u76EE\u7684\u8BB0\u5FC6\u3002
+
+## \u4F60\u7684\u804C\u8D23
+
+1. **\u4FE1\u606F\u6536\u96C6**\uFF1A\u5728\u63D0\u53D6\u8BB0\u5FC6\u524D\uFF0C\u5148\u6536\u96C6\u9879\u76EE\u4E0A\u4E0B\u6587\u4FE1\u606F
+2. **\u4ECE\u5BF9\u8BDD\u4E2D\u63D0\u53D6\u8BB0\u5FC6**\uFF1A\u5206\u6790 messages\uFF0C\u63D0\u53D6\u4E0E\u9879\u76EE\u76F8\u5173\u7684\u77E5\u8BC6\u3001\u51B3\u7B56\u3001\u89E3\u51B3\u65B9\u6848
+3. **\u751F\u6210 memory.md**\uFF1A\u66F4\u65B0\u9879\u76EE\u8BB0\u5FC6\u7D22\u5F15
+
+## \u4FE1\u606F\u6536\u96C6\u6B65\u9AA4\uFF08\u91CD\u8981\uFF01\uFF09
+
+\u5728\u63D0\u53D6\u8BB0\u5FC6\u4E4B\u524D\uFF0C\u8BF7\u5148\u4F7F\u7528\u53EF\u7528\u5DE5\u5177\u6536\u96C6\u9879\u76EE\u4E0A\u4E0B\u6587\uFF1A
+
+1. **\u9605\u8BFB\u9879\u76EE README**\uFF1A\u4E86\u89E3\u9879\u76EE\u6982\u8FF0\u3001\u529F\u80FD\u3001\u4F7F\u7528\u65B9\u6CD5
+   - \u8DEF\u5F84\u793A\u4F8B\uFF1AREADME.md, README.zh-CN.md, docs/README.md
+
+2. **\u68C0\u67E5\u8BBE\u8BA1\u6587\u6863**\uFF1A\u4E86\u89E3\u9879\u76EE\u67B6\u6784\u548C\u8BBE\u8BA1\u51B3\u7B56
+   - \u8DEF\u5F84\u793A\u4F8B\uFF1Adocs/design.md, docs/ARCHITECTURE.md, docs/superpowers/specs/*.md
+
+3. **\u67E5\u770B\u4EE3\u7801\u5B9E\u73B0**\uFF1A\u4E86\u89E3\u5173\u952E\u6A21\u5757\u548C\u5B9E\u73B0\u7EC6\u8282
+   - \u8DEF\u5F84\u793A\u4F8B\uFF1Asrc/**/*.ts, packages/*/src/**/*.ts
+
+4. **\u56DE\u987E\u73B0\u6709 memory**\uFF1A\u4E86\u89E3\u5DF2\u6709\u7684\u9879\u76EE\u8BB0\u5FC6
+   - \u8DEF\u5F84\uFF1A\u5F53\u524D\u76EE\u5F55\u4E0B\u7684 .roy/memory/memory.md
+
+## \u8F93\u5165\u4FE1\u606F
+
+- \u5F53\u524D\u9879\u76EE\u7684 memory.md \u5185\u5BB9
+- \u5F53\u524D\u5BF9\u8BDD\u6D88\u606F
+
+## \u8F93\u51FA\u8981\u6C42
+
+\u8BF7\u4EE5 JSON \u683C\u5F0F\u8F93\u51FA\u7ED3\u679C\uFF0C\u5305\u542B\u4EE5\u4E0B\u5B57\u6BB5\uFF1A
+- memoryMdContent: \u65B0\u7684 memory.md \u5185\u5BB9
+- projectSummary: \u9879\u76EE\u6458\u8981\uFF08\u5305\u542B summary, shortSummary \u7B49\uFF09
+- hasUpdates: \u662F\u5426\u6709\u66F4\u65B0
+
+## \u8BB0\u5FC6\u7EC4\u7EC7\u539F\u5219
+
+- \u4F18\u5148\u8BB0\u5F55\u5177\u4F53\u3001\u53EF\u64CD\u4F5C\u7684\u8BB0\u5FC6\uFF08\u4EE3\u7801\u4F4D\u7F6E\u3001\u914D\u7F6E\u9879\u3001\u547D\u4EE4\uFF09
+- \u907F\u514D\u8FC7\u4E8E\u62BD\u8C61\u6216\u901A\u7528\u7684\u63CF\u8FF0
+- \u8BB0\u5F55\u8BBE\u8BA1\u51B3\u7B56\u53CA\u5176\u7406\u7531`;
+var GLOBAL_MEMORY_AGENT_PROMPT = `\u4F60\u662F\u5168\u5C40 Memory Agent\uFF0C\u8D1F\u8D23\u6574\u7406\u8DE8\u9879\u76EE\u7684\u901A\u7528\u8BB0\u5FC6\u3002
+
+## \u4F60\u7684\u804C\u8D23
+
+1. **\u805A\u5408\u9879\u76EE\u6458\u8981**\uFF1A\u5206\u6790 projectSummaries\uFF0C\u63D0\u53D6\u5171\u6027\u77E5\u8BC6
+2. **\u7EF4\u62A4\u5168\u5C40\u8BB0\u5FC6**\uFF1A\u66F4\u65B0\u5168\u5C40 memory.md
+3. **\u7EF4\u62A4\u9879\u76EE\u7D22\u5F15**\uFF1A\u5728 memory.md \u4E2D\u7EF4\u62A4\u9879\u76EE\u5217\u8868
+4. **\u63D0\u53D6\u5171\u6027\u7ECF\u9A8C**\uFF1A\u5C06\u9879\u76EE\u7ECF\u9A8C\u63D0\u70BC\u4E3A\u901A\u7528\u6700\u4F73\u5B9E\u8DF5
+
+## \u8F93\u5165\u4FE1\u606F
+
+- \u5168\u5C40 memory.md \u5185\u5BB9
+- \u5F53\u524D\u5BF9\u8BDD\u6D88\u606F
+- \u9879\u76EE\u6458\u8981\u5217\u8868\uFF08projectSummaries\uFF09
+
+## \u8F93\u51FA\u8981\u6C42
+
+\u8BF7\u4EE5 JSON \u683C\u5F0F\u8F93\u51FA\u7ED3\u679C\uFF0C\u5305\u542B\u4EE5\u4E0B\u5B57\u6BB5\uFF1A
+- memoryMdContent: \u65B0\u7684 memory.md \u5185\u5BB9
+- hasUpdates: \u662F\u5426\u6709\u66F4\u65B0
+
+## \u8BB0\u5FC6\u7EC4\u7EC7\u539F\u5219
+
+- \u5173\u6CE8\u8DE8\u9879\u76EE\u5171\u6027\uFF08\u5DE5\u4F5C\u6D41\u3001\u89C4\u8303\u3001\u504F\u597D\uFF09
+- \u9879\u76EE\u7D22\u5F15\u53EA\u8BB0\u5F55\u6458\u8981\u548C\u8DEF\u5F84\uFF0C\u4E0D\u590D\u5236\u5185\u5BB9
+- \u7528\u6237\u4E2A\u4EBA\u504F\u597D\uFF08\u996E\u98DF\u3001\u5DE5\u4F5C\u4E60\u60EF\uFF09\u4F18\u5148\u8BB0\u5F55`;
+function createMemoryAgent(scope) {
+  const name = `memory-agent-${scope}-${Date.now()}`;
+  const systemPrompt = scope === "project" ? PROJECT_MEMORY_AGENT_PROMPT : GLOBAL_MEMORY_AGENT_PROMPT;
+  return {
+    name,
+    systemPrompt,
+    maxIterations: 5
+  };
+}
+function formatMemoryInput(input) {
+  const lines = [];
+  lines.push(`# Memory Agent Input (${input.scope} scope)
+`);
+  lines.push("## Current memory.md");
+  lines.push(input.currentMemoryMd || "_No existing memory_");
+  lines.push("");
+  lines.push("## Recent Messages");
+  if (input.messages.length === 0) {
+    lines.push("_No messages_");
+  } else {
+    for (const msg of input.messages.slice(-10)) {
+      const content = typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content);
+      lines.push(`**${msg.role}**: ${content.substring(0, 500)}`);
+    }
+  }
+  lines.push("");
+  if (input.scope === "global" && input.projectSummaries && input.projectSummaries.length > 0) {
+    lines.push("## Project Summaries");
+    for (const ps of input.projectSummaries) {
+      lines.push(`### ${ps.projectName}`);
+      lines.push(`Path: ${ps.projectPath}`);
+      lines.push(`Last Updated: ${new Date(ps.lastUpdated).toLocaleString()}`);
+      lines.push(`Summary: ${ps.summary}`);
+      lines.push(`Memory: ${ps.memoryMdPath}`);
+      lines.push("---");
+    }
+    lines.push("");
+  }
+  lines.push("## Task");
+  lines.push("\u8BF7\u5206\u6790\u4EE5\u4E0A\u4FE1\u606F\uFF0C\u66F4\u65B0\u8BB0\u5FC6\u5E76\u4EE5 JSON \u683C\u5F0F\u8F93\u51FA\u7ED3\u679C\u3002");
+  return lines.join(`
+`);
+}
+function parseMemoryAgentOutput(output, scope) {
+  let jsonStr = output;
+  const jsonMatch = output.match(/```json\s*([\s\S]*?)\s*```/) || output.match(/```\s*([\s\S]*?)\s*```/) || output.match(/(\{[\s\S]*\})/);
+  if (jsonMatch) {
+    jsonStr = jsonMatch[1] || jsonMatch[0];
+  }
+  try {
+    const parsed = JSON.parse(jsonStr);
+    return {
+      scope,
+      memoryMdContent: parsed.memoryMdContent || "",
+      projectSummary: parsed.projectSummary,
+      hasUpdates: parsed.hasUpdates ?? false
+    };
+  } catch {
+    return {
+      scope,
+      memoryMdContent: output,
+      hasUpdates: false
+    };
+  }
+}
+function createEmptyResult(scope) {
+  return {
+    scope,
+    memoryMdContent: "",
+    hasUpdates: false
+  };
+}
+async function buildProjectInput(params) {
+  const baseDir = params.projectPath + "/.roy/memory";
+  return {
+    scope: "project",
+    baseDir,
+    currentMemoryMd: params.currentMemoryMd,
+    messages: params.messages
+  };
+}
+function buildGlobalInput(params) {
+  return {
+    scope: "global",
+    baseDir: params.baseDir,
+    currentMemoryMd: params.currentMemoryMd,
+    messages: params.messages,
+    projectSummaries: params.projectSummaries
+  };
+}
+async function applyMemoryResult(result, baseDir) {
+  const fs2 = await import("fs/promises");
+  const path3 = await import("path");
+  const memoryMdPath = path3.join(baseDir, "memory.md");
+  await fs2.mkdir(path3.dirname(memoryMdPath), { recursive: true });
+  await fs2.writeFile(memoryMdPath, result.memoryMdContent, "utf-8");
+}
+function generateProjectSummary(params) {
+  const paragraphs = params.memoryMdContent.split(/\n\n+/);
+  const firstParagraph = paragraphs[0] || "";
+  const summary = firstParagraph.replace(/^#+\s*/g, "").trim() || "No summary available";
+  const firstSentence = summary.split(/[.!?]/)[0] || summary;
+  const shortSummary = firstSentence.substring(0, 50) + (firstSentence.length > 50 ? "..." : "");
+  return {
+    projectPath: params.projectPath,
+    projectName: params.projectName,
+    lastUpdated: Date.now(),
+    summary,
+    shortSummary,
+    memoryMdPath: params.memoryMdPath
+  };
+}
+// packages/core/src/env/memory/types.ts
+import { z as z3 } from "zod";
+var RecordMemorySchema3 = z3.object({
+  scope: z3.enum(["project", "global"]).describe("\u4F5C\u7528\u57DF: project/global"),
+  mode: z3.enum(["append", "prepend", "overwrite", "delete"]).describe("\u6A21\u5F0F: append(\u8FFD\u52A0)/prepend(\u63D2\u5165)/overwrite(\u8986\u76D6)/delete(\u5220\u9664)"),
+  content: z3.string().optional().describe("\u8BB0\u5FC6\u5185\u5BB9"),
+  title: z3.string().optional().describe("\u7AE0\u8282\u6807\u9898")
+});
+var RecallMemorySchema3 = z3.object({
+  scope: z3.enum(["project", "global"]).optional().describe("\u4F5C\u7528\u57DF\uFF08\u53EF\u9009\uFF0C\u4E0D\u4F20\u5219\u8BFB\u53D6\u6240\u6709\uFF09")
+});
+// packages/core/src/env/memory/memory-config.ts
+import path3 from "path";
+import os2 from "os";
+var DEFAULT_MEMORY_CONFIG = {
+  memoryPaths: [
+    {
+      type: "global",
+      path: path3.join(os2.homedir(), ".config", "roy-agent", "memory")
+    },
+    {
+      type: "project",
+      path: ".roy/memory"
+    }
+  ],
+  recursive: true,
+  cacheEnabled: true,
+  cacheTTL: 5 * 60 * 1000
+};
+var SOURCE_PRIORITY = {
+  global: 0,
+  project: 1
+};
+function getSourcePriority(source) {
+  return SOURCE_PRIORITY[source] ?? 0;
+}
+// packages/core/src/env/component.ts
+class BaseComponent {
+  _status = "created";
+  _enabled = true;
+  env;
+  hookManager;
+  constructor() {
+    this.hookManager = new HookManager;
+  }
+  getStatus() {
+    return this._status;
+  }
+  getConfig() {
+    return {
+      name: this.name,
+      version: this.version,
+      enabled: this._enabled,
+      env: this.env
+    };
+  }
+  isEnvInitialized() {
+    return this._status !== "created";
+  }
+  setStatus(status) {
+    this._status = status;
+  }
+  getEnv() {
+    return this.env;
+  }
+  async init(config) {
+    if (config?.env) {
+      this.env = config.env;
+    }
+    this.setStatus("initializing");
+    try {
+      if (config?.name)
+        Object.defineProperty(this, "name", { value: config.name, writable: false });
+      if (config?.version)
+        Object.defineProperty(this, "version", { value: config.version, writable: false });
+    } catch {}
+    if (config?.enabled !== undefined)
+      this._enabled = config.enabled;
+    this.hookManager.setComponentInfo(this.name, this.version);
+    await this.onInit();
+    this.setStatus("running");
+  }
+  async start() {
+    if (this._started)
+      return;
+    this._started = true;
+    await this.onStart();
+    this.setStatus("running");
+  }
+  async stop() {
+    this.setStatus("stopping");
+    this.hookManager.clear();
+    await this.onStop();
+    this.setStatus("stopped");
+  }
+  async onInit() {}
+  async onStart() {}
+  async onStop() {}
+  registerHook(hookPoint, hook) {
+    this.hookManager.register(hookPoint, hook);
+  }
+  addHook(hookPoint, name, fn, priority) {
+    this.hookManager.register(hookPoint, createHook({ name, priority }, fn));
+  }
+  removeHook(hookPoint, name) {
+    return this.hookManager.unregister(hookPoint, name);
+  }
+  async executeHooks(hookPoint, data, metadata) {
+    await this.hookManager.execute(hookPoint, data, metadata);
+  }
+  getConfigComponent() {
+    return this.env?.getComponent("config");
+  }
+  getRuntimeConfig(key, defaultValue) {
+    const configComponent = this.getConfigComponent();
+    if (configComponent) {
+      const value = configComponent.get(key);
+      if (value !== undefined) {
+        return value;
+      }
+    }
+    return defaultValue;
+  }
+}
+
+// packages/core/src/env/memory/memory-component.ts
+init_logger();
+
+// packages/core/src/env/memory/memory-config-registration.ts
+import path4 from "path";
+import os3 from "os";
+var MEMORY_DEFAULTS = {
+  "memory.recursive": true,
+  "memory.cacheEnabled": true,
+  "memory.cacheTTL": 300000,
+  "memory.memoryFile": "memory.md",
+  "memory.memoryPaths": [
+    { type: "global", path: path4.join(os3.homedir(), ".config", "roy-agent", "memory") },
+    { type: "project", path: ".roy/memory" }
+  ]
+};
+var MEMORY_CONFIG_REGISTRATION = {
+  name: "memory",
+  sources: [
+    { type: "env", envPrefix: "MEMORY", priority: 20, watch: false }
+  ],
+  keys: [
+    { key: "memory.recursive", sources: ["env", "file"] },
+    { key: "memory.cacheEnabled", sources: ["env", "file"] },
+    { key: "memory.cacheTTL", sources: ["env", "file"] },
+    { key: "memory.memoryPaths", sources: ["env", "file"] },
+    { key: "memory.memoryFile", sources: ["env", "file"] }
+  ]
+};
+
+// packages/core/src/config/env-key.ts
+function toEnvKey(key, prefix) {
+  let keyNormalized = key.replace(/[.-]/g, "_");
+  keyNormalized = keyNormalized.replace(/([a-z])([A-Z])/g, "$1_$2").replace(/_+/g, "_").toUpperCase();
+  if (prefix) {
+    const separator = prefix.endsWith("_") ? "" : "_";
+    return `${prefix}${separator}${keyNormalized}`;
+  }
+  return keyNormalized;
+}
+function fromEnvKey(envKey, prefix) {
+  if (!prefix) {
+    return envKey;
+  }
+  if (envKey.startsWith(prefix)) {
+    const afterPrefix = envKey.slice(prefix.length);
+    if (afterPrefix.startsWith("_")) {
+      return afterPrefix.slice(1);
+    }
+    return afterPrefix;
+  }
+  return envKey;
+}
+function envKeyToConfigKey(envKey, prefix, componentName) {
+  const prefixUpper = prefix.toUpperCase();
+  if (!envKey.startsWith(prefixUpper)) {
+    return;
+  }
+  const componentUpperNormalized = componentName.replace(/-/g, "_").toUpperCase();
+  let keyPart = envKey.slice(prefixUpper.length);
+  if (keyPart.startsWith("_")) {
+    keyPart = keyPart.slice(1);
+  }
+  if (!keyPart) {
+    return;
+  }
+  const firstUnderscore = keyPart.indexOf("_");
+  let restPart;
+  if (firstUnderscore === -1) {
+    restPart = keyPart;
+  } else {
+    const firstPart = keyPart.slice(0, firstUnderscore);
+    const remaining = keyPart.slice(firstUnderscore + 1);
+    if (firstPart === componentUpperNormalized) {
+      restPart = remaining;
+    } else {
+      restPart = keyPart;
+    }
+  }
+  if (!restPart) {
+    return;
+  }
+  const restPartConverted = restPart.replace(/_/g, ".");
+  return `${componentName}.${restPartConverted.toLowerCase()}`;
+}
+
+// packages/core/src/env/memory/memory-component.ts
+import path5 from "path";
+import fs2 from "fs/promises";
+var logger3 = createLogger("memory");
+
+class MemoryComponent extends BaseComponent {
+  name = "memory";
+  version = "2.0.0";
+  config;
+  toolComponent;
+  configComponent;
+  cache = new Map;
+  configWatcher;
+  async init(config) {
+    await super.init(config);
+    const options = config?.options;
+    if (!options?.configComponent) {
+      throw new Error("ConfigComponent is required for MemoryComponent initialization");
+    }
+    this.configComponent = options.configComponent;
+    await this.registerConfig(options);
+    logger3.info("[MemoryComponent] Initialized (simplified)");
+  }
+  async registerConfig(options) {
+    const configComponent = this.configComponent;
+    if (!configComponent)
+      return;
+    const { configPath, envPrefix, config } = options;
+    const prefix = envPrefix ?? "MEMORY";
+    configComponent.registerComponent(MEMORY_CONFIG_REGISTRATION);
+    if (configPath) {
+      configComponent.registerSource({
+        type: "file",
+        relativePath: configPath,
+        optional: true,
+        watch: false
+      });
+    }
+    configComponent.registerSource({
+      type: "env",
+      envPrefix: prefix,
+      priority: 20,
+      watch: false
+    });
+    await configComponent.load("memory");
+    for (const envKey of Object.keys(process.env)) {
+      const configKey = envKeyToConfigKey(envKey, prefix, "memory");
+      if (!configKey)
+        continue;
+      const value = process.env[envKey];
+      if (value !== undefined) {
+        await configComponent.set(configKey, value);
+      }
+    }
+    for (const [key, value] of Object.entries(MEMORY_DEFAULTS)) {
+      if (configComponent.get(key) === undefined) {
+        await configComponent.set(key, value);
+      }
+    }
+    if (config) {
+      const flatConfig = this.flattenConfig(config);
+      for (const [key, value] of Object.entries(flatConfig)) {
+        await configComponent.set(key, value);
+      }
+    }
+    this.registerConfigWatcher(configComponent);
+    this.buildConfig(configComponent);
+  }
+  buildConfig(configComponent) {
+    const recursive = configComponent.get("memory.recursive") ?? true;
+    const cacheEnabled = configComponent.get("memory.cacheEnabled") ?? true;
+    const cacheTTL = configComponent.get("memory.cacheTTL") ?? 300000;
+    const memoryFile = configComponent.get("memory.memoryFile") ?? "memory.md";
+    const memoryPathsConfig = configComponent.get("memory.memoryPaths");
+    let memoryPaths = [];
+    if (Array.isArray(memoryPathsConfig)) {
+      memoryPaths = memoryPathsConfig;
+    } else if (typeof memoryPathsConfig === "string") {
+      try {
+        memoryPaths = JSON.parse(memoryPathsConfig);
+      } catch {
+        memoryPaths = DEFAULT_MEMORY_CONFIG.memoryPaths;
+      }
+    }
+    if (memoryPaths.length === 0) {
+      memoryPaths = DEFAULT_MEMORY_CONFIG.memoryPaths;
+    }
+    this.config = {
+      memoryPaths,
+      recursive,
+      cacheEnabled,
+      cacheTTL,
+      memoryFile
+    };
+  }
+  flattenConfig(obj, prefix = "memory") {
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+      const fullKey = `${prefix}.${key}`;
+      if (value && typeof value === "object" && !Array.isArray(value)) {
+        Object.assign(result, this.flattenConfig(value, fullKey));
+      } else {
+        result[fullKey] = value;
+      }
+    }
+    return result;
+  }
+  registerConfigWatcher(configComponent) {
+    if (typeof configComponent.watch !== "function") {
+      return;
+    }
+    this.configWatcher = configComponent.watch("memory.*", (event) => {
+      this.onConfigChange(event);
+    });
+  }
+  onConfigChange(event) {
+    logger3.info(`[MemoryComponent] Config changed: ${event.key}`, {
+      oldValue: event.oldValue,
+      newValue: event.newValue
+    });
+    if (this.configComponent) {
+      this.buildConfig(this.configComponent);
+    }
+    this.cache.clear();
+  }
+  async start() {
+    await super.start();
+    this.toolComponent = this.env?.getComponent("tool");
+    if (!this.toolComponent) {
+      logger3.warn("[MemoryComponent] ToolComponent not found, skipping tool registration");
+      return;
+    }
+    await this.registerTools();
+    this.setStatus("running");
+    logger3.info(`[MemoryComponent] Started with ${this.toolComponent.getToolCount()} tools`);
+  }
+  async stop() {
+    if (this.configWatcher) {
+      this.configWatcher();
+      this.configWatcher = undefined;
+    }
+    if (this.toolComponent) {
+      this.toolComponent.unregister("record_memory");
+      this.toolComponent.unregister("recall_memory");
+    }
+    this.cache.clear();
+    await super.stop();
+    logger3.info("[MemoryComponent] Stopped");
+  }
+  async registerTools() {
+    if (!this.toolComponent)
+      return;
+    const tools = createMemoryTools((args) => this.recordMemory(args), (scope) => this.recallMemory(scope), {
+      getMemoryPaths: () => this.getMemoryPaths(),
+      getMemoryFile: () => this.getMemoryFile()
+    });
+    for (const tool of tools) {
+      this.toolComponent.register(tool);
+    }
+    logger3.info("[MemoryComponent] Registered memory tools");
+  }
+  getMemoryPaths() {
+    return this.config.memoryPaths;
+  }
+  updateMemoryPaths(paths) {
+    this.config.memoryPaths = paths;
+    this.clearCache();
+  }
+  getMemoryFile() {
+    return this.config.memoryFile ?? "memory.md";
+  }
+  async recordMemory(args) {
+    const { mode, content, title, filename, scope } = args;
+    const memoryFile = filename ?? this.getMemoryFile();
+    const paths = this.config.memoryPaths;
+    if (paths.length === 0) {
+      return null;
+    }
+    let basePath;
+    if (scope) {
+      const targetPath = paths.find((p) => p.type === scope);
+      if (!targetPath) {
+        logger3.warn(`[recordMemory] No ${scope} path configured, using first available path`);
+        basePath = paths[0].path;
+      } else {
+        basePath = targetPath.path;
+      }
+    } else {
+      basePath = paths[0].path;
+    }
+    const filePath = path5.join(basePath, memoryFile);
+    try {
+      let existingContent = "";
+      let fileExists = false;
+      try {
+        existingContent = await fs2.readFile(filePath, "utf-8");
+        fileExists = true;
+      } catch {}
+      let newContent;
+      let action;
+      switch (mode) {
+        case "delete":
+          if (fileExists) {
+            await fs2.unlink(filePath);
+            this.clearCache();
+            return { path: filePath, action: "delete" };
+          }
+          return null;
+        case "overwrite":
+          if (title && content) {
+            newContent = `## ${title}
+
+${content}
+`;
+          } else {
+            newContent = content ?? "";
+          }
+          action = fileExists ? "overwrite" : "created";
+          break;
+        case "append":
+          if (!content) {
+            throw new Error("content is required for append mode");
+          }
+          if (title) {
+            newContent = existingContent + `
+## ${title}
+
+${content}
+`;
+          } else {
+            newContent = existingContent + `
+${content}
+`;
+          }
+          action = fileExists ? "append" : "created";
+          break;
+        case "prepend":
+          if (!content) {
+            throw new Error("content is required for prepend mode");
+          }
+          if (title) {
+            newContent = `## ${title}
+
+${content}
+
+---
+
+${existingContent}`;
+          } else {
+            newContent = `${content}
+
+---
+
+${existingContent}`;
+          }
+          action = fileExists ? "prepend" : "created";
+          break;
+        default:
+          throw new Error(`Unknown mode: ${mode}`);
+      }
+      await fs2.mkdir(basePath, { recursive: true });
+      await fs2.writeFile(filePath, newContent, "utf-8");
+      this.clearCache();
+      return { path: filePath, action };
+    } catch (error) {
+      logger3.error(`[recordMemory] Failed: ${error}`);
+      throw error;
+    }
+  }
+  async recallMemory(scope) {
+    const memoryFile = this.getMemoryFile();
+    const paths = this.config.memoryPaths;
+    const results = [];
+    for (const memoryPath of paths) {
+      if (scope && memoryPath.type !== scope) {
+        continue;
+      }
+      const filePath = path5.join(memoryPath.path, memoryFile);
+      try {
+        const content = await fs2.readFile(filePath, "utf-8");
+        if (content.trim()) {
+          results.push(`## [${memoryPath.type}] ${memoryFile}
+${content}`);
+        }
+      } catch {}
+    }
+    return results.join(`
+
+`);
+  }
+  clearCache() {
+    this.cache.clear();
+  }
+  getCache(key) {
+    if (!this.config.cacheEnabled)
+      return;
+    const entry = this.cache.get(key);
+    if (!entry)
+      return;
+    const age = Date.now() - entry.timestamp;
+    if (age > (this.config.cacheTTL ?? 300000)) {
+      this.cache.delete(key);
+      return;
+    }
+    return entry.data;
+  }
+  setCache(key, data) {
+    if (!this.config.cacheEnabled)
+      return;
+    this.cache.set(key, { data, timestamp: Date.now() });
+  }
+}
+export {
+  recallMemory,
+  parseMemoryAgentOutput,
+  getSourcePriority,
+  generateProjectSummary,
+  formatMemoryInput,
+  createMemoryPlugin,
+  createMemoryAgent,
+  createEmptyResult,
+  buildProjectInput,
+  buildGlobalInput,
+  applyMemoryResult,
+  SOURCE_PRIORITY,
+  RecordMemorySchema,
+  RecallMemorySchema,
+  PROJECT_MEMORY_AGENT_PROMPT,
+  MemoryPlugin,
+  MemoryManager,
+  MemoryComponent,
+  GLOBAL_MEMORY_AGENT_PROMPT,
+  DEFAULT_MEMORY_CONFIG
+};