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

package/dist/env/task/delegate/index.js

@@ -0,0 +1,1844 @@
+// @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/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 } 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/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/delegate/delegate-tool.ts
+var logger = 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);
+    logger.debug(`[delegate] Registered subagent: ${subagentType}`);
+  }
+  return agentInstance;
+}
+var DelegateToolParameters = z.object({
+  description: z.string().describe("A short (3-5 words) description of the task"),
+  prompt: z.string().describe("The task for the agent to perform"),
+  subagent_type: z.string().describe("The type of specialized agent to use for this task").default("general"),
+  background: z.boolean().describe("Whether to run the task in background. If true, returns immediately and notifies when complete (default: false)").default(false),
+  timeout: z.number().describe("Task timeout in milliseconds. If set, task will be terminated after timeout (optional)").optional(),
+  cleanup: z.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: z.number().describe("Optional task ID to associate with this delegate task, for tracking in operation records").optional(),
+  reason: z.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) => {
+      logger.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) {
+      logger.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) {
+        logger.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);
+      logger.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();
+      logger.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
+      });
+      logger.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);
+      logger.debug(`[BackgroundTaskManager] Cleared progress timer for task: ${taskId}`);
+    }
+    this.progressTimers.clear();
+    for (const [taskId, controller] of this.abortControllers) {
+      controller.abort();
+      logger.debug(`[BackgroundTaskManager] Aborted task: ${taskId}`);
+    }
+    this.abortControllers.clear();
+    this.tasks.clear();
+    logger.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";
+      logger.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 z2 } from "zod";
+var StopTaskToolParameters = z2.object({
+  task_id: z2.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
+          }
+        };
+      }
+    }
+  };
+}
+export {
+  createStopTool,
+  createDelegateTool,
+  TaskEventTypes,
+  BackgroundTaskManager
+};