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

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

@@ -0,0 +1,1626 @@
+// @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/workflow/storage/sqlite.ts
+var exports_sqlite = {};
+__export(exports_sqlite, {
+  resetDatabase: () => resetDatabase,
+  initializeTables: () => initializeTables,
+  initDatabase: () => initDatabase,
+  getDatabasePath: () => getDatabasePath,
+  getDatabase: () => getDatabase,
+  closeDatabase: () => closeDatabase
+});
+import { join as join2 } from "path";
+function getDefaultDataDir() {
+  const home = process.env.HOME || process.env.USERPROFILE || "/tmp";
+  return join2(home, ".local", "share", "roy-agent");
+}
+function getDatabasePath() {
+  return join2(getDefaultDataDir(), "workflows.db");
+}
+function getDatabase(path) {
+  if (!dbInstance) {
+    const dbPath = path ?? getDatabasePath();
+    const dbDir = dbPath.substring(0, dbPath.lastIndexOf("/"));
+    if (dbDir && dbDir !== "/") {
+      try {
+        const { mkdirSync: mkdirSync2 } = __require("fs");
+        mkdirSync2(dbDir, { recursive: true });
+      } catch {}
+    }
+    const { Database } = __require("bun:sqlite");
+    dbInstance = new Database(dbPath);
+    try {
+      if (typeof dbInstance.pragma === "function") {
+        dbInstance.pragma("journal_mode = WAL");
+      }
+    } catch {
+      logger?.debug("WAL mode not available, using default journal mode");
+    }
+  }
+  return dbInstance;
+}
+function closeDatabase() {
+  if (dbInstance) {
+    dbInstance.close();
+    dbInstance = null;
+  }
+}
+function initializeTables() {
+  const db = getDatabase();
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS workflows (
+      id TEXT PRIMARY KEY,
+      name TEXT NOT NULL UNIQUE,
+      version TEXT NOT NULL DEFAULT '1.0',
+      description TEXT,
+      definition TEXT NOT NULL,
+      config TEXT NOT NULL DEFAULT '{}',
+      metadata TEXT NOT NULL DEFAULT '{}',
+      tags TEXT NOT NULL DEFAULT '[]',
+      task_id INTEGER,
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL
+    )
+  `);
+  db.exec(`
+    CREATE INDEX IF NOT EXISTS idx_workflows_name ON workflows(name);
+    CREATE INDEX IF NOT EXISTS idx_workflows_tags ON workflows(tags);
+    CREATE INDEX IF NOT EXISTS idx_workflows_task_id ON workflows(task_id);
+  `);
+}
+function resetDatabase() {
+  closeDatabase();
+  dbInstance = null;
+}
+function initDatabase(path) {
+  const db = getDatabase(path);
+  initializeTables();
+  return db;
+}
+var logger, dbInstance = null;
+var init_sqlite = __esm(() => {
+  init_logger();
+  logger = createLogger("workflow:sqlite");
+});
+
+// packages/core/src/env/session/search-query-parser.ts
+var exports_search_query_parser = {};
+__export(exports_search_query_parser, {
+  parseSearchQuery: () => parseSearchQuery,
+  matchesQuery: () => matchesQuery
+});
+function parseSearchQuery(query) {
+  const result = {
+    required: [],
+    excluded: [],
+    phrases: []
+  };
+  if (!query || !query.trim()) {
+    return result;
+  }
+  const phraseRegex = /"([^"]+)"/g;
+  let match;
+  while ((match = phraseRegex.exec(query)) !== null) {
+    result.phrases.push(match[1].toLowerCase());
+  }
+  query = query.replace(phraseRegex, "");
+  query = query.replace(/\s+/g, " ").trim();
+  if (!query) {
+    return result;
+  }
+  const parts = [];
+  let remaining = query;
+  const singleOpRegex = /\s+(AND|OR|NOT)\s+/gi;
+  let opMatch;
+  while ((opMatch = singleOpRegex.exec(remaining)) !== null) {
+    const op = opMatch[1].toUpperCase();
+    const beforeText = remaining.slice(0, opMatch.index).trim();
+    if (beforeText) {
+      parts.push({ text: beforeText, operator: undefined });
+    }
+    parts.push({ text: op, operator: op });
+    remaining = remaining.slice(opMatch.index + opMatch[0].length);
+    singleOpRegex.lastIndex = 0;
+  }
+  if (remaining.trim()) {
+    parts.push({ text: remaining.trim(), operator: undefined });
+  }
+  let currentOperator = "AND";
+  for (const part of parts) {
+    if (part.operator) {
+      currentOperator = part.operator;
+    } else {
+      const wordRegex = /[\w\u4e00-\u9fff\u3040-\u309f\u30a0-\u30ff]+/gu;
+      const words = part.text.match(wordRegex) || [];
+      for (const word of words) {
+        const lowerWord = word.toLowerCase();
+        if (lowerWord === "and" || lowerWord === "or" || lowerWord === "not") {
+          currentOperator = lowerWord.toUpperCase();
+          continue;
+        }
+        if (currentOperator === "NOT") {
+          if (!result.excluded.includes(lowerWord)) {
+            result.excluded.push(lowerWord);
+          }
+        } else {
+          if (!result.required.includes(lowerWord)) {
+            result.required.push(lowerWord);
+          }
+        }
+        currentOperator = "AND";
+      }
+    }
+  }
+  return result;
+}
+function matchesQuery(content, query) {
+  if (!content) {
+    return query.required.length === 0 && query.phrases.length === 0;
+  }
+  const lowerContent = content.toLowerCase();
+  for (const term of query.excluded) {
+    if (lowerContent.includes(term.toLowerCase())) {
+      return false;
+    }
+  }
+  for (const phrase of query.phrases) {
+    if (!lowerContent.includes(phrase)) {
+      return false;
+    }
+  }
+  if (query.required.length > 0) {
+    for (const term of query.required) {
+      if (!lowerContent.includes(term)) {
+        return false;
+      }
+    }
+  }
+  return true;
+}
+
+// packages/core/src/env/workflow/storage/workflow-repo.ts
+var exports_workflow_repo = {};
+__export(exports_workflow_repo, {
+  rowToWorkflow: () => rowToWorkflow,
+  WorkflowRepository: () => WorkflowRepository
+});
+import { randomUUID } from "crypto";
+function rowToWorkflow(row) {
+  const metadata = JSON.parse(row.metadata);
+  if (row.task_id !== null) {
+    metadata.taskId = row.task_id;
+  }
+  return {
+    id: row.id,
+    name: row.name,
+    version: row.version,
+    description: row.description || undefined,
+    definition: JSON.parse(row.definition),
+    config: JSON.parse(row.config),
+    metadata,
+    tags: JSON.parse(row.tags),
+    createdAt: new Date(row.created_at),
+    updatedAt: new Date(row.updated_at)
+  };
+}
+
+class WorkflowRepository {
+  db;
+  constructor(db) {
+    this.db = db || getDatabase();
+  }
+  create(workflow) {
+    const id = randomUUID();
+    const now = new Date().toISOString();
+    const stmt = this.db.prepare(`
+      INSERT INTO workflows (id, name, version, description, definition, config, metadata, tags, task_id, created_at, updated_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+    stmt.run(id, workflow.name, workflow.version, workflow.description || null, JSON.stringify(workflow.definition), JSON.stringify(workflow.config), JSON.stringify(workflow.metadata), JSON.stringify(workflow.tags), workflow.metadata?.taskId || null, now, now);
+    return {
+      ...workflow,
+      id,
+      createdAt: new Date(now),
+      updatedAt: new Date(now)
+    };
+  }
+  createFromDefinition(definition, options) {
+    const workflow = {
+      name: definition.name,
+      version: definition.version,
+      description: definition.description,
+      definition,
+      config: options?.config || definition.config || {},
+      metadata: options?.metadata || definition.metadata || {},
+      tags: options?.tags || definition.metadata?.tags || []
+    };
+    return this.create(workflow);
+  }
+  getById(id) {
+    const row = this.db.prepare("SELECT * FROM workflows WHERE id = ?").get(id);
+    if (!row)
+      return;
+    return rowToWorkflow(row);
+  }
+  getByName(name) {
+    const row = this.db.prepare("SELECT * FROM workflows WHERE name = ? ORDER BY updated_at DESC LIMIT 1").get(name);
+    if (!row)
+      return;
+    return rowToWorkflow(row);
+  }
+  getByNameAndVersion(name, version) {
+    const row = this.db.prepare("SELECT * FROM workflows WHERE name = ? AND version = ?").get(name, version);
+    if (!row)
+      return;
+    return rowToWorkflow(row);
+  }
+  list(options) {
+    let sql = "SELECT * FROM workflows";
+    const params = [];
+    const conditions = [];
+    if (options?.tag) {
+      conditions.push("tags LIKE ?");
+      params.push(`%${options.tag}%`);
+    }
+    if (options?.taskId !== undefined) {
+      conditions.push("task_id = ?");
+      params.push(options.taskId);
+    }
+    if (conditions.length > 0) {
+      sql += " WHERE " + conditions.join(" AND ");
+    }
+    const orderBy = options?.orderBy || "updated_at";
+    const order = options?.order || "desc";
+    sql += ` ORDER BY ${orderBy} ${order.toUpperCase()}`;
+    if (options?.limit !== undefined) {
+      sql += " LIMIT ?";
+      params.push(options.limit);
+    }
+    if (options?.offset !== undefined) {
+      sql += " OFFSET ?";
+      params.push(options.offset);
+    }
+    const rows = this.db.prepare(sql).all(...params);
+    let workflows = rows.map(rowToWorkflow);
+    if (options?.search) {
+      const { parseSearchQuery: parseSearchQuery2, matchesQuery: matchesQuery2 } = __toCommonJS(exports_search_query_parser);
+      const query = parseSearchQuery2(options.search);
+      workflows = workflows.filter((w) => {
+        const descMatch = w.description ? matchesQuery2(w.description, query) : false;
+        const tagsMatch = w.tags.some((tag) => matchesQuery2(tag, query));
+        return descMatch || tagsMatch;
+      });
+    }
+    return workflows;
+  }
+  listVersions(name) {
+    const rows = this.db.prepare("SELECT * FROM workflows WHERE name = ? ORDER BY version DESC").all(name);
+    return rows.map(rowToWorkflow);
+  }
+  update(id, updates) {
+    const existing = this.getById(id);
+    if (!existing)
+      return;
+    const now = new Date().toISOString();
+    const setClauses = ["updated_at = ?"];
+    const params = [now];
+    if (updates.name !== undefined) {
+      setClauses.push("name = ?");
+      params.push(updates.name);
+    }
+    if (updates.version !== undefined) {
+      setClauses.push("version = ?");
+      params.push(updates.version);
+    }
+    if (updates.description !== undefined) {
+      setClauses.push("description = ?");
+      params.push(updates.description);
+    }
+    if (updates.definition !== undefined) {
+      setClauses.push("definition = ?");
+      params.push(JSON.stringify(updates.definition));
+    }
+    if (updates.config !== undefined) {
+      setClauses.push("config = ?");
+      params.push(JSON.stringify(updates.config));
+    }
+    if (updates.metadata !== undefined) {
+      setClauses.push("metadata = ?");
+      params.push(JSON.stringify(updates.metadata));
+      if (updates.metadata.taskId !== undefined) {
+        setClauses.push("task_id = ?");
+        params.push(updates.metadata.taskId);
+      }
+    }
+    if (updates.tags !== undefined) {
+      setClauses.push("tags = ?");
+      params.push(JSON.stringify(updates.tags));
+    }
+    params.push(id);
+    this.db.prepare(`UPDATE workflows SET ${setClauses.join(", ")} WHERE id = ?`).run(...params);
+    return this.getById(id);
+  }
+  delete(id) {
+    const existing = this.getById(id);
+    if (!existing)
+      return false;
+    this.db.prepare("DELETE FROM workflows WHERE id = ?").run(id);
+    return true;
+  }
+  exists(id) {
+    const result = this.db.prepare("SELECT 1 FROM workflows WHERE id = ?").get(id);
+    return result !== undefined;
+  }
+  existsByNameAndVersion(name, version) {
+    const result = this.db.prepare("SELECT 1 FROM workflows WHERE name = ? AND version = ?").get(name, version);
+    return result !== undefined;
+  }
+  count() {
+    const result = this.db.prepare("SELECT COUNT(*) as count FROM workflows").get();
+    return result.count;
+  }
+  search(query, limit) {
+    let sql = "SELECT * FROM workflows WHERE name LIKE ? ORDER BY updated_at DESC";
+    const params = [`%${query}%`];
+    if (limit !== undefined) {
+      sql += " LIMIT ?";
+      params.push(limit);
+    }
+    const rows = this.db.prepare(sql).all(...params);
+    return rows.map(rowToWorkflow);
+  }
+}
+var init_workflow_repo = __esm(() => {
+  init_sqlite();
+});
+
+// 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/plugins/task-plugin.ts
+class TaskPlugin {
+  config;
+  constructor(config = {}) {
+    this.config = { enabled: true, priority: 0, ...config };
+  }
+  getHookPoints() {
+    return this.hooks.map((h) => h.point);
+  }
+  getPriorityForHook(hookPoint) {
+    const hook = this.hooks.find((h) => h.point === hookPoint);
+    return hook?.priority ?? this.config.priority ?? 0;
+  }
+  isEnabled() {
+    return this.config.enabled ?? true;
+  }
+  setEnabled(enabled) {
+    this.config.enabled = enabled;
+  }
+}
+// packages/core/src/env/task/plugins/task-tag-plugin.ts
+init_logger();
+
+// packages/core/src/env/task/plugins/workflow-extractor-agent.ts
+var WORKFLOW_EXTRACTOR_PROMPT = `\u4F60\u662F Workflow \u63D0\u53D6\u4E13\u5BB6\uFF0C\u8D1F\u8D23\u5C06\u81EA\u7136\u8BED\u8A00\u63CF\u8FF0\u8F6C\u6362\u4E3A\u7B26\u5408\u89C4\u8303\u7684 Workflow YAML\u3002
+
+## \u63D0\u53D6\u539F\u5219
+
+1. **\u4F18\u5148\u5177\u8C61\u8282\u70B9**\uFF1A\u4F18\u5148\u4F7F\u7528\u7279\u5B9A\u5DE5\u5177\u8282\u70B9\uFF08\u5982 read_file, write_file, grep, bash \u7B49\uFF09
+2. **Fallback \u5230\u901A\u7528\u8282\u70B9**\uFF1A\u6CA1\u6709\u5BF9\u5E94\u5DE5\u5177\u65F6\uFF0C\u4F7F\u7528 agent/llm/bash \u8282\u70B9
+3. **\u907F\u514D\u6761\u4EF6\u5206\u652F**\uFF1A\u4E0D\u63D0\u53D6\u5FAA\u73AF\u548C\u6761\u4EF6\u5224\u65AD\uFF0C\u4FDD\u6301\u7EBF\u6027\u6D41\u7A0B
+4. **\u6CDB\u5316\u4F46\u53EF\u6267\u884C**\uFF1A\u6B65\u9AA4\u63CF\u8FF0\u53EF\u6CDB\u5316\uFF0C\u4F46\u8282\u70B9\u7C7B\u578B\u548C\u5DE5\u5177\u8981\u5177\u4F53
+
+## \u6784\u5EFA\u6D41\u7A0B
+
+**\u91CD\u8981**\uFF1A\u6784\u5EFA\u7684 Workflow \u5FC5\u987B\u901A\u8FC7 \`roy workflow validate\` \u9A8C\u8BC1\u624D\u80FD\u8F93\u51FA\u3002
+
+\`\`\`
+1. \u7406\u89E3\u7528\u6237\u9700\u6C42
+2. \u53C2\u8003 roy workflow nodes \u67E5\u770B\u53EF\u7528\u8282\u70B9\u7C7B\u578B
+3. \u53C2\u8003 roy workflow get <name> \u67E5\u770B\u5DF2\u6709 workflow \u793A\u4F8B
+4. \u751F\u6210 Workflow YAML
+5. \u4F7F\u7528 roy workflow validate --yaml "<\u751F\u6210\u7684YAML>" \u9A8C\u8BC1
+6. \u9A8C\u8BC1\u901A\u8FC7\u540E\u8F93\u51FA\u6700\u7EC8\u7ED3\u679C
+\`\`\`
+
+## \u9A8C\u8BC1\u68C0\u67E5\u6E05\u5355
+
+\u5B8C\u6210 Workflow \u6784\u5EFA\u540E\uFF0C\u5FC5\u987B\u4F7F\u7528\u4EE5\u4E0B\u547D\u4EE4\u9A8C\u8BC1\uFF1A
+
+\`\`\`bash
+roy workflow validate --yaml "<your-yaml>"
+\`\`\`
+
+\u9A8C\u8BC1\u901A\u8FC7\u540E\uFF08\u65E0\u9519\u8BEF\u8F93\u51FA\uFF09\u624D\u8F93\u51FA\u6700\u7EC8\u7ED3\u679C\u3002\u9A8C\u8BC1\u5931\u8D25\u65F6\u6839\u636E\u9519\u8BEF\u4FE1\u606F\u4FEE\u6B63\u540E\u91CD\u65B0\u9A8C\u8BC1\u3002
+
+## \u53EF\u7528\u7684 Workflow \u8282\u70B9\u7C7B\u578B
+
+\u4F7F\u7528\u4EE5\u4E0B\u547D\u4EE4\u67E5\u770B\u6240\u6709\u8282\u70B9\u7C7B\u578B\u7684\u8BE6\u7EC6\u914D\u7F6E\uFF1A
+
+\`\`\`bash
+roy workflow nodes              # \u5217\u51FA\u6240\u6709\u8282\u70B9\u7C7B\u578B
+roy workflow nodes <type>      # \u67E5\u770B\u7279\u5B9A\u8282\u70B9\u8BE6\u60C5\uFF08\u5982 tool, agent, skill\uFF09
+\`\`\`
+
+**\u652F\u6301\u7684\u8282\u70B9\u7C7B\u578B\uFF1A**
+- **tool**\uFF1A\u6267\u884C\u5DE5\u5177\uFF08bash, read-file, write-file, grep \u7B49\uFF09
+- **skill**\uFF1A\u8C03\u7528\u6280\u80FD
+- **agent**\uFF1AAI Agent
+- **workflow**\uFF1A\u5B50\u5DE5\u4F5C\u6D41
+- **condition**\uFF1A\u6761\u4EF6\u5224\u65AD
+- **merge**\uFF1A\u5408\u5E76\u7ED3\u679C
+- **decorator**\uFF1A\u88C5\u9970\u5668\u65B9\u6CD5
+
+## \u67E5\u770B\u5DF2\u6709 Workflow \u793A\u4F8B
+
+\u4F7F\u7528\u4EE5\u4E0B\u547D\u4EE4\u67E5\u770B\u5DF2\u6709 workflow \u7684 YAML \u7ED3\u6784\uFF1A
+
+\`\`\`bash
+roy workflow list              # \u5217\u51FA\u6240\u6709 workflow
+roy workflow get <name>       # \u83B7\u53D6\u6307\u5B9A workflow \u8BE6\u60C5\uFF08YAML \u683C\u5F0F\uFF09
+\`\`\`
+
+## \u8F93\u51FA\u8981\u6C42
+
+\u9A8C\u8BC1\u901A\u8FC7\u540E\uFF0C\u8F93\u51FA\u7B26\u5408\u4EE5\u4E0B\u683C\u5F0F\u7684 YAML Workflow\uFF1A
+
+\`\`\`yaml
+name: {\u6CDB\u5316\u7684\u4EFB\u52A1\u540D\u79F0}
+version: "1.0"
+description: {\u4E00\u53E5\u8BDD\u63CF\u8FF0}
+nodes:
+  - id: node-1
+    type: tool|skill|agent|workflow|condition|merge|decorator
+    name: {\u8282\u70B9\u540D\u79F0}
+    config:
+      # \u6839\u636E\u7C7B\u578B\u914D\u7F6E\u5FC5\u586B\u5B57\u6BB5\uFF1A
+      # tool: tool, input/args
+      # skill: skill, input
+      # agent: agent_type, prompt, options
+      # workflow: workflow_name, input
+      # condition: condition
+      # merge: strategy, depends_on
+      # decorator: _methodName, _instance
+    depends_on: []
+outputs: []
+\`\`\`
+
+## \u9650\u5236
+
+- \u81F3\u5C11 2 \u4E2A\u8282\u70B9\u624D\u6709\u610F\u4E49
+- \u4E0D\u8981\u751F\u6210\u6761\u4EF6\u8282\u70B9\uFF08if/else/switch\uFF09
+- \u4E0D\u8981\u751F\u6210\u5FAA\u73AF\u8282\u70B9\uFF08while/for\uFF09
+- \u6BCF\u4E2A\u8282\u70B9\u8981\u6709\u6E05\u6670\u7684\u540D\u79F0\u548C\u63CF\u8FF0
+- \u5FC5\u987B\u4E3A tool \u8282\u70B9\u6307\u5B9A tool \u540D\u79F0
+- \u5FC5\u987B\u4E3A agent \u8282\u70B9\u6307\u5B9A agent_type \u548C prompt`;
+function createWorkflowExtractorAgent() {
+  return {
+    type: "sub",
+    name: "workflow-extractor",
+    systemPrompt: WORKFLOW_EXTRACTOR_PROMPT,
+    maxIterations: 10,
+    filterHistory: false
+  };
+}
+function formatExtractorInput(params) {
+  const lines = [];
+  lines.push("# \u4EFB\u52A1\u4FE1\u606F");
+  lines.push(`- \u6807\u9898: ${params.task.title}`);
+  if (params.task.description) {
+    lines.push(`- \u63CF\u8FF0: ${params.task.description}`);
+  }
+  if (params.task.goals_and_expected_deliverables) {
+    lines.push(`- \u76EE\u6807: ${params.task.goals_and_expected_deliverables}`);
+  }
+  lines.push("");
+  if (params.operations.length > 0) {
+    lines.push("# \u64CD\u4F5C\u8BB0\u5F55");
+    for (const op of params.operations) {
+      lines.push(`- [${op.actionType}] ${op.actionTitle}`);
+      if (op.actionDescription) {
+        lines.push(`  ${op.actionDescription.slice(0, 200)}`);
+      }
+    }
+    lines.push("");
+  }
+  lines.push("# Session \u6D88\u606F\u5386\u53F2");
+  lines.push("(\u4EE5\u4E0B\u662F\u76F8\u5173\u7684\u5BF9\u8BDD\u5386\u53F2\uFF0C\u8BF7\u4ECE\u4E2D\u63D0\u53D6 Workflow)");
+  for (const msg of params.messages.slice(-50)) {
+    const content = typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content);
+    const truncated = content.slice(0, 500);
+    lines.push(`**${msg.role}**: ${truncated}${content.length > 500 ? "..." : ""}`);
+  }
+  lines.push("");
+  lines.push("## \u4EFB\u52A1");
+  lines.push("\u8BF7\u5206\u6790\u4EE5\u4E0A\u4FE1\u606F\uFF0C\u6784\u5EFA\u4E00\u4E2A\u53EF\u590D\u7528\u7684 Workflow\u3002");
+  lines.push("\u4F7F\u7528\u8FED\u4EE3\u5F0F\u6D41\u7A0B\uFF1A\u751F\u6210 YAML \u2192 validate \u9A8C\u8BC1 \u2192 \u4FEE\u6B63\u9519\u8BEF \u2192 \u91CD\u590D\u76F4\u5230\u901A\u8FC7\u9A8C\u8BC1\u3002");
+  return lines.join(`
+`);
+}
+function formatExtractorInputFromDescription(params) {
+  const lines = [];
+  lines.push("# Workflow \u63CF\u8FF0");
+  lines.push(params.description);
+  lines.push("");
+  lines.push("## \u4EFB\u52A1");
+  lines.push("\u8BF7\u6839\u636E\u4EE5\u4E0A\u63CF\u8FF0\uFF0C\u6784\u5EFA\u4E00\u4E2A\u53EF\u590D\u7528\u7684 Workflow\u3002");
+  lines.push("\u4F7F\u7528\u8FED\u4EE3\u5F0F\u6D41\u7A0B\uFF1A\u751F\u6210 YAML \u2192 validate \u9A8C\u8BC1 \u2192 \u4FEE\u6B63\u9519\u8BEF \u2192 \u91CD\u590D\u76F4\u5230\u901A\u8FC7\u9A8C\u8BC1\u3002");
+  return lines.join(`
+`);
+}
+async function parseExtractorOutput(output) {
+  const yamlMatch = output.match(/```yaml\n?([\s\S]*?)\n?```/) || output.match(/```\n?([\s\S]*?)\n?```/) || output.match(/(\|[\s\S]*?)(?:\n\n|$)/);
+  const yamlContent = yamlMatch?.[1] || output;
+  try {
+    const YAML = await import("yaml");
+    const parsed = YAML.parse(yamlContent);
+    if (!parsed.name || !parsed.nodes || !Array.isArray(parsed.nodes)) {
+      return null;
+    }
+    if (parsed.nodes.length < 2) {
+      return null;
+    }
+    parsed.version = parsed.version || "1.0";
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+
+// packages/core/src/env/task/plugins/task-tag-plugin.ts
+var logger2 = createLogger("task:plugin:tag");
+
+class TaskTagPlugin extends TaskPlugin {
+  name = "TaskTagPlugin";
+  hooks = [
+    { point: TaskHookPoints.DELEGATE_BEFORE, priority: 20 },
+    { point: TaskHookPoints.OPERATION_AFTER_CREATE, priority: 10 }
+  ];
+  taskComponent = null;
+  agentComponent = null;
+  constructor(config = {}) {
+    super({ enabled: true, priority: 0, ...config });
+  }
+  static getRequiredAgents() {
+    return [createWorkflowExtractorAgent()];
+  }
+  setComponents(_llmComponent, taskComponent) {
+    this.taskComponent = taskComponent;
+    if (taskComponent?.env) {
+      this.agentComponent = taskComponent.env.getComponent("agent");
+    }
+  }
+  async execute(ctx) {
+    if (!this.config.enabled)
+      return;
+    switch (ctx.hookPoint) {
+      case TaskHookPoints.DELEGATE_BEFORE:
+        await this.onDelegateBefore(ctx);
+        break;
+      case TaskHookPoints.OPERATION_AFTER_CREATE:
+        await this.onOperationAfterCreate(ctx);
+        break;
+    }
+  }
+  async onDelegateBefore(ctx) {
+    const { taskId, tagService, prompt } = ctx.data;
+    if (!taskId || !this.taskComponent) {
+      return;
+    }
+    try {
+      const currentTask = await this.taskComponent.getTask(taskId);
+      if (!currentTask)
+        return;
+      const keywords = this.extractKeywords(currentTask);
+      if (keywords.length === 0)
+        return;
+      const tagServiceForSearch = tagService;
+      const similarTasks = await tagServiceForSearch?.findSimilarTasksByKeywords?.(keywords, {
+        limit: 5,
+        excludeTaskId: taskId
+      }) ?? [];
+      if (similarTasks.length === 0)
+        return;
+      const hint = this.formatSimilarTasks(similarTasks);
+      ctx.data.prompt = `${hint}
+
+---
+
+## \u7528\u6237\u6307\u4EE4
+
+${prompt}`;
+      logger2.info(`[TaskTagPlugin] Injected ${similarTasks.length} similar tasks`);
+    } catch (error) {
+      logger2.warn(`[TaskTagPlugin] Similar tasks injection failed: ${error}`);
+    }
+  }
+  extractKeywords(task) {
+    const keywords = [];
+    if (task.tags?.length) {
+      keywords.push(...task.tags);
+    }
+    if (task.title) {
+      const words = task.title.split(/[\s\-_,\uFF0C\u3002\u3001#]+/).filter((w) => w.length > 2 && !/^\d+$/.test(w)).slice(0, 5);
+      keywords.push(...words);
+    }
+    return keywords;
+  }
+  formatSimilarTasks(tasks) {
+    const lines = [
+      "## \uD83D\uDD0D \u7C7B\u4F3C\u4EFB\u52A1\u53C2\u8003",
+      "",
+      "_\u63D0\u793A\uFF1A\u53EF\u901A\u8FC7 `task_get <id>` \u83B7\u53D6\u8BE6\u60C5\uFF0C`task_operation_list <id>` \u83B7\u53D6\u64CD\u4F5C\u8BB0\u5F55_",
+      ""
+    ];
+    for (const task of tasks) {
+      lines.push(`### Task #${task.id}`);
+      lines.push(`**Title**: ${task.title}`);
+      if (task.description) {
+        const desc = task.description.slice(0, 100);
+        lines.push(`**Description**: ${desc}${task.description.length > 100 ? "..." : ""}`);
+      }
+      if (task.goals_and_expected_deliverables) {
+        const goal = task.goals_and_expected_deliverables.slice(0, 100);
+        lines.push(`**Goal**: ${goal}${task.goals_and_expected_deliverables.length > 100 ? "..." : ""}`);
+      }
+      lines.push("");
+    }
+    return lines.join(`
+`);
+  }
+  async onOperationAfterCreate(ctx) {
+    const data = ctx.data;
+    const operation = data?.operation ?? data?.data?.operation;
+    if (!operation || operation?.actionType !== "completed")
+      return;
+    await this.extractWorkflow(operation.taskId, operation.sessionId);
+  }
+  async extractWorkflow(taskId, sessionId) {
+    try {
+      const task = await this.taskComponent?.getTask(taskId);
+      if (!task)
+        return;
+      const operations = await this.taskComponent?.listOperations({ taskId }) ?? [];
+      const allSessionIds = [...new Set([sessionId, ...operations.map((op) => op.sessionId).filter(Boolean)])];
+      const sessionComponent = this.taskComponent?.env?.getComponent("session");
+      const allMessages = [];
+      for (const sid of allSessionIds) {
+        try {
+          const ctx = await sessionComponent?.getContext(sid, { fullHistory: false, minUserMessages: 200 });
+          if (ctx?.messages)
+            allMessages.push(...ctx.messages);
+        } catch {}
+      }
+      if (!this.agentComponent)
+        return;
+      const input = formatExtractorInput({ task, operations, messages: allMessages });
+      const result = await this.agentComponent.run("workflow-extractor", input);
+      const workflowDef = await parseExtractorOutput(result.finalText || "");
+      if (!workflowDef)
+        return;
+      const workflowRepo = await this.getWorkflowRepository();
+      if (!workflowRepo)
+        return;
+      let version = workflowDef.version || "1.0";
+      const existingWf = workflowRepo.getByName(workflowDef.name);
+      if (existingWf) {
+        const parts = existingWf.version?.split(".") ?? ["1", "0"];
+        version = `${parts[0]}.${parseInt(parts[1] || "0") + 1}`;
+      }
+      const workflow = workflowRepo.create({
+        name: workflowDef.name,
+        version,
+        description: workflowDef.description,
+        definition: workflowDef,
+        config: workflowDef.config || {},
+        metadata: { author: "workflow-extractor", created_at: new Date().toISOString() },
+        tags: [`task:${taskId}`]
+      });
+      await this.taskComponent?.createOperation({
+        taskId,
+        sessionId,
+        actionType: "workflow_extracted",
+        actionTitle: `Workflow extracted: ${workflow.name}`,
+        actionDescription: workflow.id
+      });
+      logger2.info(`Workflow extracted: ${workflow.id}`);
+    } catch (error) {
+      logger2.warn(`Workflow extraction failed: ${error}`);
+    }
+  }
+  async getWorkflowRepository() {
+    const workflowComponent = this.taskComponent?.env?.getComponent("workflow");
+    if (workflowComponent?.workflowService?.workflowRepository) {
+      return workflowComponent.workflowService.workflowRepository;
+    }
+    if (!this._workflowRepo) {
+      try {
+        const sqlite = await Promise.resolve().then(() => (init_sqlite(), exports_sqlite));
+        this.ensureDataDir();
+        const db = sqlite.getDatabase();
+        sqlite.initializeTables();
+        const { WorkflowRepository: WorkflowRepository2 } = await Promise.resolve().then(() => (init_workflow_repo(), exports_workflow_repo));
+        this._workflowRepo = new WorkflowRepository2(db);
+        return this._workflowRepo;
+      } catch {
+        return null;
+      }
+    }
+    return this._workflowRepo;
+  }
+  ensureDataDir() {
+    const { join: join3 } = __require("path");
+    const { mkdirSync: mkdirSync2, existsSync: existsSync2 } = __require("fs");
+    const home = process.env.HOME || process.env.USERPROFILE || "/tmp";
+    const dataDir = join3(home, ".local", "share", "roy-agent");
+    if (!existsSync2(dataDir))
+      mkdirSync2(dataDir, { recursive: true });
+  }
+  _workflowRepo = null;
+}
+export {
+  parseExtractorOutput,
+  formatExtractorInputFromDescription,
+  formatExtractorInput,
+  createWorkflowExtractorAgent,
+  WORKFLOW_EXTRACTOR_PROMPT,
+  TaskTagPlugin,
+  TaskPlugin
+};