@ai-setting/roy-agent-core 1.7.66 → 1.7.67

package/dist/shared/@ai-setting/roy-agent-core-8zas6w5q.js

@@ -0,0 +1,1083 @@
+import {
+  LayaDecisionPort,
+  createAutoTaskPlugin,
+  createLayaDecisionPlugin,
+  loadLayaAuthForPurpose,
+  pickGateConfidence
+} from "./roy-agent-core-b7jbqfsy.js";
+import {
+  TaskHookPoints
+} from "./roy-agent-core-1pg0fepg.js";
+import {
+  ContextError,
+  ErrorCodes
+} from "./roy-agent-core-ctdhjv68.js";
+import {
+  BaseComponent
+} from "./roy-agent-core-pgvcf91v.js";
+import {
+  init_hook
+} from "./roy-agent-core-ax9e9szb.js";
+import {
+  init_context
+} from "./roy-agent-core-qqaak24r.js";
+import {
+  getEnvContext,
+  init_env_context,
+  runWithEnvContextAsync
+} from "./roy-agent-core-7cbpmk4q.js";
+import {
+  TracedAs,
+  envQueryParamFilter,
+  init_decorator,
+  init_trace_filters
+} from "./roy-agent-core-qq96p0tj.js";
+import {
+  createLogger,
+  init_logger
+} from "./roy-agent-core-7f7t9wwp.js";
+import {
+  __legacyDecorateClassTS
+} from "./roy-agent-core-fs0mn2jk.js";
+
+// src/env/environment.ts
+init_logger();
+
+// src/utils/id.ts
+function generateId(prefix = "id") {
+  const timestamp = Date.now().toString(36);
+  const random = Math.random().toString(36).substring(2, 11);
+  return `${prefix}_${timestamp}_${random}`;
+}
+function generateDescendingId(prefix = "id") {
+  const timestamp = (Number.MAX_SAFE_INTEGER - Date.now()).toString(36);
+  const random = Math.random().toString(36).substring(2, 11);
+  return `${prefix}_${timestamp}_${random}`;
+}
+
+// src/env/environment.ts
+init_decorator();
+init_trace_filters();
+init_env_context();
+import * as fsSync from "fs";
+import * as path from "path";
+
+// src/env/task/plugins/laya-completion-plugin.ts
+init_logger();
+init_decorator();
+var logger = createLogger("plugin:laya-completion");
+var LAYA_COMPLETION_THRESHOLD = 0.92;
+var CHOICE_PASS = "PASS_COMPLETED";
+var CHOICE_FAIL = "FAIL_INCOMPLETE";
+var MAX_OPERATIONS_IN_STATE = 20;
+var OP_TITLE_MAX = 60;
+var OP_DESC_MAX = 120;
+var GOALS_MAX = 400;
+function buildCompletionHint(task, confidence) {
+  return [
+    "[TASK_COMPLETION_HINT] 决策模型检测到「目标 vs 交付物」可能不匹配：任务已标记完成，但操作记录链显示目标或交付物可能未达成。",
+    "",
+    `任务：#${task.id} [${task.type}] ${task.title}`,
+    `状态：${task.status} ｜ 判定置信度：${confidence.toFixed(4)}`,
+    "",
+    "⚠️ 你必须核实本提示：先用 task_get(task_id=" + task.id + ") 复核任务的目标（description / goals_and_expected_deliverables）与交付物证据（context.deliverable_storage_path、操作记录链）。",
+    "核实后二选一执行：",
+    "(a) 确认未完成 → task_update(task_id=" + task.id + ", status=todo) 重开任务继续推进；",
+    "(b) 确认已完成 → task_operation_create(task_id=" + task.id + ", milestone_type=decision, ...) 落一条操作记录说明已完成的理由。",
+    "不允许无视本提示。"
+  ].join(`
+`);
+}
+function renderOperations(ops) {
+  if (ops.length === 0)
+    return "(无操作记录)";
+  const sorted = [...ops].sort((a, b) => new Date(a.timestamp ?? 0).getTime() - new Date(b.timestamp ?? 0).getTime());
+  let windowed;
+  if (sorted.length <= MAX_OPERATIONS_IN_STATE) {
+    windowed = sorted;
+  } else {
+    const tail = sorted.slice(-(MAX_OPERATIONS_IN_STATE - 1));
+    const head = sorted.slice(0, 1);
+    const seen = new Set(tail.map((o) => o.id));
+    windowed = seen.has(head[0].id) ? tail : [...head, ...tail];
+  }
+  return windowed.map((op, i) => {
+    const title = (op.milestoneTitle || "").slice(0, OP_TITLE_MAX);
+    const desc = (op.milestoneDescription || "").replace(/\n/g, " ").slice(0, OP_DESC_MAX);
+    const proc = (op.processDescription || "").replace(/\n/g, " ").slice(0, OP_DESC_MAX);
+    const parts = [`#${i + 1} [${op.milestoneType}] ${title}`];
+    if (desc)
+      parts.push(`    ${desc}`);
+    if (proc)
+      parts.push(`    过程：${proc}`);
+    return parts.join(`
+`);
+  }).join(`
+`);
+}
+function readDeliverablePath(task) {
+  try {
+    const parsed = JSON.parse(task.context || "{}");
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+      const p = parsed.deliverable_storage_path;
+      return typeof p === "string" ? p : "";
+    }
+  } catch {}
+  return "";
+}
+function looksLikeFilePath(token) {
+  if (token.startsWith("//"))
+    return false;
+  if ((token.match(/\//g) ?? []).length >= 2)
+    return true;
+  return /\.[A-Za-z0-9]+$/.test(token);
+}
+function firstPathToken(text) {
+  const m = text.match(/(?:^|[\s（(【「:：,，])(\/[A-Za-z0-9._~\-/@%+]{2,})/);
+  if (!m)
+    return null;
+  return looksLikeFilePath(m[1]) ? m[1] : null;
+}
+var CHECKLIST_MAX = 1200;
+var DELIVERABLE_SPLIT = /[,，;；、\n]/;
+var DELIVERABLE_PLUS_SPLIT = /\s\+\s/;
+function stripDeliverableToken(t) {
+  const seg = t.trim();
+  if (!seg)
+    return null;
+  if (/^[a-z][a-z0-9+.-]*:\/\//i.test(seg))
+    return null;
+  const m = seg.match(/(?:^|[\s（(【「:：,，])(\/[A-Za-z0-9._~\-/@%+]{2,})/);
+  if (!m)
+    return null;
+  const path = m[1].replace(/[。，、；：）】」"'”’.,;:!?)\]}]+$/u, "");
+  return path.startsWith("/") ? path : null;
+}
+function isUrlSegment(seg) {
+  return /^[a-z][a-z0-9+.-]*:\/\//i.test(seg.trim());
+}
+function splitDeliverableSegments(deliverable) {
+  return deliverable.split(DELIVERABLE_PLUS_SPLIT).flatMap((s) => s.split(DELIVERABLE_SPLIT)).flatMap((s) => splitUrlSegments(s)).flatMap((s) => splitSpaceSeparatedPaths(s)).map((s) => s.trim()).filter(Boolean);
+}
+function splitUrlSegments(seg) {
+  const re = /([a-z][a-z0-9+.-]*:\/\/\S+)/gi;
+  const parts = [];
+  let last = 0;
+  let m;
+  while ((m = re.exec(seg)) !== null) {
+    const before = seg.slice(last, m.index).trim();
+    if (before)
+      parts.push(before);
+    const url = m[1];
+    if (/^file:\/\//i.test(url)) {
+      const local = url.replace(/^file:\/\//i, "");
+      if (local)
+        parts.push(local);
+    } else {
+      parts.push(url);
+    }
+    last = m.index + url.length;
+  }
+  const rest = seg.slice(last).trim();
+  if (rest)
+    parts.push(rest);
+  return parts.length > 0 ? parts : [seg];
+}
+function spaceSeparatedPathStarts(seg) {
+  const re = /(?:^|[\s（(【「:：,，])(\/[A-Za-z0-9._~\-/@%+]{2,})/g;
+  const starts = [];
+  let m;
+  while ((m = re.exec(seg)) !== null) {
+    const pathStart = m[0].startsWith("/") ? m.index : m.index + 1;
+    if (m[1].startsWith("//"))
+      continue;
+    starts.push(pathStart);
+  }
+  return starts;
+}
+function splitSpaceSeparatedPaths(seg) {
+  const starts = spaceSeparatedPathStarts(seg);
+  if (starts.length < 2)
+    return [seg];
+  const parts = [seg.slice(0, starts[1])];
+  for (let i = 1;i < starts.length; i++) {
+    const end = i + 1 < starts.length ? starts[i + 1] : seg.length;
+    parts.push(seg.slice(starts[i], end));
+  }
+  return parts;
+}
+function isPathLikeDeliverable(deliverable) {
+  if (!deliverable.includes("/"))
+    return false;
+  const segs = splitDeliverableSegments(deliverable);
+  if (segs.length === 0)
+    return false;
+  const paths = segs.map(stripDeliverableToken).filter((p) => p !== null);
+  if (paths.length === 0)
+    return false;
+  return segs.every((s, i) => stripDeliverableToken(s) !== null || isUrlSegment(s));
+}
+function renderCriteriaChecklist(goalsText, deliverable) {
+  if (!deliverable || deliverable === "(未声明)")
+    return null;
+  if (!isPathLikeDeliverable(deliverable))
+    return null;
+  const items = goalsText.split(`
+`).map((l) => l.trim()).filter((l) => /^\d+\s*[.、)）]/.test(l));
+  if (items.length === 0)
+    return null;
+  const tokens = items.map(firstPathToken);
+  if (tokens.some((t) => t === null))
+    return null;
+  const declared = splitDeliverableSegments(deliverable).map(stripDeliverableToken).filter((t) => t !== null);
+  const declaredSet = new Set(declared);
+  const lines = items.map((item, i) => {
+    const token = tokens[i];
+    const done = declaredSet.has(token);
+    const origNum = item.match(/^(\d+)\s*[.、)）]/)?.[1] ?? String(i + 1);
+    return done ? `${origNum}. ${token} 已产出` : `${origNum}. ${token} 未产出`;
+  });
+  const anyUndone = tokens.some((t) => !declaredSet.has(t));
+  const raw = `【逐条对照】${lines.join("；")}，目标${anyUndone ? "未完成" : "全部完成"}`;
+  if (raw.length > CHECKLIST_MAX) {
+    const suffix = `目标${anyUndone ? "未完成" : "全部完成"}`;
+    const head = raw.slice(0, CHECKLIST_MAX - suffix.length - 2);
+    const lastSep = head.lastIndexOf("；");
+    const cut = lastSep > 0 ? head.slice(0, lastSep) : head;
+    return `${cut}；…，${suffix}`;
+  }
+  return raw;
+}
+function renderCompletionState(task, ops) {
+  const goals = (task.goals_and_expected_deliverables || "(无)").replace(/\n/g, " ").slice(0, GOALS_MAX);
+  const deliverable = readDeliverablePath(task) || "(未声明)";
+  const checklist = renderCriteriaChecklist(task.goals_and_expected_deliverables || "", deliverable);
+  return `【任务标题】${task.title}
+` + `【任务目标】${goals}
+` + `【交付物声明】${deliverable}
+` + (checklist ? `${checklist}
+` : "") + `【操作记录】
+` + renderOperations(ops);
+}
+function buildCompletionQuestion() {
+  return {
+    completion_check: {
+      type: "choice",
+      instructions: "根据任务目标、交付物声明与操作记录链，判断该任务是否真正达成目标且产出交付物。" + `若证据充分支持已完成，选 ${CHOICE_PASS}；若目标或交付物疑似未达成，选 ${CHOICE_FAIL}。`,
+      criteria: {
+        [CHOICE_PASS]: "目标已达成且交付物已产出",
+        [CHOICE_FAIL]: "目标或交付物疑似未达成"
+      }
+    }
+  };
+}
+
+class LayaCompletionPlugin {
+  name = "laya-completion";
+  version = "1.0.0";
+  description = "Task #4760 — task:after.complete 完成判定（目标/交付物 match，只提示不拦截）";
+  options;
+  port = null;
+  portResolved = false;
+  constructor(options = {}) {
+    this.options = options;
+    if (options.decisionPort) {
+      this.port = options.decisionPort;
+      this.portResolved = true;
+    }
+  }
+  isDisabled() {
+    return this.port?.isDisabled() ?? false;
+  }
+  async resolvePort() {
+    if (this.portResolved)
+      return this.port;
+    this.portResolved = true;
+    try {
+      const auth = await loadLayaAuthForPurpose(this.options.authPath ?? `${process.env.HOME ?? "~"}/.roy-agent/auth.json`, "goal");
+      if (!auth)
+        return null;
+      this.port = new LayaDecisionPort({
+        baseURL: auth.baseURL,
+        apiKey: auth.apiKey,
+        model: auth.model,
+        timeoutMs: this.options.timeoutMs,
+        maxStrikes: this.options.maxStrikes
+      });
+    } catch (err) {
+      logger.warn(`[laya-completion] loadLayaAuth failed (fail-open): ${err?.message}`);
+      this.port = null;
+    }
+    return this.port;
+  }
+  async execute(ctx, taskComponent) {
+    try {
+      const data = normalizeHookCtx(ctx);
+      await this.run(data, taskComponent);
+    } catch (err) {
+      logger.warn(`[laya-completion] unexpected failure, ignored: ${err?.message}`);
+    }
+  }
+  async run(ctx, taskComponent) {
+    if (!taskComponent) {
+      logger.warn("[laya-completion] taskComponent not injected — skip");
+      return;
+    }
+    if (ctx.terminalStatus !== "completed") {
+      logger.debug(`[laya-completion] terminalStatus=${ctx.terminalStatus} — skip (only completed)`);
+      return;
+    }
+    const task = ctx.task;
+    if (!task?.id)
+      return;
+    let ops = [];
+    try {
+      ops = await taskComponent.listOperations({
+        taskId: task.id,
+        limit: 1e6,
+        offset: 0
+      });
+    } catch (err) {
+      logger.warn(`[laya-completion] listOperations failed (fail-open): ${err?.message}`);
+      return;
+    }
+    logger.info(`[laya-completion] judging task #${task.id}: chain=${ops?.length ?? 0} ops, terminalStatus=${ctx.terminalStatus}`);
+    if (!ops || ops.length === 0) {
+      logger.debug("[laya-completion] empty operation chain — pass through");
+      return;
+    }
+    const port = await this.resolvePort();
+    if (!port) {
+      logger.debug("[laya-completion] no decision port configured — skip");
+      return;
+    }
+    if (port.isDisabled()) {
+      logger.debug("[laya-completion] port self-disabled (circuit open) — skip");
+      return;
+    }
+    const req = {
+      state: renderCompletionState(task, ops),
+      questions: buildCompletionQuestion()
+    };
+    let answer;
+    try {
+      const res = await port.decide(req);
+      answer = res?.answers?.["completion_check"];
+    } catch (err) {
+      logger.warn(`[laya-completion] decide failed (fail-open): ${err?.message}`);
+      return;
+    }
+    if (!answer || typeof answer.choice !== "string") {
+      logger.debug("[laya-completion] malformed answer — skip");
+      return;
+    }
+    const confidence = pickGateConfidence(answer);
+    const threshold = this.options.completionThreshold ?? LAYA_COMPLETION_THRESHOLD;
+    if (confidence < threshold) {
+      logger.debug(`[laya-completion] confidence ${confidence} < ${threshold} — pass through`);
+      return;
+    }
+    if (answer.choice !== CHOICE_FAIL) {
+      logger.debug(`[laya-completion] choice=${answer.choice} (not FAIL_INCOMPLETE) — no hint`);
+      return;
+    }
+    await this.writeHint(task, confidence, taskComponent);
+  }
+  async writeHint(task, confidence, taskComponent) {
+    const hint = buildCompletionHint(task, confidence);
+    try {
+      let parsed = {};
+      try {
+        const p = JSON.parse(task.context || "{}");
+        if (p && typeof p === "object" && !Array.isArray(p)) {
+          parsed = p;
+        }
+      } catch {}
+      parsed.completion_hint = hint;
+      await taskComponent.updateTaskContext(task.id, JSON.stringify(parsed));
+      logger.info(`[laya-completion] hint written to task #${task.id} context (conf=${confidence.toFixed(4)})`);
+    } catch (err) {
+      logger.warn(`[laya-completion] updateTask hint failed (ignored): ${err?.message}`);
+    }
+    try {
+      await taskComponent.createOperation({
+        taskId: task.id,
+        sessionId: "laya-completion",
+        milestoneType: "decision",
+        milestoneTitle: "[TASK_COMPLETION_HINT] 目标/交付物疑似未达成",
+        milestoneDescription: `决策模型判定 FAIL_INCOMPLETE（conf=${confidence.toFixed(4)}）。hint 已写入 task.context.completion_hint，等待 agent 核实。`
+      });
+    } catch (err) {
+      logger.warn(`[laya-completion] createOperation hint failed (ignored): ${err?.message}`);
+    }
+  }
+}
+__legacyDecorateClassTS([
+  TracedAs("task.laya.completion.onAfterComplete", {
+    recordParams: false,
+    recordResult: false,
+    log: false,
+    paramFilter: (args) => {
+      const raw = args[0] ?? {};
+      const ctx = raw?.data ?? raw;
+      return {
+        taskId: ctx?.task?.id,
+        terminalStatus: ctx?.terminalStatus,
+        hasTaskComponent: Boolean(args[1])
+      };
+    },
+    resultFilter: (_res) => ({ ok: true })
+  })
+], LayaCompletionPlugin.prototype, "execute", null);
+function normalizeHookCtx(ctx) {
+  const maybe = ctx;
+  return maybe && typeof maybe === "object" && maybe.data ? maybe.data : ctx;
+}
+function createLayaCompletionPlugin(options) {
+  const inner = options && Object.keys(options).length > 0 ? new LayaCompletionPlugin(options) : getSharedCompletionPlugin();
+  return {
+    name: "laya-completion",
+    priority: 20,
+    execute: async (ctx) => {
+      await inner.execute(ctx, inner.__taskComponent);
+    },
+    plugin: inner
+  };
+}
+var sharedCompletionPlugin = null;
+function getSharedCompletionPlugin() {
+  if (!sharedCompletionPlugin) {
+    sharedCompletionPlugin = new LayaCompletionPlugin;
+  }
+  return sharedCompletionPlugin;
+}
+function registerLayaCompletionTaskHook(taskComponent, options) {
+  if (!taskComponent) {
+    logger.warn("[registerLayaCompletionTaskHook] TaskComponent not available — skip (fail-open)");
+    return false;
+  }
+  try {
+    const hook = createLayaCompletionPlugin(options);
+    hook.plugin.__taskComponent = taskComponent;
+    taskComponent.unregisterHook(TaskHookPoints.AFTER_COMPLETE, hook.name);
+    taskComponent.registerHook(TaskHookPoints.AFTER_COMPLETE, {
+      name: hook.name,
+      priority: hook.priority,
+      execute: async (ctx) => {
+        try {
+          const data = ctx && typeof ctx === "object" && "data" in ctx ? ctx.data : ctx;
+          await hook.plugin.execute(data, taskComponent);
+        } catch (err) {
+          logger.warn(`[registerLayaCompletionTaskHook] hook execution failed (ignored): ${err?.message}`);
+        }
+      }
+    });
+    logger.info(`[registerLayaCompletionTaskHook] registered hook "${hook.name}" at ${TaskHookPoints.AFTER_COMPLETE} (priority=${hook.priority})`);
+    return true;
+  } catch (err) {
+    logger.warn(`[registerLayaCompletionTaskHook] registration failed (ignored): ${err?.message}`);
+    return false;
+  }
+}
+
+// src/env/environment.ts
+var logger2 = createLogger("environment");
+function registerLayaDecisionTaskHook(taskComponent, options) {
+  if (!taskComponent) {
+    logger2.warn("[registerLayaDecisionTaskHook] TaskComponent not available — skip (fail-open)");
+    return false;
+  }
+  try {
+    const hook = createLayaDecisionPlugin(options);
+    taskComponent.unregisterHook(TaskHookPoints.BEFORE_CREATE, hook.name);
+    taskComponent.registerHook(TaskHookPoints.BEFORE_CREATE, {
+      name: hook.name,
+      priority: hook.priority,
+      execute: async (ctx) => {
+        try {
+          const data = ctx && typeof ctx === "object" && "data" in ctx ? ctx.data : ctx;
+          await hook.execute(data);
+        } catch (err) {
+          logger2.warn(`[registerLayaDecisionTaskHook] hook execution failed (ignored): ${err?.message}`);
+        }
+      }
+    });
+    logger2.info(`[registerLayaDecisionTaskHook] registered hook "${hook.name}" at ${TaskHookPoints.BEFORE_CREATE} (priority=${hook.priority})`);
+    return true;
+  } catch (err) {
+    logger2.warn(`[registerLayaDecisionTaskHook] registration failed (ignored): ${err?.message}`);
+    return false;
+  }
+}
+var DEFAULT_AGENT_NAME = "Roy";
+function injectAgentNamePlaceholder(prompt, context) {
+  if (!prompt.includes("{{agent_name}}")) {
+    return prompt;
+  }
+  const metadata = context?.metadata;
+  const defaultAgentName = typeof metadata?.defaultAgentName === "string" && metadata.defaultAgentName.length > 0 ? metadata.defaultAgentName : DEFAULT_AGENT_NAME;
+  return prompt.replace(/\{\{agent_name\}\}/g, defaultAgentName);
+}
+
+class BaseEnvironment extends BaseComponent {
+  name;
+  version;
+  components = new Map;
+  constructor(config) {
+    super();
+    this.name = config?.name ?? "base-environment";
+    this.version = config?.version ?? "1.0.0";
+    this.registerDefaultComponents();
+  }
+  registerDefaultComponents() {}
+  getConfig() {
+    return {
+      name: this.name,
+      version: this.version,
+      enabled: true,
+      env: this
+    };
+  }
+  registerComponent(component) {
+    this.components.set(component.name, component);
+    logger2.debug(`Component registered: ${component.name}`);
+  }
+  unregisterComponent(name) {
+    const component = this.components.get(name);
+    if (component) {
+      this.components.delete(name);
+      logger2.debug(`Component unregistered: ${name}`);
+    }
+  }
+  getComponent(name) {
+    return this.components.get(name);
+  }
+  listComponents() {
+    return Array.from(this.components.values());
+  }
+  async handle_query(query, context) {
+    const agentComponent = this.getComponent("agent");
+    if (!agentComponent) {
+      throw new Error("AgentComponent not found. Please register AgentComponent before calling handle_query.");
+    }
+    const agentName = context?.agentType && context.agentType !== "default" ? context.agentType : "default";
+    const registry = agentComponent.getRegistry?.();
+    if (registry) {
+      const agentDef = registry.get(agentName);
+      if (agentDef?.type === "workflow") {
+        const existingCtx = getEnvContext();
+        const workflowEnvContext = {
+          envEvent: context || { type: "workflow" },
+          sourceId: "workflow",
+          userId: context?.metadata?.userId || "",
+          replyChannel: existingCtx?.replyChannel,
+          pluginEnabled: existingCtx?.pluginEnabled,
+          agentContext: existingCtx?.agentContext ?? {}
+        };
+        return await runWithEnvContextAsync(workflowEnvContext, async () => {
+          return await this.handleWorkflowAgentQuery(agentName, query, agentComponent, context);
+        });
+      }
+    }
+    let systemPrompt = "You are a helpful assistant.";
+    let promptSource = "fallback";
+    try {
+      const promptComponent = this.getComponent("prompt");
+      if (promptComponent) {
+        const loadedPrompt = await promptComponent.getPrompt("default", {}, {
+          agentType: "primary"
+        });
+        if (loadedPrompt) {
+          systemPrompt = loadedPrompt;
+          promptSource = "PromptComponent";
+        }
+      }
+    } catch (err) {
+      logger2.warn(`[handle_query] Failed to get prompt from PromptComponent: ${err}`);
+    }
+    logger2.info(`[handle_query] Using system prompt from ${promptSource}, length: ${systemPrompt.length}`);
+    let finalSystemPrompt = systemPrompt;
+    if (systemPrompt.includes("{{memory}}")) {
+      try {
+        const memoryComponent = this.getComponent("memory");
+        if (memoryComponent) {
+          const memoryContent = await memoryComponent.recallMemory();
+          finalSystemPrompt = systemPrompt.replace("{{memory}}", memoryContent || "(No memory)");
+          logger2.info(`[handle_query] Injected memory content, length: ${memoryContent.length}`);
+        } else {
+          finalSystemPrompt = systemPrompt.replace("{{memory}}", "(Memory component not available)");
+        }
+      } catch (err) {
+        logger2.warn(`[handle_query] Failed to load memory content: ${err}`);
+        finalSystemPrompt = systemPrompt.replace("{{memory}}", "(Failed to load memory)");
+      }
+    }
+    if (finalSystemPrompt.includes("{{workspace_dir}}")) {
+      const workspaceDir = process.cwd();
+      finalSystemPrompt = finalSystemPrompt.replace("{{workspace_dir}}", workspaceDir);
+      logger2.debug(`[handle_query] Injected workspace_dir: ${workspaceDir}`);
+    }
+    {
+      const prev = finalSystemPrompt;
+      finalSystemPrompt = injectAgentNamePlaceholder(finalSystemPrompt, context);
+      if (prev !== finalSystemPrompt) {
+        const metadata = context?.metadata;
+        const injectedName = typeof metadata?.defaultAgentName === "string" && metadata.defaultAgentName.length > 0 ? metadata.defaultAgentName : DEFAULT_AGENT_NAME;
+        logger2.debug(`[handle_query] Injected agent_name: ${injectedName}`);
+      }
+    }
+    let agent = agentComponent.getAgent(agentName);
+    if (!agent) {
+      if (agentName !== "default") {
+        logger2.warn(`[handle_query] Agent "${agentName}" not found, falling back to "default"`);
+      }
+      agent = agentComponent.getAgent("default");
+    }
+    if (!agent) {
+      const defaultDeniedTools = [
+        "echo",
+        "glob",
+        "grep",
+        "write_file",
+        "edit_file",
+        "task_create",
+        "task_update",
+        "task_delete",
+        "task_complete",
+        "task_operation_create",
+        "task_operation_update",
+        "task_operation_delete",
+        "skill",
+        "record_memory",
+        "recall_memory",
+        "search_sessions",
+        "get_session",
+        "write_memory"
+      ];
+      try {
+        const toolComponent = this.getComponent("tool");
+        if (toolComponent?.listTools) {
+          const allTools = toolComponent.listTools();
+          const mcpTools = allTools.filter((t) => t.name.startsWith("mcp_")).map((t) => t.name);
+          if (mcpTools.length > 0) {
+            defaultDeniedTools.push(...mcpTools);
+            logger2.debug(`[handle_query] Dynamically denied MCP tools: ${mcpTools.join(", ")}`);
+          }
+        }
+      } catch (err) {
+        logger2.warn(`[handle_query] Failed to dynamically filter MCP tools: ${err}`);
+      }
+      agent = agentComponent.registerAgent("default", {
+        type: "primary",
+        systemPrompt: finalSystemPrompt,
+        deniedTools: defaultDeniedTools
+      });
+      logger2.info(`[handle_query] Created default receptionist agent with deniedTools: ${defaultDeniedTools.length} tools denied`);
+      try {
+        const autoTaskPlugin = createAutoTaskPlugin({
+          threshold: 20
+        });
+        agentComponent.registerPlugin("default", autoTaskPlugin);
+        logger2.info("[handle_query] AutoTaskPlugin v5.0 registered on default agent (threshold=20)");
+      } catch (err) {
+        logger2.warn(`[handle_query] Failed to register AutoTaskPlugin: ${err}`);
+      }
+    } else {
+      if (agent.config?.systemPrompt) {
+        if (agent.config.systemPrompt.includes("{{memory}}")) {
+          try {
+            const memoryComponent = this.getComponent("memory");
+            if (memoryComponent) {
+              const memoryContent = await memoryComponent.recallMemory();
+              agent.config.systemPrompt = agent.config.systemPrompt.replace("{{memory}}", memoryContent || "(No memory)");
+            } else {
+              agent.config.systemPrompt = agent.config.systemPrompt.replace("{{memory}}", "(Memory component not available)");
+            }
+          } catch (err) {
+            logger2.warn(`[handle_query] Failed to inject memory for agent ${agentName}: ${err}`);
+            agent.config.systemPrompt = agent.config.systemPrompt.replace("{{memory}}", "(Failed to load memory)");
+          }
+        }
+        if (agent.config.systemPrompt.includes("{{workspace_dir}}")) {
+          agent.config.systemPrompt = agent.config.systemPrompt.replace("{{workspace_dir}}", process.cwd());
+        }
+        agent.config.systemPrompt = injectAgentNamePlaceholder(agent.config.systemPrompt, context);
+      }
+      logger2.debug(`[handle_query] Injected memory/workspace_dir for existing agent: ${agentName}`);
+    }
+    try {
+      const taskComponent = this.getComponent("task");
+      registerLayaDecisionTaskHook(taskComponent);
+    } catch (err) {
+      logger2.warn(`[handle_query] Failed to register LayaDecisionTaskHook: ${err}`);
+    }
+    try {
+      const taskComponent = this.getComponent("task");
+      registerLayaCompletionTaskHook(taskComponent);
+    } catch (err) {
+      logger2.warn(`[handle_query] Failed to register LayaCompletionTaskHook: ${err}`);
+    }
+    const result = await agentComponent.run(agent.name, query, context);
+    if (result.error) {
+      if (result.originalError instanceof ContextError) {
+        throw result.originalError;
+      }
+      const errorMsg = result.error.toLowerCase();
+      if (errorMsg.includes("context") || errorMsg.includes("threshold") || errorMsg.includes("token") || result.error.includes("CTX_001")) {
+        const usageMatch = result.error.match(/(\d+)\/(\d+)\s*\(([\d.]+)%\)/);
+        let usage;
+        let contextWindow;
+        if (usageMatch) {
+          const totalTokens = parseInt(usageMatch[1], 10);
+          usage = {
+            promptTokens: totalTokens,
+            completionTokens: 0,
+            totalTokens
+          };
+          contextWindow = parseInt(usageMatch[2], 10);
+        }
+        const ctxError = new ContextError(result.error, ErrorCodes.CONTEXT_THRESHOLD_EXCEEDED, context?.sessionId, usage, contextWindow);
+        throw ctxError;
+      }
+      throw new Error(result.error, result.originalError ? { cause: result.originalError } : undefined);
+    }
+    return result.finalText || "";
+  }
+  async handleWorkflowAgentQuery(agentName, query, agentComponent, context) {
+    const registry = agentComponent.getRegistry?.();
+    if (!registry) {
+      return null;
+    }
+    const agentDef = registry.get(agentName);
+    if (!agentDef || agentDef.type !== "workflow") {
+      return null;
+    }
+    const workflowComponent = this.getComponent("workflow");
+    if (!workflowComponent) {
+      throw new Error(`WorkflowComponent not available — cannot run workflow agent "${agentName}". ` + `Ensure the workflow component is registered.`);
+    }
+    const workflowName = agentDef.workflow;
+    if (!workflowName) {
+      throw new Error(`Agent "${agentName}" has type 'workflow' but no workflow configured.`);
+    }
+    const svc = workflowComponent.getService?.();
+    if (!svc || typeof svc.getWorkflowByName !== "function") {
+      throw new Error(`WorkflowService not available. Cannot run workflow agent "${agentName}".`);
+    }
+    const workflow = svc.getWorkflowByName(workflowName);
+    if (!workflow) {
+      throw new Error(`Workflow "${workflowName}" not found. ` + `Use 'roy-agent workflow add' to register it first.`);
+    }
+    const wfResult = await workflowComponent.runWorkflow(workflow.definition, { query }, { context });
+    if (wfResult.status === "paused") {
+      return JSON.stringify({
+        status: "paused",
+        message: `Workflow "${workflowName}" paused, waiting for user input.`,
+        pendingNodeId: wfResult.pendingNodeId,
+        query: wfResult.query,
+        sessionId: wfResult.sessionId,
+        hint: `Resume with: roy-agent workflow run -s ${wfResult.sessionId} --input "your response"`
+      });
+    }
+    if (wfResult.status === "failed") {
+      throw new Error(`Workflow "${workflowName}" execution failed: ${wfResult.error || "Unknown error (status: " + wfResult.status + ")"}`);
+    }
+    if (typeof wfResult.output === "string") {
+      return wfResult.output;
+    }
+    if (wfResult.output !== undefined && wfResult.output !== null) {
+      return JSON.stringify(wfResult.output);
+    }
+    if (wfResult.error) {
+      throw new Error(`Workflow "${workflowName}" completed with error: ${wfResult.error}`);
+    }
+    return "";
+  }
+  async handle_action(action, context) {
+    throw new Error("handle_action not implemented. Override in subclass.");
+  }
+  eventHandlers = new Map;
+  wildcardHandlers = new Set;
+  subscribe(handler) {
+    this.wildcardHandlers.add(handler);
+    logger2.debug(`EnvEvent handler subscribed (wildcard)`);
+    return () => {
+      this.wildcardHandlers.delete(handler);
+      logger2.debug(`EnvEvent handler unsubscribed (wildcard)`);
+    };
+  }
+  subscribeTo(eventType, handler) {
+    const types = Array.isArray(eventType) ? eventType : [eventType];
+    for (const type of types) {
+      if (!this.eventHandlers.has(type)) {
+        this.eventHandlers.set(type, new Set);
+      }
+      this.eventHandlers.get(type).add(handler);
+    }
+    logger2.debug(`EnvEvent handler subscribed for types: ${types.join(", ")}`);
+    return () => {
+      for (const type of types) {
+        this.eventHandlers.get(type)?.delete(handler);
+      }
+      logger2.debug(`EnvEvent handler unsubscribed for types: ${types.join(", ")}`);
+    };
+  }
+  subscribeAll(handler) {
+    return this.subscribe(handler);
+  }
+  pushEnvEvent(event) {
+    const fullEvent = "id" in event && event.id ? event : {
+      id: event.id ?? generateId(),
+      type: event.type,
+      timestamp: event.timestamp ?? Date.now(),
+      metadata: {
+        ...event.metadata,
+        env_name: event.metadata?.env_name ?? this.name
+      },
+      payload: event.payload ?? {}
+    };
+    for (const handler of this.wildcardHandlers) {
+      try {
+        handler(fullEvent);
+      } catch (error) {
+        logger2.error(`Error in EnvEvent handler: ${error}`);
+      }
+    }
+    const handlers = this.eventHandlers.get(fullEvent.type);
+    if (handlers) {
+      for (const handler of handlers) {
+        try {
+          handler(fullEvent);
+        } catch (error) {
+          logger2.error(`Error in EnvEvent handler for ${fullEvent.type}: ${error}`);
+        }
+      }
+    }
+  }
+  emit(type, payload, metadata) {
+    const event = {
+      id: generateId(),
+      type,
+      timestamp: Date.now(),
+      metadata: {
+        env_name: this.name,
+        ...metadata
+      },
+      payload
+    };
+    this.pushEnvEvent(event);
+  }
+  async initializeComponents() {
+    logger2.debug(`Starting component initialization, total: ${this.components.size}`);
+    const configComp = this.components.get("config");
+    if (configComp && configComp.getStatus() === "created") {
+      logger2.debug(`Initializing ConfigComponent first...`);
+      await configComp.init({
+        name: "config",
+        version: configComp.version,
+        enabled: true,
+        env: this
+      });
+      logger2.debug(`ConfigComponent initialized`);
+    } else {
+      logger2.debug(`No ConfigComponent found, skipping first stage`);
+    }
+    const otherComponents = Array.from(this.components.values()).filter((c) => c.getStatus() === "created");
+    if (otherComponents.length > 0) {
+      logger2.debug(`Initializing ${otherComponents.length} other components...`);
+      for (const component of otherComponents) {
+        logger2.debug(`Initializing component: ${component.name}`);
+        await component.init({
+          name: component.name,
+          version: component.version,
+          enabled: true,
+          env: this
+        });
+        logger2.debug(`Component initialized: ${component.name}`);
+      }
+    }
+    logger2.debug(`All components initialized`);
+  }
+  async startComponents() {
+    const allComponents = Array.from(this.components.values());
+    if (allComponents.length > 0) {
+      logger2.debug(`Starting ${allComponents.length} components...`);
+      for (const component of allComponents) {
+        logger2.debug(`Starting component: ${component.name} (current status: ${component.getStatus()})`);
+        await component.start();
+        logger2.debug(`Component started: ${component.name}`);
+      }
+    }
+  }
+  async stopComponents() {
+    const componentsToStop = Array.from(this.components.values()).filter((c) => c.getStatus() !== "stopped").reverse();
+    if (componentsToStop.length > 0) {
+      logger2.debug(`Stopping ${componentsToStop.length} components...`);
+      for (const component of componentsToStop) {
+        logger2.debug(`Stopping component: ${component.name}`);
+        await component.stop();
+        logger2.debug(`Component stopped: ${component.name}`);
+      }
+    }
+  }
+  async onInit() {
+    await this.initializeComponents();
+    logger2.info(`Environment "${this.name}" initialized`);
+  }
+  async onStart() {
+    await this.startComponents();
+    logger2.info(`Environment "${this.name}" started`);
+  }
+  async onStop() {
+    await this.stopComponents();
+    this.eventHandlers.clear();
+    this.wildcardHandlers.clear();
+    logger2.info(`Environment "${this.name}" stopped`);
+  }
+  async init() {
+    Object.defineProperty(this, "env", {
+      value: this,
+      writable: true,
+      enumerable: false,
+      configurable: true
+    });
+    this.setStatus("initializing");
+    await this.onInit();
+    this.setStatus("running");
+  }
+  async start() {
+    if (this._started)
+      return;
+    this._started = true;
+    await this.onStart();
+    this.setStatus("running");
+    logger2.info(`Environment "${this.name}" started`);
+  }
+  async stop() {
+    this.setStatus("stopping");
+    await this.onStop();
+    this.setStatus("stopped");
+  }
+  async loadServiceConfig(configPath) {
+    const configComponent = this.getComponent("config");
+    if (!configComponent) {
+      throw new Error("ConfigComponent not found. Please register ConfigComponent before loading service config.");
+    }
+    const xdgDataHome = configComponent.getXdgDataHome();
+    const fullPath = path.resolve(xdgDataHome, configPath);
+    if (!fsSync.existsSync(fullPath)) {
+      throw new Error(`Service config file not found: ${fullPath}`);
+    }
+    const content = fsSync.readFileSync(fullPath, "utf-8");
+    let config;
+    try {
+      config = JSON.parse(content);
+    } catch (e) {
+      throw new Error(`Failed to parse service config: ${e}`);
+    }
+    logger2.debug(`Service config loaded from: ${fullPath}`);
+    return config;
+  }
+  generateComponentOptions(componentName, configEntry) {
+    const configComponent = this.getComponent("config");
+    if (!configComponent) {
+      throw new Error("ConfigComponent not found. Please register ConfigComponent before generating component options.");
+    }
+    const options = {
+      configComponent,
+      configPath: configEntry.configPath,
+      envPrefix: configEntry.envPrefix,
+      config: configEntry.config
+    };
+    logger2.debug(`Generated options for component: ${componentName}`);
+    return options;
+  }
+  async registerComponentWithConfig(component, configEntry) {
+    if (!this.components.has(component.name)) {
+      this.registerComponent(component);
+    }
+    const options = this.generateComponentOptions(component.name, configEntry);
+    if (component.getStatus() === "running") {
+      logger2.debug(`Component ${component.name} already initialized, skipping`);
+      return;
+    }
+    await component.init({
+      name: component.name,
+      version: component.version,
+      enabled: configEntry.enabled ?? true,
+      env: this,
+      options
+    });
+    logger2.debug(`Component ${component.name} registered and initialized with config`);
+  }
+  async initFromConfig(configPath) {
+    if (!this.env) {
+      Object.defineProperty(this, "env", {
+        value: this,
+        writable: true,
+        enumerable: false,
+        configurable: true
+      });
+    }
+    const serviceConfig = await this.loadServiceConfig(configPath);
+    if (serviceConfig.environment) {
+      if (serviceConfig.environment.name) {
+        this.name = serviceConfig.environment.name;
+      }
+      if (serviceConfig.environment.version) {
+        this.version = serviceConfig.environment.version;
+      }
+    }
+    const configComponent = this.getComponent("config");
+    if (!configComponent) {
+      throw new Error("ConfigComponent not found. Please register ConfigComponent before initFromConfig.");
+    }
+    if (configComponent.getStatus() === "created") {
+      await configComponent.init({
+        name: "config",
+        version: configComponent.version,
+        enabled: true,
+        env: this
+      });
+    }
+    const components = serviceConfig.components || {};
+    for (const [componentName, configEntry] of Object.entries(components)) {
+      if (configEntry.enabled === false) {
+        logger2.debug(`Component ${componentName} is disabled, skipping`);
+        continue;
+      }
+      const component = this.getComponent(componentName);
+      if (!component) {
+        logger2.warn(`Component ${componentName} not registered, skipping`);
+        continue;
+      }
+      if (component.name === "config")
+        continue;
+      await this.registerComponentWithConfig(component, configEntry);
+    }
+    this.setStatus("running");
+    logger2.info(`Environment "${this.name}" initialized from config: ${configPath}`);
+  }
+}
+__legacyDecorateClassTS([
+  TracedAs("env.handle_query", {
+    paramFilter: envQueryParamFilter,
+    recordResult: false,
+    logResult: true,
+    log: true
+  })
+], BaseEnvironment.prototype, "handle_query", null);
+__legacyDecorateClassTS([
+  TracedAs("env.handle_workflow_agent_query", {
+    paramFilter: envQueryParamFilter,
+    recordResult: false,
+    logResult: true,
+    log: true
+  })
+], BaseEnvironment.prototype, "handleWorkflowAgentQuery", null);
+
+// src/env/index.ts
+init_hook();
+init_context();
+
+export { generateId, generateDescendingId, BaseEnvironment };