@ai-setting/roy-agent-core 1.7.44 → 1.7.47

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

@@ -0,0 +1,2396 @@
+import {
+  getSharedEventStore
+} from "./roy-agent-core-xyys5m1a.js";
+import {
+  TaskHookPoints
+} from "./roy-agent-core-1pg0fepg.js";
+import {
+  WORKFLOW_EXTRACT_PROMPT
+} from "./roy-agent-core-223v204d.js";
+import {
+  validateWorkflowDefinition
+} from "./roy-agent-core-6vbgswjw.js";
+import {
+  enqueueToAddFakeUserMessage
+} from "./roy-agent-core-4cj6hram.js";
+import {
+  BasePlugin
+} from "./roy-agent-core-az13yzmc.js";
+import {
+  init_context
+} from "./roy-agent-core-wn59p0zw.js";
+import {
+  getEnvContextOrEmpty
+} from "./roy-agent-core-zbb3sk72.js";
+import {
+  TracedAs,
+  init_decorator,
+  wrapFunction
+} from "./roy-agent-core-a9pbda78.js";
+import {
+  createLogger,
+  init_logger
+} from "./roy-agent-core-8seq65bp.js";
+import {
+  __legacyDecorateClassTS,
+  __require
+} from "./roy-agent-core-fs0mn2jk.js";
+
+// src/env/task/plugins/task-tag-plugin.ts
+init_logger();
+
+// src/env/task/plugins/workflow-extractor-agent.ts
+var WORKFLOW_EXTRACTOR_PROMPT = WORKFLOW_EXTRACT_PROMPT;
+function formatExtractorInput(params) {
+  const lines = [];
+  lines.push("# 任务信息");
+  lines.push(`- 标题: ${params.task.title}`);
+  if (params.task.description) {
+    lines.push(`- 描述: ${params.task.description}`);
+  }
+  if (params.task.goals_and_expected_deliverables) {
+    lines.push(`- 目标: ${params.task.goals_and_expected_deliverables}`);
+  }
+  lines.push("");
+  if (params.operations.length > 0) {
+    lines.push("# 操作记录");
+    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 消息历史");
+  lines.push("(以下是相关的对话历史，请从中提取 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("## 任务");
+  lines.push("请分析以上信息，构建一个可复用的 Workflow。");
+  lines.push("使用迭代式流程：生成 YAML → validate 验证 → 修正错误 → 重复直到通过验证。");
+  return lines.join(`
+`);
+}
+function formatExtractorInputFromDescription(params) {
+  const lines = [];
+  lines.push("# Workflow 描述");
+  lines.push(params.description);
+  lines.push("");
+  lines.push("## 任务");
+  lines.push("请根据以上描述，构建一个可复用的 Workflow。");
+  lines.push("使用迭代式流程：生成 YAML → validate 验证 → 修正错误 → 重复直到通过验证。");
+  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;
+  }
+}
+
+// src/env/task/plugins/task-tag-plugin.ts
+var logger = createLogger("plugin:task-tag");
+
+class TaskTagPlugin extends BasePlugin {
+  name = "task-tag";
+  version = "1.0.0";
+  description = "Inject similar task information into delegate prompt and extract workflow on task completion";
+  env;
+  taskComponent = null;
+  agentComponent = null;
+  tagService = null;
+  constructor() {
+    super();
+  }
+  init(env) {
+    this.env = env;
+    this.taskComponent = env.getComponent("task");
+    if (this.taskComponent && typeof this.taskComponent.getTagService === "function") {
+      this.tagService = this.taskComponent.getTagService();
+    }
+    this.agentComponent = env.getComponent("agent");
+    env.registerHook({
+      point: TaskHookPoints.DELEGATE_BEFORE,
+      priority: 20,
+      handler: this.onDelegateBefore.bind(this)
+    });
+    env.registerHook({
+      point: TaskHookPoints.OPERATION_AFTER_CREATE,
+      priority: 10,
+      handler: this.onOperationAfterCreate.bind(this)
+    });
+    logger.info("[TaskTagPlugin] Initialized");
+  }
+  dispose() {
+    this.env = null;
+    this.taskComponent = null;
+    this.agentComponent = null;
+    this.tagService = null;
+    logger.info("[TaskTagPlugin] Disposed");
+  }
+  async onDelegateBefore(ctx) {
+    const data = ctx.data;
+    const { taskId, prompt } = 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 similarTasks = await this.tagService?.findSimilarTasksByKeywords?.(keywords, {
+        limit: 5,
+        excludeTaskId: taskId
+      }) ?? [];
+      if (similarTasks.length === 0)
+        return;
+      const hint = this.formatSimilarTasks(similarTasks);
+      data.prompt = `${hint}
+
+---
+
+## 用户指令
+
+${prompt}`;
+      logger.info(`[TaskTagPlugin] Injected ${similarTasks.length} similar tasks`);
+    } catch (error) {
+      logger.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\-_,，。、#]+/).filter((w) => w.length > 2 && !/^\d+$/.test(w)).slice(0, 5);
+      keywords.push(...words);
+    }
+    return keywords;
+  }
+  formatSimilarTasks(tasks) {
+    const lines = [
+      "## \uD83D\uDD0D 类似任务参考",
+      "",
+      "_提示：可通过 `task_get <id>` 获取详情，`task_operation_list <id>` 获取操作记录_",
+      ""
+    ];
+    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.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-extract", input);
+      const workflowDef = await parseExtractorOutput(result.finalText || "");
+      if (!workflowDef)
+        return;
+      const validation = this.validateWorkflowDefinition(workflowDef);
+      if (!validation.valid) {
+        logger.warn(`[TaskTagPlugin] Skipping workflow creation due to validation failure: ` + `${validation.errors.join("; ")}`);
+        await this.taskComponent?.createOperation({
+          taskId,
+          sessionId,
+          actionType: "workflow_extraction_failed",
+          actionTitle: `Workflow extraction failed validation: ${workflowDef.name}`,
+          actionDescription: validation.errors.join("; ")
+        });
+        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-extract", 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
+      });
+      logger.info(`[TaskTagPlugin] Workflow extracted: ${workflow.id}`);
+    } catch (error) {
+      logger.warn(`[TaskTagPlugin] Workflow extraction failed: ${error}`);
+    }
+  }
+  validateWorkflowDefinition(workflowDef) {
+    return validateWorkflowDefinition(workflowDef);
+  }
+  _workflowRepo = null;
+  async getWorkflowRepository() {
+    const workflowComponent = this.env.getComponent("workflow");
+    if (workflowComponent?.workflowService?.workflowRepository) {
+      return workflowComponent.workflowService.workflowRepository;
+    }
+    if (!this._workflowRepo) {
+      try {
+        const sqlite = await import("./roy-agent-core-9cqpdrnk.js");
+        this.ensureDataDir();
+        const db = sqlite.getDatabase();
+        sqlite.initializeTables();
+        const { WorkflowRepository } = await import("./roy-agent-core-5j4awbgc.js");
+        this._workflowRepo = new WorkflowRepository(db);
+        return this._workflowRepo;
+      } catch {
+        return null;
+      }
+    }
+    return this._workflowRepo;
+  }
+  ensureDataDir() {
+    const { join } = __require("path");
+    const dataDir = join(process.env.XDG_DATA_HOME || join(process.env.HOME || "", ".local/share"), "roy-agent");
+    __require("fs").mkdirSync(dataDir, { recursive: true });
+  }
+}
+// src/env/task/plugins/auto-task-plugin.ts
+init_logger();
+init_decorator();
+var logger2 = createLogger("AutoTaskPlugin");
+function createAutoTaskPlugin(config) {
+  const threshold = config?.threshold ?? 20;
+  const agentName = config?.agentName ?? "default";
+  let lastProcessedTraceId = "";
+  async function executeImpl(ctx) {
+    try {
+      logger2.info(`[AutoTaskPlugin:ENTER] agentName=${ctx.agent.name} iteration=${ctx.iteration} threshold=${threshold}`);
+      if (ctx.agent.name !== agentName)
+        return { continue: true };
+      if (ctx.iteration !== threshold)
+        return { continue: true };
+      const traceId = ctx.context?.traceId ?? ctx.context?.sessionId ?? "unknown";
+      if (traceId === lastProcessedTraceId) {
+        logger2.debug(`[AutoTaskPlugin] skip - traceId=${traceId.slice(0, 20)}... already processed`);
+        return { continue: true };
+      }
+      lastProcessedTraceId = traceId;
+      logger2.debug(`[AutoTaskPlugin] new query detected (traceId=${traceId.slice(0, 20)}...)`);
+      const reminderContent = `⚠️ **系统提醒**: 你已经调用了 ${ctx.iteration} 次工具，达到 iteration 阈值（默认 ${threshold}）。
+` + `当前请求较为复杂，建议通过 \`delegate_task\` 工具将整个任务委托给 \`roy\` sub-agent 处理。` + `注意，需要让roy为这个任务调用task create工具来创建任务进行跟踪，这个是必走程序哈。`;
+      if (!ctx.toolResult) {
+        logger2.warn(`[AutoTaskPlugin] toolResult missing, skip meta-protocol (iteration=${ctx.iteration})`);
+        return { continue: true };
+      }
+      enqueueToAddFakeUserMessage(ctx.toolResult, {
+        role: "user",
+        content: reminderContent
+      }, "delegate");
+      logger2.info(`[AutoTaskPlugin] user reminder meta-protocol set (session=${(ctx.context?.sessionId ?? "unknown").slice(0, 12)}..., iteration=${ctx.iteration})`);
+      return { continue: true };
+    } catch (err) {
+      logger2.error(`[AutoTaskPlugin] hook failed: ${err instanceof Error ? err.message : String(err)}`);
+      return { continue: true };
+    }
+  }
+  const execute = wrapFunction(executeImpl, "plugin.auto-task.launch-agent", {
+    recordParams: false,
+    recordResult: true,
+    log: true
+  });
+  return {
+    name: "AutoTaskPlugin",
+    version: "5.2.0",
+    description: "ReAct iteration 达到阈值时通过共享 meta-protocol helper 注入 user 消息（与 MaxIterReminder 共用字段、确定性合并）",
+    hooks: [
+      { point: "agent:after.tool", priority: 50 }
+    ],
+    execute
+  };
+}
+// src/env/task/plugins/lark-cli-task-notify-plugin.ts
+init_decorator();
+init_logger();
+init_context();
+
+// src/env/task/plugins/lark-card-patch-notifier.ts
+init_logger();
+init_decorator();
+import { spawn } from "node:child_process";
+var logger3 = createLogger("lark-cli:card-patch-notifier");
+var HEADER_TEMPLATE = {
+  running: "blue",
+  completed: "green",
+  failed: "red"
+};
+var STATUS_PHRASE = {
+  running: "实时同步中",
+  completed: "\uD83C\uDF89 全部完成！",
+  failed: "\uD83D\uDEA8 任务失败"
+};
+var SPINNER_EMOJIS = ["⏳", "\uD83D\uDD04", "\uD83D\uDD03", "⌛", "⏰", "\uD83D\uDD01"];
+var PROGRESS_BAR_CELLS = 20;
+function formatTimestampForDisplay(iso) {
+  if (!iso)
+    return "";
+  const d = new Date(iso);
+  if (isNaN(d.getTime())) {
+    return iso;
+  }
+  return new Intl.DateTimeFormat("en-GB", {
+    timeZone: "Asia/Shanghai",
+    hour: "2-digit",
+    minute: "2-digit",
+    second: "2-digit",
+    hour12: false
+  }).format(d);
+}
+function sanitizeInlineText(text, maxLen = 300) {
+  if (!text)
+    return "";
+  const flat = text.replace(/\r\n?/g, `
+`).replace(/^#{1,6}\s+/gm, "").replace(/^\s*[-*+]\s+/gm, "· ").replace(/^\s*\d+\.\s+/gm, "· ").replace(/\*\*/g, "").replace(/`/g, "").replace(/\n+/g, " · ").replace(/\s{2,}/g, " ").replace(/(?:\s*·\s*){2,}/g, " · ").replace(/^(\s*·\s*)+/, "").replace(/(\s*·\s*)+$/, "").trim();
+  return flat.length <= maxLen ? flat : `${flat.slice(0, maxLen)}…`;
+}
+function formatDateTimeForDisplay(value) {
+  const d = new Date(value);
+  if (isNaN(d.getTime()))
+    return value;
+  const parts = new Intl.DateTimeFormat("en-CA", {
+    timeZone: "Asia/Shanghai",
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit",
+    hour: "2-digit",
+    minute: "2-digit",
+    hour12: false
+  }).formatToParts(d);
+  const get = (t) => parts.find((p) => p.type === t)?.value ?? "";
+  return `${get("year")}-${get("month")}-${get("day")} ${get("hour")}:${get("minute")}`;
+}
+function looksLikeIsoDateTime(v) {
+  return /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}/.test(v);
+}
+function renderProgressBar(progress) {
+  const clamped = Math.max(0, Math.min(100, progress));
+  const filled = Math.round(clamped / 100 * PROGRESS_BAR_CELLS);
+  const bar = "▓".repeat(filled) + "░".repeat(PROGRESS_BAR_CELLS - filled);
+  return `${bar} ${Math.round(clamped)}%`;
+}
+function humanizeValue(value, maxLen = 200) {
+  const truncate = (t) => t.length <= maxLen ? t : `${t.slice(0, maxLen)}…`;
+  if (value === null || value === undefined)
+    return "";
+  if (typeof value === "string") {
+    if (looksLikeIsoDateTime(value))
+      return formatDateTimeForDisplay(value);
+    return truncate(sanitizeInlineText(value, maxLen));
+  }
+  if (typeof value === "number" || typeof value === "boolean") {
+    return String(value);
+  }
+  if (Array.isArray(value)) {
+    return truncate(value.map((v) => humanizeValue(v, 80)).filter((t) => t.length > 0).join("、"));
+  }
+  if (typeof value === "object") {
+    const entries = Object.entries(value).map(([k, v]) => {
+      const rendered = humanizeValue(v, 80);
+      return rendered ? `${k}: ${rendered}` : "";
+    }).filter((t) => t.length > 0);
+    return truncate(entries.join(" · "));
+  }
+  return "";
+}
+var CONTEXT_LABELS = {
+  worktree_path: "\uD83C\uDF3F Worktree",
+  branch: "\uD83C\uDF3F 分支",
+  created_at: "\uD83D\uDD50 创建时间",
+  prior_context: "\uD83D\uDCDC 背景",
+  project_path: "\uD83D\uDCC2 项目",
+  type: "\uD83C\uDFF7️ 类型",
+  feature: "\uD83C\uDFF7️ 特性",
+  goal: "\uD83C\uDFAF 目标",
+  feishu_chat_id: "\uD83D\uDCAC 飞书群",
+  trigger_message_id: "✉️ 触发消息",
+  trigger_sender_id: "\uD83D\uDC64 触发人",
+  related_task: "\uD83D\uDD17 关联任务",
+  repo: "\uD83D\uDCE6 仓库",
+  commit: "\uD83D\uDD16 Commit",
+  session_id: "\uD83E\uDDF5 Session",
+  worktree: "\uD83C\uDF3F Worktree",
+  larkPerTaskChatId: "\uD83D\uDDC2️ 任务群聊",
+  larkPerTaskChatProfile: "\uD83D\uDDC2️ 群聊 Profile"
+};
+var CONTEXT_SKIP_KEYS = new Set([
+  "larkPerTaskChatTaskId",
+  "larkPerTaskChatCreatedAt"
+]);
+function renderTaskInfoLines(meta) {
+  const lines = [];
+  if (meta.id !== undefined)
+    lines.push(`- **\uD83C\uDD94 任务 ID**：#${meta.id}`);
+  if (meta.title) {
+    lines.push(`- **\uD83D\uDCCC 标题**：${sanitizeInlineText(meta.title, 120)}`);
+  }
+  if (meta.description) {
+    lines.push(`- **\uD83D\uDCDD 描述**：${sanitizeInlineText(meta.description, 300)}`);
+  }
+  if (meta.goals) {
+    lines.push(`- **\uD83C\uDFAF 目标**：${sanitizeInlineText(meta.goals, 300)}`);
+  }
+  if (meta.parentTaskId)
+    lines.push(`- **\uD83D\uDD17 父任务**：#${meta.parentTaskId}`);
+  if (meta.priority || meta.type) {
+    lines.push(`- **⚡ 优先级 / 类型**：${meta.priority ?? "—"} / ${meta.type ?? "—"}`);
+  }
+  if (meta.currentStatus) {
+    lines.push(`- **\uD83D\uDCF6 当前状态**：${sanitizeInlineText(meta.currentStatus, 200)}`);
+  }
+  const project = realValue(meta.projectPath);
+  if (project)
+    lines.push(`- **\uD83D\uDCC2 项目**：\`${sanitizeInlineText(project, 160)}\``);
+  const contextLines = renderContextAsLines(meta.context);
+  lines.push(...contextLines);
+  return lines;
+}
+function realValue(v) {
+  if (!v)
+    return;
+  const t = v.trim();
+  if (t.length === 0 || t === "unknown" || t === "undefined" || t === "null") {
+    return;
+  }
+  return t;
+}
+function renderContextAsLines(context) {
+  const raw = realValue(context);
+  if (!raw)
+    return [];
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return [];
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+    return [];
+  const obj = parsed;
+  const lines = [];
+  const knownKeys = Object.keys(obj).filter((k) => CONTEXT_LABELS[k] && !CONTEXT_SKIP_KEYS.has(k));
+  const otherKeys = Object.keys(obj).filter((k) => !CONTEXT_LABELS[k] && !CONTEXT_SKIP_KEYS.has(k));
+  for (const k of knownKeys) {
+    const rendered = humanizeValue(obj[k], 160);
+    if (rendered)
+      lines.push(`- **${CONTEXT_LABELS[k]}**：${rendered}`);
+  }
+  for (const k of otherKeys) {
+    const rendered = humanizeValue(obj[k], 160);
+    if (rendered)
+      lines.push(`- **${k}**：${rendered}`);
+  }
+  return lines;
+}
+function renderMilestones(milestones) {
+  if (milestones.length === 0) {
+    return "_（暂无里程碑）_";
+  }
+  return milestones.map((m) => {
+    const ts = formatTimestampForDisplay(m.timestamp) || "—";
+    const head = `- **${ts}** ${sanitizeInlineText(m.title, 120)}`;
+    return m.description ? `${head}
+  - ${sanitizeInlineText(m.description, 300)}` : head;
+  }).join(`
+`);
+}
+function renderProcessSteps(steps) {
+  if (steps.length === 0) {
+    return "_（暂无过程记录）_";
+  }
+  return steps.map((s) => {
+    const startTime = formatTimestampForDisplay(s.timestamp);
+    const endTime = formatTimestampForDisplay(s.endTimestamp) || "现在";
+    const range = startTime ? `${startTime} → ${endTime}` : endTime;
+    const title = s.category ? `${s.title}（${s.category}）` : s.title;
+    const head = `- **${range}** ${sanitizeInlineText(title, 120)}`;
+    return s.description ? `${head}
+  - ${sanitizeInlineText(s.description, 300)}` : head;
+  }).join(`
+`);
+}
+function milestoneKey(m) {
+  return `${m.title}|${m.timestamp ?? ""}|${m.description ?? ""}`;
+}
+function processStepKey(s) {
+  return `${s.title}|${s.timestamp ?? ""}|${s.endTimestamp ?? ""}|${s.description ?? ""}`;
+}
+function buildTaskCard(opts) {
+  const status = opts.status ?? "running";
+  const milestones = opts.milestones ?? [];
+  const processSteps = opts.processSteps ?? [];
+  const updateCount = opts.updateCount ?? 0;
+  const spinner = opts.spinner ?? "";
+  const elements = [];
+  const infoLines = renderTaskInfoLines(opts.meta);
+  if (infoLines.length > 0) {
+    elements.push({ tag: "markdown", content: infoLines.join(`
+`) });
+    elements.push({ tag: "hr" });
+  }
+  elements.push({ tag: "markdown", content: `## \uD83C\uDFAF 里程碑序列` });
+  elements.push({ tag: "markdown", content: renderMilestones(milestones) });
+  elements.push({ tag: "hr" });
+  elements.push({ tag: "markdown", content: `## \uD83D\uDD27 过程信息` });
+  elements.push({ tag: "markdown", content: renderProcessSteps(processSteps) });
+  elements.push({ tag: "hr" });
+  const effectiveProgress = status === "completed" ? 100 : opts.progress;
+  elements.push({
+    tag: "markdown",
+    content: effectiveProgress !== undefined ? `**\uD83D\uDCCA 进度**：${renderProgressBar(effectiveProgress)}` : `**\uD83D\uDCCA 进度**：进行中（第 ${updateCount} 次更新，尚未上报百分比）`
+  });
+  const taskLabel = opts.meta.id !== undefined ? `#${opts.meta.id}` : "任务";
+  return {
+    schema: "2.0",
+    header: {
+      title: { tag: "plain_text", content: `\uD83D\uDCCA Task 实时更新（${taskLabel}）` },
+      subtitle: {
+        tag: "plain_text",
+        content: `spinner: '${spinner}' · 第 ${updateCount} 次更新 | ` + STATUS_PHRASE[status]
+      },
+      template: HEADER_TEMPLATE[status]
+    },
+    body: { elements }
+  };
+}
+function buildChatAppLink(chatId, base = DEFAULT_APP_LINK_BASE) {
+  return `${base}/client/chat/open?openChatId=${chatId}`;
+}
+var DEFAULT_APP_LINK_BASE = "https://applink.feishu.cn";
+function buildRedirectCard(opts) {
+  const taskLabel = opts.taskId !== undefined ? `#${opts.taskId}` : "本任务";
+  const title = opts.taskTitle ? ` ${sanitizeInlineText(opts.taskTitle, 120)}` : "";
+  const link = buildChatAppLink(opts.targetChatId);
+  const groupName = opts.targetChatName ? sanitizeInlineText(opts.targetChatName, 60) : "专属群";
+  return {
+    schema: "2.0",
+    header: {
+      title: { tag: "plain_text", content: "\uD83D\uDCC2 任务卡片已改投专属群" },
+      subtitle: { tag: "plain_text", content: "这里不是本任务的群，进展请看专属群" },
+      template: "grey"
+    },
+    body: {
+      elements: [
+        {
+          tag: "markdown",
+          content: [
+            `- **任务**：${taskLabel}${title}`,
+            `- **专属群**：[${groupName}](${link})`,
+            `- **群 ID**：\`${opts.targetChatId}\`（搜群名也能进）`,
+            opts.reason ? `- **原因**：${sanitizeInlineText(opts.reason, 280)}` : ""
+          ].filter(Boolean).join(`
+`)
+        }
+      ]
+    }
+  };
+}
+
+class MutexImpl {
+  chain = Promise.resolve();
+  async run(fn) {
+    const prev = this.chain;
+    const next = prev.then(() => fn());
+    this.chain = next.catch(() => {});
+    return next;
+  }
+}
+
+class LarkCardPatchNotifier {
+  options;
+  mutexes = new Map;
+  states = new Map;
+  redirectsSent = new Set;
+  constructor(options = {}) {
+    this.options = {
+      pinOnStart: true,
+      unpinOnFinish: true,
+      ...options
+    };
+  }
+  mutexFor(messageId) {
+    let m = this.mutexes.get(messageId);
+    if (!m) {
+      m = new MutexImpl;
+      this.mutexes.set(messageId, m);
+    }
+    return m;
+  }
+  async startTask(opts) {
+    const now = new Date().toISOString();
+    const spinner = SPINNER_EMOJIS[0];
+    const milestones = opts.milestones?.length ? opts.milestones : [{ title: "Task 创建", timestamp: now }];
+    const card = buildTaskCard({
+      status: "running",
+      meta: opts.meta,
+      milestones,
+      processSteps: [],
+      updateCount: 1,
+      spinner
+    });
+    const stdout = await this.runLarkCli(this.buildSendCardArgs({ chatId: opts.chatId, profile: opts.profile, card }), "send");
+    const messageId = this.extractMessageId(stdout);
+    if (!messageId) {
+      throw new Error(`lark-cli +messages-send did not return message_id: ${stdout.slice(0, 500)}`);
+    }
+    this.states.set(messageId, {
+      chatId: opts.chatId,
+      profile: opts.profile,
+      meta: opts.meta,
+      startedAt: now,
+      updateCount: 1,
+      spinnerIndex: 0,
+      milestones,
+      processSteps: []
+    });
+    let pinned = false;
+    let pinError;
+    if (this.options.pinOnStart) {
+      try {
+        await this.runLarkCli(this.buildPinArgs({ messageId, profile: opts.profile }), "pin");
+        pinned = true;
+      } catch (pinErr) {
+        pinError = pinErr.message;
+        logger3.warn(`Pin failed (non-fatal) for message ${messageId}: ${pinError}`);
+      }
+    }
+    return { messageId, pinned, pinError };
+  }
+  async sendRedirectNotice(opts) {
+    const redirectKey = opts.taskId !== undefined ? `${opts.taskId}:${opts.targetChatId}` : undefined;
+    if (redirectKey) {
+      if (this.redirectsSent.has(redirectKey)) {
+        logger3.debug(`sendRedirectNotice: 已发过改投卡片（${redirectKey}）→ 跳过重复发送`);
+        return false;
+      }
+      this.redirectsSent.add(redirectKey);
+    }
+    const card = buildRedirectCard({
+      taskId: opts.taskId,
+      taskTitle: opts.taskTitle,
+      targetChatId: opts.targetChatId,
+      targetChatName: opts.targetChatName,
+      reason: opts.reason
+    });
+    try {
+      await this.runLarkCli(this.buildSendCardArgs({
+        chatId: opts.chatId,
+        profile: opts.profile,
+        card
+      }), "send-redirect");
+      return true;
+    } catch (err) {
+      if (redirectKey)
+        this.redirectsSent.delete(redirectKey);
+      logger3.warn(`sendRedirectNotice failed (non-fatal) for chat ${opts.chatId}: ${err.message}`);
+      return false;
+    }
+  }
+  async updateTask(opts) {
+    await this.mutexFor(opts.messageId).run(async () => {
+      const state = this.states.get(opts.messageId) ?? {
+        chatId: opts.chatId ?? "",
+        profile: opts.profile,
+        meta: opts.meta ?? { title: "任务" },
+        startedAt: new Date().toISOString(),
+        updateCount: 0,
+        spinnerIndex: 0,
+        milestones: [],
+        processSteps: []
+      };
+      const mergedMilestones = mergeUnique(state.milestones, opts.milestones ?? [], milestoneKey);
+      const mergedSteps = mergeUnique(state.processSteps, opts.processSteps ?? [], processStepKey);
+      const updateCount = state.updateCount + 1;
+      const spinner = SPINNER_EMOJIS[updateCount % SPINNER_EMOJIS.length];
+      const card = buildTaskCard({
+        status: opts.status,
+        meta: mergeTaskMeta(state.meta, opts.meta),
+        progress: opts.progress ?? state.progress,
+        milestones: mergedMilestones,
+        processSteps: mergedSteps,
+        updateCount,
+        spinner
+      });
+      await this.runLarkCli(this.buildPatchCardArgs({
+        messageId: opts.messageId,
+        profile: opts.profile ?? state.profile,
+        card
+      }), "patch");
+      this.states.set(opts.messageId, {
+        ...state,
+        chatId: opts.chatId ?? state.chatId,
+        profile: opts.profile ?? state.profile,
+        meta: mergeTaskMeta(state.meta, opts.meta),
+        updateCount,
+        spinnerIndex: spinnerIndexFor(updateCount),
+        milestones: mergedMilestones,
+        processSteps: mergedSteps,
+        progress: opts.progress ?? state.progress
+      });
+    });
+  }
+  async finishTask(opts) {
+    await this.mutexFor(opts.messageId).run(async () => {
+      const state = this.states.get(opts.messageId);
+      const now = new Date().toISOString();
+      const updateCount = (state?.updateCount ?? 0) + 1;
+      const spinner = SPINNER_EMOJIS[updateCount % SPINNER_EMOJIS.length];
+      const finalMilestone = {
+        title: opts.status === "completed" ? "Task 完成" : "Task 失败",
+        timestamp: now,
+        description: opts.finalStep
+      };
+      const card = buildTaskCard({
+        status: opts.status,
+        meta: mergeTaskMeta(state?.meta, opts.meta),
+        progress: opts.status === "completed" ? 100 : opts.progress ?? state?.progress,
+        milestones: mergeUnique(state?.milestones ?? [], [finalMilestone], milestoneKey),
+        processSteps: state?.processSteps ?? [],
+        updateCount,
+        spinner
+      });
+      await this.runLarkCli(this.buildPatchCardArgs({
+        messageId: opts.messageId,
+        profile: opts.profile ?? state?.profile,
+        card
+      }), "patch");
+    });
+    if (this.options.unpinOnFinish) {
+      const state = this.states.get(opts.messageId);
+      try {
+        await this.runLarkCli(this.buildUnpinArgs({
+          messageId: opts.messageId,
+          profile: opts.profile ?? state?.profile
+        }), "unpin");
+      } catch (unpinErr) {
+        logger3.warn(`Unpin failed (non-fatal) for ${opts.messageId}: ${unpinErr.message}`);
+      }
+    }
+    this.states.delete(opts.messageId);
+    this.mutexes.delete(opts.messageId);
+  }
+  trackedCardCount() {
+    return this.states.size;
+  }
+  buildSendCardArgs(opts) {
+    const args = [
+      "im",
+      "+messages-send",
+      "--chat-id",
+      opts.chatId,
+      "--msg-type",
+      "interactive",
+      "--content",
+      JSON.stringify(opts.card),
+      "--as",
+      "bot"
+    ];
+    if (opts.profile) {
+      args.unshift("--profile", opts.profile);
+    }
+    return args;
+  }
+  buildPatchCardArgs(opts) {
+    const data = JSON.stringify({ content: JSON.stringify(opts.card) });
+    const args = [
+      "im",
+      "messages",
+      "patch",
+      "--message-id",
+      opts.messageId,
+      "--data",
+      data,
+      "--as",
+      "bot"
+    ];
+    if (opts.profile) {
+      args.unshift("--profile", opts.profile);
+    }
+    return args;
+  }
+  buildPinArgs(opts) {
+    const args = [
+      "im",
+      "pins",
+      "create",
+      "--data",
+      JSON.stringify({ message_id: opts.messageId }),
+      "--as",
+      "bot"
+    ];
+    if (opts.profile) {
+      args.unshift("--profile", opts.profile);
+    }
+    return args;
+  }
+  buildUnpinArgs(opts) {
+    const args = [
+      "im",
+      "pins",
+      "delete",
+      "--message-id",
+      opts.messageId,
+      "--yes",
+      "--as",
+      "bot"
+    ];
+    if (opts.profile) {
+      args.unshift("--profile", opts.profile);
+    }
+    return args;
+  }
+  runLarkCli(argv, op) {
+    return new Promise((resolve, reject) => {
+      if (process.env.ROY_HOOK_DEBUG === "1") {
+        console.error(`[DEBUG LarkCardPatchNotifier.runLarkCli] op=${op} args=${JSON.stringify(argv).slice(0, 300)}`);
+      }
+      const proc = spawn("lark-cli", argv, {
+        shell: false,
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+      let stdout = "";
+      let stderr = "";
+      proc.stdout?.on("data", (data) => {
+        stdout += data.toString();
+      });
+      proc.stderr?.on("data", (data) => {
+        stderr += data.toString();
+      });
+      proc.on("close", (code) => {
+        if (process.env.ROY_HOOK_DEBUG === "1") {
+          console.error(`[DEBUG LarkCardPatchNotifier.runLarkCli] op=${op} CLOSE code=${code} stdoutLen=${stdout.length} stderrLen=${stderr.length}`);
+        }
+        if (code === 0) {
+          resolve(stdout);
+        } else {
+          reject(new Error(`lark-cli ${op} exited with code ${code}: ${sanitize(stderr || stdout)}`));
+        }
+      });
+      proc.on("error", (error) => {
+        reject(error);
+      });
+    });
+  }
+  extractMessageId(stdout) {
+    try {
+      const obj = JSON.parse(stdout);
+      const data = obj?.data ?? obj;
+      const id = data?.message_id ?? data?.messageId ?? obj?.message_id ?? obj?.messageId;
+      return typeof id === "string" ? id : undefined;
+    } catch {
+      return;
+    }
+  }
+}
+__legacyDecorateClassTS([
+  TracedAs("lark-card.startTask", {
+    recordParams: true,
+    recordResult: true,
+    flattenParamFilter: true,
+    paramFilter: (args) => ({
+      chatId: args[0]?.chatId,
+      profile: args[0]?.profile,
+      taskId: args[0]?.taskId
+    }),
+    resultFilter: (r) => ({
+      messageId: r?.messageId,
+      pinned: r?.pinned
+    })
+  })
+], LarkCardPatchNotifier.prototype, "startTask", null);
+__legacyDecorateClassTS([
+  TracedAs("lark-card.updateTask", {
+    recordParams: true,
+    recordResult: false,
+    flattenParamFilter: true,
+    paramFilter: (args) => ({
+      messageId: args[0]?.messageId,
+      profile: args[0]?.profile,
+      status: args[0]?.status,
+      taskId: args[0]?.taskId,
+      progress: args[0]?.progress,
+      newMilestones: args[0]?.milestones?.length ?? 0,
+      newProcessSteps: args[0]?.processSteps?.length ?? 0
+    })
+  })
+], LarkCardPatchNotifier.prototype, "updateTask", null);
+__legacyDecorateClassTS([
+  TracedAs("lark-card.finishTask", {
+    recordParams: true,
+    recordResult: false,
+    flattenParamFilter: true,
+    paramFilter: (args) => ({
+      messageId: args[0]?.messageId,
+      profile: args[0]?.profile,
+      status: args[0]?.status,
+      taskId: args[0]?.taskId
+    })
+  })
+], LarkCardPatchNotifier.prototype, "finishTask", null);
+__legacyDecorateClassTS([
+  TracedAs("lark-card.runLarkCli", {
+    recordParams: true,
+    recordResult: true,
+    flattenParamFilter: true,
+    paramFilter: (args) => {
+      const argv = args[0] ?? [];
+      const op = args[1] ?? "unknown";
+      return {
+        op,
+        argv: argv.join(" ").slice(0, 300),
+        hasProfile: argv.includes("--profile"),
+        msgType: valueAfter(argv, "--msg-type"),
+        contentLength: (valueAfter(argv, "--content") ?? "").length,
+        dataLength: (valueAfter(argv, "--data") ?? "").length
+      };
+    },
+    resultFilter: (r) => ({
+      stdoutLength: (r ?? "").length
+    })
+  })
+], LarkCardPatchNotifier.prototype, "runLarkCli", null);
+function mergeTaskMeta(base, incoming) {
+  const merged = { ...base ?? {} };
+  if (!incoming)
+    return merged;
+  for (const [k, v] of Object.entries(incoming)) {
+    if (v === undefined || v === null || v === "")
+      continue;
+    merged[k] = v;
+  }
+  return merged;
+}
+function mergeUnique(base, incoming, keyOf) {
+  const seen = new Set(base.map(keyOf));
+  const merged = [...base];
+  for (const item of incoming) {
+    const k = keyOf(item);
+    if (seen.has(k))
+      continue;
+    seen.add(k);
+    merged.push(item);
+  }
+  return merged;
+}
+function spinnerIndexFor(updateCount) {
+  return updateCount % SPINNER_EMOJIS.length;
+}
+function valueAfter(argv, flag) {
+  const idx = argv.indexOf(flag);
+  if (idx < 0 || idx + 1 >= argv.length)
+    return;
+  return argv[idx + 1];
+}
+function sanitize(text) {
+  const trimmed = text.trim();
+  if (trimmed.length <= 500)
+    return trimmed;
+  return `${trimmed.slice(0, 500)}…`;
+}
+
+// src/env/task/plugins/card-chat-routing.ts
+var GROUP_NAME_TASK_ID_RE = /(?:Task\s*#?\s*|#)(\d{1,7})\b/i;
+var DEDICATED_CHAT_ID_FIELD_RE = /^(larkPerTaskChatId|[a-z0-9_]*(followup|group|per_?task)[a-z0-9_]*chat[_]?id)$/i;
+var CONVERSATION_CHAT_ID_FIELD_RE = /^(feishu_chat_id|chat_id|message_?chat_?id)$/i;
+var CTX_FIELD_LARK_PER_TASK_CHAT_ID = "larkPerTaskChatId";
+function extractPerTaskChatId(contextStr) {
+  if (!contextStr)
+    return;
+  try {
+    const obj = JSON.parse(contextStr);
+    const v = obj?.[CTX_FIELD_LARK_PER_TASK_CHAT_ID];
+    return typeof v === "string" && v.length > 0 ? v : undefined;
+  } catch {
+    return;
+  }
+}
+function extractPerTaskChatProfile(contextStr) {
+  if (!contextStr)
+    return;
+  try {
+    const obj = JSON.parse(contextStr);
+    const v = obj?.["larkPerTaskChatProfile"];
+    return typeof v === "string" && v.length > 0 ? v : undefined;
+  } catch {
+    return;
+  }
+}
+function extractRecordedChatNames(contextStr) {
+  if (!contextStr)
+    return [];
+  const out = [];
+  try {
+    const obj = JSON.parse(contextStr);
+    for (const [k, v] of Object.entries(obj ?? {})) {
+      if (typeof v === "string" && /chat_?name$/i.test(k) && v.length > 0) {
+        out.push(v);
+      }
+    }
+  } catch {
+    return [];
+  }
+  return out;
+}
+function analyzeContextOwnership(contextStr, chatId) {
+  const sources = [];
+  const impliedTaskIds = [];
+  if (!contextStr)
+    return { owned: false, sources, impliedTaskIds };
+  let obj;
+  try {
+    const parsed = JSON.parse(contextStr);
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+      obj = parsed;
+    }
+  } catch {
+    obj = undefined;
+  }
+  if (!obj)
+    return { owned: false, sources, impliedTaskIds };
+  for (const [k, v] of Object.entries(obj)) {
+    if (typeof v !== "string" || v.length === 0)
+      continue;
+    const isDedicatedField = DEDICATED_CHAT_ID_FIELD_RE.test(k);
+    const isConversationField = CONVERSATION_CHAT_ID_FIELD_RE.test(k);
+    if (isDedicatedField && !isConversationField && v === chatId) {
+      sources.push(k);
+      continue;
+    }
+    if (/chat_?name$/i.test(k)) {
+      const m = v.match(GROUP_NAME_TASK_ID_RE);
+      if (m) {
+        const id = Number(m[1]);
+        if (Number.isFinite(id) && id > 0)
+          impliedTaskIds.push(id);
+      }
+    }
+  }
+  return { owned: sources.length > 0, sources, impliedTaskIds };
+}
+function mergeChatOwnership(chatId, candidates, extra = {}) {
+  const ownerTaskIds = new Set;
+  const sources = [];
+  let chatName = extra.chatName;
+  if (typeof extra.boundTaskId === "number" && extra.boundTaskId > 0) {
+    ownerTaskIds.add(extra.boundTaskId);
+    sources.push("chat-binding");
+  }
+  for (const c of candidates) {
+    const r = analyzeContextOwnership(c.context, chatId);
+    if (r.owned) {
+      ownerTaskIds.add(c.id);
+      sources.push(`#${c.id}:${r.sources.join("+")}`);
+    }
+    if (!chatName) {
+      const names = extractRecordedChatNames(c.context);
+      const matched = names.find((n) => n.includes(chatId) || GROUP_NAME_TASK_ID_RE.test(n));
+      if (matched)
+        chatName = matched;
+    }
+    for (const implied of r.impliedTaskIds) {
+      if (implied === c.id) {
+        ownerTaskIds.add(c.id);
+        sources.push(`#${c.id}:chat-name`);
+      }
+    }
+  }
+  if (chatName) {
+    const m = chatName.match(GROUP_NAME_TASK_ID_RE);
+    if (m) {
+      const id = Number(m[1]);
+      if (Number.isFinite(id) && id > 0) {
+        ownerTaskIds.add(id);
+        sources.push("chat-name");
+      }
+    }
+  }
+  return {
+    chatId,
+    ownerTaskIds: [...ownerTaskIds],
+    sources,
+    chatName,
+    dedicated: ownerTaskIds.size > 0
+  };
+}
+function decideCardChatTarget(input) {
+  const {
+    lineageIds,
+    lineageChat,
+    triggerChatId,
+    triggerProfile,
+    triggerOwnership
+  } = input;
+  const foreign = !!triggerChatId && !!triggerOwnership?.dedicated && triggerOwnership.ownerTaskIds.length > 0 && !triggerOwnership.ownerTaskIds.some((id) => lineageIds.includes(id));
+  if (triggerChatId && !foreign) {
+    return {
+      chatId: triggerChatId,
+      profile: triggerProfile,
+      source: "trigger-chat",
+      reason: triggerOwnership?.dedicated ? `触发群属于自己的 lineage（owner=${triggerOwnership.ownerTaskIds.join(",")}），直接用` : "触发群（普通会话群），直接用"
+    };
+  }
+  if (lineageChat) {
+    return {
+      chatId: lineageChat.chatId,
+      profile: lineageChat.profile,
+      source: lineageChat.isSelf ? "own-group" : "ancestor-group",
+      reroutedFrom: foreign ? {
+        chatId: triggerChatId,
+        ownerTaskIds: triggerOwnership.ownerTaskIds,
+        sources: triggerOwnership.sources
+      } : undefined,
+      reason: foreign ? `触发群 ${triggerChatId} 是 task ${triggerOwnership.ownerTaskIds.join(",")} 的专属群，改投 lineage 群 ${lineageChat.chatId}` : `无触发群，用 lineage 群 ${lineageChat.chatId}`
+    };
+  }
+  if (!triggerChatId) {
+    return {
+      chatId: undefined,
+      source: "none",
+      reason: "既没有触发群也没有 lineage 群（无法决定投递目标）"
+    };
+  }
+  return {
+    chatId: undefined,
+    source: "new-group",
+    profile: triggerProfile,
+    reroutedFrom: foreign ? {
+      chatId: triggerChatId,
+      ownerTaskIds: triggerOwnership.ownerTaskIds,
+      sources: triggerOwnership.sources
+    } : undefined,
+    reason: foreign ? `触发群 ${triggerChatId} 是 task ${triggerOwnership.ownerTaskIds.join(",")} 的专属群，且本 task 无群 → 需要新建` : "无触发群且本 task 无群 → 需要新建"
+  };
+}
+
+// src/env/task/plugins/lark-cli-task-notify-plugin.ts
+var logger4 = createLogger("lark-cli:task-notify");
+var CTX_FIELD_CHAT_ID = "larkPerTaskChatId";
+var CTX_FIELD_CHAT_PROFILE = "larkPerTaskChatProfile";
+function parseLarkPerTaskChatId(ctxStr) {
+  if (!ctxStr)
+    return;
+  try {
+    const obj = JSON.parse(ctxStr);
+    const id = obj[CTX_FIELD_CHAT_ID];
+    return typeof id === "string" ? id : undefined;
+  } catch {
+    return;
+  }
+}
+function parseLarkPerTaskChatProfile(ctxStr) {
+  if (!ctxStr)
+    return;
+  try {
+    const obj = JSON.parse(ctxStr);
+    const profile = obj[CTX_FIELD_CHAT_PROFILE];
+    return typeof profile === "string" ? profile : undefined;
+  } catch {
+    return;
+  }
+}
+var NotifyType;
+((NotifyType2) => {
+  NotifyType2["TASK_CREATED"] = "task_created";
+  NotifyType2["TASK_COMPLETED"] = "task_completed";
+  NotifyType2["TASK_UPDATED"] = "task_updated";
+  NotifyType2["TASK_FAILED"] = "task_failed";
+  NotifyType2["OPERATION_CREATED"] = "operation_created";
+})(NotifyType ||= {});
+
+class LarkCliTaskNotifyHook {
+  name;
+  priority;
+  description;
+  pluginName;
+  sourceId;
+  config;
+  cardNotifier;
+  cardMessageIds = new Map;
+  lastNotifyTimestamps = new Map;
+  cardRoutingPorts;
+  static CARD_START_FAILED_SENTINEL = "__card_start_failed__";
+  static CARD_START_INFLIGHT_SENTINEL = "__card_start_inflight__";
+  constructor(config = {}) {
+    this.name = config.pluginName || "LarkCliTaskNotifyHook";
+    this.priority = config.priority ?? 5;
+    this.description = "LarkCli 任务通知 Hook（卡片模式）";
+    this.pluginName = config.pluginName;
+    this.sourceId = config.sourceId;
+    this.config = {
+      enabled: true,
+      priority: 5,
+      notifyTypes: [
+        "task_created" /* TASK_CREATED */,
+        "task_updated" /* TASK_UPDATED */,
+        "task_completed" /* TASK_COMPLETED */,
+        "operation_created" /* OPERATION_CREATED */
+      ],
+      ...config
+    };
+    if (this.config.cardMode !== false) {
+      this.cardNotifier = config.cardNotifier ?? new LarkCardPatchNotifier;
+    }
+  }
+  setCardRoutingPorts(ports) {
+    this.cardRoutingPorts = ports;
+    logger4.debug(`CardRoutingPorts injected: lookup=${typeof ports.lookupChatOwnership}, ` + `getTask=${typeof ports.getTask}, ensureGroup=${typeof ports.ensureTaskGroupChat}`);
+  }
+  hasCardRoutingPorts() {
+    return this.cardRoutingPorts !== undefined;
+  }
+  async execute(ctx) {
+    if (!this.config.enabled) {
+      return;
+    }
+    const env = getEnvContextOrEmpty();
+    if (this.pluginName && this.sourceId) {
+      const key = `${this.sourceId}:${this.pluginName}`;
+      if (env.pluginEnabled && env.pluginEnabled[key] !== true) {
+        logger4.debug(`Plugin not enabled for source: ${key}`);
+        return;
+      }
+    }
+    switch (ctx.hookPoint) {
+      case TaskHookPoints.AFTER_CREATE:
+        await this.onAfterCreate(ctx);
+        break;
+      case TaskHookPoints.AFTER_UPDATE:
+        await this.onAfterUpdate(ctx);
+        break;
+      case TaskHookPoints.AFTER_COMPLETE:
+        await this.onAfterComplete(ctx);
+        break;
+      case TaskHookPoints.OPERATION_AFTER_CREATE:
+        await this.onAfterOperationCreate(ctx);
+        break;
+    }
+  }
+  async onAfterCreate(ctx) {
+    const { task } = ctx.data;
+    if (!task || !this.shouldNotify("task_created" /* TASK_CREATED */))
+      return;
+    if (!this.isCardModeEnabled())
+      return;
+    await this.sendCardStart(task);
+  }
+  async onAfterUpdate(ctx) {
+    const data = ctx.data;
+    if (!data?.task)
+      return;
+    const { task, changes } = data;
+    let notifyType;
+    if (changes?.status === "completed" || changes?.progress === 100) {
+      notifyType = "task_completed" /* TASK_COMPLETED */;
+    } else if (changes?.status) {
+      notifyType = "task_updated" /* TASK_UPDATED */;
+    } else if (task.status === "completed" || task.progress === 100) {
+      notifyType = "task_completed" /* TASK_COMPLETED */;
+    } else if (changes && Object.keys(changes).length > 0) {
+      notifyType = "task_updated" /* TASK_UPDATED */;
+    } else {
+      return;
+    }
+    if (!this.shouldNotify(notifyType))
+      return;
+    if (!this.isCardModeEnabled())
+      return;
+    if (notifyType === "task_completed" /* TASK_COMPLETED */ || task.status === "completed") {
+      await this.sendCardFinish(task);
+    } else {
+      await this.sendCardUpdate(task, changes);
+    }
+  }
+  async onAfterComplete(ctx) {
+    const data = ctx.data;
+    const task = data?.task ?? data;
+    if (!task || !this.shouldNotify("task_completed" /* TASK_COMPLETED */))
+      return;
+    if (!this.isCardModeEnabled())
+      return;
+    await this.sendCardFinish(task);
+  }
+  async onAfterOperationCreate(ctx) {
+    const { operation } = ctx.data;
+    if (!operation)
+      return;
+    if (!this.shouldNotify("operation_created" /* OPERATION_CREATED */))
+      return;
+    if (this.shouldThrottleOperation(operation))
+      return;
+    if (!this.isCardModeEnabled())
+      return;
+    const messageId = this.cardMessageIds.get(operation.taskId);
+    if (!messageId || messageId === LarkCliTaskNotifyHook.CARD_START_FAILED_SENTINEL) {
+      logger4.debug(`onAfterOperationCreate: no card for task #${operation.taskId}, skip`);
+      return;
+    }
+    const { milestones, processSteps } = this.deriveTimelineFromOperation(operation);
+    if (milestones.length === 0 && processSteps.length === 0)
+      return;
+    const env = getEnvContextOrEmpty();
+    const profile = env.replyChannel?.profile;
+    try {
+      await this.cardNotifier.updateTask({
+        messageId,
+        profile,
+        status: "running",
+        milestones,
+        processSteps
+      });
+    } catch (err) {
+      logger4.error(`sendCardOperation failed for task #${operation.taskId}: ${err.message}`);
+    }
+  }
+  isCardModeEnabled() {
+    if (this.config.cardMode === false || !this.cardNotifier) {
+      logger4.debug("cardMode=false (legacy opt-out), skip task notification (no text fallback)");
+      return false;
+    }
+    return true;
+  }
+  async resolveCardTarget(task) {
+    const env = getEnvContextOrEmpty();
+    const triggerChatId = env.replyChannel?.chatId;
+    const triggerProfile = env.replyChannel?.profile;
+    const lineage = await this.collectLineage(task);
+    const lineageIds = lineage.map((t) => t.id);
+    const selfChatId = extractPerTaskChatId(task.context);
+    let lineageChat;
+    for (const node of lineage) {
+      const chatId = extractPerTaskChatId(node.context);
+      if (chatId) {
+        lineageChat = {
+          chatId,
+          profile: extractPerTaskChatProfile(node.context),
+          isSelf: node.id === task.id
+        };
+        break;
+      }
+    }
+    if (!lineageChat && selfChatId) {
+      lineageChat = {
+        chatId: selfChatId,
+        profile: extractPerTaskChatProfile(task.context),
+        isSelf: true
+      };
+    }
+    let triggerOwnership;
+    if (triggerChatId && this.cardRoutingPorts?.lookupChatOwnership) {
+      try {
+        triggerOwnership = await this.cardRoutingPorts.lookupChatOwnership(triggerChatId);
+      } catch (err) {
+        logger4.warn(`lookupChatOwnership failed for ${triggerChatId} (degrade to trigger chat): ${err.message}`);
+      }
+    }
+    const decision = decideCardChatTarget({
+      taskId: task.id,
+      lineageIds,
+      lineageChat,
+      triggerChatId,
+      triggerProfile,
+      triggerOwnership
+    });
+    if (decision.source === "new-group") {
+      if (this.cardRoutingPorts?.ensureTaskGroupChat) {
+        try {
+          const created = await this.cardRoutingPorts.ensureTaskGroupChat(task);
+          if (created?.chatId) {
+            return {
+              ...decision,
+              chatId: created.chatId,
+              profile: created.profile ?? decision.profile,
+              chatName: created.name,
+              reason: `${decision.reason}；已新建专属群 ${created.chatId}`
+            };
+          }
+        } catch (err) {
+          logger4.warn(`ensureTaskGroupChat failed for task #${task.id}: ${err.message}`);
+        }
+      }
+      return {
+        ...decision,
+        chatId: triggerChatId,
+        profile: triggerProfile,
+        source: triggerChatId ? "trigger-chat" : "none",
+        reroutedFrom: undefined,
+        reason: `${decision.reason}；但建群失败/不可用 → 退回触发群`
+      };
+    }
+    return decision;
+  }
+  async collectLineage(task) {
+    const out = [
+      { id: task.id, context: task.context }
+    ];
+    let parentId = typeof task.parent_task_id === "number" && task.parent_task_id > 0 ? task.parent_task_id : undefined;
+    let depth = 0;
+    while (parentId && depth < 10 && this.cardRoutingPorts?.getTask) {
+      try {
+        const parent = await this.cardRoutingPorts.getTask(parentId);
+        if (!parent)
+          break;
+        out.push({ id: parentId, context: parent.context });
+        parentId = typeof parent.parent_task_id === "number" && parent.parent_task_id > 0 ? parent.parent_task_id : undefined;
+      } catch {
+        break;
+      }
+      depth++;
+    }
+    return out;
+  }
+  async sendCardStart(task) {
+    if (!this.cardNotifier)
+      return;
+    const claim = this.cardMessageIds.get(task.id);
+    if (claim) {
+      logger4.debug(`sendCardStart: task #${task.id} 已有首卡（${claim}）→ 跳过重复发卡`);
+      return;
+    }
+    this.cardMessageIds.set(task.id, LarkCliTaskNotifyHook.CARD_START_INFLIGHT_SENTINEL);
+    let target;
+    try {
+      target = await this.resolveCardTarget(task);
+    } catch (err) {
+      this.cardMessageIds.delete(task.id);
+      throw err;
+    }
+    const chatId = target.chatId;
+    const profile = target.profile;
+    if (!chatId) {
+      this.cardMessageIds.delete(task.id);
+      logger4.debug(`sendCardStart: no chatId for task #${task.id}, skip`);
+      return;
+    }
+    try {
+      const { messageId, pinned } = await this.cardNotifier.startTask({
+        chatId,
+        profile,
+        meta: this.buildTaskMeta(task),
+        milestones: [
+          {
+            title: "Task 创建",
+            timestamp: new Date().toISOString(),
+            description: task.current_status || undefined
+          }
+        ]
+      });
+      this.cardMessageIds.set(task.id, messageId);
+      logger4.debug(`sendCardStart: task #${task.id} → message ${messageId} (pinned=${pinned}) ` + `chat=${chatId} source=${target.source} reason=${target.reason}`);
+      if (target.reroutedFrom) {
+        await this.cardNotifier.sendRedirectNotice({
+          chatId: target.reroutedFrom.chatId,
+          profile: target.profile,
+          taskId: task.id,
+          taskTitle: task.title,
+          targetChatId: chatId,
+          targetChatName: target.chatName,
+          reason: target.reason
+        });
+      }
+    } catch (err) {
+      this.cardMessageIds.set(task.id, LarkCliTaskNotifyHook.CARD_START_FAILED_SENTINEL);
+      logger4.error(`sendCardStart failed for task #${task.id}: ${err.message}`);
+    }
+  }
+  async sendCardUpdate(task, changes) {
+    if (!this.cardNotifier)
+      return;
+    let messageId = this.cardMessageIds.get(task.id);
+    const target = messageId ? undefined : await this.resolveCardTarget(task);
+    const chatId = target?.chatId ?? this.resolveChatId(task, getEnvContextOrEmpty());
+    const profile = target?.profile ?? this.resolveProfile(task, getEnvContextOrEmpty());
+    if (!chatId) {
+      logger4.debug(`sendCardUpdate: no chatId for task #${task.id}, skip`);
+      return;
+    }
+    if (messageId === LarkCliTaskNotifyHook.CARD_START_FAILED_SENTINEL) {
+      logger4.debug(`sendCardUpdate: startTask failed previously for task #${task.id}, skip`);
+      return;
+    }
+    if (messageId === LarkCliTaskNotifyHook.CARD_START_INFLIGHT_SENTINEL) {
+      logger4.debug(`sendCardUpdate: task #${task.id} 首卡正在发送中（in-flight）→ 跳过本次 update`);
+      return;
+    }
+    if (!messageId) {
+      try {
+        const res = await this.cardNotifier.startTask({
+          chatId,
+          profile,
+          meta: this.buildTaskMeta(task)
+        });
+        messageId = res.messageId;
+        this.cardMessageIds.set(task.id, messageId);
+      } catch (err) {
+        this.cardMessageIds.set(task.id, LarkCliTaskNotifyHook.CARD_START_FAILED_SENTINEL);
+        logger4.error(`sendCardUpdate fallback start failed: ${err.message}`);
+        return;
+      }
+    }
+    const changeKeys = Object.keys(changes ?? {});
+    const processSteps = changeKeys.length > 0 ? [
+      {
+        title: "状态更新",
+        timestamp: new Date().toISOString(),
+        description: changeKeys.map((k) => `${k}=${humanizeValue(changes[k], 80)}`).join(" · ")
+      }
+    ] : [];
+    try {
+      await this.cardNotifier.updateTask({
+        messageId,
+        chatId,
+        profile,
+        status: "running",
+        meta: this.buildTaskMeta(task),
+        progress: typeof task.progress === "number" && task.progress > 0 ? task.progress : undefined,
+        milestones: [],
+        processSteps
+      });
+    } catch (err) {
+      logger4.error(`sendCardUpdate failed: ${err.message}`);
+    }
+  }
+  async sendCardFinish(task) {
+    if (!this.cardNotifier)
+      return;
+    const messageId = this.cardMessageIds.get(task.id);
+    const ctx = getEnvContextOrEmpty();
+    const profile = this.resolveProfile(task, ctx);
+    if (!messageId || messageId === LarkCliTaskNotifyHook.CARD_START_FAILED_SENTINEL) {
+      logger4.debug(`sendCardFinish: no card messageId for task #${task.id}, skip`);
+      return;
+    }
+    const status = String(task.status) === "failed" || String(task.status) === "cancelled" || String(task.status) === "timeout" ? "failed" : "completed";
+    try {
+      await this.cardNotifier.finishTask({
+        messageId,
+        profile,
+        status,
+        meta: this.buildTaskMeta(task),
+        finalStep: task.current_status || undefined
+      });
+      this.cardMessageIds.delete(task.id);
+    } catch (err) {
+      logger4.error(`sendCardFinish failed: ${err.message}`);
+    }
+  }
+  resolveChatId(task, env) {
+    const envChat = env.replyChannel?.chatId;
+    if (envChat)
+      return envChat;
+    const ctxStr = task.context;
+    if (typeof ctxStr === "string") {
+      const ctxChat = parseLarkPerTaskChatId(ctxStr);
+      if (ctxChat)
+        return ctxChat;
+    }
+    return;
+  }
+  resolveProfile(task, env) {
+    const envProfile = env.replyChannel?.profile;
+    if (envProfile)
+      return envProfile;
+    const ctxStr = task.context;
+    if (typeof ctxStr === "string") {
+      const ctxProfile = parseLarkPerTaskChatProfile(ctxStr);
+      if (ctxProfile)
+        return ctxProfile;
+    }
+    return;
+  }
+  buildTaskMeta(task) {
+    return {
+      id: task.id,
+      title: task.title,
+      description: task.description,
+      goals: task.goals_and_expected_deliverables,
+      parentTaskId: typeof task.parent_task_id === "number" && task.parent_task_id > 0 ? task.parent_task_id : undefined,
+      priority: task.priority,
+      type: task.type,
+      projectPath: task.project_path,
+      context: task.context,
+      currentStatus: task.current_status
+    };
+  }
+  deriveTimelineFromOperation(operation) {
+    const raw = operation;
+    const title = operation.milestoneTitle ?? operation.actionTitle ?? raw.action_title ?? raw.description ?? raw.type ?? undefined;
+    const detail = operation.milestoneDescription ?? operation.actionDescription ?? raw.action_description ?? undefined;
+    const timestamp = operation.timestamp ?? new Date().toISOString();
+    const milestones = [];
+    const processSteps = [];
+    if (operation.milestoneTitle || operation.milestoneType || title) {
+      milestones.push({
+        title: title ?? String(operation.milestoneType ?? "里程碑"),
+        timestamp,
+        description: detail
+      });
+    }
+    if (operation.processDescription || detail) {
+      processSteps.push({
+        title: title ?? "过程",
+        timestamp,
+        description: operation.processDescription ?? detail
+      });
+    }
+    const currentStep = operation.processDescription ?? detail ?? title ?? undefined;
+    return { milestones, processSteps, currentStep };
+  }
+  shouldThrottleOperation(operation) {
+    const throttleMs = this.config.operationThrottleMs ?? 5000;
+    if (throttleMs <= 0)
+      return false;
+    const key = `op:${operation.taskId}`;
+    const now = Date.now();
+    const lastTime = this.lastNotifyTimestamps.get(key);
+    if (lastTime && now - lastTime < throttleMs) {
+      logger4.debug(`[throttle] skip OPERATION_CREATED patch for task #${operation.taskId} (${now - lastTime}ms ago)`);
+      return true;
+    }
+    this.lastNotifyTimestamps.set(key, now);
+    return false;
+  }
+  shouldNotify(type) {
+    const { notifyTypes } = this.config;
+    if (notifyTypes && notifyTypes.length === 0)
+      return true;
+    if (notifyTypes)
+      return notifyTypes.includes(type);
+    return type === "task_completed" /* TASK_COMPLETED */;
+  }
+}
+__legacyDecorateClassTS([
+  TracedAs("lark-cli-task-notify.execute")
+], LarkCliTaskNotifyHook.prototype, "execute", null);
+__legacyDecorateClassTS([
+  TracedAs("lark-cli-task-notify.resolveCardTarget", {
+    recordParams: true,
+    recordResult: true,
+    flattenParamFilter: true,
+    paramFilter: (args) => ({
+      taskId: args[0]?.id,
+      triggerChatId: undefined
+    }),
+    resultFilter: (r) => ({
+      source: r?.source,
+      chatId: r?.chatId,
+      chatName: r?.chatName,
+      reroutedFrom: r?.reroutedFrom?.chatId,
+      rerouteOwners: r?.reroutedFrom?.ownerTaskIds?.join(","),
+      reason: r?.reason?.slice(0, 200)
+    })
+  })
+], LarkCliTaskNotifyHook.prototype, "resolveCardTarget", null);
+function createLarkCliTaskNotifyHook(config = {}) {
+  return new LarkCliTaskNotifyHook(config);
+}
+// src/env/task/plugins/per-task-group-chat-plugin.ts
+init_decorator();
+init_logger();
+init_context();
+import { spawn as spawn2 } from "child_process";
+var logger5 = createLogger("lark-cli:per-task-group");
+function isPluginDebugEnabled() {
+  return process.env.ROY_TASK_NOTIFY_DEBUG === "1" || process.env.ROY_TRACE_DEBUG === "1";
+}
+var CTX_FIELD_CHAT_ID2 = "larkPerTaskChatId";
+var CTX_FIELD_CHAT_PROFILE2 = "larkPerTaskChatProfile";
+var CTX_FIELD_CHAT_CREATED_AT = "larkPerTaskChatCreatedAt";
+var CTX_FIELD_CHAT_TASK_ID = "larkPerTaskChatTaskId";
+
+class PerTaskGroupChatPlugin {
+  name;
+  priority;
+  pluginName;
+  sourceId;
+  config;
+  lastNotifyTimestamps = new Map;
+  taskUpdater;
+  taskGetter;
+  sessionComponent;
+  cardNotifier;
+  cardMessageIds = new Map;
+  static CARD_START_FAILED_SENTINEL = "__card_start_failed__";
+  groupChatInflight = new Map;
+  constructor(config = {}) {
+    this.config = {
+      enabled: config.enabled ?? true,
+      priority: config.priority ?? 100,
+      pluginName: config.pluginName ?? "PerTaskGroupChatPlugin",
+      sourceId: config.sourceId ?? "",
+      nameTemplate: config.nameTemplate ?? "Task #{id} - #{title}",
+      descriptionTemplate: config.descriptionTemplate ?? "roy-agent task #{id} - #{project_path}",
+      botAppIds: config.botAppIds ?? [],
+      inviteUserIds: config.inviteUserIds ?? ["sender"],
+      defaultInviteUserIds: config.defaultInviteUserIds ?? [],
+      fallbackToMain: config.fallbackToMain ?? true,
+      operationThrottleMs: config.operationThrottleMs ?? 5000,
+      disableSubTaskSkip: config.disableSubTaskSkip ?? false,
+      requireReplyChannel: config.requireReplyChannel ?? true,
+      fallbackProfile: config.fallbackProfile ?? "",
+      sendWelcomeMessage: config.sendWelcomeMessage ?? true,
+      resolveToTriggerChatFallback: config.resolveToTriggerChatFallback ?? false,
+      cardInitialMessage: config.cardInitialMessage !== false,
+      cardNotifier: config.cardNotifier ?? new LarkCardPatchNotifier
+    };
+    this.cardNotifier = this.config.cardNotifier;
+    this.name = this.config.pluginName;
+    this.priority = this.config.priority;
+    this.pluginName = this.config.pluginName;
+    this.sourceId = this.config.sourceId;
+  }
+  async ensureGroupChat(task, replyChannelOverride) {
+    const renderedName = this.renderTemplate(this.config.nameTemplate, task);
+    const existingChatId = this.getTaskChatId(task);
+    if (existingChatId) {
+      logger5.debug(`ensureGroupChat[${this.pluginName}]: task #${task.id} 已有专属群 ${existingChatId} → 复用（不重复建群）`);
+      return {
+        chatId: existingChatId,
+        profile: this.parseProfileFromContext(task.context),
+        name: renderedName
+      };
+    }
+    const inflight = this.groupChatInflight.get(task.id);
+    if (inflight) {
+      logger5.debug(`ensureGroupChat[${this.pluginName}]: task #${task.id} 建群已在进行中 → 复用同一 promise`);
+      return inflight;
+    }
+    const pending = this.doEnsureGroupChat(task, renderedName, replyChannelOverride);
+    this.groupChatInflight.set(task.id, pending);
+    try {
+      return await pending;
+    } finally {
+      this.groupChatInflight.delete(task.id);
+    }
+  }
+  async doEnsureGroupChat(task, name, replyChannelOverride) {
+    const replyChannel = replyChannelOverride ?? getEnvContextOrEmpty().replyChannel;
+    if (!replyChannel?.chatId && this.config.requireReplyChannel) {
+      logger5.warn(`ensureGroupChat[${this.pluginName}]: no replyChannel.chatId for task #${task.id} ` + `(requireReplyChannel=true) → 无法建群`);
+      return;
+    }
+    const description = this.renderTemplate(this.config.descriptionTemplate, task);
+    const profile = replyChannel?.profile || (this.config.fallbackProfile || undefined);
+    const botAppIds = this.resolveBotAppIds(replyChannel ?? {});
+    const userIds = this.resolveUserIds(replyChannel);
+    try {
+      const chatId = await this.createGroupChat({
+        name,
+        description,
+        profile,
+        botAppIds,
+        userIds
+      });
+      await this.writeChatBinding(task, chatId, profile, "creating");
+      await this.attachChatIdToTask(task, chatId, profile);
+      await this.writeChatBinding(task, chatId, profile, "ready");
+      logger5.info(`ensureGroupChat[${this.pluginName}]: created group ${chatId} for task #${task.id}`);
+      return { chatId, profile, name };
+    } catch (error) {
+      logger5.error(`ensureGroupChat[${this.pluginName}]: failed for task #${task.id}: ${error}`);
+      return;
+    }
+  }
+  setTaskUpdater(updater) {
+    this.taskUpdater = updater;
+    logger5.debug(`TaskUpdater injected for plugin ${this.name} (sourceId=${this.sourceId})`);
+  }
+  hasTaskUpdater() {
+    return this.taskUpdater !== undefined;
+  }
+  setTaskGetter(getter) {
+    this.taskGetter = getter;
+    logger5.debug(`TaskGetter injected for plugin ${this.name} (sourceId=${this.sourceId})`);
+  }
+  hasTaskGetter() {
+    return this.taskGetter !== undefined;
+  }
+  setSessionComponent(sessionComponent) {
+    this.sessionComponent = sessionComponent;
+    logger5.debug(`SessionComponent injected for plugin ${this.name} (sourceId=${this.sourceId})`);
+  }
+  hasSessionComponent() {
+    return this.sessionComponent !== undefined;
+  }
+  async execute(ctx) {
+    if (process.env.ROY_HOOK_DEBUG === "1") {
+      console.error(`[DEBUG per-task-group-chat.execute] ENTER hookPoint=${ctx.hookPoint} pluginName=${this.pluginName} sourceId=${this.sourceId}`);
+    }
+    if (!this.config.enabled) {
+      if (process.env.ROY_HOOK_DEBUG === "1") {
+        console.error(`[DEBUG per-task-group-chat.execute] → SKIP (config.enabled=false)`);
+      }
+      logger5.debug(`execute: plugin disabled (pluginName=${this.pluginName})`);
+      return;
+    }
+    if (this.pluginName && this.sourceId) {
+      const env = getEnvContextOrEmpty();
+      const key = `${this.sourceId}:${this.pluginName}`;
+      if (process.env.ROY_HOOK_DEBUG === "1") {
+        console.error(`[DEBUG per-task-group-chat.execute] check pluginEnabled key=${key} env.pluginEnabled=${JSON.stringify(env.pluginEnabled)}`);
+      }
+      if (env.pluginEnabled && env.pluginEnabled[key] !== true) {
+        if (process.env.ROY_HOOK_DEBUG === "1") {
+          console.error(`[DEBUG per-task-group-chat.execute] → SKIP (plugin NOT enabled for ${key})`);
+        }
+        logger5.debug(`execute[${this.pluginName}]: plugin NOT enabled (key=${key}, ` + `env.pluginEnabled=${JSON.stringify(env.pluginEnabled)}, ` + `hookPoint=${ctx.hookPoint}). ` + `→ skip. 修复：roy-agent eventsource update <id> 必须包含 PerTaskGroupChatPlugin`);
+        return;
+      }
+      const enabledState = env.pluginEnabled ? env.pluginEnabled[key] === true ? "✅ enabled" : "❌ NOT enabled" : "⚠️  env.pluginEnabled 未设置 (env 没创建 / 插件未注册到 eventsource)";
+      logger5.debug(`execute[${this.pluginName}]: ${enabledState} (key=${key}, ` + `hookPoint=${ctx.hookPoint}, taskUpdaterInjected=${this.hasTaskUpdater()})`);
+    } else {
+      logger5.debug(`execute[${this.pluginName}]: missing pluginName/sourceId metadata ` + `(pluginName=${this.pluginName}, sourceId=${this.sourceId}), ` + `skipping pluginEnabled check. hookPoint=${ctx.hookPoint}`);
+    }
+    if (process.env.ROY_HOOK_DEBUG === "1") {
+      console.error(`[DEBUG per-task-group-chat.execute] → PASSED pluginEnabled check, will dispatch hookPoint=${ctx.hookPoint}`);
+    }
+    switch (ctx.hookPoint) {
+      case TaskHookPoints.AFTER_CREATE:
+        await this.onAfterCreate(ctx);
+        break;
+      case TaskHookPoints.AFTER_UPDATE:
+        await this.onAfterUpdate(ctx);
+        break;
+      case TaskHookPoints.OPERATION_AFTER_CREATE:
+        await this.onAfterOperationCreate(ctx);
+        break;
+      case TaskHookPoints.AFTER_COMPLETE:
+        await this.onAfterComplete(ctx);
+        break;
+      default:
+        logger5.debug(`execute: unhandled hookPoint=${ctx.hookPoint}, skip`);
+    }
+  }
+  async onAfterCreate(ctx) {
+    const data = ctx.data;
+    if (!data?.task) {
+      logger5.debug("onAfterCreate: task is missing, skip");
+      return;
+    }
+    const { task } = data;
+    if (process.env.ROY_HOOK_DEBUG === "1") {
+      const env = getEnvContextOrEmpty();
+      console.error(`[DEBUG per-task-group-chat.onAfterCreate] task=#${task.id} title="${task.title}" parent_task_id=${task.parent_task_id ?? "none"}`);
+      console.error(`[DEBUG per-task-group-chat.onAfterCreate] env.replyChannel=${JSON.stringify(env.replyChannel)}`);
+      console.error(`[DEBUG per-task-group-chat.onAfterCreate] env.messageId=${env.messageId}`);
+      console.error(`[DEBUG per-task-group-chat.onAfterCreate] env.sourceId=${env.sourceId}`);
+    }
+    logger5.debug(`onAfterCreate[${this.pluginName}]: enter task=${task.id} "${task.title}" ` + `parent_task_id=${task.parent_task_id ?? "none"} ` + `requireReplyChannel=${this.config.requireReplyChannel} ` + `disableSubTaskSkip=${this.config.disableSubTaskSkip} ` + `sendWelcomeMessage=${this.config.sendWelcomeMessage}`);
+    const replyChannel = this.getReplyChannelFromCtx(ctx);
+    if (!replyChannel?.chatId && this.config.requireReplyChannel) {
+      logger5.debug(`onAfterCreate[${this.pluginName}]: no replyChannel.chatId for task #${task.id}, skip. ` + `修复：eventsource 收到 im.message.receive_v1 事件时 replyChannel 应有值；` + `或在 plugin config 设 requireReplyChannel=false 强制创建群聊（profile 降级到 fallbackProfile/无）`);
+      return;
+    }
+    if (!replyChannel?.chatId && !this.config.requireReplyChannel) {
+      logger5.debug(`onAfterCreate[${this.pluginName}]: no replyChannel but requireReplyChannel=false, ` + `proceeding with profile fallback (fallbackProfile="${this.config.fallbackProfile}")`);
+    }
+    if (this.isSubTask(task) && !this.config.disableSubTaskSkip) {
+      logger5.debug(`onAfterCreate[${this.pluginName}]: task #${task.id} is sub-task, ` + `skip group chat creation. 关闭方式：config.disableSubTaskSkip=true`);
+      return;
+    }
+    if (this.isSubTask(task) && this.config.disableSubTaskSkip) {
+      logger5.debug(`onAfterCreate[${this.pluginName}]: task #${task.id} is sub-task but ` + `disableSubTaskSkip=true, proceeding to create group chat`);
+    }
+    try {
+      const created = await this.ensureGroupChat(task, replyChannel);
+      if (!created?.chatId) {
+        logger5.error(`onAfterCreate[${this.pluginName}]: ensureGroupChat 未返回 chatId for task #${task.id}`);
+        if (!this.config.fallbackToMain) {
+          throw new Error(`per-task group chat unavailable for task #${task.id}`);
+        }
+        return;
+      }
+      logger5.info(`onAfterCreate[${this.pluginName}]: task #${task.id} → group ${created.chatId} ` + `(initial card owned by LarkCliTaskNotifyHook)`);
+    } catch (error) {
+      logger5.error(`onAfterCreate[${this.pluginName}]: group chat failed for task #${task.id}: ${error}`);
+      if (!this.config.fallbackToMain)
+        throw error;
+    }
+  }
+  async writeChatBinding(task, chatId, profile, status, errorMessage) {
+    if (!this.sessionComponent) {
+      if (isPluginDebugEnabled()) {
+        logger5.debug(`writeChatBinding[${this.pluginName}]: no sessionComponent injected, ` + `skip chat-task binding for chat ${chatId} (status=${status})`);
+      }
+      return;
+    }
+    try {
+      await this.sessionComponent.upsertChatTaskBinding({
+        chatId,
+        taskId: task.id,
+        profile,
+        status,
+        errorMessage: errorMessage ?? null
+      });
+    } catch (bindErr) {
+      logger5.warn(`writeChatBinding[${this.pluginName}]: failed to write chat-task binding for ` + `chat ${chatId} / task #${task.id} (status=${status}): ${bindErr}. ` + `群消息 handler 将无法自动注入 parentTaskId。`);
+    }
+  }
+  async onAfterUpdate(ctx) {
+    const data = ctx.data;
+    if (!data?.task) {
+      logger5.debug("onAfterUpdate: task is missing, skip");
+      return;
+    }
+    logger5.debug(`onAfterUpdate[${this.pluginName}]: task #${data.task.id} 卡片由 ` + `LarkCliTaskNotifyHook 负责（本插件不再 patch），skip`);
+  }
+  async onAfterOperationCreate(ctx) {
+    const data = ctx.data;
+    if (!data?.operation) {
+      logger5.debug("onAfterOperationCreate: operation is missing, skip");
+      return;
+    }
+    logger5.debug(`onAfterOperationCreate[${this.pluginName}]: operation #${data.operation.id} ` + `卡片由 LarkCliTaskNotifyHook 负责，skip`);
+  }
+  async onAfterComplete(ctx) {
+    const data = ctx.data;
+    if (!data?.task) {
+      logger5.debug("onAfterComplete: task is missing, skip");
+      return;
+    }
+    logger5.debug(`onAfterComplete[${this.pluginName}]: task #${data.task.id} 终态卡片由 ` + `LarkCliTaskNotifyHook 负责，skip`);
+  }
+  createGroupChat(opts) {
+    const args = this.buildCreateGroupChatArgs(opts);
+    if (isPluginDebugEnabled()) {
+      logger5.debug(`Creating group chat: lark-cli ${args.join(" ")}`);
+    }
+    return new Promise((resolve, reject) => {
+      const proc = spawn2("lark-cli", args, {
+        shell: false,
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+      let stdout = "";
+      let stderr = "";
+      proc.stdout?.on("data", (data) => {
+        stdout += data.toString();
+      });
+      proc.stderr?.on("data", (data) => {
+        stderr += data.toString();
+      });
+      proc.on("close", (code) => {
+        if (code !== 0) {
+          reject(new Error(`lark-cli +chat-create exited with code ${code}: ${stderr}`));
+          return;
+        }
+        const chatId = this.parseChatId(stdout);
+        if (!chatId) {
+          reject(new Error(`lark-cli +chat-create did not return chat_id: ${stdout}`));
+          return;
+        }
+        resolve(chatId);
+      });
+      proc.on("error", (error) => {
+        reject(error);
+      });
+    });
+  }
+  buildCreateGroupChatArgs(opts) {
+    const nameTrimmed = this.truncate(opts.name, 60);
+    const descriptionTrimmed = this.truncate(opts.description, 100);
+    const args = [
+      "im",
+      "+chat-create",
+      "--name",
+      nameTrimmed,
+      "--description",
+      descriptionTrimmed
+    ];
+    if (opts.profile) {
+      args.push("--as", "bot");
+    }
+    if (opts.botAppIds.length > 0) {
+      args.push("--bots", opts.botAppIds.join(","));
+      args.push("--set-bot-manager");
+    }
+    if (opts.userIds && opts.userIds.length > 0) {
+      args.push("--users", opts.userIds.join(","));
+    }
+    if (opts.profile) {
+      args.unshift("--profile", opts.profile);
+    }
+    return args;
+  }
+  async attachChatIdToTask(task, chatId, profile) {
+    const contextStr = task.context ?? "{}";
+    let parsed = {};
+    try {
+      const obj = JSON.parse(contextStr);
+      if (obj && typeof obj === "object" && !Array.isArray(obj)) {
+        parsed = obj;
+      }
+    } catch {
+      parsed = {};
+    }
+    parsed[CTX_FIELD_CHAT_ID2] = chatId;
+    parsed[CTX_FIELD_CHAT_PROFILE2] = profile;
+    parsed[CTX_FIELD_CHAT_CREATED_AT] = new Date().toISOString();
+    parsed[CTX_FIELD_CHAT_TASK_ID] = task.id;
+    const newContext = JSON.stringify(parsed);
+    if (!this.taskUpdater) {
+      logger5.warn(`attachChatIdToTask[${this.pluginName}]: ⚠️  no taskUpdater injected, ` + `chat_id ${chatId} NOT persisted to db for task #${task.id}. ` + `后果：下次 AFTER_UPDATE 从 DB 加载 task 时 getTaskChatId() 返回 undefined，` + `所有 update/complete/operation 通知 silently 丢失。` + `修复：event-source-handlers.ts:registerPluginHooks 应自动注入 setTaskUpdater。`);
+      task.context = newContext;
+      return;
+    }
+    try {
+      await this.taskUpdater(task.id, newContext);
+      task.context = newContext;
+      logger5.debug(`attachChatIdToTask[${this.pluginName}]: ✅ persisted chat_id ${chatId} ` + `to task #${task.id} context`);
+    } catch (error) {
+      logger5.error(`Failed to persist chat_id to task #${task.id}: ${error}`);
+      task.context = newContext;
+    }
+  }
+  getReplyChannelFromCtx(ctx) {
+    const metadata = ctx.metadata;
+    const alsEnv = getEnvContextOrEmpty();
+    if (alsEnv.replyChannel?.chatId) {
+      return alsEnv.replyChannel;
+    }
+    if (!metadata)
+      return;
+    const envCtx = metadata.envContext;
+    if (envCtx?.replyChannel?.chatId) {
+      return envCtx.replyChannel;
+    }
+    const direct = metadata.replyChannel;
+    if (direct?.chatId) {
+      return direct;
+    }
+    return;
+  }
+  parseChatIdFromContext(ctxStr) {
+    if (!ctxStr)
+      return;
+    try {
+      const obj = JSON.parse(ctxStr);
+      const id = obj[CTX_FIELD_CHAT_ID2];
+      return typeof id === "string" ? id : undefined;
+    } catch {
+      return;
+    }
+  }
+  parseProfileFromContext(ctxStr) {
+    if (!ctxStr)
+      return;
+    try {
+      const obj = JSON.parse(ctxStr);
+      const profile = obj[CTX_FIELD_CHAT_PROFILE2];
+      return typeof profile === "string" ? profile : undefined;
+    } catch {
+      return;
+    }
+  }
+  getTaskChatId(task) {
+    return this.parseChatIdFromContext(task.context);
+  }
+  getTaskChatProfile(task) {
+    return this.parseProfileFromContext(task.context);
+  }
+  async resolveEffectiveChat(task) {
+    const ownChatId = this.getTaskChatId(task);
+    if (ownChatId) {
+      return { chatId: ownChatId, profile: this.getTaskChatProfile(task) };
+    }
+    if (!this.taskGetter)
+      return {};
+    const seen = new Set;
+    let id = task.parent_task_id;
+    while (typeof id === "number" && id > 0 && !seen.has(id) && seen.size < 8) {
+      seen.add(id);
+      let parent;
+      try {
+        parent = await this.taskGetter(id);
+      } catch {
+        return {};
+      }
+      if (!parent)
+        return {};
+      const chatId = this.parseChatIdFromContext(parent.context);
+      if (chatId) {
+        return { chatId, profile: this.parseProfileFromContext(parent.context) };
+      }
+      id = parent.parent_task_id ?? undefined;
+    }
+    if (this.config.resolveToTriggerChatFallback) {
+      const store = getSharedEventStore();
+      const triggerEventId = getEnvContextOrEmpty()?.envEvent?.metadata?.triggerEventId;
+      if (store && typeof triggerEventId === "string" && triggerEventId.length > 0) {
+        try {
+          const triggerEvent = await store.getEventById(triggerEventId);
+          const fallbackChatId = triggerEvent?.metadata?.chatId ?? triggerEvent?.metadata?.replyChannel?.chatId;
+          if (fallbackChatId) {
+            return {
+              chatId: fallbackChatId,
+              profile: triggerEvent?.metadata?.profile ?? triggerEvent?.metadata?.replyChannel?.profile
+            };
+          }
+        } catch {}
+      }
+    }
+    return {};
+  }
+  resolveBotAppIds(replyChannel) {
+    if (this.config.botAppIds.length > 0) {
+      logger5.debug(`resolveBotAppIds[${this.pluginName}]: using config.botAppIds=${JSON.stringify(this.config.botAppIds)}`);
+      return this.config.botAppIds;
+    }
+    const appId = replyChannel ? replyChannel.appId : undefined;
+    if (appId) {
+      logger5.debug(`resolveBotAppIds[${this.pluginName}]: using replyChannel.appId=${appId} (auto-detected from event header.app_id)`);
+      return [appId];
+    }
+    logger5.warn(`resolveBotAppIds[${this.pluginName}]: ⚠️ no botAppIds found, creating group WITHOUT --bots. ` + `Bot will NOT be invited automatically. ` + `可能原因：(1) eventsource 没有收到 im.message.receive_v1 事件（replyChannel.appId 缺失）；` + `(2) 配置了 requireReplyChannel=false 模式；` + `(3) buildReplyChannel 没透传 appId（应在 v1.10+ 修复）。` + `修复：手动设置 config.botAppIds: ["cli_xxx"] 或确认 eventsource 处理了 lark event。`);
+    return [];
+  }
+  resolveUserIds(replyChannel) {
+    const ids = new Set;
+    if (this.config.defaultInviteUserIds && this.config.defaultInviteUserIds.length > 0) {
+      for (const id of this.config.defaultInviteUserIds) {
+        if (id && id !== "sender" && id.startsWith("ou_")) {
+          ids.add(id);
+        } else if (id && id !== "sender") {
+          logger5.debug(`resolveUserIds[${this.pluginName}]: skip non-open_id in defaultInviteUserIds: "${id}"`);
+        }
+      }
+    }
+    if (this.config.inviteUserIds && this.config.inviteUserIds.length > 0) {
+      for (const id of this.config.inviteUserIds) {
+        if (id !== "sender" && id)
+          ids.add(id);
+      }
+    }
+    if (this.config.inviteUserIds?.includes("sender")) {
+      const senderId = replyChannel?.userId || replyChannel?.params?.userId || getEnvContextOrEmpty().userId;
+      if (senderId && senderId.startsWith("ou_")) {
+        ids.add(senderId);
+      }
+    }
+    if (ids.size === 0 && this.config.inviteUserIds?.includes("sender")) {
+      const alsUserId = getEnvContextOrEmpty().userId;
+      if (alsUserId && alsUserId.startsWith("ou_")) {
+        ids.add(alsUserId);
+      }
+    }
+    if (isPluginDebugEnabled()) {
+      logger5.debug(`resolveUserIds[${this.pluginName}]: ` + `defaultInviteUserIds=${JSON.stringify(this.config.defaultInviteUserIds)} ` + `inviteUserIds=${JSON.stringify(this.config.inviteUserIds)} ` + `replyChannel.userId=${replyChannel?.userId ?? "(none)"} ` + `→ final userIds=${JSON.stringify(Array.from(ids))}`);
+    }
+    return Array.from(ids);
+  }
+  isSubTask(task) {
+    const parentId = task.parent_task_id;
+    return typeof parentId === "number" && parentId > 0;
+  }
+  hasMeaningfulChange(changes) {
+    if (!changes || Object.keys(changes).length === 0)
+      return false;
+    const keys = Object.keys(changes);
+    return keys.some((k) => [
+      "status",
+      "progress",
+      "priority",
+      "title",
+      "description",
+      "current_status",
+      "tags",
+      "goals_and_expected_deliverables"
+    ].includes(k));
+  }
+  shouldThrottleOperation(operation) {
+    if (this.config.operationThrottleMs <= 0)
+      return false;
+    const taskId = operation.taskId ?? operation.task_id ?? 0;
+    if (taskId === 0)
+      return false;
+    const now = Date.now();
+    const last = this.lastNotifyTimestamps.get(taskId) ?? 0;
+    if (now - last < this.config.operationThrottleMs) {
+      return true;
+    }
+    this.lastNotifyTimestamps.set(taskId, now);
+    return false;
+  }
+  renderTemplate(template, task) {
+    const id = String(task.id);
+    const title = this.truncate(task.title ?? "", 60);
+    const projectPath = task.project_path ?? "";
+    return template.replace(/#\{id\}/g, id).replace(/(^|[^{]){id\}/g, `$1${id}`).replace(/#\{title\}/g, title).replace(/(^|[^{]){title\}/g, `$1${title}`).replace(/#\{project_path\}/g, projectPath).replace(/(^|[^{]){project_path\}/g, `$1${projectPath}`);
+  }
+  truncate(text, maxLen) {
+    if (!text)
+      return "";
+    if (text.length <= maxLen)
+      return text;
+    return text.substring(0, Math.max(0, maxLen - 3)) + "...";
+  }
+  parseChatId(stdout) {
+    if (!stdout)
+      return;
+    try {
+      const obj = JSON.parse(stdout.trim());
+      const data = obj.data;
+      if (data?.chat_id)
+        return data.chat_id;
+      if (data?.chatId)
+        return data.chatId;
+    } catch {}
+    const match = stdout.match(/oc_[a-zA-Z0-9]+/);
+    return match ? match[0] : undefined;
+  }
+}
+__legacyDecorateClassTS([
+  TracedAs("per-task-group-chat.ensureGroupChat", {
+    recordParams: true,
+    recordResult: true,
+    flattenParamFilter: true,
+    paramFilter: (args) => ({ taskId: args[0]?.id }),
+    resultFilter: (r) => ({ chatId: r?.chatId })
+  })
+], PerTaskGroupChatPlugin.prototype, "ensureGroupChat", null);
+__legacyDecorateClassTS([
+  TracedAs("per-task-group-chat.execute")
+], PerTaskGroupChatPlugin.prototype, "execute", null);
+__legacyDecorateClassTS([
+  TracedAs("per-task-group-chat.onAfterCreate", { recordParams: false })
+], PerTaskGroupChatPlugin.prototype, "onAfterCreate", null);
+__legacyDecorateClassTS([
+  TracedAs("per-task-group-chat.writeChatBinding", {
+    recordParams: true,
+    recordResult: false,
+    flattenParamFilter: true,
+    paramFilter: (args) => ({
+      taskId: args[0]?.id,
+      chatId: args[1],
+      status: args[3]
+    })
+  })
+], PerTaskGroupChatPlugin.prototype, "writeChatBinding", null);
+__legacyDecorateClassTS([
+  TracedAs("per-task-group-chat.onAfterUpdate", { recordParams: false })
+], PerTaskGroupChatPlugin.prototype, "onAfterUpdate", null);
+__legacyDecorateClassTS([
+  TracedAs("per-task-group-chat.onAfterOperationCreate", { recordParams: false })
+], PerTaskGroupChatPlugin.prototype, "onAfterOperationCreate", null);
+__legacyDecorateClassTS([
+  TracedAs("per-task-group-chat.onAfterComplete", { recordParams: false })
+], PerTaskGroupChatPlugin.prototype, "onAfterComplete", null);
+__legacyDecorateClassTS([
+  TracedAs("per-task-group-chat.createGroupChat", {
+    recordParams: true,
+    recordResult: true,
+    flattenParamFilter: true,
+    paramFilter: (args) => ({
+      profile: args[0]?.profile,
+      botAppIdsCount: args[0]?.botAppIds?.length,
+      userIdsCount: args[0]?.userIds?.length ?? 0,
+      userIds: args[0]?.userIds,
+      name: args[0]?.name,
+      description: args[0]?.description
+    }),
+    resultFilter: (r) => ({
+      chatId: r,
+      ok: !!r
+    })
+  })
+], PerTaskGroupChatPlugin.prototype, "createGroupChat", null);
+__legacyDecorateClassTS([
+  TracedAs("per-task-group-chat.buildCreateGroupChatArgs", {
+    recordParams: false,
+    recordResult: true,
+    flattenParamFilter: true,
+    paramFilter: (args) => ({
+      hasProfile: !!args[0]?.profile,
+      botAppIdsCount: args[0]?.botAppIds?.length,
+      hasUsers: !!args[0]?.userIds?.length
+    }),
+    resultFilter: (r) => ({
+      argsSummary: r.join(" "),
+      hasAsBot: r.includes("--as") && r[r.indexOf("--as") + 1] === "bot",
+      hasBots: r.includes("--bots"),
+      hasUsers: r.includes("--users")
+    })
+  })
+], PerTaskGroupChatPlugin.prototype, "buildCreateGroupChatArgs", null);
+__legacyDecorateClassTS([
+  TracedAs("per-task-group-chat.attachChatIdToTask", {
+    recordParams: false,
+    flattenParamFilter: true,
+    paramFilter: (args) => ({
+      taskId: args[0]?.id,
+      chatId: args[1],
+      profile: args[2],
+      taskUpdaterInjected: !!args[0] && !!args[0].context
+    })
+  })
+], PerTaskGroupChatPlugin.prototype, "attachChatIdToTask", null);
+function createPerTaskGroupChatPlugin(config = {}) {
+  return new PerTaskGroupChatPlugin(config);
+}
+export { createAutoTaskPlugin, WORKFLOW_EXTRACTOR_PROMPT, formatExtractorInput, formatExtractorInputFromDescription, parseExtractorOutput, TaskTagPlugin, mergeChatOwnership, NotifyType, LarkCliTaskNotifyHook, createLarkCliTaskNotifyHook, PerTaskGroupChatPlugin, createPerTaskGroupChatPlugin };