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

package/dist/env/task/index.js

@@ -1,3578 +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/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/task/storage/sqlite-task-store.ts
-init_logger();
-import { join as join2 } from "path";
-var logger = createLogger("task:store");
-function getDefaultDataDir() {
-  const home = process.env.HOME || process.env.USERPROFILE || "/tmp";
-  return join2(home, ".local", "share");
-}
-function getDefaultTaskDbPath() {
-  return join2(getDefaultDataDir(), "roy-agent", "tasks.db");
-}
-
-class SQLiteTaskStore {
-  db = null;
-  dbPath;
-  initialized = false;
-  tasksCache = new Map;
-  operationsCache = new Map;
-  constructor(dbPath) {
-    this.dbPath = dbPath || getDefaultTaskDbPath();
-  }
-  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 task (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        title TEXT NOT NULL,
-        description TEXT DEFAULT '',
-        status TEXT DEFAULT 'todo',
-        priority TEXT DEFAULT 'medium',
-        progress INTEGER DEFAULT 0,
-        current_status TEXT DEFAULT '',
-        goals_and_expected_deliverables TEXT DEFAULT '',
-        parent_task_id INTEGER,
-        created_at INTEGER NOT NULL,
-        updated_at INTEGER NOT NULL,
-        due_date TEXT,
-        tags TEXT
-      )
-    `);
-    this.db.run(`
-      CREATE TABLE IF NOT EXISTS task_operation (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        task_id INTEGER NOT NULL,
-        session_id TEXT NOT NULL,
-        action_type TEXT NOT NULL,
-        action_title TEXT NOT NULL,
-        action_description TEXT DEFAULT '',
-        timestamp INTEGER NOT NULL,
-        md_path TEXT,
-        FOREIGN KEY (task_id) REFERENCES task(id) ON DELETE CASCADE
-      )
-    `);
-    this.db.run("CREATE INDEX IF NOT EXISTS idx_task_operation_task_id ON task_operation(task_id)");
-    this.db.run("CREATE INDEX IF NOT EXISTS idx_task_operation_session_id ON task_operation(session_id)");
-    this.db.run(`
-      CREATE TABLE IF NOT EXISTS task_tag (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        name TEXT NOT NULL UNIQUE,
-        created_at INTEGER NOT NULL,
-        task_count INTEGER DEFAULT 0
-      )
-    `);
-    this.db.run(`
-      CREATE TABLE IF NOT EXISTS task_tag_relation (
-        task_id INTEGER NOT NULL,
-        tag_id INTEGER NOT NULL,
-        created_at INTEGER NOT NULL,
-        PRIMARY KEY (task_id, tag_id),
-        FOREIGN KEY (task_id) REFERENCES task(id) ON DELETE CASCADE,
-        FOREIGN KEY (tag_id) REFERENCES task_tag(id) ON DELETE CASCADE
-      )
-    `);
-    this.db.run("CREATE INDEX IF NOT EXISTS idx_task_tag_relation_tag_id ON task_tag_relation(tag_id)");
-    this.initialized = true;
-    logger.info(`TaskStore initialized at ${this.dbPath}`);
-  }
-  async createTask(options) {
-    await this.initialize();
-    const now = Date.now();
-    const stmt = this.db.prepare(`
-      INSERT INTO task (title, description, priority, parent_task_id, 
-        goals_and_expected_deliverables, due_date, tags, status, 
-        current_status, created_at, updated_at)
-      VALUES (?, ?, ?, ?, ?, ?, ?, 'todo', '', ?, ?)
-    `);
-    const result = stmt.run(options.title, options.description || "", options.priority || "medium", options.parent_task_id || null, options.goals_and_expected_deliverables || "", options.due_date || null, options.tags ? JSON.stringify(options.tags) : null, now, now);
-    const task = await this.getTask(result.lastInsertRowid);
-    if (task) {
-      this.tasksCache.set(task.id, task);
-      return task;
-    }
-    throw new Error("Failed to create task");
-  }
-  async getTask(id) {
-    await this.initialize();
-    if (this.tasksCache.has(id)) {
-      return this.tasksCache.get(id);
-    }
-    const stmt = this.db.prepare("SELECT * FROM task WHERE id = ?");
-    const row = stmt.get(id);
-    if (!row)
-      return;
-    const task = this.rowToTask(row);
-    this.tasksCache.set(id, task);
-    return task;
-  }
-  async updateTask(id, options) {
-    await this.initialize();
-    const task = await this.getTask(id);
-    if (!task)
-      return;
-    const updates = [];
-    const values = [];
-    if (options.title !== undefined) {
-      updates.push("title = ?");
-      values.push(options.title);
-    }
-    if (options.description !== undefined) {
-      updates.push("description = ?");
-      values.push(options.description);
-    }
-    if (options.status !== undefined) {
-      updates.push("status = ?");
-      values.push(options.status);
-    }
-    if (options.priority !== undefined) {
-      updates.push("priority = ?");
-      values.push(options.priority);
-    }
-    if (options.progress !== undefined) {
-      updates.push("progress = ?");
-      values.push(options.progress);
-    }
-    if (options.current_status !== undefined) {
-      updates.push("current_status = ?");
-      values.push(options.current_status);
-    }
-    if (options.goals_and_expected_deliverables !== undefined) {
-      updates.push("goals_and_expected_deliverables = ?");
-      values.push(options.goals_and_expected_deliverables);
-    }
-    if (options.due_date !== undefined) {
-      updates.push("due_date = ?");
-      values.push(options.due_date);
-    }
-    if (options.tags !== undefined) {
-      updates.push("tags = ?");
-      values.push(JSON.stringify(options.tags));
-    }
-    if (updates.length === 0)
-      return task;
-    updates.push("updated_at = ?");
-    values.push(Date.now());
-    values.push(id);
-    const stmt = this.db.prepare(`UPDATE task SET ${updates.join(", ")} WHERE id = ?`);
-    stmt.run(...values);
-    this.tasksCache.delete(id);
-    return this.getTask(id);
-  }
-  async deleteTask(id) {
-    await this.initialize();
-    const stmt = this.db.prepare("DELETE FROM task WHERE id = ?");
-    const result = stmt.run(id);
-    if (result.changes > 0) {
-      this.tasksCache.delete(id);
-      this.operationsCache.delete(id);
-    }
-    return result.changes > 0;
-  }
-  async listTasks(options) {
-    await this.initialize();
-    let sql = "SELECT * FROM task WHERE 1=1";
-    const params = [];
-    if (options?.status) {
-      sql += " AND status = ?";
-      params.push(options.status);
-    }
-    if (options?.priority) {
-      sql += " AND priority = ?";
-      params.push(options.priority);
-    }
-    if (options?.parent_task_id !== undefined) {
-      sql += " AND parent_task_id = ?";
-      params.push(options.parent_task_id);
-    }
-    sql += " ORDER BY updated_at DESC";
-    if (options?.limit) {
-      sql += " LIMIT ?";
-      params.push(options.limit);
-    }
-    if (options?.offset) {
-      sql += " OFFSET ?";
-      params.push(options.offset);
-    }
-    const stmt = this.db.prepare(sql);
-    const rows = stmt.all(...params);
-    return rows.map((row) => {
-      const task = this.rowToTask(row);
-      this.tasksCache.set(task.id, task);
-      return task;
-    });
-  }
-  async createOperation(options) {
-    await this.initialize();
-    const now = Date.now();
-    const stmt = this.db.prepare(`
-      INSERT INTO task_operation (task_id, session_id, action_type, action_title, 
-        action_description, timestamp, md_path)
-      VALUES (?, ?, ?, ?, ?, ?, ?)
-    `);
-    const result = stmt.run(options.taskId, options.sessionId, options.actionType, options.actionTitle, options.actionDescription || "", now, options.mdPath || null);
-    this.operationsCache.delete(options.taskId);
-    const operation = await this.getOperation(result.lastInsertRowid);
-    if (!operation) {
-      throw new Error("Failed to create operation");
-    }
-    return operation;
-  }
-  async getOperation(id) {
-    await this.initialize();
-    const stmt = this.db.prepare("SELECT * FROM task_operation WHERE id = ?");
-    const row = stmt.get(id);
-    if (!row)
-      return;
-    return this.rowToOperation(row);
-  }
-  async updateOperation(id, updates) {
-    await this.initialize();
-    const op = await this.getOperation(id);
-    if (!op)
-      return;
-    const setClauses = [];
-    const values = [];
-    if (updates.actionTitle !== undefined) {
-      setClauses.push("action_title = ?");
-      values.push(updates.actionTitle);
-    }
-    if (updates.actionDescription !== undefined) {
-      setClauses.push("action_description = ?");
-      values.push(updates.actionDescription);
-    }
-    if (setClauses.length === 0)
-      return op;
-    const stmt = this.db.prepare(`UPDATE task_operation SET ${setClauses.join(", ")} WHERE id = ?`);
-    stmt.run(...values, id);
-    this.operationsCache.delete(op.taskId);
-    return this.getOperation(id);
-  }
-  async deleteOperation(id) {
-    await this.initialize();
-    const op = await this.getOperation(id);
-    if (!op)
-      return false;
-    const stmt = this.db.prepare("DELETE FROM task_operation WHERE id = ?");
-    const result = stmt.run(id);
-    if (result.changes > 0) {
-      this.operationsCache.delete(op.taskId);
-    }
-    return result.changes > 0;
-  }
-  async listOperations(options) {
-    await this.initialize();
-    const cacheKey = options.taskId;
-    if (!this.operationsCache.has(cacheKey)) {
-      const stmt = this.db.prepare("SELECT * FROM task_operation WHERE task_id = ? ORDER BY timestamp DESC");
-      const rows = stmt.all(options.taskId);
-      this.operationsCache.set(cacheKey, rows.map((row) => this.rowToOperation(row)));
-    }
-    let ops = this.operationsCache.get(cacheKey);
-    if (options.actionType) {
-      ops = ops.filter((op) => op.actionType === options.actionType);
-    }
-    const offset = options.offset || 0;
-    const limit = options.limit || 20;
-    return ops.slice(offset, offset + limit);
-  }
-  rowToTask(row) {
-    return {
-      id: row.id,
-      title: row.title,
-      description: row.description,
-      status: row.status,
-      priority: row.priority,
-      progress: row.progress,
-      current_status: row.current_status,
-      goals_and_expected_deliverables: row.goals_and_expected_deliverables,
-      parent_task_id: row.parent_task_id || undefined,
-      createdAt: new Date(row.created_at).toISOString(),
-      updatedAt: new Date(row.updated_at).toISOString(),
-      due_date: row.due_date || undefined,
-      tags: row.tags ? JSON.parse(row.tags) : undefined
-    };
-  }
-  rowToOperation(row) {
-    return {
-      id: row.id,
-      taskId: row.task_id,
-      sessionId: row.session_id,
-      actionType: row.action_type,
-      actionTitle: row.action_title,
-      actionDescription: row.action_description,
-      timestamp: new Date(row.timestamp).toISOString(),
-      mdPath: row.md_path || undefined
-    };
-  }
-  async createTag(name) {
-    await this.initialize();
-    const now = Date.now();
-    const existing = await this.getTagByName(name);
-    if (existing) {
-      return existing;
-    }
-    const stmt = this.db.prepare(`
-      INSERT INTO task_tag (name, created_at, task_count)
-      VALUES (?, ?, 0)
-    `);
-    const result = stmt.run(name, now);
-    return {
-      id: result.lastInsertRowid,
-      name,
-      createdAt: new Date(now).toISOString(),
-      taskCount: 0
-    };
-  }
-  async getTag(id) {
-    await this.initialize();
-    const stmt = this.db.prepare("SELECT * FROM task_tag WHERE id = ?");
-    const row = stmt.get(id);
-    if (!row)
-      return;
-    return this.rowToTag(row);
-  }
-  async getTagByName(name) {
-    await this.initialize();
-    const stmt = this.db.prepare("SELECT * FROM task_tag WHERE name = ?");
-    const row = stmt.get(name);
-    if (!row)
-      return;
-    return this.rowToTag(row);
-  }
-  async listTags(options) {
-    await this.initialize();
-    let sql = "SELECT * FROM task_tag";
-    const params = [];
-    const orderBy = options?.orderBy || "count";
-    if (orderBy === "count") {
-      sql += " ORDER BY task_count DESC";
-    } else if (orderBy === "name") {
-      sql += " ORDER BY name ASC";
-    } else {
-      sql += " ORDER BY created_at DESC";
-    }
-    if (options?.limit) {
-      sql += " LIMIT ?";
-      params.push(options.limit);
-    }
-    if (options?.offset) {
-      sql += " OFFSET ?";
-      params.push(options.offset);
-    }
-    const stmt = this.db.prepare(sql);
-    const rows = stmt.all(...params);
-    return rows.map((row) => this.rowToTag(row));
-  }
-  async searchTags(options) {
-    await this.initialize();
-    const sql = `
-      SELECT * FROM task_tag 
-      WHERE name LIKE ? 
-      ORDER BY task_count DESC 
-      LIMIT ?
-    `;
-    const stmt = this.db.prepare(sql);
-    const rows = stmt.all(`%${options.query}%`, options.limit || 20);
-    return rows.map((row) => this.rowToTag(row));
-  }
-  async deleteTag(id) {
-    await this.initialize();
-    const stmt = this.db.prepare("DELETE FROM task_tag WHERE id = ?");
-    const result = stmt.run(id);
-    return result.changes > 0;
-  }
-  async addTagsToTask(taskId, tagIds) {
-    await this.initialize();
-    const now = Date.now();
-    const stmt = this.db.prepare(`
-      INSERT OR IGNORE INTO task_tag_relation (task_id, tag_id, created_at)
-      VALUES (?, ?, ?)
-    `);
-    for (const tagId of tagIds) {
-      stmt.run(taskId, tagId, now);
-      this.db.run(`
-        UPDATE task_tag SET task_count = task_count + 1 WHERE id = ?
-      `, tagId);
-    }
-    await this.syncTaskTagsJson(taskId);
-  }
-  async removeTagsFromTask(taskId, tagIds) {
-    await this.initialize();
-    const stmt = this.db.prepare("DELETE FROM task_tag_relation WHERE task_id = ? AND tag_id = ?");
-    for (const tagId of tagIds) {
-      stmt.run(taskId, tagId);
-      this.db.run(`
-        UPDATE task_tag SET task_count = MAX(0, task_count - 1) WHERE id = ?
-      `, tagId);
-    }
-    await this.syncTaskTagsJson(taskId);
-  }
-  async getTagsForTask(taskId) {
-    await this.initialize();
-    const sql = `
-      SELECT t.* FROM task_tag t
-      INNER JOIN task_tag_relation r ON t.id = r.tag_id
-      WHERE r.task_id = ?
-      ORDER BY t.name ASC
-    `;
-    const stmt = this.db.prepare(sql);
-    const rows = stmt.all(taskId);
-    return rows.map((row) => this.rowToTag(row));
-  }
-  async getTaskIdsByTags(tagNames) {
-    await this.initialize();
-    if (tagNames.length === 0)
-      return [];
-    const placeholders = tagNames.map(() => "?").join(", ");
-    const sql = `
-      SELECT DISTINCT r.task_id FROM task_tag_relation r
-      INNER JOIN task_tag t ON r.tag_id = t.id
-      WHERE t.name IN (${placeholders})
-    `;
-    const stmt = this.db.prepare(sql);
-    const rows = stmt.all(...tagNames);
-    return rows.map((row) => row.task_id);
-  }
-  async updateTaskTags(taskId, tagNames) {
-    await this.initialize();
-    const currentTags = await this.getTagsForTask(taskId);
-    if (currentTags.length > 0) {
-      await this.removeTagsFromTask(taskId, currentTags.map((t) => t.id));
-    }
-    const tagIds = [];
-    for (const name of tagNames) {
-      let tag = await this.getTagByName(name);
-      if (!tag) {
-        tag = await this.createTag(name);
-      }
-      tagIds.push(tag.id);
-    }
-    if (tagIds.length > 0) {
-      await this.addTagsToTask(taskId, tagIds);
-    }
-  }
-  async searchTasksByKeywords(keywords, options = {}) {
-    await this.initialize();
-    if (!keywords || keywords.length === 0) {
-      return [];
-    }
-    const { limit = 20, excludeTaskId } = options;
-    const tasks = new Map;
-    let taskSql = "SELECT * FROM task WHERE 1=1";
-    const taskParams = [];
-    if (excludeTaskId) {
-      taskSql += " AND id != ?";
-      taskParams.push(excludeTaskId);
-    }
-    taskSql += " ORDER BY updated_at DESC LIMIT ?";
-    taskParams.push(limit * 2);
-    const taskRows = this.db.prepare(taskSql).all(...taskParams);
-    for (const row of taskRows) {
-      const task = this.rowToTask(row);
-      let matchCount = 0;
-      if (task.title) {
-        const lowerTitle = task.title.toLowerCase();
-        for (const keyword of keywords) {
-          if (lowerTitle.includes(keyword.toLowerCase())) {
-            matchCount++;
-          }
-        }
-      }
-      if (task.tags && Array.isArray(task.tags)) {
-        for (const keyword of keywords) {
-          const lowerKeyword = keyword.toLowerCase();
-          if (task.tags.some((tag) => tag.toLowerCase().includes(lowerKeyword))) {
-            matchCount += 2;
-          }
-        }
-      }
-      if (task.description) {
-        const lowerDesc = task.description.toLowerCase();
-        for (const keyword of keywords) {
-          if (lowerDesc.includes(keyword.toLowerCase())) {
-            matchCount++;
-          }
-        }
-      }
-      if (task.goals_and_expected_deliverables) {
-        const lowerGoals = task.goals_and_expected_deliverables.toLowerCase();
-        for (const keyword of keywords) {
-          if (lowerGoals.includes(keyword.toLowerCase())) {
-            matchCount++;
-          }
-        }
-      }
-      if (matchCount > 0) {
-        tasks.set(task.id, { task, matchCount });
-      }
-    }
-    const allOps = this.db.prepare("SELECT DISTINCT task_id FROM task_operation WHERE 1=1").all();
-    for (const opRow of allOps) {
-      const opSql = `
-        SELECT * FROM task_operation 
-        WHERE task_id = ? 
-          AND (action_title LIKE ? OR action_description LIKE ?)
-        LIMIT 10
-      `;
-      for (const keyword of keywords) {
-        const pattern = `%${keyword}%`;
-        const ops = this.db.prepare(opSql).all(opRow.task_id, pattern, pattern);
-        if (ops.length > 0) {
-          const taskRow = this.db.prepare("SELECT * FROM task WHERE id = ?").get(opRow.task_id);
-          if (taskRow) {
-            const task = this.rowToTask(taskRow);
-            if (excludeTaskId && task.id === excludeTaskId)
-              continue;
-            const existing = tasks.get(task.id);
-            if (existing) {
-              existing.matchCount += 2;
-            } else {
-              tasks.set(task.id, { task, matchCount: 2 });
-            }
-          }
-        }
-      }
-    }
-    const results = Array.from(tasks.values()).sort((a, b) => b.matchCount - a.matchCount).slice(0, limit).map((item) => item.task);
-    return results;
-  }
-  async findSimilarTasksByKeywords(keywords, options = {}) {
-    const mergedOptions = { ...options, limit: options.limit ?? 5 };
-    return this.searchTasksByKeywords(keywords, mergedOptions);
-  }
-  async findSimilarTasks(taskId, limit = 5) {
-    await this.initialize();
-    const taskTags = await this.getTagsForTask(taskId);
-    if (taskTags.length === 0) {
-      return [];
-    }
-    const tagIds = taskTags.map((t) => t.id);
-    const placeholders = tagIds.map(() => "?").join(", ");
-    const sql = `
-      SELECT t.*, COUNT(r2.tag_id) as match_count
-      FROM task t
-      INNER JOIN task_tag_relation r ON t.id = r.task_id
-      INNER JOIN task_tag_relation r2 ON t.id = r2.task_id
-      WHERE r.tag_id IN (${placeholders})
-        AND t.id != ?
-      GROUP BY t.id
-      ORDER BY match_count DESC, t.updated_at DESC
-      LIMIT ?
-    `;
-    const stmt = this.db.prepare(sql);
-    const rows = stmt.all(...tagIds, taskId, limit);
-    return rows.map((row) => this.rowToTask(row));
-  }
-  async searchTasks(query, limit = 20) {
-    await this.initialize();
-    const sql = `
-      SELECT * FROM task 
-      WHERE title LIKE ? OR description LIKE ?
-      ORDER BY updated_at DESC
-      LIMIT ?
-    `;
-    const stmt = this.db.prepare(sql);
-    const rows = stmt.all(`%${query}%`, `%${query}%`, limit);
-    return rows.map((row) => this.rowToTask(row));
-  }
-  rowToTag(row) {
-    return {
-      id: row.id,
-      name: row.name,
-      createdAt: new Date(row.created_at).toISOString(),
-      taskCount: row.task_count
-    };
-  }
-  async syncTaskTagsJson(taskId) {
-    const tags = await this.getTagsForTask(taskId);
-    const tagNames = tags.map((t) => t.name);
-    const stmt = this.db.prepare("UPDATE task SET tags = ? WHERE id = ?");
-    stmt.run(tagNames.length > 0 ? JSON.stringify(tagNames) : null, taskId);
-    this.tasksCache.delete(taskId);
-  }
-  async close() {
-    if (this.db) {
-      this.db.close();
-      this.db = null;
-      this.initialized = false;
-    }
-  }
-}
-// packages/core/src/env/task/tools/task-types.ts
-import { z } from "zod";
-var CreateTaskToolSchema = z.object({
-  title: z.string().describe("Task title"),
-  description: z.string().optional().describe("Task description"),
-  priority: z.enum(["low", "medium", "high"]).optional().describe("Task priority"),
-  goals_and_expected_deliverables: z.string().optional().describe("Goals and expected deliverables"),
-  due_date: z.string().optional().describe("Due date (ISO format)"),
-  tags: z.array(z.string()).optional().describe("Task tags (for search, stored in task.tags JSON field)")
-});
-var GetTaskToolSchema = z.object({
-  task_id: z.number().describe("Task ID"),
-  include_operations: z.boolean().optional().default(false).describe("Include operation records")
-});
-var ListTasksToolSchema = z.object({
-  status: z.enum(["todo", "active", "completed", "paused", "cancelled"]).optional(),
-  priority: z.enum(["low", "medium", "high"]).optional(),
-  limit: z.number().optional().default(20),
-  offset: z.number().optional().default(0)
-});
-var UpdateTaskToolSchema = z.object({
-  task_id: z.number().describe("Task ID"),
-  title: z.string().optional(),
-  description: z.string().optional(),
-  status: z.enum(["todo", "active", "completed", "paused", "cancelled"]).optional(),
-  priority: z.enum(["low", "medium", "high"]).optional(),
-  progress: z.number().min(0).max(100).optional(),
-  current_status: z.string().optional(),
-  goals_and_expected_deliverables: z.string().optional(),
-  due_date: z.string().optional(),
-  tags: z.array(z.string()).optional()
-});
-var DeleteTaskToolSchema = z.object({
-  task_id: z.number().describe("Task ID")
-});
-
-// packages/core/src/env/task/tools/create-tool.ts
-function createTaskTool(taskComponent) {
-  return {
-    name: "task_create",
-    description: "Create a new task. The task will be associated with the current session.",
-    parameters: CreateTaskToolSchema,
-    execute: async (args, ctx) => {
-      const params = CreateTaskToolSchema.parse(args);
-      const sessionId = ctx.session_id || "unknown";
-      try {
-        const task = await taskComponent.createTask({
-          title: params.title,
-          description: params.description,
-          priority: params.priority,
-          goals_and_expected_deliverables: params.goals_and_expected_deliverables,
-          due_date: params.due_date,
-          tags: params.tags,
-          sessionId
-        });
-        return {
-          success: true,
-          output: `Task created successfully: #${task.id} - ${task.title}`,
-          metadata: {
-            execution_time_ms: 0,
-            task_id: task.id,
-            status: task.status,
-            createdAt: task.createdAt
-          }
-        };
-      } catch (error) {
-        return {
-          success: false,
-          output: "",
-          error: error instanceof Error ? error.message : String(error),
-          metadata: { execution_time_ms: 0 }
-        };
-      }
-    }
-  };
-}
-// packages/core/src/env/task/tools/get-tool.ts
-function getTaskTool(taskComponent) {
-  return {
-    name: "task_get",
-    description: "Get task details by ID. Optionally include operation records.",
-    parameters: GetTaskToolSchema,
-    execute: async (args, ctx) => {
-      const params = GetTaskToolSchema.parse(args);
-      try {
-        if (params.include_operations) {
-          const result = await taskComponent.getTaskWithOperations(params.task_id);
-          if (!result) {
-            return {
-              success: false,
-              output: "",
-              error: `Task not found: ${params.task_id}`,
-              metadata: { execution_time_ms: 0 }
-            };
-          }
-          return {
-            success: true,
-            output: JSON.stringify(result, null, 2),
-            metadata: { execution_time_ms: 0 }
-          };
-        } else {
-          const task = await taskComponent.getTask(params.task_id);
-          if (!task) {
-            return {
-              success: false,
-              output: "",
-              error: `Task not found: ${params.task_id}`,
-              metadata: { execution_time_ms: 0 }
-            };
-          }
-          return {
-            success: true,
-            output: JSON.stringify(task, null, 2),
-            metadata: { execution_time_ms: 0 }
-          };
-        }
-      } catch (error) {
-        return {
-          success: false,
-          output: "",
-          error: error instanceof Error ? error.message : String(error),
-          metadata: { execution_time_ms: 0 }
-        };
-      }
-    }
-  };
-}
-// packages/core/src/env/task/tools/list-tool.ts
-function listTasksTool(taskComponent) {
-  return {
-    name: "task_list",
-    description: "List tasks with optional filters for status and priority.",
-    parameters: ListTasksToolSchema,
-    execute: async (args, ctx) => {
-      const params = ListTasksToolSchema.parse(args);
-      try {
-        const tasks = await taskComponent.listTasks({
-          status: params.status,
-          priority: params.priority,
-          limit: params.limit,
-          offset: params.offset
-        });
-        return {
-          success: true,
-          output: JSON.stringify({ tasks, count: tasks.length }),
-          metadata: { execution_time_ms: 0 }
-        };
-      } catch (error) {
-        return {
-          success: false,
-          output: "",
-          error: error instanceof Error ? error.message : String(error),
-          metadata: { execution_time_ms: 0 }
-        };
-      }
-    }
-  };
-}
-// packages/core/src/env/task/tools/update-tool.ts
-function updateTaskTool(taskComponent) {
-  return {
-    name: "task_update",
-    description: "Update an existing task's properties. Status and progress changes will create operation records.",
-    parameters: UpdateTaskToolSchema,
-    execute: async (args, ctx) => {
-      const params = UpdateTaskToolSchema.parse(args);
-      const sessionId = ctx.session_id || "unknown";
-      try {
-        const task = await taskComponent.updateTask(params.task_id, {
-          title: params.title,
-          description: params.description,
-          status: params.status,
-          priority: params.priority,
-          progress: params.progress,
-          current_status: params.current_status,
-          goals_and_expected_deliverables: params.goals_and_expected_deliverables,
-          due_date: params.due_date,
-          tags: params.tags
-        });
-        if (!task) {
-          return {
-            success: false,
-            output: "",
-            error: `Task not found: ${params.task_id}`,
-            metadata: { execution_time_ms: 0 }
-          };
-        }
-        if (params.status || params.progress !== undefined || params.current_status) {
-          await taskComponent.createOperation({
-            taskId: params.task_id,
-            sessionId,
-            actionType: "progress",
-            actionTitle: params.current_status || `Updated: ${params.status || `${params.progress}%`}`,
-            actionDescription: JSON.stringify({
-              status: params.status,
-              progress: params.progress,
-              current_status: params.current_status
-            })
-          });
-        }
-        return {
-          success: true,
-          output: `Task updated: #${task.id} - ${task.title}`,
-          metadata: { execution_time_ms: 0, task }
-        };
-      } catch (error) {
-        return {
-          success: false,
-          output: "",
-          error: error instanceof Error ? error.message : String(error),
-          metadata: { execution_time_ms: 0 }
-        };
-      }
-    }
-  };
-}
-// packages/core/src/env/task/tools/delete-tool.ts
-function deleteTaskTool(taskComponent) {
-  return {
-    name: "task_delete",
-    description: "Delete a task and all its operation records.",
-    parameters: DeleteTaskToolSchema,
-    execute: async (args, ctx) => {
-      const params = DeleteTaskToolSchema.parse(args);
-      try {
-        const deleted = await taskComponent.deleteTask(params.task_id);
-        if (!deleted) {
-          return {
-            success: false,
-            output: "",
-            error: `Task not found: ${params.task_id}`,
-            metadata: { execution_time_ms: 0 }
-          };
-        }
-        return {
-          success: true,
-          output: `Task deleted: #${params.task_id}`,
-          metadata: { execution_time_ms: 0 }
-        };
-      } catch (error) {
-        return {
-          success: false,
-          output: "",
-          error: error instanceof Error ? error.message : String(error),
-          metadata: { execution_time_ms: 0 }
-        };
-      }
-    }
-  };
-}
-// packages/core/src/env/task/tools/complete-tool.ts
-function completeTaskTool(taskComponent) {
-  return {
-    name: "task_complete",
-    description: "Mark a task as completed (progress=100, status=completed). Creates an operation record.",
-    parameters: DeleteTaskToolSchema,
-    execute: async (args, ctx) => {
-      const params = DeleteTaskToolSchema.parse(args);
-      const sessionId = ctx.session_id || "unknown";
-      try {
-        const task = await taskComponent.completeTask(params.task_id, sessionId);
-        if (!task) {
-          return {
-            success: false,
-            output: "",
-            error: `Task not found: ${params.task_id}`,
-            metadata: { execution_time_ms: 0 }
-          };
-        }
-        return {
-          success: true,
-          output: `Task completed: #${task.id} - ${task.title}`,
-          metadata: { execution_time_ms: 0, task }
-        };
-      } catch (error) {
-        return {
-          success: false,
-          output: "",
-          error: error instanceof Error ? error.message : String(error),
-          metadata: { execution_time_ms: 0 }
-        };
-      }
-    }
-  };
-}
-// packages/core/src/env/task/tools/operation/operation-types.ts
-import { z as z2 } from "zod";
-var ActionTypeEnum = z2.enum([
-  "create",
-  "progress",
-  "milestone",
-  "problem",
-  "solution",
-  "decision",
-  "review",
-  "completed"
-]);
-var CreateOperationToolSchema = z2.object({
-  task_id: z2.number().describe("Task ID"),
-  action_type: ActionTypeEnum.describe("Type of action"),
-  action_title: z2.string().describe("Title of the action"),
-  action_description: z2.string().optional().describe("Detailed description"),
-  md_path: z2.string().optional().describe("Path to detailed markdown documentation")
-});
-var GetOperationToolSchema = z2.object({
-  operation_id: z2.number().describe("Operation ID")
-});
-var ListOperationsToolSchema = z2.object({
-  task_id: z2.number().describe("Task ID"),
-  action_type: ActionTypeEnum.optional(),
-  limit: z2.number().optional().default(20),
-  offset: z2.number().optional().default(0)
-});
-var UpdateOperationToolSchema = z2.object({
-  operation_id: z2.number().describe("Operation ID"),
-  action_title: z2.string().optional(),
-  action_description: z2.string().optional()
-});
-var DeleteOperationToolSchema = z2.object({
-  operation_id: z2.number().describe("Operation ID")
-});
-
-// packages/core/src/env/task/tools/operation/create-tool.ts
-function createOperationTool(taskComponent) {
-  return {
-    name: "task_operation_create",
-    description: "Create an operation record for a task. Tracks progress, milestones, problems, etc.",
-    parameters: CreateOperationToolSchema,
-    execute: async (args, ctx) => {
-      const params = CreateOperationToolSchema.parse(args);
-      const sessionId = ctx.session_id || "unknown";
-      try {
-        const operation = await taskComponent.createOperation({
-          taskId: params.task_id,
-          sessionId,
-          actionType: params.action_type,
-          actionTitle: params.action_title,
-          actionDescription: params.action_description,
-          mdPath: params.md_path
-        });
-        return {
-          success: true,
-          output: `Operation created: #${operation.id} for task #${operation.taskId}`,
-          metadata: {
-            execution_time_ms: 0,
-            operation_id: operation.id,
-            task_id: operation.taskId,
-            session_id: operation.sessionId
-          }
-        };
-      } catch (error) {
-        return {
-          success: false,
-          output: "",
-          error: error instanceof Error ? error.message : String(error),
-          metadata: { execution_time_ms: 0 }
-        };
-      }
-    }
-  };
-}
-// packages/core/src/env/task/tools/operation/get-tool.ts
-function getOperationTool(taskComponent) {
-  return {
-    name: "task_operation_get",
-    description: "Get a single operation record by ID.",
-    parameters: GetOperationToolSchema,
-    execute: async (args, ctx) => {
-      const params = GetOperationToolSchema.parse(args);
-      try {
-        const operation = await taskComponent.getOperation(params.operation_id);
-        if (!operation) {
-          return {
-            success: false,
-            output: "",
-            error: `Operation not found: ${params.operation_id}`,
-            metadata: { execution_time_ms: 0 }
-          };
-        }
-        return {
-          success: true,
-          output: JSON.stringify(operation, null, 2),
-          metadata: { execution_time_ms: 0 }
-        };
-      } catch (error) {
-        return {
-          success: false,
-          output: "",
-          error: error instanceof Error ? error.message : String(error),
-          metadata: { execution_time_ms: 0 }
-        };
-      }
-    }
-  };
-}
-// packages/core/src/env/task/tools/operation/list-tool.ts
-function listOperationsTool(taskComponent) {
-  return {
-    name: "task_operation_list",
-    description: "List operation records for a task with optional filters.",
-    parameters: ListOperationsToolSchema,
-    execute: async (args, ctx) => {
-      const params = ListOperationsToolSchema.parse(args);
-      try {
-        const operations = await taskComponent.listOperations({
-          taskId: params.task_id,
-          actionType: params.action_type,
-          limit: params.limit,
-          offset: params.offset
-        });
-        return {
-          success: true,
-          output: JSON.stringify({ operations, count: operations.length }),
-          metadata: { execution_time_ms: 0 }
-        };
-      } catch (error) {
-        return {
-          success: false,
-          output: "",
-          error: error instanceof Error ? error.message : String(error),
-          metadata: { execution_time_ms: 0 }
-        };
-      }
-    }
-  };
-}
-// packages/core/src/env/task/tools/operation/update-tool.ts
-function updateOperationTool(taskComponent) {
-  return {
-    name: "task_operation_update",
-    description: "Update an operation record's title or description.",
-    parameters: UpdateOperationToolSchema,
-    execute: async (args, ctx) => {
-      const params = UpdateOperationToolSchema.parse(args);
-      try {
-        const operation = await taskComponent.updateOperation(params.operation_id, {
-          actionTitle: params.action_title,
-          actionDescription: params.action_description
-        });
-        if (!operation) {
-          return {
-            success: false,
-            output: "",
-            error: `Operation not found: ${params.operation_id}`,
-            metadata: { execution_time_ms: 0 }
-          };
-        }
-        return {
-          success: true,
-          output: `Operation updated: #${operation.id}`,
-          metadata: { execution_time_ms: 0, operation }
-        };
-      } catch (error) {
-        return {
-          success: false,
-          output: "",
-          error: error instanceof Error ? error.message : String(error),
-          metadata: { execution_time_ms: 0 }
-        };
-      }
-    }
-  };
-}
-// packages/core/src/env/task/tools/operation/delete-tool.ts
-function deleteOperationTool(taskComponent) {
-  return {
-    name: "task_operation_delete",
-    description: "Delete an operation record.",
-    parameters: DeleteOperationToolSchema,
-    execute: async (args, ctx) => {
-      const params = DeleteOperationToolSchema.parse(args);
-      try {
-        const deleted = await taskComponent.deleteOperation(params.operation_id);
-        if (!deleted) {
-          return {
-            success: false,
-            output: "",
-            error: `Operation not found: ${params.operation_id}`,
-            metadata: { execution_time_ms: 0 }
-          };
-        }
-        return {
-          success: true,
-          output: `Operation deleted: #${params.operation_id}`,
-          metadata: { execution_time_ms: 0 }
-        };
-      } catch (error) {
-        return {
-          success: false,
-          output: "",
-          error: error instanceof Error ? error.message : String(error),
-          metadata: { execution_time_ms: 0 }
-        };
-      }
-    }
-  };
-}
-// packages/core/src/env/task/hooks/task-hook-points.ts
-var TaskHookPoints = {
-  BEFORE_CREATE: "task:before.create",
-  AFTER_CREATE: "task:after.create",
-  BEFORE_UPDATE: "task:before.update",
-  AFTER_UPDATE: "task:after.update",
-  BEFORE_DELETE: "task:before.delete",
-  AFTER_DELETE: "task:after.delete",
-  DELEGATE_BEFORE: "task:delegate:before",
-  DELEGATE_AFTER: "task:delegate:after",
-  OPERATION_BEFORE_CREATE: "task:operation:before.create",
-  OPERATION_AFTER_CREATE: "task:operation:after.create"
-};
-// packages/core/src/env/task/delegate/delegate-tool.ts
-init_logger();
-import { z as z3 } from "zod";
-
-// packages/core/src/env/task/delegate/task-events.ts
-var TaskEventTypes = {
-  TASK_STARTED: "task.started",
-  TASK_PROGRESS: "task.progress",
-  TASK_COMPLETED: "task.completed",
-  TASK_FAILED: "task.failed",
-  TASK_TIMEOUT: "task.timeout",
-  TASK_STOPPED: "task.stopped"
-};
-function createTaskStartedPayload(task, parentSessionId) {
-  return {
-    taskId: task.id,
-    subSessionId: task.subSessionId,
-    parentSessionId,
-    description: task.description,
-    subagentType: task.subagentType,
-    associatedTaskId: task.taskId
-  };
-}
-function createTaskProgressPayload(task, parentSessionId) {
-  return {
-    taskId: task.id,
-    subSessionId: task.subSessionId,
-    parentSessionId,
-    status: task.status,
-    progress: task.progress,
-    progressMessage: task.progressMessage,
-    description: task.description,
-    subagentType: task.subagentType
-  };
-}
-function createTaskCompletedPayload(task, parentSessionId, executionTimeMs) {
-  return {
-    taskId: task.id,
-    subSessionId: task.subSessionId,
-    parentSessionId,
-    status: task.status,
-    result: task.result,
-    error: task.error,
-    executionTimeMs,
-    associatedTaskId: task.taskId,
-    description: task.description,
-    subagentType: task.subagentType
-  };
-}
-
-// packages/core/src/env/task/delegate/delegate-tool.ts
-var logger2 = createLogger("task:delegate");
-var builtInSubAgents = [
-  {
-    id: "general",
-    name: "general",
-    mode: "subagent",
-    description: "General-purpose agent for researching complex questions and executing multi-step tasks.",
-    promptOverride: `You are a subagent created by the main agent to handle a specific task.
-
-## Your Role
-- You were created to handle: {task_description}
-- Complete this task. That's your entire purpose.
-- You are NOT the main agent. Don't try to be.
-
-## Task Context Awareness (Required Behavior)
-
-**IMPORTANT: Before starting any work, you MUST gather task context to avoid working with outdated or missing information.**
-
-1. **Read task details first**: Use \`task_get\` to read the task's:
-   - \`description\`: Detailed description of what needs to be done
-   - \`goals_and_expected_deliverables\`: Clear success criteria and expected outputs
-   - \`current_status\`: Current work progress
-   - \`parent_task_id\`: If exists, this is a sub-task
-
-2. **Read recent operations**: Use \`task_operation_list\` to get the last ~15 operation records
-   - These provide history, progress, decisions, and context from previous work
-
-3. **Read parent task context** (if \`parent_task_id\` exists):
-   - Use \`task_get\` to read the parent task's description and goals
-   - Use \`task_operation_list\` to get parent's recent operations
-   - This forms the overall task background and ensures alignment
-
-**Why this matters**: 
-- The main agent may have made critical decisions recorded in operations
-- Parent task goals provide the broader context for your sub-task
-- Without this context, you risk working on wrong/outdated goals
-
-## Rules
-1. **Gather context first** - Always read task details and operations before starting
-2. **Stay focused** - Do your assigned task, nothing else
-3. **Complete the task** - Your final message will be automatically reported to the main agent
-4. **Don't initiate** - No heartbeats, no proactive actions, no side quests
-5. **Be ephemeral** - You may be terminated after task completion. That's fine.
-6. **No nested delegation** - Do NOT use delegate_task or stop_task tools. Complete the task yourself.
-
-## Execution
-- Use the available tools to complete the task
-- If you need more information, ask the main agent through the result
-- Return a clear summary of what you did and the results`,
-    deniedTools: ["delegate_task", "stop_task"]
-  },
-  {
-    id: "explore",
-    name: "explore",
-    mode: "subagent",
-    description: "Fast agent specialized for exploring codebases, finding files, and searching for patterns.",
-    allowedTools: ["glob", "grep", "read", "bash"],
-    deniedTools: ["delegate_task", "stop_task"]
-  },
-  {
-    id: "file_agent",
-    name: "file_agent",
-    mode: "subagent",
-    description: "File operation expert, skilled at reading, writing, searching and organizing files.",
-    allowedTools: ["file_read", "file_write", "file_glob", "grep", "glob", "read"],
-    deniedTools: ["delegate_task", "stop_task"]
-  },
-  {
-    id: "web_search_agent",
-    name: "web_search_agent",
-    mode: "subagent",
-    description: "Web search expert, using Exa search engine to get latest information.",
-    allowedTools: ["exa_web_search_exa"],
-    deniedTools: ["delegate_task", "stop_task"]
-  }
-];
-function getSubAgentSpec(id) {
-  return builtInSubAgents.find((agent) => agent.id === id);
-}
-function getSubAgentToolDescription() {
-  return builtInSubAgents.map((agent) => `- ${agent.id}: ${agent.description}`).join(`
-`);
-}
-function ensureSubAgentRegistered(agentComponent, subagentType, basePrompt, subAgent, deniedTools) {
-  let agentInstance = agentComponent.getAgent(subagentType);
-  if (!agentInstance) {
-    const agentConfig = {
-      type: "sub",
-      systemPrompt: basePrompt
-    };
-    if (subAgent?.allowedTools && subAgent.allowedTools.length > 0) {
-      agentConfig.allowedTools = subAgent.allowedTools;
-    }
-    if (deniedTools.length > 0) {
-      agentConfig.deniedTools = deniedTools;
-    }
-    agentInstance = agentComponent.registerAgent(subagentType, agentConfig);
-    logger2.debug(`[delegate] Registered subagent: ${subagentType}`);
-  }
-  return agentInstance;
-}
-var DelegateToolParameters = z3.object({
-  description: z3.string().describe("A short (3-5 words) description of the task"),
-  prompt: z3.string().describe("The task for the agent to perform"),
-  subagent_type: z3.string().describe("The type of specialized agent to use for this task").default("general"),
-  background: z3.boolean().describe("Whether to run the task in background. If true, returns immediately and notifies when complete (default: false)").default(false),
-  timeout: z3.number().describe("Task timeout in milliseconds. If set, task will be terminated after timeout (optional)").optional(),
-  cleanup: z3.enum(["delete", "keep"]).describe("Whether to delete sub session after completion. 'delete' removes the session, 'keep' retains it (default: keep)").default("keep").optional(),
-  task_id: z3.number().describe("Optional task ID to associate with this delegate task, for tracking in operation records").optional(),
-  reason: z3.string().describe("Brief reason for calling this tool (max 30 chars, e.g., 'Delegate refactor task')").optional()
-});
-var DEFAULT_TIMEOUT = 900000;
-var PROGRESS_INTERVAL = 120000;
-
-class BackgroundTaskManager {
-  env;
-  tasks = new Map;
-  progressTimers = new Map;
-  abortControllers = new Map;
-  constructor(env) {
-    this.env = env;
-  }
-  getSessionComponent() {
-    return this.env?.getComponent?.("session");
-  }
-  async createTask(options) {
-    const { parentSessionId, description, prompt, subagentType, timeout, cleanup, taskId } = options;
-    const taskIdGen = `task_${Date.now()}_${Math.random().toString(36).slice(2, 11)}`;
-    const sessionComponent = this.getSessionComponent();
-    if (!sessionComponent) {
-      throw new Error("SessionComponent not found");
-    }
-    const parentSession = await sessionComponent.get(parentSessionId);
-    if (!parentSession) {
-      throw new Error(`Parent session not found: ${parentSessionId}`);
-    }
-    const metadata = {
-      subagent_type: subagentType,
-      created_by: "subagent",
-      task_description: description
-    };
-    if (taskId) {
-      metadata.task_id = taskId;
-    }
-    const subSession = await sessionComponent.create({
-      title: `${description} (@${subagentType} subagent)`,
-      metadata
-    });
-    if (!subSession) {
-      throw new Error("Failed to create sub-session");
-    }
-    const abortController = new AbortController;
-    const task = {
-      id: taskIdGen,
-      subSessionId: subSession.id,
-      parentSessionId,
-      description,
-      subagentType,
-      status: "pending",
-      createdAt: Date.now(),
-      abortController,
-      taskId
-    };
-    this.tasks.set(taskIdGen, task);
-    this.abortControllers.set(taskIdGen, abortController);
-    this.publishEvent(TaskEventTypes.TASK_STARTED, createTaskStartedPayload(task, parentSessionId), parentSessionId);
-    this.executeTask(taskIdGen, prompt, timeout, cleanup, parentSessionId).catch((err) => {
-      logger2.error(`[BackgroundTaskManager] executeTask unhandled rejection`, {
-        taskId: taskIdGen,
-        error: err instanceof Error ? err.message : String(err)
-      });
-    });
-    return { taskId: taskIdGen, subSessionId: subSession.id };
-  }
-  async executeTask(taskId, prompt, timeout, cleanup, parentSessionId) {
-    const task = this.tasks.get(taskId);
-    if (!task) {
-      logger2.warn(`[BackgroundTaskManager] executeTask: Task not found`, { taskId });
-      return;
-    }
-    task.status = "running";
-    task.startedAt = Date.now();
-    const timeoutMs = timeout || DEFAULT_TIMEOUT;
-    const abortController = this.abortControllers.get(taskId);
-    this.startProgressReporter(taskId, parentSessionId || task.parentSessionId);
-    try {
-      const sessionComponent = this.getSessionComponent();
-      const subSession = await sessionComponent.get(task.subSessionId);
-      if (!subSession) {
-        throw new Error(`Sub session not found: ${task.subSessionId}`);
-      }
-      const result = await this.executeWithAbort(subSession, prompt, timeoutMs, abortController?.signal);
-      if (abortController?.signal.aborted) {
-        logger2.info(`[BackgroundTaskManager] Task was aborted`, { taskId });
-        return;
-      }
-      task.status = "completed";
-      task.completedAt = Date.now();
-      task.result = result;
-      const executionTimeMs = task.completedAt - task.startedAt;
-      this.publishEvent(TaskEventTypes.TASK_COMPLETED, createTaskCompletedPayload(task, parentSessionId || task.parentSessionId, executionTimeMs), parentSessionId || task.parentSessionId);
-      logger2.info(`[BackgroundTaskManager] Task completed successfully`, {
-        taskId,
-        executionTimeMs
-      });
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      const isStoppedError = errorMessage.toLowerCase().includes("stopped") || errorMessage.toLowerCase().includes("aborted");
-      if (isStoppedError) {
-        task.status = "stopped";
-        this.publishEvent(TaskEventTypes.TASK_STOPPED, createTaskCompletedPayload(task, parentSessionId || task.parentSessionId, task.completedAt - task.startedAt), parentSessionId || task.parentSessionId);
-      } else if (errorMessage.includes("timeout")) {
-        task.status = "timeout";
-        this.publishEvent(TaskEventTypes.TASK_TIMEOUT, createTaskCompletedPayload(task, parentSessionId || task.parentSessionId, task.completedAt - task.startedAt), parentSessionId || task.parentSessionId);
-      } else {
-        task.status = "failed";
-        this.publishEvent(TaskEventTypes.TASK_FAILED, createTaskCompletedPayload(task, parentSessionId || task.parentSessionId, task.completedAt - task.startedAt), parentSessionId || task.parentSessionId);
-      }
-      task.error = errorMessage;
-      task.completedAt = Date.now();
-      logger2.error(`[BackgroundTaskManager] Task execution error`, {
-        taskId,
-        status: task.status,
-        error: errorMessage
-      });
-    } finally {
-      this.stopProgressReporter(taskId);
-    }
-  }
-  async executeWithAbort(subSession, prompt, timeoutMs, signal) {
-    return new Promise((resolve, reject) => {
-      const timer = setTimeout(() => {
-        reject(new Error(`Task execution timeout after ${timeoutMs}ms`));
-      }, timeoutMs);
-      signal?.addEventListener("abort", () => {
-        clearTimeout(timer);
-        reject(new Error("Task execution stopped"));
-      });
-      const metadata = subSession.info?.metadata || {};
-      const taskId = metadata.task_id;
-      const taskDescription = metadata.task_description || "";
-      const sessionId = subSession.id;
-      const subagentType = metadata.subagent_type || "general";
-      const subAgent = getSubAgentSpec(subagentType);
-      let basePrompt = subAgent?.promptOverride || `You are a subagent. Complete this task: {task_description}`;
-      const deniedTools = subAgent?.deniedTools || [];
-      let fullPrompt = basePrompt.replace(/{task_description}/g, taskDescription || "N/A");
-      fullPrompt += `
-
----
-
-# Session Info
-- task_id: ${taskId || "N/A"}
-- session_id: ${sessionId}
-
----
-
-## \u7528\u6237\u6307\u4EE4
-${prompt}
-
----
-
-## \u6267\u884C\u89C4\u8303
-- \u4F7F\u7528\u53EF\u7528\u5DE5\u5177\u5B8C\u6210\u4EFB\u52A1
-- \u8FD4\u56DE\u6E05\u6670\u7684\u4EFB\u52A1\u6267\u884C\u7ED3\u679C\u6458\u8981
-- \u9002\u65F6\u8C03\u7528 task_operation_create \u8BB0\u5F55\u8FDB\u5C55`;
-      const agentComponent = this.env?.getComponent?.("agent");
-      if (!agentComponent) {
-        clearTimeout(timer);
-        reject(new Error("AgentComponent not found"));
-        return;
-      }
-      ensureSubAgentRegistered(agentComponent, subagentType, basePrompt, subAgent, deniedTools);
-      this.env.handle_query?.(fullPrompt, {
-        sessionId,
-        deniedTools: deniedTools.length > 0 ? deniedTools : undefined,
-        agentType: subagentType
-      }).then((result) => {
-        clearTimeout(timer);
-        resolve(result);
-      }).catch((error) => {
-        clearTimeout(timer);
-        reject(error);
-      });
-    });
-  }
-  startProgressReporter(taskId, parentSessionId) {
-    const timer = setInterval(() => {
-      const task = this.tasks.get(taskId);
-      if (!task || task.status !== "running") {
-        this.stopProgressReporter(taskId);
-        return;
-      }
-      if (task.startedAt) {
-        const elapsedMs = Date.now() - task.startedAt;
-        task.progress = Math.min(95, Math.floor(elapsedMs / PROGRESS_INTERVAL * 100));
-      }
-      this.publishEvent(TaskEventTypes.TASK_PROGRESS, createTaskProgressPayload(task, parentSessionId), parentSessionId);
-    }, PROGRESS_INTERVAL);
-    this.progressTimers.set(taskId, timer);
-  }
-  stopProgressReporter(taskId) {
-    const timer = this.progressTimers.get(taskId);
-    if (timer) {
-      clearInterval(timer);
-      this.progressTimers.delete(taskId);
-    }
-  }
-  publishEvent(type, payload, triggerSessionId) {
-    if (this.env?.pushEnvEvent) {
-      this.env.pushEnvEvent({
-        type,
-        metadata: {
-          trigger_session_id: triggerSessionId,
-          source: "task.delegate"
-        },
-        payload
-      });
-      logger2.info(`[BackgroundTaskManager] Event published: ${type}`, { payload });
-    }
-  }
-  stopTask(taskId) {
-    const task = this.tasks.get(taskId);
-    if (!task) {
-      return { success: false, message: "Task not found" };
-    }
-    if (task.status === "completed" || task.status === "failed" || task.status === "stopped" || task.status === "timeout") {
-      return {
-        success: false,
-        task,
-        message: `Cannot stop task with status: ${task.status}`
-      };
-    }
-    task.status = "stopped";
-    task.abortController?.abort();
-    task.completedAt = Date.now();
-    this.publishEvent(TaskEventTypes.TASK_STOPPED, createTaskCompletedPayload(task, task.parentSessionId, task.completedAt - task.startedAt), task.parentSessionId);
-    return { success: true, task, message: "Task has been stopped" };
-  }
-  getTask(taskId) {
-    return this.tasks.get(taskId);
-  }
-  listTasks() {
-    return Array.from(this.tasks.values());
-  }
-  dispose() {
-    for (const [taskId, timer] of this.progressTimers) {
-      clearInterval(timer);
-      logger2.debug(`[BackgroundTaskManager] Cleared progress timer for task: ${taskId}`);
-    }
-    this.progressTimers.clear();
-    for (const [taskId, controller] of this.abortControllers) {
-      controller.abort();
-      logger2.debug(`[BackgroundTaskManager] Aborted task: ${taskId}`);
-    }
-    this.abortControllers.clear();
-    this.tasks.clear();
-    logger2.info(`[BackgroundTaskManager] Disposed`);
-  }
-}
-function createDelegateTool(taskComponent) {
-  const env = taskComponent.env;
-  const backgroundTaskManager = new BackgroundTaskManager(env);
-  const tool = {
-    name: "delegate_task",
-    description: `Launch a new sub-agent to handle complex, multistep tasks autonomously.
-
-Available agent types:
-${getSubAgentToolDescription()}
-
-When using the delegate_task tool, you must specify a subagent_type parameter to select which agent type to use.
-
-## When to use delegate_task:
-- When you need to perform complex, multi-step tasks that require independent execution
-- When you need to explore a codebase thoroughly (use "explore" subagent)
-- When you need to run long-running tasks without blocking the main agent (use background=true)
-
-## Parameters:
-- **description**: A short (3-5 words) description of the task
-- **prompt**: The task for the agent to perform
-- **subagent_type**: The type of specialized agent to use (e.g., "general", "explore")
-- **background**: Whether to run in background (default: false)
-- **timeout**: Task timeout in milliseconds (optional)
-- **task_id**: Optional task ID to associate with this delegate task
-
-## Synchronous vs Background mode:
-**Synchronous mode (default)**: Waits for subagent to complete and returns result directly
-**Background mode (background=true)**: Returns immediately with "accepted" status, runs independently`,
-    parameters: DelegateToolParameters,
-    execute: async (args, ctx) => {
-      const startTime = Date.now();
-      const params = DelegateToolParameters.parse(args);
-      const { description, prompt, subagent_type = "general", background = false, timeout, cleanup, task_id, reason } = params;
-      const parentSessionId = ctx.session_id || "default";
-      logger2.info(`[delegate_task] Called: description=${description}, subagent_type=${subagent_type}, background=${background}, task_id=${task_id}`);
-      const subAgent = getSubAgentSpec(subagent_type);
-      if (!subAgent) {
-        return {
-          success: false,
-          output: "",
-          error: `Unknown subagent type: ${subagent_type}`,
-          metadata: { execution_time_ms: Date.now() - startTime }
-        };
-      }
-      const tagService = taskComponent.getTagService();
-      let promptWithTaskInfo = prompt;
-      const delegateCtx = {
-        taskId: task_id,
-        prompt: promptWithTaskInfo,
-        subagentType: subagent_type,
-        background,
-        timeout,
-        cleanup,
-        reason,
-        tagService
-      };
-      const hookCtx = {
-        component: { name: "task", version: "1.0.0" },
-        data: delegateCtx,
-        metadata: { sessionId: parentSessionId },
-        phase: "before",
-        hookPoint: TaskHookPoints.DELEGATE_BEFORE
-      };
-      await globalHookManager.execute(TaskHookPoints.DELEGATE_BEFORE, hookCtx, { sessionId: parentSessionId });
-      promptWithTaskInfo = delegateCtx.prompt;
-      if (background) {
-        return await handleBackgroundTask(taskComponent, backgroundTaskManager, parentSessionId, description, promptWithTaskInfo, delegateCtx.subagentType, delegateCtx.timeout, delegateCtx.cleanup, delegateCtx.taskId);
-      } else {
-        return await handleSyncTask(taskComponent, parentSessionId, description, promptWithTaskInfo, delegateCtx.subagentType, delegateCtx.timeout, delegateCtx.taskId);
-      }
-    }
-  };
-  return tool;
-}
-async function handleSyncTask(taskComponent, parentSessionId, description, prompt, subagentType, timeout, taskId) {
-  const startTime = Date.now();
-  try {
-    const sessionComponent = taskComponent.env?.getComponent?.("session");
-    if (!sessionComponent) {
-      return {
-        success: false,
-        output: "",
-        error: "SessionComponent not found",
-        metadata: { execution_time_ms: Date.now() - startTime }
-      };
-    }
-    const parentSession = await sessionComponent.get(parentSessionId);
-    if (!parentSession) {
-      return {
-        success: false,
-        output: "",
-        error: `Parent session not found: ${parentSessionId}`,
-        metadata: { execution_time_ms: Date.now() - startTime }
-      };
-    }
-    const metadata = {
-      subagent_type: subagentType,
-      created_by: "subagent",
-      task_description: description
-    };
-    if (taskId) {
-      metadata.task_id = taskId;
-    }
-    const subSession = await sessionComponent.create({
-      parentID: parentSessionId,
-      title: `${description} (@${subagentType} subagent)`,
-      metadata
-    });
-    if (!subSession) {
-      return {
-        success: false,
-        output: "",
-        error: "Failed to create sub-session",
-        metadata: { execution_time_ms: Date.now() - startTime }
-      };
-    }
-    const subAgent = getSubAgentSpec(subagentType);
-    let basePrompt = subAgent?.promptOverride || `You are a subagent. Complete this task: {task_description}`;
-    const deniedTools = subAgent?.deniedTools || [];
-    let fullPrompt = basePrompt.replace(/{task_description}/g, description || "N/A");
-    fullPrompt += `
-
----
-
-# Session Info
-- task_id: ${taskId || "N/A"}
-- session_id: ${subSession.id}
-
----
-
-## \u7528\u6237\u6307\u4EE4
-${prompt}
-
----
-
-## \u6267\u884C\u89C4\u8303
-- \u4F7F\u7528\u53EF\u7528\u5DE5\u5177\u5B8C\u6210\u4EFB\u52A1
-- \u8FD4\u56DE\u6E05\u6670\u7684\u4EFB\u52A1\u6267\u884C\u7ED3\u679C\u6458\u8981
-- \u9002\u65F6\u8C03\u7528 task_operation_create \u8BB0\u5F55\u8FDB\u5C55`;
-    const agentComponent = taskComponent.env?.getComponent?.("agent");
-    if (!agentComponent) {
-      return {
-        success: false,
-        output: "",
-        error: "AgentComponent not found",
-        metadata: { execution_time_ms: Date.now() - startTime }
-      };
-    }
-    ensureSubAgentRegistered(agentComponent, subagentType, basePrompt, subAgent, deniedTools);
-    const timeoutMs = timeout || DEFAULT_TIMEOUT;
-    let result;
-    try {
-      result = await Promise.race([
-        taskComponent.env?.handle_query?.(fullPrompt, {
-          sessionId: subSession.id,
-          deniedTools: deniedTools.length > 0 ? deniedTools : undefined,
-          agentType: subagentType
-        }),
-        new Promise((_, reject) => setTimeout(() => reject(new Error(`Task execution timeout after ${timeoutMs}ms`)), timeoutMs))
-      ]);
-    } catch (error) {
-      result = error instanceof Error ? error.message : String(error);
-    }
-    await sessionComponent.addMessage(subSession.id, {
-      role: "assistant",
-      content: result
-    });
-    return {
-      success: true,
-      output: result + `
-
-` + [
-        "<task_metadata>",
-        `session_id: ${subSession.id}`,
-        `subagent_type: ${subagentType}`,
-        "</task_metadata>"
-      ].join(`
-`),
-      metadata: {
-        execution_time_ms: Date.now() - startTime,
-        sessionId: subSession.id
-      }
-    };
-  } catch (error) {
-    return {
-      success: false,
-      output: "",
-      error: error instanceof Error ? error.message : String(error),
-      metadata: { execution_time_ms: Date.now() - startTime }
-    };
-  }
-}
-async function handleBackgroundTask(taskComponent, backgroundTaskManager, parentSessionId, description, prompt, subagentType, timeout, cleanup, taskId) {
-  const startTime = Date.now();
-  try {
-    let associatedTaskId = taskId;
-    if (!associatedTaskId) {
-      const newTask = await taskComponent.createTask({
-        title: description,
-        description: `Background task delegated to ${subagentType} subagent`,
-        priority: "medium",
-        goals_and_expected_deliverables: prompt,
-        sessionId: parentSessionId
-      });
-      associatedTaskId = newTask.id;
-      await taskComponent.createOperation({
-        taskId: associatedTaskId,
-        sessionId: parentSessionId,
-        actionType: "create",
-        actionTitle: `Delegated to ${subagentType} subagent`,
-        actionDescription: `Background task started: ${description}`
-      });
-    } else {
-      await taskComponent.updateTask(associatedTaskId, {
-        status: "active",
-        current_status: `Running ${subagentType} subagent`
-      });
-      await taskComponent.createOperation({
-        taskId: associatedTaskId,
-        sessionId: parentSessionId,
-        actionType: "progress",
-        actionTitle: `Started ${subagentType} subagent`,
-        actionDescription: `Background task: ${description}`
-      });
-    }
-    const { taskId: bgTaskId, subSessionId } = await backgroundTaskManager.createTask({
-      parentSessionId,
-      description,
-      prompt,
-      subagentType,
-      timeout,
-      cleanup,
-      taskId: associatedTaskId
-    });
-    const output = [
-      `\u2705 Background task accepted`,
-      "",
-      `\uD83D\uDCCB Task ID: ${bgTaskId}`,
-      `\uD83D\uDCDD Description: ${description}`,
-      `\uD83E\uDD16 Sub-agent: ${subagentType}`,
-      associatedTaskId ? `\uD83D\uDCCC Associated Task: #${associatedTaskId}` : "",
-      `\u23F1\uFE0F Timeout: ${(timeout || DEFAULT_TIMEOUT) / 1000}s`,
-      "",
-      `Use stop_task with task_id="${bgTaskId}" to cancel this task.`
-    ].filter(Boolean).join(`
-`);
-    return {
-      success: true,
-      output,
-      metadata: {
-        execution_time_ms: Date.now() - startTime,
-        sessionId: subSessionId,
-        background: true,
-        status: "accepted",
-        task_id: associatedTaskId,
-        bgTaskId
-      }
-    };
-  } catch (error) {
-    return {
-      success: false,
-      output: "",
-      error: error instanceof Error ? error.message : String(error),
-      metadata: { execution_time_ms: Date.now() - startTime }
-    };
-  }
-}
-// packages/core/src/env/task/delegate/stop-tool.ts
-import { z as z4 } from "zod";
-var StopTaskToolParameters = z4.object({
-  task_id: z4.string().describe("The ID of the background task to stop")
-});
-var STOP_TASK_DESCRIPTION = `Stop a running background task.
-
-Use this tool to stop a background task that is currently running. This is useful when:
-- The user wants to cancel a long-running task
-- The task is taking too long and needs to be stopped
-- The user wants to change direction and doesn't need the task result anymore
-
-When stopped, the task will be terminated immediately and you will receive a confirmation.
-
-Parameters:
-- task_id: The ID of the background task to stop (obtained from the delegate_task response)`;
-function formatDuration(ms) {
-  const seconds = Math.floor(ms / 1000);
-  const minutes = Math.floor(seconds / 60);
-  const hours = Math.floor(minutes / 60);
-  if (hours > 0) {
-    return `${hours}h ${minutes % 60}m ${seconds % 60}s`;
-  } else if (minutes > 0) {
-    return `${minutes}m ${seconds % 60}s`;
-  } else {
-    return `${seconds}s`;
-  }
-}
-function createStopTool(taskManager) {
-  return {
-    name: "stop_task",
-    description: STOP_TASK_DESCRIPTION,
-    parameters: StopTaskToolParameters,
-    execute: async (args, ctx) => {
-      const startTime = Date.now();
-      const params = StopTaskToolParameters.parse(args);
-      const { task_id } = params;
-      const result = taskManager.stopTask(task_id);
-      if (result.success) {
-        const task = result.task;
-        const elapsedMs = task.startedAt ? Date.now() - task.startedAt : Date.now() - task.createdAt;
-        const output = [
-          `\u2705 Task stopped successfully`,
-          "",
-          `\uD83D\uDCCB Task ID: ${task_id}`,
-          `\uD83D\uDCDD Description: ${task.description}`,
-          `\uD83D\uDD04 Status: ${task.status} \u2192 stopped`,
-          `\u23F1\uFE0F Elapsed Time: ${formatDuration(elapsedMs)}`,
-          "",
-          result.message
-        ].join(`
-`);
-        return {
-          success: true,
-          output,
-          metadata: {
-            execution_time_ms: Date.now() - startTime,
-            task_id,
-            previous_status: task.status
-          }
-        };
-      } else {
-        const task = result.task;
-        let output;
-        if (task) {
-          output = [
-            `\u26A0\uFE0F Cannot stop task`,
-            "",
-            `\uD83D\uDCCB Task ID: ${task_id}`,
-            `\uD83D\uDCDD Description: ${task.description}`,
-            `\uD83D\uDD04 Current Status: ${task.status}`,
-            "",
-            result.message
-          ].join(`
-`);
-        } else {
-          output = [
-            `\u274C Task not found`,
-            "",
-            `\uD83D\uDCCB Task ID: ${task_id}`,
-            "",
-            result.message
-          ].join(`
-`);
-        }
-        return {
-          success: false,
-          output,
-          error: result.message,
-          metadata: {
-            execution_time_ms: Date.now() - startTime,
-            task_id
-          }
-        };
-      }
-    }
-  };
-}
-// 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/task/task-component.ts
-init_logger();
-
-// packages/core/src/env/task/task-config-registration.ts
-var TASK_DEFAULTS = {
-  "task.storage.type": "sqlite",
-  "task.storage.dbPath": undefined
-};
-var TASK_CONFIG_REGISTRATION = {
-  name: "task",
-  sources: [
-    { type: "env", envPrefix: "TASK", priority: 20, watch: false }
-  ],
-  keys: [
-    { key: "task.storage.type", sources: ["env", "file"] },
-    { key: "task.storage.dbPath", sources: ["env", "file"] }
-  ]
-};
-
-// packages/core/src/config/env-key.ts
-function toEnvKey(key, prefix) {
-  let keyNormalized = key.replace(/[.-]/g, "_");
-  keyNormalized = keyNormalized.replace(/([a-z])([A-Z])/g, "$1_$2").replace(/_+/g, "_").toUpperCase();
-  if (prefix) {
-    const separator = prefix.endsWith("_") ? "" : "_";
-    return `${prefix}${separator}${keyNormalized}`;
-  }
-  return keyNormalized;
-}
-function fromEnvKey(envKey, prefix) {
-  if (!prefix) {
-    return envKey;
-  }
-  if (envKey.startsWith(prefix)) {
-    const afterPrefix = envKey.slice(prefix.length);
-    if (afterPrefix.startsWith("_")) {
-      return afterPrefix.slice(1);
-    }
-    return afterPrefix;
-  }
-  return envKey;
-}
-function envKeyToConfigKey(envKey, prefix, componentName) {
-  const prefixUpper = prefix.toUpperCase();
-  if (!envKey.startsWith(prefixUpper)) {
-    return;
-  }
-  const componentUpperNormalized = componentName.replace(/-/g, "_").toUpperCase();
-  let keyPart = envKey.slice(prefixUpper.length);
-  if (keyPart.startsWith("_")) {
-    keyPart = keyPart.slice(1);
-  }
-  if (!keyPart) {
-    return;
-  }
-  const firstUnderscore = keyPart.indexOf("_");
-  let restPart;
-  if (firstUnderscore === -1) {
-    restPart = keyPart;
-  } else {
-    const firstPart = keyPart.slice(0, firstUnderscore);
-    const remaining = keyPart.slice(firstUnderscore + 1);
-    if (firstPart === componentUpperNormalized) {
-      restPart = remaining;
-    } else {
-      restPart = keyPart;
-    }
-  }
-  if (!restPart) {
-    return;
-  }
-  const restPartConverted = restPart.replace(/_/g, ".");
-  return `${componentName}.${restPartConverted.toLowerCase()}`;
-}
-
-// packages/core/src/env/task/tag-service.ts
-init_logger();
-var logger3 = createLogger("task:tag");
-
-class DefaultTagService {
-  store;
-  constructor(store) {
-    this.store = store;
-  }
-  async createTag(name) {
-    const tag = await this.store.createTag(name);
-    logger3.debug(`[TagService] Created tag: ${tag.name} (id=${tag.id})`);
-    return tag;
-  }
-  async getTag(id) {
-    return this.store.getTag(id);
-  }
-  async getTagByName(name) {
-    return this.store.getTagByName(name);
-  }
-  async listTags(options) {
-    return this.store.listTags(options);
-  }
-  async searchTags(options) {
-    return this.store.searchTags(options);
-  }
-  async deleteTag(id) {
-    const result = await this.store.deleteTag(id);
-    if (result) {
-      logger3.debug(`[TagService] Deleted tag id=${id}`);
-    }
-    return result;
-  }
-  async addTagsToTask(taskId, tagIds) {
-    await this.store.addTagsToTask(taskId, tagIds);
-    logger3.debug(`[TagService] Added ${tagIds.length} tags to task ${taskId}`);
-  }
-  async removeTagsFromTask(taskId, tagIds) {
-    await this.store.removeTagsFromTask(taskId, tagIds);
-    logger3.debug(`[TagService] Removed ${tagIds.length} tags from task ${taskId}`);
-  }
-  async getTagsForTask(taskId) {
-    return this.store.getTagsForTask(taskId);
-  }
-  async getTaskIdsByTags(tagNames) {
-    return this.store.getTaskIdsByTags(tagNames);
-  }
-  async findSimilarTasks(taskId, limit = 5) {
-    return this.store.findSimilarTasks(taskId, limit);
-  }
-  async searchTasks(query, limit = 20) {
-    return this.store.searchTasks(query, limit);
-  }
-  async searchTasksByKeywords(keywords, options) {
-    return this.store.searchTasksByKeywords(keywords, options);
-  }
-  async findSimilarTasksByKeywords(keywords, options) {
-    return this.store.findSimilarTasksByKeywords(keywords, options);
-  }
-  async syncTagsToTask(taskId, tagNames) {
-    const tagIds = [];
-    for (const name of tagNames) {
-      let tag = await this.store.getTagByName(name);
-      if (!tag) {
-        tag = await this.store.createTag(name);
-      }
-      tagIds.push(tag.id);
-    }
-    const currentTags = await this.store.getTagsForTask(taskId);
-    const currentTagIds = new Set(currentTags.map((t) => t.id));
-    const newTagIds = new Set(tagIds);
-    const toAdd = tagIds.filter((id) => !currentTagIds.has(id));
-    const toRemove = currentTags.filter((t) => !newTagIds.has(t.id)).map((t) => t.id);
-    if (toRemove.length > 0) {
-      await this.store.removeTagsFromTask(taskId, toRemove);
-    }
-    if (toAdd.length > 0) {
-      await this.store.addTagsToTask(taskId, toAdd);
-    }
-    await this.store.updateTaskTags(taskId, tagNames);
-    logger3.info(`[TagService] Synced tags for task ${taskId}: ${tagNames.join(", ")}`);
-  }
-}
-
-// packages/core/src/env/task/task-component.ts
-var logger4 = createLogger("task");
-
-class TaskComponent extends BaseComponent {
-  name = "task";
-  version = "1.0.0";
-  store;
-  config;
-  toolComponent;
-  backgroundTaskManager;
-  configComponent;
-  tagService;
-  plugins = new Map;
-  constructor() {
-    super();
-  }
-  async init(config) {
-    await super.init(config);
-    const options = config?.options;
-    if (!options?.configComponent) {
-      throw new Error("ConfigComponent is required for TaskComponent initialization");
-    }
-    this.configComponent = options.configComponent;
-    await this.registerConfig(options);
-    this.setStatus("running");
-    logger4.info("[TaskComponent] Initialized");
-  }
-  async registerConfig(options) {
-    const configComponent = this.configComponent;
-    if (!configComponent)
-      return;
-    const { configPath, envPrefix, config } = options;
-    const prefix = envPrefix ?? "TASK";
-    configComponent.registerComponent(TASK_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("task");
-    for (const envKey of Object.keys(process.env)) {
-      const configKey = envKeyToConfigKey(envKey, prefix, "task");
-      if (!configKey)
-        continue;
-      const value = process.env[envKey];
-      if (value !== undefined) {
-        await configComponent.set(configKey, value);
-      }
-    }
-    for (const [key, value] of Object.entries(TASK_DEFAULTS)) {
-      if (configComponent.get(key) === undefined) {
-        await configComponent.set(key, value);
-      }
-    }
-    if (configComponent.get("task.storage.dbPath") === undefined) {
-      await configComponent.set("task.storage.dbPath", getDefaultTaskDbPath());
-    }
-    if (config) {
-      const flatConfig = this.flattenConfig(config);
-      for (const [key, value] of Object.entries(flatConfig)) {
-        await configComponent.set(key, value);
-      }
-    }
-    this.registerConfigWatcher(configComponent);
-    await this.initStore();
-    this.tagService = new DefaultTagService(this.store);
-  }
-  async initStore() {
-    const configComponent = this.configComponent;
-    if (!configComponent)
-      return;
-    const storageType = configComponent.get("task.storage.type") ?? "sqlite";
-    const dbPath = configComponent.get("task.storage.dbPath");
-    if (storageType === "sqlite") {
-      this.store = new SQLiteTaskStore(dbPath);
-      logger4.info(`[TaskComponent] Using SQLite storage: ${dbPath || "default path"}`);
-    } else {
-      this.store = new SQLiteTaskStore;
-      logger4.info("[TaskComponent] Using SQLite storage (default)");
-    }
-  }
-  flattenConfig(obj, prefix = "task") {
-    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("task.*", (event) => {
-      this.onConfigChange(event);
-    });
-  }
-  onConfigChange(event) {
-    logger4.info(`[TaskComponent] Config changed: ${event.key}`, {
-      oldValue: event.oldValue,
-      newValue: event.newValue
-    });
-    if (event.key === "task.storage.type" || event.key === "task.storage.dbPath") {
-      this.initStore();
-    }
-  }
-  configWatcher;
-  async start() {
-    await super.start();
-    this.backgroundTaskManager = new BackgroundTaskManager(this.env);
-    this.toolComponent = this.env?.getComponent("tool");
-    if (this.toolComponent) {
-      await this.registerTools();
-    } else {
-      logger4.warn("[TaskComponent] ToolComponent not found, skipping tool registration");
-    }
-  }
-  async stop() {
-    if (this.configWatcher) {
-      this.configWatcher();
-      this.configWatcher = undefined;
-    }
-    if (this.backgroundTaskManager) {
-      this.backgroundTaskManager.dispose();
-    }
-    if (this.store) {
-      await this.store.close();
-    }
-    await super.stop();
-  }
-  async registerTools() {
-    if (!this.toolComponent)
-      return;
-    const taskToolsList = [
-      createTaskTool(this),
-      getTaskTool(this),
-      listTasksTool(this),
-      updateTaskTool(this),
-      deleteTaskTool(this),
-      completeTaskTool(this)
-    ];
-    const operationToolsList = [
-      createOperationTool(this),
-      getOperationTool(this),
-      listOperationsTool(this),
-      updateOperationTool(this),
-      deleteOperationTool(this)
-    ];
-    const delegateTools = [
-      createDelegateTool(this),
-      createStopTool(this.backgroundTaskManager)
-    ];
-    for (const tool of [...taskToolsList, ...operationToolsList, ...delegateTools]) {
-      this.toolComponent.register(tool);
-      logger4.info(`[TaskComponent] Registered tool: ${tool.name}`);
-    }
-  }
-  async executeHook(hookPoint, data, metadata = {}) {
-    const ctx = {
-      component: { name: this.name, version: this.version },
-      data,
-      metadata,
-      phase: hookPoint.includes("before") ? "before" : "after",
-      hookPoint
-    };
-    await globalHookManager.execute(hookPoint, ctx, metadata);
-  }
-  async createTask(options) {
-    const sessionId = options.sessionId;
-    const createCtx = {
-      options: { ...options },
-      sessionId,
-      tagService: this.tagService
-    };
-    await this.executeHook(TaskHookPoints.BEFORE_CREATE, createCtx);
-    const task = await this.store.createTask(createCtx.options);
-    await this.store.createOperation({
-      taskId: task.id,
-      sessionId,
-      actionType: "create",
-      actionTitle: `Task created: ${task.title}`,
-      actionDescription: task.description || ""
-    });
-    const resultCtx = {
-      task,
-      sessionId,
-      tagService: this.tagService
-    };
-    await this.executeHook(TaskHookPoints.AFTER_CREATE, resultCtx);
-    logger4.info(`[TaskComponent] Task created: ${task.id} - ${task.title}`);
-    return task;
-  }
-  async getTask(id) {
-    return this.store.getTask(id);
-  }
-  async getTaskWithOperations(id) {
-    const task = await this.store.getTask(id);
-    if (!task)
-      return;
-    const operations = await this.store.listOperations({ taskId: id });
-    return { task, operations };
-  }
-  async updateTask(id, options) {
-    const updateCtx = {
-      id,
-      options: { ...options },
-      tagService: this.tagService
-    };
-    await this.executeHook(TaskHookPoints.BEFORE_UPDATE, updateCtx);
-    const task = await this.store.updateTask(id, updateCtx.options);
-    if (task) {
-      const resultCtx = {
-        task,
-        changes: options,
-        tagService: this.tagService
-      };
-      await this.executeHook(TaskHookPoints.AFTER_UPDATE, resultCtx);
-      logger4.info(`[TaskComponent] Task updated: ${id}`);
-    }
-    return task;
-  }
-  async deleteTask(id) {
-    const deleteCtx = { id };
-    await this.executeHook(TaskHookPoints.BEFORE_DELETE, deleteCtx);
-    const result = await this.store.deleteTask(id);
-    const resultCtx = { id, deleted: result };
-    await this.executeHook(TaskHookPoints.AFTER_DELETE, resultCtx);
-    if (result) {
-      logger4.info(`[TaskComponent] Task deleted: ${id}`);
-    }
-    return result;
-  }
-  async listTasks(options) {
-    return this.store.listTasks(options);
-  }
-  async completeTask(id, sessionId) {
-    const task = await this.store.updateTask(id, {
-      status: "completed",
-      progress: 100
-    });
-    if (task) {
-      await this.createOperation({
-        taskId: id,
-        sessionId,
-        actionType: "completed",
-        actionTitle: "Task completed"
-      });
-      logger4.info(`[TaskComponent] Task completed: ${id}`);
-    }
-    return task;
-  }
-  async createOperation(options) {
-    const createCtx = {
-      options: { ...options }
-    };
-    await this.executeHook(TaskHookPoints.OPERATION_BEFORE_CREATE, createCtx);
-    const op = await this.store.createOperation(createCtx.options);
-    const resultCtx = { operation: op };
-    await this.executeHook(TaskHookPoints.OPERATION_AFTER_CREATE, resultCtx);
-    logger4.info(`[TaskComponent] Operation created: ${op.id} for task ${op.taskId}`);
-    return op;
-  }
-  async getOperation(id) {
-    return this.store.getOperation(id);
-  }
-  async updateOperation(id, updates) {
-    return this.store.updateOperation(id, updates);
-  }
-  async deleteOperation(id) {
-    return this.store.deleteOperation(id);
-  }
-  async listOperations(options) {
-    return this.store.listOperations(options);
-  }
-  getTagService() {
-    return this.tagService;
-  }
-  registerPlugin(plugin) {
-    this.plugins.set(plugin.name, plugin);
-    const llmComponent = this.env?.getComponent("llm");
-    plugin.setComponents?.(llmComponent, this);
-    const getRequiredAgents = plugin.constructor.getRequiredAgents;
-    if (typeof getRequiredAgents === "function") {
-      const agentComponent = this.env?.getComponent("agent");
-      if (agentComponent) {
-        try {
-          const agents = getRequiredAgents();
-          for (const agentConfig of agents) {
-            agentComponent.registerAgent(agentConfig.name, agentConfig);
-          }
-        } catch (err) {
-          logger4.warn(`Failed to auto-register agents for plugin ${plugin.name}: ${err}`);
-        }
-      }
-    }
-    for (const hook of plugin.hooks) {
-      const pluginConfig = plugin.config;
-      const priority = hook.priority ?? pluginConfig?.priority ?? 0;
-      const hookName = `${this.name}:${plugin.name}:${hook.point}`;
-      const pluginRef = plugin;
-      globalHookManager.register(hook.point, {
-        name: hookName,
-        priority,
-        execute: async (ctx) => {
-          const pluginCtx = {
-            component: ctx.component,
-            data: ctx.data,
-            metadata: ctx.metadata,
-            phase: ctx.phase,
-            hookPoint: hook.point
-          };
-          await pluginRef.execute(pluginCtx);
-        }
-      });
-    }
-    logger4.info(`[TaskComponent] Registered plugin: ${plugin.name}`, {
-      hooks: plugin.hooks.map((h) => h.point)
-    });
-  }
-  unregisterPlugin(name) {
-    const plugin = this.plugins.get(name);
-    if (!plugin)
-      return false;
-    for (const hook of plugin.hooks) {
-      globalHookManager.unregister(hook.point, `${this.name}:${name}`);
-    }
-    this.plugins.delete(name);
-    logger4.info(`[TaskComponent] Unregistered plugin: ${name}`);
-    return true;
-  }
-  listPlugins() {
-    return Array.from(this.plugins.values());
-  }
-}
-// packages/core/src/env/task/types.ts
-import { z as z5 } from "zod";
-var TaskStatusEnum = z5.enum(["todo", "active", "completed", "paused", "cancelled"]);
-var TaskPriorityEnum = z5.enum(["low", "medium", "high"]);
-var ActionTypeEnum2 = z5.enum([
-  "create",
-  "progress",
-  "milestone",
-  "problem",
-  "solution",
-  "decision",
-  "review",
-  "completed",
-  "workflow_extracted"
-]);
-var TaskConfigSchema = z5.object({
-  storage: z5.object({
-    type: z5.enum(["memory", "sqlite"]).default("sqlite"),
-    dbPath: z5.string().optional()
-  }).default({})
-}).default({});
-export {
-  TaskStatusEnum,
-  TaskPriorityEnum,
-  TaskConfigSchema,
-  TaskComponent,
-  SQLiteTaskStore,
-  ActionTypeEnum2 as ActionTypeEnum
-};