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

package/dist/env/session/index.js

@@ -1,3594 +0,0 @@
-// @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/log-trace/decorator.ts
-function Traced(options) {
-  return function(target, propertyKey, descriptor) {
-    const originalFn = descriptor.value;
-    const spanName = options?.name || propertyKey;
-    descriptor.value = wrapFunction(originalFn, spanName, {
-      recordParams: options?.recordParams ?? true,
-      recordResult: options?.recordResult ?? false,
-      recordError: options?.recordError ?? true,
-      log: options?.log ?? false,
-      maxLogSize: options?.maxLogSize,
-      paramFilter: options?.paramFilter
-    });
-    return descriptor;
-  };
-}
-function TracedAs(name, options) {
-  return Traced({ name, ...options });
-}
-function TracedLightweight(options) {
-  return Traced({ recordParams: false, recordResult: false, log: options?.log ?? false, maxLogSize: options?.maxLogSize });
-}
-function wrapFunction(fn, name, options) {
-  const shouldLog = options?.log ?? false;
-  const getMaxLogSize = () => {
-    if (options?.maxLogSize !== undefined) {
-      return options.maxLogSize;
-    }
-    const configMaxOutput = getMaxOutput();
-    return configMaxOutput !== undefined ? configMaxOutput : 500;
-  };
-  const truncate = (obj) => {
-    if (obj === undefined)
-      return;
-    if (obj === null)
-      return null;
-    const maxLogSize = getMaxLogSize();
-    let str;
-    try {
-      str = typeof obj === "string" ? obj : JSON.stringify(obj, null, 0).replace(/\n/g, "");
-    } catch (e) {
-      str = `[Object with circular reference: ${e instanceof Error ? e.message : String(e)}]`;
-    }
-    if (maxLogSize > 0 && str.length > maxLogSize) {
-      return str.slice(0, maxLogSize) + " [TRUNCATED]";
-    }
-    try {
-      return JSON.parse(str);
-    } catch {
-      return str;
-    }
-  };
-  const truncateString = (obj) => {
-    if (obj === undefined)
-      return "undefined";
-    if (obj === null)
-      return "null";
-    const maxLogSize = getMaxLogSize();
-    let str;
-    try {
-      str = typeof obj === "string" ? obj : JSON.stringify(obj, null, 0).replace(/\n/g, "");
-    } catch (e) {
-      str = `[Object with circular reference: ${e instanceof Error ? e.message : String(e)}]`;
-    }
-    return maxLogSize > 0 && str.length > maxLogSize ? str.slice(0, maxLogSize) + " [TRUNCATED]" : str;
-  };
-  const TRACE_LOG_PREFIX = "[TRACE]";
-  const getCallerLocation = () => {
-    const originalLimit = Error.stackTraceLimit;
-    Error.stackTraceLimit = 15;
-    const err = new Error;
-    Error.captureStackTrace(err, getCallerLocation);
-    const stack = err.stack?.split(`
-`) || [];
-    Error.stackTraceLimit = originalLimit;
-    for (let i = 1;i < stack.length; i++) {
-      const line = stack[i];
-      if (line.includes("decorator.ts") || line.includes("decorator.js") || line.includes("logFn") || line.includes("getCallerLocation"))
-        continue;
-      const match = line.match(/at\s+.+\s+\((.+):(\d+):\d+\)/) || line.match(/at\s+(.+):(\d+):\d+/);
-      if (match) {
-        const filePath = match[1];
-        if (!filePath || filePath === "native")
-          continue;
-        const relativePath = simplifyFilePath(filePath);
-        return `${relativePath}:${match[2]}`;
-      }
-    }
-    return "";
-  };
-  const logFn = (event, argsOrData, callerLocation) => {
-    if (!shouldLog)
-      return;
-    const logger = createLogger("traced:" + name);
-    const tag = event === "enter" ? ">>>" : event === "quit" ? "<<<" : "!!!";
-    const prefix = `${TRACE_LOG_PREFIX} ${tag} ${name}`;
-    const originalFnLocation = callerLocation || getCallerLocation();
-    const logMessage = (msg, data) => {
-      if (data !== undefined) {
-        logger.info(`${prefix} ${msg}: ${truncateString(data)}`, { callerLocation: originalFnLocation });
-      } else {
-        logger.info(`${prefix} ${msg}`, { callerLocation: originalFnLocation });
-      }
-    };
-    if (event === "enter") {
-      logMessage("enter", argsOrData);
-    } else if (event === "quit") {
-      logMessage("quit", options?.recordResult ? argsOrData : undefined);
-    } else {
-      logMessage("error", argsOrData);
-    }
-  };
-  return function(...args) {
-    const tracer = getTracerProvider().getTracer("roy-tracer");
-    const attributes = {};
-    if (options?.recordParams !== false) {
-      if (options?.paramFilter) {
-        attributes["params"] = truncate(options.paramFilter(args));
-      } else {
-        attributes["params"] = truncate(args);
-      }
-    }
-    const callerLocation = getCallerLocation();
-    logFn("enter", args, callerLocation);
-    const span = tracer.startSpan(name, { attributes });
-    try {
-      const result = fn.call(this, ...args);
-      if (result && typeof result === "object" && typeof result.then === "function") {
-        return result.then((resolved) => {
-          span.setAttribute("result", JSON.stringify(truncate(resolved)));
-          span.end(resolved);
-          logFn("quit", options?.recordResult ? resolved : undefined, callerLocation);
-          return resolved;
-        }, (rejected) => {
-          span.setAttribute("error", String(rejected));
-          span.end(undefined, rejected instanceof Error ? rejected : new Error(String(rejected)));
-          logFn("error", rejected.message, callerLocation);
-          throw rejected;
-        });
-      }
-      span.setAttribute("result", JSON.stringify(truncate(result)));
-      span.end(result);
-      logFn("quit", options?.recordResult ? result : undefined, callerLocation);
-      return result;
-    } catch (error) {
-      span.setAttribute("error", String(error));
-      span.end(undefined, error instanceof Error ? error : new Error(String(error)));
-      logFn("error", error.message, callerLocation);
-      throw error;
-    }
-  };
-}
-var init_decorator = __esm(() => {
-  init_tracer_provider();
-  init_logger();
-});
-
-// packages/core/src/env/session/search-query-parser.ts
-var exports_search_query_parser = {};
-__export(exports_search_query_parser, {
-  parseSearchQuery: () => parseSearchQuery,
-  matchesQuery: () => matchesQuery
-});
-function parseSearchQuery(query) {
-  const result = {
-    required: [],
-    excluded: [],
-    phrases: []
-  };
-  if (!query || !query.trim()) {
-    return result;
-  }
-  const phraseRegex = /"([^"]+)"/g;
-  let match;
-  while ((match = phraseRegex.exec(query)) !== null) {
-    result.phrases.push(match[1].toLowerCase());
-  }
-  query = query.replace(phraseRegex, "");
-  query = query.replace(/\s+/g, " ").trim();
-  if (!query) {
-    return result;
-  }
-  const parts = [];
-  let remaining = query;
-  const singleOpRegex = /\s+(AND|OR|NOT)\s+/gi;
-  let opMatch;
-  while ((opMatch = singleOpRegex.exec(remaining)) !== null) {
-    const op = opMatch[1].toUpperCase();
-    const beforeText = remaining.slice(0, opMatch.index).trim();
-    if (beforeText) {
-      parts.push({ text: beforeText, operator: undefined });
-    }
-    parts.push({ text: op, operator: op });
-    remaining = remaining.slice(opMatch.index + opMatch[0].length);
-    singleOpRegex.lastIndex = 0;
-  }
-  if (remaining.trim()) {
-    parts.push({ text: remaining.trim(), operator: undefined });
-  }
-  let currentOperator = "AND";
-  for (const part of parts) {
-    if (part.operator) {
-      currentOperator = part.operator;
-    } else {
-      const wordRegex = /[\w\u4e00-\u9fff\u3040-\u309f\u30a0-\u30ff]+/gu;
-      const words = part.text.match(wordRegex) || [];
-      for (const word of words) {
-        const lowerWord = word.toLowerCase();
-        if (lowerWord === "and" || lowerWord === "or" || lowerWord === "not") {
-          currentOperator = lowerWord.toUpperCase();
-          continue;
-        }
-        if (currentOperator === "NOT") {
-          if (!result.excluded.includes(lowerWord)) {
-            result.excluded.push(lowerWord);
-          }
-        } else {
-          if (!result.required.includes(lowerWord)) {
-            result.required.push(lowerWord);
-          }
-        }
-        currentOperator = "AND";
-      }
-    }
-  }
-  return result;
-}
-function matchesQuery(content, query) {
-  if (!content) {
-    return query.required.length === 0 && query.phrases.length === 0;
-  }
-  const lowerContent = content.toLowerCase();
-  for (const term of query.excluded) {
-    if (lowerContent.includes(term.toLowerCase())) {
-      return false;
-    }
-  }
-  for (const phrase of query.phrases) {
-    if (!lowerContent.includes(phrase)) {
-      return false;
-    }
-  }
-  if (query.required.length > 0) {
-    for (const term of query.required) {
-      if (!lowerContent.includes(term)) {
-        return false;
-      }
-    }
-  }
-  return true;
-}
-
-// 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/session/session-message-converter.ts
-init_decorator();
-import { randomUUID } from "crypto";
-var DEFAULT_REASONING_BUDGET_TOKENS = 1e4;
-
-class SessionMessageConverter {
-  toModelMessage(msg) {
-    if (msg.role === "assistant") {
-      const content = [];
-      for (const part of msg.parts || []) {
-        if (part.type === "text") {
-          const textPart = part;
-          content.push({
-            type: "text",
-            text: textPart.content,
-            ...textPart.synthetic !== undefined && { synthetic: textPart.synthetic }
-          });
-        } else if (part.type === "reasoning") {
-          const reasoningPart = part;
-          content.push({
-            type: "reasoning",
-            text: reasoningPart.content,
-            reasoningType: reasoningPart.reasoningType
-          });
-        } else if (part.type === "tool-call") {
-          const toolPart = part;
-          let parsedArgs = {};
-          if (typeof toolPart.arguments === "string") {
-            try {
-              parsedArgs = JSON.parse(toolPart.arguments);
-            } catch {
-              parsedArgs = { _raw: toolPart.arguments };
-            }
-          } else {
-            parsedArgs = toolPart.arguments;
-          }
-          content.push({
-            type: "tool-call",
-            toolCallId: toolPart.toolCallId,
-            toolName: toolPart.toolName,
-            input: parsedArgs
-          });
-        } else if (part.type === "file") {
-          const filePart = part;
-          content.push({
-            type: "file",
-            url: filePart.url,
-            mimeType: filePart.mime,
-            filename: filePart.filename
-          });
-        } else if (part.type === "tool-result" || part.type === "checkpoint") {} else {
-          console.debug(`[session-message-converter] Skipping unsupported part type in assistant: ${part.type}`);
-        }
-      }
-      if (content.length === 0 && msg.content) {
-        return { role: "assistant", content: msg.content };
-      }
-      return { role: "assistant", content };
-    }
-    if (msg.role === "tool") {
-      const toolPart = msg.parts?.find((p) => p.type === "tool-result");
-      return {
-        role: "tool",
-        content: [{
-          type: "tool-result",
-          toolCallId: toolPart?.toolCallId || "",
-          toolName: toolPart?.toolName || "",
-          output: toolPart?.output || msg.content || ""
-        }]
-      };
-    }
-    return {
-      role: msg.role,
-      content: msg.content || ""
-    };
-  }
-  fromModelMessage(aiMsg, options) {
-    const parts = [];
-    const content = typeof aiMsg.content === "string" || Array.isArray(aiMsg.content) ? aiMsg.content : "";
-    let hasToolCallPart = false;
-    let hasToolResultPart = false;
-    if (typeof content === "string") {
-      parts.push({ type: "text", content });
-    } else if (Array.isArray(content)) {
-      for (const part of content) {
-        const p = part;
-        if (p.type === "text") {
-          parts.push({ type: "text", content: p.text || "" });
-        } else if (p.type === "reasoning") {
-          parts.push({
-            type: "reasoning",
-            content: p.text || "",
-            reasoningType: p.reasoningType,
-            state: "completed"
-          });
-        } else if (p.type === "tool-call") {
-          hasToolCallPart = true;
-          parts.push({
-            type: "tool-call",
-            toolCallId: p.toolCallId,
-            toolName: p.toolName,
-            arguments: p.input,
-            state: "pending"
-          });
-        } else if (p.type === "tool-result") {
-          hasToolResultPart = true;
-          parts.push({
-            type: "tool-result",
-            toolCallId: p.toolCallId,
-            toolName: p.toolName,
-            output: typeof p.output === "string" ? p.output : JSON.stringify(p.output),
-            state: "completed"
-          });
-        } else if (p.type === "file") {
-          parts.push({
-            type: "file",
-            mime: p.mimeType || "application/octet-stream",
-            url: p.url,
-            filename: p.filename
-          });
-        } else {
-          console.debug(`[session-message-converter] Unknown part type: ${p.type}`);
-        }
-      }
-    }
-    let metadataType;
-    if (aiMsg.role === "assistant" && hasToolCallPart) {
-      metadataType = "tool_call";
-    } else if (aiMsg.role === "tool") {
-      metadataType = "tool_result";
-    }
-    const result = {
-      id: options?.messageID || `msg_${randomUUID()}`,
-      sessionID: options?.sessionID || "",
-      role: aiMsg.role,
-      timestamp: Date.now(),
-      parts,
-      content: typeof content === "string" ? content : ""
-    };
-    if (metadataType) {
-      result.metadata = { type: metadataType };
-    }
-    return result;
-  }
-  sessionToHistory(messages) {
-    return messages.filter((msg) => !msg.metadata?.isArchived && !msg.isArchived).map((msg) => this.toModelMessage(msg));
-  }
-  extractProviderOptions(msg) {
-    const options = {};
-    const reasoningParts = msg.parts?.filter((p) => p.type === "reasoning");
-    if (reasoningParts && reasoningParts.length > 0) {
-      const firstReasoning = reasoningParts[0];
-      if (firstReasoning.reasoningType) {
-        options.openai = {
-          thinking: {
-            type: firstReasoning.reasoningType === "effort" ? "extended" : "core"
-          }
-        };
-        if (firstReasoning.reasoningType === "effort") {
-          const budgetTokens = firstReasoning.metadata?.tokenCount || DEFAULT_REASONING_BUDGET_TOKENS;
-          options.anthropic = {
-            thinking: {
-              type: "enabled",
-              budgetTokens
-            }
-          };
-        }
-      }
-    }
-    return options;
-  }
-  migrateMessage(oldMsg) {
-    if (oldMsg.parts && oldMsg.parts.length > 0) {
-      const firstPart = oldMsg.parts[0];
-      if (firstPart && typeof firstPart.type === "string" && firstPart.type.length > 0) {
-        return {
-          ...oldMsg,
-          content: oldMsg.content || ""
-        };
-      }
-    }
-    return {
-      ...oldMsg,
-      content: oldMsg.content || "",
-      parts: oldMsg.content ? [{ type: "text", content: oldMsg.content }] : []
-    };
-  }
-}
-__legacyDecorateClassTS([
-  TracedAs("session-message-converter.toModelMessage", { recordParams: true, recordResult: true, log: true })
-], SessionMessageConverter.prototype, "toModelMessage", null);
-__legacyDecorateClassTS([
-  TracedAs("session-message-converter.fromModelMessage", { recordParams: true, recordResult: true, log: true })
-], SessionMessageConverter.prototype, "fromModelMessage", null);
-
-// packages/core/src/env/session/storage/memory.ts
-import { randomUUID as randomUUID2 } from "crypto";
-function generateSessionId() {
-  return `session_${randomUUID2()}`;
-}
-function generateMessageId() {
-  return `msg_${randomUUID2()}`;
-}
-
-class MemorySessionStore {
-  sessions = new Map;
-  messages = new Map;
-  checkpoints = new Map;
-  messageConverter = new SessionMessageConverter;
-  async create(options) {
-    const now = Date.now();
-    const session = {
-      id: options.id ?? generateSessionId(),
-      title: options.title ?? "Session",
-      directory: options.directory ?? "/tmp",
-      parentID: options.parentID,
-      createdAt: now,
-      updatedAt: now,
-      messageCount: 0,
-      metadata: {
-        ...options.metadata,
-        messageCount: 0,
-        checkpoints: { checkpoints: [] }
-      }
-    };
-    if (this.sessions.has(session.id)) {
-      throw new Error(`Session with ID '${session.id}' already exists`);
-    }
-    this.sessions.set(session.id, session);
-    this.messages.set(session.id, []);
-    this.checkpoints.set(session.id, []);
-    return session;
-  }
-  async get(id) {
-    return this.sessions.get(id);
-  }
-  async list(options) {
-    let sessions = Array.from(this.sessions.values());
-    if (options?.filter?.metadata) {
-      sessions = sessions.filter((s) => {
-        for (const [key, value] of Object.entries(options.filter.metadata)) {
-          if (s.metadata?.[key] !== value)
-            return false;
-        }
-        return true;
-      });
-    }
-    if (options?.filter?.startTime) {
-      sessions = sessions.filter((s) => s.createdAt >= options.filter.startTime);
-    }
-    if (options?.filter?.endTime) {
-      sessions = sessions.filter((s) => s.createdAt <= options.filter.endTime);
-    }
-    const sortField = options?.sort?.field ?? "updatedAt";
-    const sortOrder = options?.sort?.order ?? "desc";
-    sessions.sort((a, b) => {
-      let aVal;
-      let bVal;
-      if (sortField === "title") {
-        aVal = a.title;
-        bVal = b.title;
-      } else if (sortField === "createdAt") {
-        aVal = a.createdAt;
-        bVal = b.createdAt;
-      } else {
-        aVal = a.updatedAt;
-        bVal = b.updatedAt;
-      }
-      if (aVal < bVal)
-        return sortOrder === "asc" ? -1 : 1;
-      if (aVal > bVal)
-        return sortOrder === "asc" ? 1 : -1;
-      return 0;
-    });
-    const offset = options?.offset ?? 0;
-    const limit = options?.limit ?? 100;
-    return sessions.slice(offset, offset + limit);
-  }
-  async update(id, updates) {
-    const session = this.sessions.get(id);
-    if (!session)
-      return false;
-    if (updates.title !== undefined) {
-      session.title = updates.title;
-    }
-    if (updates.metadata !== undefined) {
-      session.metadata = { ...session.metadata, ...updates.metadata };
-    }
-    session.updatedAt = Date.now();
-    return true;
-  }
-  async delete(id) {
-    const deleted = this.sessions.delete(id);
-    if (deleted) {
-      this.messages.delete(id);
-      this.checkpoints.delete(id);
-    }
-    return deleted;
-  }
-  async getCount() {
-    return this.sessions.size;
-  }
-  async addMessage(sessionId, message) {
-    const session = this.sessions.get(sessionId);
-    if (!session) {
-      throw new Error(`Session not found: ${sessionId}`);
-    }
-    const rawMessage = {
-      sessionID: sessionId,
-      role: message.role,
-      content: message.content,
-      parts: message.parts,
-      metadata: message.metadata
-    };
-    const msg = this.messageConverter.migrateMessage(rawMessage);
-    msg.id = generateMessageId();
-    msg.timestamp = Date.now();
-    const sessionMessages = this.messages.get(sessionId) ?? [];
-    sessionMessages.push(msg);
-    this.messages.set(sessionId, sessionMessages);
-    session.messageCount = sessionMessages.filter((m) => !m.isArchived).length;
-    session.metadata = {
-      ...session.metadata,
-      messageCount: session.messageCount
-    };
-    session.updatedAt = Date.now();
-    return msg.id;
-  }
-  async getMessages(sessionId, offset = 0, limit = 50, options) {
-    let messages = this.messages.get(sessionId) ?? [];
-    if (!options?.includeArchived) {
-      messages = messages.filter((m) => !m.isArchived);
-    }
-    if (options?.fromCheckpointId) {
-      const checkpoint = await this.getCheckpoint(sessionId, options.fromCheckpointId);
-      if (checkpoint) {
-        const checkpointIndex = messages.findIndex((m) => m.metadata?.checkpointId === options.fromCheckpointId);
-        if (checkpointIndex >= 0) {
-          messages = messages.slice(checkpointIndex);
-        }
-      }
-    }
-    let actualOffset = offset;
-    if (offset < 0) {
-      const total = messages.length;
-      actualOffset = Math.max(0, total + offset * limit);
-    }
-    if (options?.reverse) {
-      messages = messages.reverse();
-    }
-    return messages.slice(actualOffset, actualOffset + limit);
-  }
-  async getMessageCount(sessionId, includeArchived = false) {
-    const messages = this.messages.get(sessionId) ?? [];
-    if (includeArchived) {
-      return messages.length;
-    }
-    return messages.filter((m) => !m.isArchived).length;
-  }
-  async getMessageIndexes(sessionId, role) {
-    const messages = this.messages.get(sessionId) ?? [];
-    const indexes = [];
-    messages.filter((m) => !m.isArchived).forEach((msg, filteredIdx) => {
-      if (msg.role === role) {
-        indexes.push(filteredIdx);
-      }
-    });
-    return indexes;
-  }
-  async saveCheckpoint(sessionId, checkpoint) {
-    const session = this.sessions.get(sessionId);
-    if (!session) {
-      throw new Error(`Session not found: ${sessionId}`);
-    }
-    const cps = this.checkpoints.get(sessionId) ?? [];
-    cps.push(checkpoint);
-    this.checkpoints.set(sessionId, cps);
-    const meta = session.metadata || {};
-    const checkpointsMeta = meta.checkpoints || { checkpoints: [] };
-    checkpointsMeta.checkpoints.push({
-      id: checkpoint.id,
-      messageIndex: checkpoint.messageIndex,
-      title: checkpoint.title,
-      createdAt: checkpoint.createdAt,
-      type: checkpoint.type
-    });
-    checkpointsMeta.latestCheckpointId = checkpoint.id;
-    meta.checkpoints = checkpointsMeta;
-    if (!meta.checkpointDetails) {
-      meta.checkpointDetails = {};
-    }
-    meta.checkpointDetails[checkpoint.id] = checkpoint;
-    session.metadata = meta;
-    session.updatedAt = Date.now();
-  }
-  async getCheckpoints(sessionId) {
-    return this.checkpoints.get(sessionId) ?? [];
-  }
-  async getCheckpoint(sessionId, checkpointId) {
-    const cps = this.checkpoints.get(sessionId) ?? [];
-    return cps.find((cp) => cp.id === checkpointId);
-  }
-  async deleteCheckpoint(sessionId, checkpointId) {
-    const session = this.sessions.get(sessionId);
-    if (!session)
-      return false;
-    const cps = this.checkpoints.get(sessionId) ?? [];
-    const index = cps.findIndex((cp) => cp.id === checkpointId);
-    if (index === -1)
-      return false;
-    cps.splice(index, 1);
-    this.checkpoints.set(sessionId, cps);
-    const messages = this.messages.get(sessionId) ?? [];
-    for (const msg of messages) {
-      if (msg.checkpointId === checkpointId) {
-        msg.isArchived = false;
-        msg.archivedAt = undefined;
-        msg.checkpointId = undefined;
-      }
-    }
-    const meta = session.metadata || {};
-    const checkpointsMeta = meta.checkpoints || { checkpoints: [] };
-    checkpointsMeta.checkpoints = checkpointsMeta.checkpoints.filter((cp) => cp.id !== checkpointId);
-    checkpointsMeta.latestCheckpointId = cps[cps.length - 1]?.id;
-    if (meta.checkpointDetails) {
-      delete meta.checkpointDetails[checkpointId];
-    }
-    session.metadata = meta;
-    session.messageCount = messages.filter((m) => !m.isArchived).length;
-    session.updatedAt = Date.now();
-    return true;
-  }
-  async archiveMessages(sessionId, checkpointId, beforeIndex) {
-    const session = this.sessions.get(sessionId);
-    if (!session)
-      return 0;
-    const messages = this.messages.get(sessionId) ?? [];
-    let archivedCount = 0;
-    for (let i = 0;i < beforeIndex; i++) {
-      if (!messages[i].isArchived) {
-        messages[i].isArchived = true;
-        messages[i].archivedAt = Date.now();
-        messages[i].checkpointId = checkpointId;
-        archivedCount++;
-      }
-    }
-    session.messageCount = messages.filter((m) => !m.isArchived).length;
-    session.updatedAt = Date.now();
-    return archivedCount;
-  }
-  async getActiveMessages(sessionId, offset = 0, limit = 50) {
-    const messages = this.messages.get(sessionId) ?? [];
-    const activeMessages = messages.filter((m) => !m.isArchived);
-    return activeMessages.slice(offset, offset + limit);
-  }
-  async searchMessages(options) {
-    const matches = [];
-    const {
-      query,
-      sessionId,
-      limit = 10,
-      beforeTime,
-      afterTime,
-      includeArchived = false
-    } = options;
-    let sessionsToSearch;
-    if (sessionId) {
-      const session = await this.get(sessionId);
-      sessionsToSearch = session ? [session] : [];
-    } else {
-      sessionsToSearch = Array.from(this.sessions.values());
-    }
-    const queryTerms = this.parseQuery(query);
-    for (const session of sessionsToSearch) {
-      if (beforeTime && session.updatedAt > beforeTime)
-        continue;
-      if (afterTime && session.updatedAt < afterTime)
-        continue;
-      let messages = this.messages.get(session.id) ?? [];
-      if (!includeArchived) {
-        messages = messages.filter((m) => !m.isArchived);
-      }
-      for (const msg of messages) {
-        if (beforeTime && msg.timestamp > beforeTime)
-          continue;
-        if (afterTime && msg.timestamp < afterTime)
-          continue;
-        const content = msg.content.toLowerCase();
-        let matchesQuery = true;
-        for (const term of queryTerms.required) {
-          if (!content.includes(term.toLowerCase())) {
-            matchesQuery = false;
-            break;
-          }
-        }
-        for (const term of queryTerms.excluded) {
-          if (content.includes(term.toLowerCase())) {
-            matchesQuery = false;
-            break;
-          }
-        }
-        if (matchesQuery) {
-          matches.push({
-            messageId: msg.id,
-            sessionId: session.id,
-            role: msg.role,
-            content: msg.content,
-            timestamp: msg.timestamp
-          });
-          if (matches.length >= limit) {
-            return matches;
-          }
-        }
-      }
-    }
-    return matches;
-  }
-  parseQuery(query) {
-    const terms = query.split(/\s+/).filter((t) => !t.startsWith('"') && !t.endsWith('"'));
-    const required = [];
-    const excluded = [];
-    for (const term of terms) {
-      if (term.startsWith("-") || term.startsWith("NOT ")) {
-        excluded.push(term.replace(/^-|^NOT /i, ""));
-      } else {
-        required.push(term);
-      }
-    }
-    return { required, excluded };
-  }
-  async close() {
-    this.sessions.clear();
-    this.messages.clear();
-    this.checkpoints.clear();
-  }
-}
-// packages/core/src/env/session/storage/sqlite.ts
-import { join as join2 } from "path";
-import { randomUUID as randomUUID3 } from "crypto";
-function generateSessionId2() {
-  return `session_${randomUUID3()}`;
-}
-function generateMessageId2() {
-  return `msg_${randomUUID3()}`;
-}
-function getDefaultDataDir() {
-  const home = process.env.HOME || process.env.USERPROFILE || "/tmp";
-  return join2(home, ".local", "share");
-}
-function getDefaultSessionDbPath() {
-  return join2(getDefaultDataDir(), "roy-agent", "sessions.db");
-}
-
-class SQLiteSessionStore {
-  db = null;
-  dbPath;
-  initialized = false;
-  sessionsCache = new Map;
-  messagesCache = new Map;
-  checkpointsCache = new Map;
-  messageConverter = new SessionMessageConverter;
-  constructor(dbPath) {
-    this.dbPath = dbPath || getDefaultSessionDbPath();
-  }
-  async initialize() {
-    if (this.initialized)
-      return;
-    const { Database } = __require("bun:sqlite");
-    if (this.dbPath !== ":memory:") {
-      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(`
-      CREATE TABLE IF NOT EXISTS session (
-        id TEXT PRIMARY KEY,
-        title TEXT NOT NULL,
-        directory TEXT NOT NULL,
-        parent_id TEXT,
-        created_at INTEGER NOT NULL,
-        updated_at INTEGER NOT NULL,
-        message_count INTEGER DEFAULT 0,
-        metadata TEXT
-      )
-    `);
-    this.db.run(`
-      CREATE TABLE IF NOT EXISTS message (
-        id TEXT PRIMARY KEY,
-        session_id TEXT NOT NULL,
-        role TEXT NOT NULL,
-        content TEXT NOT NULL,
-        timestamp INTEGER NOT NULL,
-        parts TEXT,
-        is_archived INTEGER DEFAULT 0,
-        archived_at INTEGER,
-        checkpoint_id TEXT,
-        metadata TEXT,
-        FOREIGN KEY (session_id) REFERENCES session(id) ON DELETE CASCADE
-      )
-    `);
-    this.db.run("CREATE INDEX IF NOT EXISTS idx_message_session ON message(session_id)");
-    this.db.run("CREATE INDEX IF NOT EXISTS idx_message_checkpoint ON message(checkpoint_id)");
-    this.initialized = true;
-  }
-  async create(options) {
-    await this.initialize();
-    const now = Date.now();
-    const session = {
-      id: options.id ?? generateSessionId2(),
-      title: options.title ?? "Session",
-      directory: options.directory ?? "/tmp",
-      parentID: options.parentID,
-      createdAt: now,
-      updatedAt: now,
-      messageCount: 0,
-      metadata: {
-        ...options.metadata,
-        messageCount: 0,
-        checkpoints: { checkpoints: [] }
-      }
-    };
-    const existing = this.db.prepare("SELECT id FROM session WHERE id = ?").get(session.id);
-    if (existing) {
-      throw new Error(`Session with ID '${session.id}' already exists`);
-    }
-    const stmt = this.db.prepare(`
-      INSERT INTO session (id, title, directory, parent_id, created_at, updated_at, message_count, metadata)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?)
-    `);
-    stmt.run(session.id, session.title, session.directory, session.parentID || null, session.createdAt, session.updatedAt, session.messageCount, JSON.stringify(session.metadata));
-    this.sessionsCache.set(session.id, session);
-    this.messagesCache.set(session.id, []);
-    this.checkpointsCache.set(session.id, []);
-    return session;
-  }
-  async get(id) {
-    await this.initialize();
-    const cached = this.sessionsCache.get(id);
-    if (cached)
-      return cached;
-    const row = this.db.prepare("SELECT * FROM session WHERE id = ?").get(id);
-    if (!row)
-      return;
-    const session = this.rowToSession(row);
-    this.sessionsCache.set(session.id, session);
-    return session;
-  }
-  async list(options) {
-    await this.initialize();
-    let sql = "SELECT * FROM session";
-    const params = [];
-    const conditions = [];
-    if (options?.filter?.metadata) {
-      for (const [key, value] of Object.entries(options.filter.metadata)) {
-        conditions.push(`json_extract(metadata, '$.${key}') = ?`);
-        params.push(JSON.stringify(value));
-      }
-    }
-    if (options?.filter?.startTime) {
-      conditions.push("created_at >= ?");
-      params.push(options.filter.startTime);
-    }
-    if (options?.filter?.endTime) {
-      conditions.push("created_at <= ?");
-      params.push(options.filter.endTime);
-    }
-    if (conditions.length > 0) {
-      sql += " WHERE " + conditions.join(" AND ");
-    }
-    const sortField = options?.sort?.field ?? "updatedAt";
-    const sortOrder = options?.sort?.order ?? "desc";
-    const orderColumn = sortField === "title" ? "title" : sortField === "createdAt" ? "created_at" : "updated_at";
-    sql += ` ORDER BY ${orderColumn} ${sortOrder.toUpperCase()}`;
-    const offset = options?.offset ?? 0;
-    const limit = options?.limit ?? 100;
-    sql += " LIMIT ? OFFSET ?";
-    params.push(limit, offset);
-    const rows = this.db.prepare(sql).all(...params);
-    return rows.map((row) => this.rowToSession(row));
-  }
-  async getCount() {
-    await this.initialize();
-    const result = this.db.prepare("SELECT COUNT(*) as count FROM session").get();
-    return result.count;
-  }
-  async update(id, updates) {
-    await this.initialize();
-    const session = await this.get(id);
-    if (!session)
-      return false;
-    if (updates.title !== undefined) {
-      session.title = updates.title;
-    }
-    if (updates.metadata !== undefined) {
-      session.metadata = { ...session.metadata, ...updates.metadata };
-    }
-    session.updatedAt = Date.now();
-    const stmt = this.db.prepare(`
-      UPDATE session 
-      SET title = ?, metadata = ?, updated_at = ?
-      WHERE id = ?
-    `);
-    stmt.run(session.title, JSON.stringify(session.metadata), session.updatedAt, id);
-    this.sessionsCache.set(id, session);
-    return true;
-  }
-  async delete(id) {
-    await this.initialize();
-    const session = await this.get(id);
-    if (!session)
-      return false;
-    this.db.prepare("DELETE FROM session WHERE id = ?").run(id);
-    this.sessionsCache.delete(id);
-    this.messagesCache.delete(id);
-    this.checkpointsCache.delete(id);
-    return true;
-  }
-  async addMessage(sessionId, message) {
-    await this.initialize();
-    const session = await this.get(sessionId);
-    if (!session) {
-      throw new Error(`Session not found: ${sessionId}`);
-    }
-    const now = Date.now();
-    const msg = {
-      id: generateMessageId2(),
-      sessionID: sessionId,
-      role: message.role,
-      content: message.content,
-      timestamp: now,
-      parts: message.parts,
-      metadata: message.metadata
-    };
-    const stmt = this.db.prepare(`
-      INSERT INTO message (id, session_id, role, content, timestamp, parts, metadata)
-      VALUES (?, ?, ?, ?, ?, ?, ?)
-    `);
-    stmt.run(msg.id, msg.sessionID, msg.role, msg.content, msg.timestamp, msg.parts ? JSON.stringify(msg.parts) : null, msg.metadata ? JSON.stringify(msg.metadata) : null);
-    const countResult = this.db.prepare("SELECT COUNT(*) as count FROM message WHERE session_id = ? AND is_archived = 0").get(sessionId);
-    session.messageCount = countResult?.count || 0;
-    session.updatedAt = now;
-    session.metadata = {
-      ...session.metadata,
-      messageCount: session.messageCount
-    };
-    this.db.prepare(`
-      UPDATE session SET message_count = ?, metadata = ?, updated_at = ? WHERE id = ?
-    `).run(session.messageCount, JSON.stringify(session.metadata), session.updatedAt, sessionId);
-    const messages = this.messagesCache.get(sessionId) ?? [];
-    messages.push(msg);
-    this.messagesCache.set(sessionId, messages);
-    this.sessionsCache.set(sessionId, session);
-    return msg.id;
-  }
-  async getMessages(sessionId, offset = 0, limit = 50, options) {
-    await this.initialize();
-    let sql = "SELECT * FROM message WHERE session_id = ?";
-    let countSql = "SELECT COUNT(*) as count FROM message WHERE session_id = ?";
-    const params = [sessionId];
-    const countParams = [sessionId];
-    if (!options?.includeArchived) {
-      sql += " AND is_archived = 0";
-      countSql += " AND is_archived = 0";
-    }
-    if (options?.fromCheckpointId) {
-      sql += " AND timestamp >= (SELECT MIN(timestamp) FROM message WHERE session_id = ? AND json_extract(metadata, '$.checkpointId') = ?)";
-      params.push(sessionId, options.fromCheckpointId);
-    }
-    let actualOffset = offset;
-    if (offset < 0) {
-      const totalResult = this.db.prepare(countSql).get(...countParams);
-      const total = totalResult?.count || 0;
-      actualOffset = Math.max(0, total + offset * limit);
-    }
-    if (options?.reverse) {
-      sql += " ORDER BY timestamp DESC";
-    } else {
-      sql += " ORDER BY timestamp ASC";
-    }
-    sql += " LIMIT ? OFFSET ?";
-    params.push(limit, actualOffset);
-    const rows = this.db.prepare(sql).all(...params);
-    return rows.map((row) => this.rowToMessage(row));
-  }
-  async getMessageCount(sessionId, includeArchived = false) {
-    await this.initialize();
-    let sql = "SELECT COUNT(*) as count FROM message WHERE session_id = ?";
-    if (!includeArchived) {
-      sql += " AND is_archived = 0";
-    }
-    const result = this.db.prepare(sql).get(sessionId);
-    return result?.count || 0;
-  }
-  async getMessageIndexes(sessionId, role) {
-    await this.initialize();
-    const sql = `
-      SELECT idx FROM (
-        SELECT 
-          ROW_NUMBER() OVER (ORDER BY timestamp ASC) - 1 as idx,
-          role
-        FROM message 
-        WHERE session_id = ? AND is_archived = 0
-      ) ranked
-      WHERE role = ?
-    `;
-    const rows = this.db.prepare(sql).all(sessionId, role);
-    return rows.map((row) => row.idx);
-  }
-  async saveCheckpoint(sessionId, checkpoint) {
-    await this.initialize();
-    const session = await this.get(sessionId);
-    if (!session) {
-      throw new Error(`Session not found: ${sessionId}`);
-    }
-    const cps = this.checkpointsCache.get(sessionId) ?? [];
-    cps.push(checkpoint);
-    this.checkpointsCache.set(sessionId, cps);
-    const meta = session.metadata || {};
-    const checkpointsMeta = meta.checkpoints || { checkpoints: [] };
-    checkpointsMeta.checkpoints.push({
-      id: checkpoint.id,
-      messageIndex: checkpoint.messageIndex,
-      title: checkpoint.title,
-      createdAt: checkpoint.createdAt,
-      type: checkpoint.type
-    });
-    checkpointsMeta.latestCheckpointId = checkpoint.id;
-    meta.checkpoints = checkpointsMeta;
-    if (!meta.checkpointDetails) {
-      meta.checkpointDetails = {};
-    }
-    meta.checkpointDetails[checkpoint.id] = checkpoint;
-    session.metadata = meta;
-    session.updatedAt = Date.now();
-    const stmt = this.db.prepare(`
-      UPDATE session SET metadata = ?, updated_at = ? WHERE id = ?
-    `);
-    stmt.run(JSON.stringify(session.metadata), session.updatedAt, sessionId);
-    this.sessionsCache.set(sessionId, session);
-  }
-  async getCheckpoints(sessionId) {
-    await this.initialize();
-    const session = await this.get(sessionId);
-    if (!session)
-      return [];
-    const meta = session.metadata;
-    const checkpointDetails = meta?.checkpointDetails;
-    if (!checkpointDetails)
-      return [];
-    return Object.values(checkpointDetails);
-  }
-  async getCheckpoint(sessionId, checkpointId) {
-    await this.initialize();
-    const checkpoints = await this.getCheckpoints(sessionId);
-    return checkpoints.find((cp) => cp.id === checkpointId);
-  }
-  async deleteCheckpoint(sessionId, checkpointId) {
-    await this.initialize();
-    const session = await this.get(sessionId);
-    if (!session)
-      return false;
-    const checkpoints = this.checkpointsCache.get(sessionId) ?? [];
-    const index = checkpoints.findIndex((cp) => cp.id === checkpointId);
-    if (index === -1)
-      return false;
-    checkpoints.splice(index, 1);
-    this.checkpointsCache.set(sessionId, checkpoints);
-    this.db.prepare(`
-      UPDATE message SET is_archived = 0, archived_at = NULL, checkpoint_id = NULL
-      WHERE session_id = ? AND checkpoint_id = ?
-    `).run(sessionId, checkpointId);
-    const meta = session.metadata || {};
-    const checkpointsMeta = meta.checkpoints || { checkpoints: [] };
-    checkpointsMeta.checkpoints = checkpointsMeta.checkpoints.filter((cp) => cp.id !== checkpointId);
-    checkpointsMeta.latestCheckpointId = checkpoints[checkpoints.length - 1]?.id;
-    if (meta.checkpointDetails) {
-      delete meta.checkpointDetails[checkpointId];
-    }
-    session.metadata = meta;
-    const countResult = this.db.prepare("SELECT COUNT(*) as count FROM message WHERE session_id = ? AND is_archived = 0").get(sessionId);
-    session.messageCount = countResult?.count || 0;
-    session.updatedAt = Date.now();
-    this.db.prepare(`
-      UPDATE session SET metadata = ?, message_count = ?, updated_at = ? WHERE id = ?
-    `).run(JSON.stringify(session.metadata), session.messageCount, session.updatedAt, sessionId);
-    this.sessionsCache.set(sessionId, session);
-    return true;
-  }
-  async archiveMessages(sessionId, checkpointId, beforeIndex) {
-    await this.initialize();
-    const session = await this.get(sessionId);
-    if (!session)
-      return 0;
-    const now = Date.now();
-    const result = this.db.prepare(`
-      UPDATE message 
-      SET is_archived = 1, archived_at = ?, checkpoint_id = ?
-      WHERE session_id = ? AND id IN (
-        SELECT id FROM message WHERE session_id = ? AND is_archived = 0
-        ORDER BY timestamp ASC LIMIT ?
-      )
-    `).run(now, checkpointId, sessionId, sessionId, beforeIndex);
-    const countResult = this.db.prepare("SELECT COUNT(*) as count FROM message WHERE session_id = ? AND is_archived = 0").get(sessionId);
-    session.messageCount = countResult?.count || 0;
-    session.updatedAt = now;
-    this.db.prepare(`
-      UPDATE session SET message_count = ?, updated_at = ? WHERE id = ?
-    `).run(session.messageCount, session.updatedAt, sessionId);
-    this.sessionsCache.set(sessionId, session);
-    this.messagesCache.delete(sessionId);
-    return result.changes;
-  }
-  async getActiveMessages(sessionId, offset = 0, limit = 50) {
-    return this.getMessages(sessionId, offset, limit, { includeArchived: false });
-  }
-  async searchMessages(options) {
-    await this.initialize();
-    const matches = [];
-    const {
-      query,
-      sessionId,
-      limit = 10,
-      beforeTime,
-      afterTime,
-      includeArchived = false
-    } = options;
-    let sql = "SELECT * FROM message WHERE 1=1";
-    const params = [];
-    if (sessionId) {
-      sql += " AND session_id = ?";
-      params.push(sessionId);
-    }
-    if (!includeArchived) {
-      sql += " AND is_archived = 0";
-    }
-    if (beforeTime) {
-      sql += " AND timestamp <= ?";
-      params.push(beforeTime);
-    }
-    if (afterTime) {
-      sql += " AND timestamp >= ?";
-      params.push(afterTime);
-    }
-    sql += " ORDER BY timestamp DESC";
-    sql += " LIMIT ?";
-    params.push(limit * 10);
-    const rows = this.db.prepare(sql).all(...params);
-    const queryTerms = this.parseQuery(query);
-    const lowerQuery = query.toLowerCase();
-    for (const row of rows) {
-      const content = row.content.toLowerCase();
-      let matchesQuery = true;
-      for (const term of queryTerms.excluded) {
-        if (content.includes(term.toLowerCase())) {
-          matchesQuery = false;
-          break;
-        }
-      }
-      if (matchesQuery && queryTerms.required.length > 0) {
-        for (const term of queryTerms.required) {
-          if (!content.includes(term.toLowerCase())) {
-            matchesQuery = false;
-            break;
-          }
-        }
-      }
-      if (!matchesQuery && lowerQuery && content.includes(lowerQuery)) {
-        matchesQuery = true;
-      }
-      if (matchesQuery) {
-        matches.push({
-          messageId: row.id,
-          sessionId: row.session_id,
-          role: row.role,
-          content: row.content,
-          timestamp: row.timestamp
-        });
-        if (matches.length >= limit)
-          break;
-      }
-    }
-    return matches;
-  }
-  parseQuery(query) {
-    const terms = query.split(/\s+/).filter((t) => !t.startsWith('"') && !t.endsWith('"'));
-    const required = [];
-    const excluded = [];
-    for (const term of terms) {
-      if (term.startsWith("-") || term.toUpperCase().startsWith("NOT ")) {
-        excluded.push(term.replace(/^-|^NOT /i, ""));
-      } else {
-        required.push(term);
-      }
-    }
-    return { required, excluded };
-  }
-  async close() {
-    if (this.db) {
-      this.db.close();
-      this.db = null;
-    }
-    this.sessionsCache.clear();
-    this.messagesCache.clear();
-    this.checkpointsCache.clear();
-    this.initialized = false;
-  }
-  rowToSession(row) {
-    return {
-      id: row.id,
-      title: row.title,
-      directory: row.directory,
-      parentID: row.parent_id,
-      createdAt: row.created_at,
-      updatedAt: row.updated_at,
-      messageCount: row.message_count,
-      metadata: row.metadata ? JSON.parse(row.metadata) : undefined
-    };
-  }
-  rowToMessage(row) {
-    const rawMessage = {
-      id: row.id,
-      sessionID: row.session_id,
-      role: row.role,
-      content: row.content,
-      timestamp: row.timestamp,
-      parts: row.parts ? JSON.parse(row.parts) : undefined,
-      isArchived: row.is_archived === 1,
-      archivedAt: row.archived_at || undefined,
-      checkpointId: row.checkpoint_id || undefined,
-      metadata: row.metadata ? JSON.parse(row.metadata) : undefined
-    };
-    return this.messageConverter.migrateMessage(rawMessage);
-  }
-}
-// 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/session/session-component.ts
-init_logger();
-
-// 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/session/session-component.ts
-init_decorator();
-
-// packages/core/src/env/agent/summary-agent.ts
-init_logger();
-init_decorator();
-var logger = createLogger("agent:summary");
-
-class SummaryAgent {
-  promptComponent;
-  llmComponent;
-  config;
-  constructor(promptComponent, llmComponent, config) {
-    this.promptComponent = promptComponent;
-    this.llmComponent = llmComponent;
-    this.config = {
-      type: "summary",
-      promptName: "session/compact",
-      maxIterations: 1,
-      model: undefined,
-      ...config
-    };
-  }
-  async generateCompactHint(options) {
-    const { messages, sessionContext } = options;
-    logger.info("[SummaryAgent] Generating compact hint for session");
-    const formattedMessages = this.formatMessages(messages);
-    const systemPrompt = this.getHintGenerationSystemPrompt();
-    const userPrompt = this.buildHintGenerationUserPrompt(formattedMessages, sessionContext);
-    let response;
-    try {
-      response = await this.llmComponent.invoke({
-        messages: [
-          { role: "system", content: systemPrompt },
-          { role: "user", content: userPrompt }
-        ],
-        skipThresholdCheck: true
-      });
-    } catch (error) {
-      logger.error(`[SummaryAgent] Hint generation LLM invoke failed: ${error}`);
-      throw new Error(`LLM invoke failed: ${error}`);
-    }
-    const responseContent = response.output?.content || response.content || "";
-    const hint = this.parseHintResponse(responseContent);
-    logger.info("[SummaryAgent] Compact hint generated", { hint: hint.substring(0, 100) });
-    return {
-      hint,
-      rawResponse: responseContent
-    };
-  }
-  async run(options) {
-    const { messages, userContext, outputFormat, scenarioHint } = options;
-    logger.info("[SummaryAgent] Starting checkpoint generation", {
-      hasScenarioHint: !!scenarioHint
-    });
-    const formattedMessages = this.formatMessages(messages);
-    const systemPrompt = this.getSystemPrompt(scenarioHint);
-    const userPrompt = this.buildUserPrompt(formattedMessages, userContext);
-    let response;
-    try {
-      response = await this.llmComponent.invoke({
-        messages: [
-          { role: "system", content: systemPrompt },
-          { role: "user", content: userPrompt }
-        ],
-        model: this.config.model,
-        skipThresholdCheck: true
-      });
-    } catch (error) {
-      logger.error(`[SummaryAgent] LLM invoke failed: ${error}`);
-      throw new Error(`LLM invoke failed: ${error}`);
-    }
-    const responseContent = response.output?.content || response.content || "";
-    if (outputFormat === "json") {
-      const result = this.parseJsonResponse(responseContent);
-      logger.info(`[SummaryAgent] Checkpoint generated: "${result.title}"`);
-      return {
-        title: result.title || "Untitled Checkpoint",
-        processKeyPoints: result.processKeyPoints || [],
-        currentState: result.currentState || "",
-        nextSteps: result.nextSteps || [],
-        userIntents: result.userIntents || [],
-        rawResponse: responseContent
-      };
-    }
-    throw new Error(`Unsupported output format: ${outputFormat}`);
-  }
-  getSystemPrompt(scenarioHint) {
-    let prompt = `You are a professional session analyst assistant. Your task is to extract key information from a conversation and generate a structured checkpoint.
-
-A checkpoint captures the progress and state of a session at a point in time. It should contain:
-
-1. **Process Key Points**: The key steps, discoveries, or decisions made during this part of the conversation
-2. **Current State**: The current progress and status at the end of the conversation
-3. **Next Steps**: Follow-up items and what needs to be done next
-4. **User Intents**: The underlying goals and intentions of the user (what they want to accomplish)
-
-Be concise and accurate. Avoid redundancy. Each section should be appropriately sized - not too long.`;
-    if (scenarioHint && scenarioHint.trim()) {
-      prompt += `
-
-## Scenario Context
-
-${scenarioHint.trim()}`;
-    }
-    return prompt;
-  }
-  getHintGenerationSystemPrompt() {
-    return `You are a compact guidance prompt engineer. Your task is to analyze a conversation and generate a "compact guidance prompt" that will instruct the checkpoint generator on what information to extract and preserve during session compression.
-
-**Purpose**: The guidance prompt will be used by the checkpoint generator to understand:
-1. What work is currently in progress
-2. What progress has been made
-3. What information MUST be preserved during compression (this is critical for task continuation)
-4. What information should be the focus of extraction
-
-**Key Principle**: The preserved information should enable seamless task continuation. If critical details are lost during compression, the user will have to re-explain context when continuing this work later.
-
-**Output Format**: A structured guidance prompt (3-4 sentences) covering:
-1. Current work type and what the user is trying to accomplish
-2. Current progress and key achievements
-3. CRITICAL information that MUST be preserved (decisions, findings, remaining issues)
-4. What the checkpoint generator should focus on when extracting information
-
-**Example good outputs**:
-1. "Bug investigation: User is debugging LSP diagnostics not updating after file edits. Progress: identified root cause (getDiagnostics needs to read latest file content and trigger didChange notification), implemented fix, CI verified. CRITICAL to preserve: the fix implementation details (file path, code changes), that 2 agent-node-integration tests still fail due to test assertion timing issue (expects 'running' but completes in ~78ms) - this is unrelated to LSP work. Focus extraction on: root cause analysis, fix implementation, known remaining test issues."
-2. "Feature development: User is implementing JWT authentication for auth-service. Progress: designed auth flow, implemented token refresh logic, middleware partially done. CRITICAL to preserve: auth flow decisions (token storage, refresh strategy), completed middleware components, modules pending implementation. Focus extraction on: architectural decisions, completed components, pending work."
-3. "Refactoring: User is migrating data layer to repository pattern. Progress: migrated UserRepository and OrderRepository, 3 more pending. CRITICAL to preserve: pattern decisions (interface definitions, dependency injection approach), completed repositories, modules pending migration. Focus extraction on: pattern implementation details, completed vs pending modules."`;
-  }
-  buildHintGenerationUserPrompt(messages, sessionContext) {
-    let prompt = `Analyze the following conversation and generate a compact guidance prompt for checkpoint generation.
-
-## Your Task
-Generate a structured guidance prompt (3-4 sentences) that will help the checkpoint generator understand:
-1. What work is currently in progress
-2. What progress has been made
-3. What information MUST be preserved during compression (critical for task continuation)
-4. What the checkpoint generator should focus on when extracting information
-
-`;
-    if (sessionContext) {
-      const ctxLines = ["## Session Context"];
-      if (sessionContext.activeTaskTitle) {
-        ctxLines.push(`- Active Task: ${sessionContext.activeTaskTitle}`);
-      }
-      if (sessionContext.workingDirectory) {
-        ctxLines.push(`- Working Directory: ${sessionContext.workingDirectory}`);
-      }
-      if (sessionContext.recentActions && sessionContext.recentActions.length > 0) {
-        ctxLines.push(`- Recent Actions: ${sessionContext.recentActions.slice(-3).join(" \u2192 ")}`);
-      }
-      if (ctxLines.length > 1) {
-        prompt += ctxLines.join(`
-`) + `
-
-`;
-      }
-    }
-    prompt += `## Conversation to Analyze
-
-${messages}
-
-`;
-    prompt += `---
-
-`;
-    prompt += `## Output Format
-
-`;
-    prompt += `Generate a structured guidance prompt covering:
-`;
-    prompt += `1. Current work type and what the user is trying to accomplish
-`;
-    prompt += `2. Current progress and key achievements
-`;
-    prompt += `3. CRITICAL information that MUST be preserved (decisions, findings, remaining issues)
-`;
-    prompt += `4. What to focus on during extraction
-
-`;
-    prompt += `Wrap the output in a JSON object with a \`guidance_prompt\` key:
-
-`;
-    prompt += `\`\`\`json
-`;
-    prompt += `{
-`;
-    prompt += `  "guidance_prompt": "Work type: ... Progress: ... CRITICAL to preserve: ... Focus extraction on: ..."
-`;
-    prompt += `}
-`;
-    prompt += `\`\`\`
-
-`;
-    prompt += `IMPORTANT: The preserved information should enable seamless task continuation. If critical details are lost, the user will need to re-explain context when continuing this work.`;
-    return prompt;
-  }
-  buildUserPrompt(messages, userContext) {
-    let prompt = `Please analyze the following conversation and generate a checkpoint:
-
-`;
-    if (userContext && userContext !== "\u65E0\u989D\u5916\u4E0A\u4E0B\u6587") {
-      prompt += `## Context
-${userContext}
-
-`;
-    }
-    prompt += `## Conversation Content
-
-${messages}
-
-`;
-    prompt += `---
-
-`;
-    prompt += `## Output Format
-
-Please output in the following JSON format:
-
-\`\`\`json
-{
-  "title": "Brief checkpoint title (max 30 characters)",
-  "processKeyPoints": [
-    "Point 1: Description of key discovery or decision",
-    "Point 2: Description of important step or conclusion",
-    "Point 3: ..."
-  ],
-  "currentState": "Current state description explaining progress and status (50-100 characters)",
-  "nextSteps": [
-    "Next follow-up item 1",
-    "Next follow-up item 2"
-  ],
-  "userIntents": [
-    "User intent 1: what the user wants to accomplish",
-    "User intent 2: another goal or request",
-    "User intent 3: ..."
-  ]
-}
-\`\`\`
-
-`;
-    prompt += `## Intent Extraction Guidelines
-
-`;
-    prompt += `- Extract user intents from the ENTIRE conversation flow (both user and assistant messages)
-`;
-    prompt += `- Focus on what the user WANTS to accomplish, not just what was discussed
-`;
-    prompt += `- Include both explicit requests and inferred goals
-`;
-    prompt += `- Aim for 2-5 intents, prioritize the most important ones
-`;
-    prompt += `- Be concise and specific in intent descriptions
-`;
-    prompt += `- Examples: "Fix authentication bug", "Optimize database performance", "Add unit tests for auth module"
-
-`;
-    prompt += `Make sure the JSON output is valid and can be parsed.`;
-    return prompt;
-  }
-  formatMessages(messages) {
-    return messages.map((m, i) => `[${i}] ${m.role}: ${m.content}`).join(`
-
-`);
-  }
-  parseJsonResponse(content) {
-    const jsonMatch = content.match(/```json\s*([\s\S]*?)\s*```/) || content.match(/```\s*([\s\S]*?)\s*```/) || [null, content];
-    const jsonStr = jsonMatch[1] || content;
-    try {
-      return JSON.parse(jsonStr.trim());
-    } catch {
-      const fixed = jsonStr.replace(/,\s*}/g, "}").replace(/,\s*]/g, "]").replace(/'/g, '"').trim();
-      try {
-        return JSON.parse(fixed);
-      } catch (e) {
-        logger.error(`[SummaryAgent] Failed to parse JSON: ${content}`);
-        throw new Error(`Failed to parse checkpoint JSON: ${e}`);
-      }
-    }
-  }
-  parseHintResponse(content) {
-    return parseCompactHintResponse(content);
-  }
-}
-__legacyDecorateClassTS([
-  TracedAs("summary-agent.generateCompactHint")
-], SummaryAgent.prototype, "generateCompactHint", null);
-__legacyDecorateClassTS([
-  TracedAs("summary-agent.run", { recordParams: true, recordResult: true })
-], SummaryAgent.prototype, "run", null);
-__legacyDecorateClassTS([
-  TracedAs("summary-agent.getHintGenerationSystemPrompt")
-], SummaryAgent.prototype, "getHintGenerationSystemPrompt", null);
-__legacyDecorateClassTS([
-  TracedAs("summary-agent.buildHintGenerationUserPrompt")
-], SummaryAgent.prototype, "buildHintGenerationUserPrompt", null);
-__legacyDecorateClassTS([
-  TracedAs("summary-agent.parseHintResponse")
-], SummaryAgent.prototype, "parseHintResponse", null);
-function parseCompactHintResponse(content) {
-  const jsonResult = extractGuidanceFromJson(content);
-  if (jsonResult !== null) {
-    const trimmed = jsonResult.trim();
-    if (!trimmed) {
-      return "[Hint extraction failed]";
-    }
-    if (trimmed.length > 500) {
-      return trimmed.substring(0, 500) + "...";
-    }
-    return trimmed;
-  }
-  let text = content.replace(/```json\s*([\s\S]*?)\s*```/g, "$1").replace(/```markdown\s*([\s\S]*?)\s*```/g, "$1").replace(/```\s*([\s\S]*?)\s*```/g, "$1").trim();
-  if (!text) {
-    return "[Hint extraction failed]";
-  }
-  if (text.length > 500) {
-    return text.substring(0, 500) + "...";
-  }
-  return text;
-}
-function extractGuidanceFromJson(content) {
-  const jsonBlockMatch = content.match(/```json\s*([\s\S]*?)\s*```/);
-  if (jsonBlockMatch) {
-    const parsed2 = tryParseJson(jsonBlockMatch[1]);
-    const guidancePrompt2 = parsed2?.guidance_prompt;
-    if (typeof guidancePrompt2 === "string") {
-      return guidancePrompt2;
-    }
-  }
-  const plainBlockMatch = content.match(/```\s*([\s\S]*?)\s*```/);
-  if (plainBlockMatch) {
-    const parsed2 = tryParseJson(plainBlockMatch[1]);
-    const guidancePrompt2 = parsed2?.guidance_prompt;
-    if (typeof guidancePrompt2 === "string") {
-      return guidancePrompt2;
-    }
-  }
-  const jsonMatch = content.match(/\{[\s\S]*"guidance_prompt"[\s\S]*\}/);
-  if (jsonMatch) {
-    const parsed2 = tryParseJson(jsonMatch[0]);
-    const guidancePrompt2 = parsed2?.guidance_prompt;
-    if (typeof guidancePrompt2 === "string") {
-      return guidancePrompt2;
-    }
-  }
-  const parsed = tryParseJson(content.trim());
-  const guidancePrompt = parsed?.guidance_prompt;
-  if (typeof guidancePrompt === "string") {
-    return guidancePrompt;
-  }
-  return null;
-}
-function tryParseJson(str) {
-  if (!str || !str.trim()) {
-    return null;
-  }
-  try {
-    return JSON.parse(str.trim());
-  } catch {
-    try {
-      const fixed = str.replace(/,\s*}/g, "}").replace(/,\s*]/g, "]").trim();
-      return JSON.parse(fixed);
-    } catch {
-      return null;
-    }
-  }
-}
-
-// packages/core/src/env/session/session-config-registration.ts
-var SESSION_DEFAULTS = {
-  "session.defaultDirectory": "/tmp",
-  "session.defaultTitleTemplate": "Session - {date}",
-  "session.maxMessages": 100,
-  "session.compactionThreshold": 80,
-  "session.autoCompact": true,
-  "session.storage.type": "sqlite",
-  "session.storage.dbPath": undefined,
-  "session.checkpoint.enabled": false,
-  "session.contextLimit": 1e5,
-  "session.maxSessions": 100
-};
-var SESSION_CONFIG_REGISTRATION = {
-  name: "session",
-  sources: [
-    { type: "env", envPrefix: "SESSION", priority: 20, watch: false }
-  ],
-  keys: [
-    { key: "session.defaultDirectory", sources: ["env", "file"] },
-    { key: "session.defaultTitleTemplate", sources: ["env", "file"] },
-    { key: "session.maxMessages", sources: ["env", "file"] },
-    { key: "session.compactionThreshold", sources: ["env", "file"] },
-    { key: "session.autoCompact", sources: ["env", "file"] },
-    { key: "session.storage.type", sources: ["env", "file"] },
-    { key: "session.storage.dbPath", sources: ["env", "file"] },
-    { key: "session.checkpoint.enabled", sources: ["env", "file"] },
-    { key: "session.contextLimit", sources: ["env", "file"] },
-    { key: "session.maxSessions", sources: ["env", "file"] }
-  ]
-};
-
-// packages/core/src/env/session/session-component.ts
-import path from "path";
-var logger2 = createLogger("session");
-
-class SessionComponent extends BaseComponent {
-  name = "session";
-  version = "1.1.0";
-  config;
-  store;
-  activeSessionId;
-  hooksConfig = {};
-  configComponent;
-  configWatcher;
-  summaryAgent;
-  promptComponent;
-  llmComponent;
-  constructor() {
-    super();
-  }
-  async init(config) {
-    await super.init(config);
-    const options = config?.options;
-    if (!options?.configComponent) {
-      throw new Error("ConfigComponent is required for SessionComponent initialization");
-    }
-    this.configComponent = options.configComponent;
-    await this.registerConfig(options);
-    const storageConfig = this.config?.storage;
-    if (storageConfig?.type === "sqlite") {
-      this.store = new SQLiteSessionStore(storageConfig.dbPath);
-      logger2.info(`[SessionComponent] Using SQLite storage: ${storageConfig.dbPath || "default path"}`);
-    } else {
-      this.store = new MemorySessionStore;
-      logger2.info("[SessionComponent] Using memory storage");
-    }
-    this.setStatus("running");
-    logger2.info("[SessionComponent] Initialized");
-  }
-  getDefaultSessionDbPath() {
-    const home = process.env.HOME || process.env.USERPROFILE || "/tmp";
-    return path.join(home, ".local", "share", "roy-agent", "sessions.db");
-  }
-  async registerConfig(options) {
-    const configComponent = options.configComponent;
-    if (!configComponent)
-      return;
-    const { configPath, envPrefix, config } = options;
-    const prefix = envPrefix !== undefined ? envPrefix : "SESSION";
-    configComponent.registerComponent(SESSION_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("session");
-    for (const envKey of Object.keys(process.env)) {
-      const configKey = envKeyToConfigKey(envKey, prefix, "session");
-      if (!configKey)
-        continue;
-      const value = process.env[envKey];
-      if (value !== undefined) {
-        await configComponent.set(configKey, value);
-      }
-    }
-    for (const [key, value] of Object.entries(SESSION_DEFAULTS)) {
-      if (configComponent.get(key) === undefined) {
-        await configComponent.set(key, value);
-      }
-    }
-    if (configComponent.get("session.storage.dbPath") === undefined) {
-      await configComponent.set("session.storage.dbPath", this.getDefaultSessionDbPath());
-    }
-    if (config) {
-      const flatConfig = this.flattenConfig(config);
-      for (const [key, value] of Object.entries(flatConfig)) {
-        await configComponent.set(key, value);
-      }
-    }
-    this.registerConfigWatcher(configComponent);
-    this.config = this.buildConfig(configComponent);
-  }
-  buildConfig(configComponent) {
-    return {
-      defaultDirectory: configComponent.get("session.defaultDirectory"),
-      defaultTitleTemplate: configComponent.get("session.defaultTitleTemplate"),
-      maxMessages: configComponent.get("session.maxMessages"),
-      compactionThreshold: configComponent.get("session.compactionThreshold"),
-      autoCompact: configComponent.get("session.autoCompact"),
-      storage: {
-        type: configComponent.get("session.storage.type"),
-        dbPath: configComponent.get("session.storage.dbPath")
-      }
-    };
-  }
-  flattenConfig(obj, prefix = "session") {
-    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("session.*", (event) => {
-      this.onConfigChange(event);
-    });
-  }
-  onConfigChange(event) {
-    logger2.info(`Session config changed: ${event.key}`, {
-      oldValue: event.oldValue,
-      newValue: event.newValue
-    });
-  }
-  async onStart() {
-    logger2.info("[SessionComponent] Started");
-  }
-  async onStop() {
-    this.configWatcher?.();
-    this.configWatcher = undefined;
-    await this.store?.close();
-    this.store = undefined;
-    this.setStatus("stopped");
-    logger2.info("[SessionComponent] Stopped");
-  }
-  async create(options = {}) {
-    await this.executeBeforeHooks("create", { options });
-    const title = options.title ?? this.generateTitle();
-    const session = await this.store.create({
-      ...options,
-      title
-    });
-    logger2.info(`[SessionComponent] Created session: ${session.id}`, { title });
-    await this.executeAfterHooks("create", { session, options });
-    return session;
-  }
-  async get(id) {
-    await this.executeBeforeHooks("session.get", { id });
-    const session = await this.store?.get(id);
-    await this.executeAfterHooks("session.get", { session });
-    return session;
-  }
-  async getSession(id) {
-    const session = await this.get(id);
-    if (!session) {
-      return null;
-    }
-    const messages = await this.getMessages(id);
-    return {
-      sessionId: session.id,
-      title: session.title || "Untitled",
-      messages: messages.map((m) => ({
-        role: m.role,
-        content: m.content,
-        timestamp: m.timestamp
-      }))
-    };
-  }
-  async searchSessions(query, options) {
-    const limit = options?.limit ?? 20;
-    if (options?.session_id) {
-      const session = await this.get(options.session_id);
-      if (session) {
-        const messages = await this.getMessages(options.session_id);
-        const lastMessage = messages[messages.length - 1];
-        return [{
-          sessionId: session.id,
-          title: session.title || "Untitled",
-          preview: lastMessage?.content?.substring(0, 200) || "",
-          timestamp: session.updatedAt || session.createdAt
-        }];
-      }
-      return [];
-    }
-    const sessions = await this.list({ limit });
-    const results = [];
-    for (const session of sessions) {
-      if (results.length >= limit)
-        break;
-      const messages = await this.getMessages(session.id);
-      const lastMessage = messages[messages.length - 1];
-      const preview = lastMessage?.content?.substring(0, 200) || "";
-      if (query) {
-        const lowerQuery = query.toLowerCase();
-        const titleMatch = (session.title || "").toLowerCase().includes(lowerQuery);
-        const previewMatch = preview.toLowerCase().includes(lowerQuery);
-        if (!titleMatch && !previewMatch) {
-          continue;
-        }
-      }
-      results.push({
-        sessionId: session.id,
-        title: session.title || "Untitled",
-        preview,
-        timestamp: session.updatedAt || session.createdAt
-      });
-    }
-    return results;
-  }
-  async list(options) {
-    await this.executeBeforeHooks("session.list", { options });
-    const sessions = await this.store?.list(options) ?? [];
-    await this.executeAfterHooks("session.list", { sessions });
-    return sessions;
-  }
-  async getCount() {
-    return await this.store?.getCount() ?? 0;
-  }
-  async update(id, updates) {
-    await this.executeBeforeHooks("session.update", { id, updates });
-    const success = await this.store?.update(id, updates);
-    if (success) {
-      logger2.info(`[SessionComponent] Updated session: ${id}`, { updates });
-      await this.executeAfterHooks("session.update", { id, updates });
-    }
-    return success ?? false;
-  }
-  async delete(id) {
-    await this.executeBeforeHooks("session.delete", { id });
-    const success = await this.store?.delete(id);
-    if (success) {
-      if (this.activeSessionId === id) {
-        this.activeSessionId = undefined;
-      }
-      logger2.info(`[SessionComponent] Deleted session: ${id}`);
-      await this.executeAfterHooks("session.delete", { id });
-    }
-    return success ?? false;
-  }
-  getActiveSession() {
-    if (!this.activeSessionId)
-      return;
-    return;
-  }
-  getActiveSessionId() {
-    return this.activeSessionId;
-  }
-  async setActiveSession(id) {
-    const session = await this.store?.get(id);
-    if (!session)
-      return false;
-    this.activeSessionId = id;
-    logger2.info(`[SessionComponent] Active session set: ${id}`);
-    return true;
-  }
-  async addMessage(sessionId, message) {
-    const contentPreview = typeof message.content === "string" ? message.content.substring(0, 100) : JSON.stringify(message.content).substring(0, 100);
-    logger2.info(`[SessionComponent.addMessage] sessionId=${sessionId}, role=${message.role}, content="${contentPreview}"`);
-    try {
-      const messageId = await this.store?.addMessage(sessionId, message);
-      logger2.info(`[SessionComponent.addMessage] Success: messageId=${messageId}`);
-      return messageId;
-    } catch (error) {
-      logger2.error(`[SessionComponent] Failed to add message: ${error}`);
-      return;
-    }
-  }
-  async getMessages(sessionId, options) {
-    const messages = await this.store?.getMessages(sessionId, options?.offset, options?.limit);
-    return messages ?? [];
-  }
-  async getMessageCount(sessionId, includeArchived) {
-    return this.store?.getMessageCount(sessionId, includeArchived) ?? 0;
-  }
-  async getMessageIndexes(sessionId, role) {
-    return this.store?.getMessageIndexes(sessionId, role) ?? [];
-  }
-  async executeBeforeHooks(operation, context) {
-    const hookKey = `before.session.${operation}`;
-    const hooks = this.hooksConfig[hookKey] ?? [];
-    const hookContext = context;
-    for (const hook of hooks) {
-      if (hook.before) {
-        await hook.before(hookContext);
-      }
-    }
-    const options = context.options;
-    if (options?.hooks) {
-      const hookArray = options.hooks[hookKey] ?? [];
-      for (const hook of hookArray) {
-        if (hook.before) {
-          await hook.before(hookContext);
-        }
-      }
-    }
-  }
-  async executeAfterHooks(operation, context) {
-    const hookKey = `after.session.${operation}`;
-    const hooks = this.hooksConfig[hookKey] ?? [];
-    const hookContext = context;
-    for (const hook of hooks) {
-      if (hook.after) {
-        await hook.after(hookContext);
-      }
-    }
-    const options = context.options;
-    if (options?.hooks) {
-      const hookArray = options.hooks[hookKey] ?? [];
-      for (const hook of hookArray) {
-        if (hook.after) {
-          await hook.after(hookContext);
-        }
-      }
-    }
-  }
-  generateTitle() {
-    const template = this.config?.defaultTitleTemplate ?? "Session - {date}";
-    const date = new Date().toISOString().replace("T", " ").substring(0, 19);
-    return template.replace("{date}", date);
-  }
-  setSummaryComponents(promptComponent, llmComponent) {
-    this.promptComponent = promptComponent;
-    this.llmComponent = llmComponent;
-    this.summaryAgent = new SummaryAgent(promptComponent, llmComponent);
-  }
-  ensureSummaryAgent() {
-    if (!this.summaryAgent) {
-      if (!this.promptComponent || !this.llmComponent) {
-        throw new Error("SummaryAgent components not initialized. Call setSummaryComponents() first.");
-      }
-      this.summaryAgent = new SummaryAgent(this.promptComponent, this.llmComponent);
-    }
-  }
-  async generateCompactHint(sessionId) {
-    const session = await this.get(sessionId);
-    if (!session) {
-      throw new Error(`Session not found: ${sessionId}`);
-    }
-    const latestCheckpoint = this.getLatestCheckpoint(session);
-    const startIndex = latestCheckpoint?.messageIndex ?? 0;
-    const MAX_SAFE_MESSAGES = Number.MAX_SAFE_INTEGER;
-    const messages = await this.store.getMessages(sessionId, startIndex, MAX_SAFE_MESSAGES, { includeArchived: false });
-    if (messages.length < 3) {
-      logger2.warn("[SessionComponent] Not enough messages for hint generation");
-      return "";
-    }
-    this.ensureSummaryAgent();
-    const result = await this.summaryAgent.generateCompactHint({
-      messages: messages.map((m) => ({ role: m.role, content: m.content })),
-      sessionContext: {}
-    });
-    logger2.info("[SessionComponent] Compact hint generated", {
-      sessionId,
-      hintLength: result.hint.length
-    });
-    return result.hint;
-  }
-  async compact(sessionId, options) {
-    const session = await this.get(sessionId);
-    if (!session) {
-      throw new Error(`Session not found: ${sessionId}`);
-    }
-    const latestCheckpoint = this.getLatestCheckpoint(session);
-    const startIndex = latestCheckpoint?.messageIndex ?? 0;
-    const MAX_SAFE_MESSAGES = Number.MAX_SAFE_INTEGER;
-    const messages = await this.store.getMessages(sessionId, startIndex, MAX_SAFE_MESSAGES, { includeArchived: false });
-    if (messages.length < 3) {
-      throw new Error("Not enough messages to compact (minimum 3 required)");
-    }
-    const recentMessages = this.extractRecentMessages(messages, 2);
-    this.ensureSummaryAgent();
-    await this.executeBeforeHooks("compact", { session, options });
-    const summaryResult = await this.summaryAgent.run({
-      messages: messages.map((m) => ({ role: m.role, content: m.content })),
-      userContext: options?.summary,
-      outputFormat: "json",
-      scenarioHint: options?.scenarioHint
-    });
-    const checkpointId = `cp_${Date.now().toString(36)}_${Math.random().toString(36).substring(2, 8)}`;
-    const checkpoint = {
-      id: checkpointId,
-      messageIndex: startIndex,
-      title: summaryResult.title,
-      summary: [
-        `Process: ${summaryResult.processKeyPoints.join("; ")}`,
-        `State: ${summaryResult.currentState}`
-      ].join(`
-`),
-      processKeyPoints: summaryResult.processKeyPoints,
-      currentState: summaryResult.currentState,
-      nextSteps: summaryResult.nextSteps,
-      userIntents: summaryResult.userIntents,
-      messageCountBefore: messages.length,
-      createdAt: Date.now(),
-      type: "compact",
-      recentMessages
-    };
-    await this.store.saveCheckpoint(sessionId, checkpoint);
-    await this.store.archiveMessages(sessionId, checkpointId, messages.length);
-    const checkpointMessage = this.createCheckpointMessage(checkpoint);
-    await this.store.addMessage(sessionId, checkpointMessage);
-    const updatedSession = await this.get(sessionId);
-    const remainingMessageCount = updatedSession?.messageCount ?? 0;
-    const checkpointCount = updatedSession?.metadata?.checkpoints?.checkpoints?.length ?? 0;
-    logger2.info(`[SessionComponent] Compacted session: ${sessionId}`, {
-      checkpointId,
-      archivedCount: messages.length,
-      remainingCount: remainingMessageCount,
-      hasScenarioHint: !!options?.scenarioHint,
-      recentMessagesCount: recentMessages.length
-    });
-    await this.executeAfterHooks("compact", { session, checkpoint, options });
-    return {
-      checkpoint,
-      deletedMessageCount: messages.length,
-      remainingMessageCount,
-      checkpointCount
-    };
-  }
-  extractRecentMessages(messages, turnCount = 2) {
-    const recentMessages = [];
-    let turnsExtracted = 0;
-    let i = messages.length - 1;
-    while (i >= 0 && turnsExtracted < turnCount) {
-      const msg = messages[i];
-      if (msg.metadata?.isCheckpoint) {
-        i--;
-        continue;
-      }
-      const hasToolParts = msg.parts?.some((p) => p.type === "tool-call" || p.type === "tool-result");
-      if (msg.role === "assistant" && !hasToolParts && msg.content.trim()) {
-        recentMessages.unshift({
-          role: "assistant",
-          content: msg.content
-        });
-        let j = i - 1;
-        while (j >= 0) {
-          const prevMsg = messages[j];
-          if (prevMsg.metadata?.isCheckpoint) {
-            j--;
-            continue;
-          }
-          if (prevMsg.role === "user") {
-            recentMessages.unshift({
-              role: "user",
-              content: prevMsg.content
-            });
-            turnsExtracted++;
-            break;
-          }
-          j--;
-        }
-        i = j;
-      } else {
-        i--;
-      }
-    }
-    logger2.debug("[SessionComponent] Extracted recent messages", {
-      turnCount,
-      messagesExtracted: recentMessages.length
-    });
-    return recentMessages;
-  }
-  async previewCompact(sessionId) {
-    const session = await this.get(sessionId);
-    if (!session) {
-      throw new Error(`Session not found: ${sessionId}`);
-    }
-    const latestCheckpoint = this.getLatestCheckpoint(session);
-    const startIndex = latestCheckpoint?.messageIndex ?? 0;
-    const MAX_SAFE_MESSAGES = Number.MAX_SAFE_INTEGER;
-    const messages = await this.store.getMessages(sessionId, startIndex, MAX_SAFE_MESSAGES, { includeArchived: false });
-    const estimatedTokens = messages.reduce((sum, m) => sum + m.content.length * 0.25, 0);
-    return {
-      messageCountToCompact: messages.length,
-      estimatedCheckpointTokens: Math.round(estimatedTokens * 0.1),
-      wouldTrigger: messages.length >= (this.config?.maxMessages ?? 50)
-    };
-  }
-  async getCheckpoints(sessionId) {
-    return await this.store.getCheckpoints(sessionId);
-  }
-  async getCheckpoint(sessionId, checkpointId) {
-    return await this.store.getCheckpoint(sessionId, checkpointId);
-  }
-  async deleteCheckpoint(sessionId, checkpointId) {
-    await this.executeBeforeHooks("deleteCheckpoint", { sessionId, checkpointId });
-    const success = await this.store.deleteCheckpoint(sessionId, checkpointId);
-    if (success) {
-      logger2.info(`[SessionComponent] Deleted checkpoint: ${checkpointId}`);
-      await this.executeAfterHooks("deleteCheckpoint", { sessionId, checkpointId });
-    }
-    return success;
-  }
-  async getContext(sessionId, options) {
-    const session = await this.get(sessionId);
-    if (!session) {
-      throw new Error(`Session not found`);
-    }
-    let contextMessages = [];
-    let startCheckpoint;
-    if (options?.fullHistory) {
-      const MAX_SAFE_MESSAGES = Number.MAX_SAFE_INTEGER;
-      contextMessages = await this.store.getMessages(sessionId, 0, MAX_SAFE_MESSAGES, {
-        includeArchived: true
-      });
-    } else {
-      const latestCheckpointId = session.metadata?.checkpoints?.latestCheckpointId;
-      if (latestCheckpointId) {
-        startCheckpoint = await this.store.getCheckpoint(sessionId, latestCheckpointId);
-        if (startCheckpoint) {
-          const MAX_SAFE_MESSAGES = Number.MAX_SAFE_INTEGER;
-          contextMessages = await this.store.getMessages(sessionId, startCheckpoint.messageIndex, MAX_SAFE_MESSAGES, { includeArchived: false });
-        }
-      }
-      if (contextMessages.length === 0) {
-        const MAX_SAFE_MESSAGES = Number.MAX_SAFE_INTEGER;
-        contextMessages = await this.store.getMessages(sessionId, 0, MAX_SAFE_MESSAGES, {
-          includeArchived: false
-        });
-      }
-    }
-    if (options?.minUserMessages && options.minUserMessages > 0) {
-      const userIndexes = [];
-      for (let i = 0;i < contextMessages.length; i++) {
-        if (contextMessages[i].role === "user") {
-          userIndexes.push(i);
-        }
-      }
-      if (userIndexes.length > options.minUserMessages) {
-        const targetIndex = userIndexes[userIndexes.length - options.minUserMessages];
-        contextMessages = contextMessages.slice(targetIndex);
-      }
-    }
-    if (options?.messageLimit) {
-      contextMessages = contextMessages.slice(-options.messageLimit);
-    }
-    const checkpoints = contextMessages.filter((m) => m.metadata?.isCheckpoint).map((m) => m.metadata.checkpointMeta);
-    const estimatedTokens = contextMessages.reduce((sum, m) => sum + m.content.length * 0.25, 0);
-    return {
-      session,
-      checkpoints,
-      startCheckpoint: startCheckpoint ?? checkpoints[checkpoints.length - 1],
-      messages: contextMessages,
-      totalMessageCount: contextMessages.length,
-      activeMessageCount: contextMessages.filter((m) => !m.isArchived).length,
-      archivedMessageCount: contextMessages.filter((m) => m.isArchived).length,
-      estimatedTokens: Math.round(estimatedTokens)
-    };
-  }
-  async shouldCompact(sessionId) {
-    const session = await this.get(sessionId);
-    if (!session)
-      return false;
-    const preview = await this.previewCompact(sessionId);
-    return preview.wouldTrigger;
-  }
-  async searchMessages(options) {
-    const {
-      query,
-      sessionId,
-      limit = 10,
-      maxResults = 100,
-      beforeTime,
-      afterTime,
-      includeArchived = false,
-      includeContext = false,
-      contextLines = 2
-    } = options;
-    if (!this.store) {
-      return [];
-    }
-    let sessions;
-    if (sessionId) {
-      const session = await this.get(sessionId);
-      sessions = session ? [session] : [];
-    } else {
-      sessions = await this.list({ limit: 1000 });
-    }
-    const results = [];
-    let totalMatches = 0;
-    for (const session of sessions) {
-      if (beforeTime && session.updatedAt > beforeTime)
-        continue;
-      if (afterTime && session.updatedAt < afterTime)
-        continue;
-      const messages = await this.store.getMessages(session.id, 0, 1000, { includeArchived });
-      const queryTerms = parseSearchQuery(query);
-      const matches = [];
-      for (const msg of messages) {
-        if (beforeTime && msg.timestamp > beforeTime)
-          continue;
-        if (afterTime && msg.timestamp < afterTime)
-          continue;
-        if (matchesQuery(msg.content, queryTerms)) {
-          const match = {
-            messageId: msg.id,
-            sessionId: session.id,
-            role: msg.role,
-            content: msg.content,
-            timestamp: msg.timestamp
-          };
-          if (includeContext) {
-            const msgIndex = messages.indexOf(msg);
-            const beforeMsgs = messages.slice(Math.max(0, msgIndex - contextLines), msgIndex);
-            const afterMsgs = messages.slice(msgIndex + 1, msgIndex + 1 + contextLines);
-            match.contextBefore = beforeMsgs.map((m) => m.content).join(`
-`);
-            match.contextAfter = afterMsgs.map((m) => m.content).join(`
-`);
-          }
-          matches.push(match);
-          if (matches.length >= limit)
-            break;
-        }
-      }
-      if (matches.length > 0) {
-        results.push({
-          sessionId: session.id,
-          sessionTitle: session.title,
-          sessionDirectory: session.directory,
-          updatedAt: session.updatedAt,
-          messageCount: session.messageCount,
-          matches
-        });
-        totalMatches += matches.length;
-        if (totalMatches >= maxResults)
-          break;
-      }
-    }
-    return results;
-  }
-  getLatestCheckpoint(session) {
-    const latestId = session.metadata?.checkpoints?.latestCheckpointId;
-    if (!latestId)
-      return;
-    return session.metadata?.checkpointDetails?.[latestId];
-  }
-  createCheckpointMessage(checkpoint) {
-    const lines = [
-      `# Checkpoint: ${checkpoint.title}`,
-      "",
-      "## Process Key Points",
-      ...checkpoint.processKeyPoints.map((p, i) => `${i + 1}. ${p}`),
-      "",
-      "## Current State",
-      checkpoint.currentState,
-      ""
-    ];
-    if (checkpoint.nextSteps?.length) {
-      lines.push("## Next Steps");
-      checkpoint.nextSteps.forEach((s, i) => lines.push(`${i + 1}. ${s}`));
-      lines.push("");
-    }
-    lines.push("## Messages Compacted");
-    lines.push(`${checkpoint.messageCountBefore} messages compacted at ${new Date(checkpoint.createdAt).toISOString()}`);
-    const content = lines.join(`
-`);
-    return {
-      role: "user",
-      content,
-      parts: [{
-        type: "checkpoint",
-        checkpointId: checkpoint.id,
-        content,
-        title: checkpoint.title,
-        processKeyPoints: checkpoint.processKeyPoints,
-        currentState: checkpoint.currentState,
-        nextSteps: checkpoint.nextSteps,
-        messageCountBefore: checkpoint.messageCountBefore,
-        createdAt: checkpoint.createdAt
-      }],
-      metadata: {
-        isCheckpoint: true,
-        checkpointId: checkpoint.id,
-        checkpointMeta: checkpoint
-      }
-    };
-  }
-}
-__legacyDecorateClassTS([
-  TracedAs("session.generateCompactHint")
-], SessionComponent.prototype, "generateCompactHint", null);
-__legacyDecorateClassTS([
-  TracedAs("session.compact", { recordParams: true, recordResult: true })
-], SessionComponent.prototype, "compact", null);
-__legacyDecorateClassTS([
-  TracedAs("session.extractRecentMessages")
-], SessionComponent.prototype, "extractRecentMessages", null);
-export {
-  SessionMessageConverter,
-  SessionComponent,
-  MemorySessionStore
-};