glab-agent 0.2.6 → 0.2.8

package/src/local-agent/watcher.ts

@@ -2,7 +2,7 @@ import { execFileSync } from "node:child_process";
 import { readFileSync } from "node:fs";
 import path from "node:path";
 
-import { AgentRunnerError, type AgentRunner } from "./agent-runner.js";
+import { AgentRunnerError, type AgentRunner, type SpawnedRun } from "./agent-runner.js";
 import type { AgentDefinition, AgentLabelConfig } from "./agent-config.js";
 import {
   loadAgentByName,
@@ -24,9 +24,9 @@ import { ClaudeRunner } from "./claude-runner.js";
 import { CodexRunner } from "./codex-runner.js";
 import { GitlabGlabClient } from "./gitlab-glab-client.js";
 import type { GitlabClient, GitlabIssue, GitlabTodoItem } from "./gitlab-glab-client.js";
-import { FileStateStore, rememberIds, appendRunHistory } from "./state-store.js";
+import { FileStateStore, rememberIds, appendRunHistory, addActiveRun, removeActiveRun } from "./state-store.js";
 import type { ActiveRunState, LocalAgentState, StateStore } from "./state-store.js";
-import { notifyAccepted, notifyCompleted, notifyFailed, sendWebhook } from "./notifier.js";
+import { notifyAccepted, notifyCompleted, notifyFailed, notifyQueued, sendWebhook } from "./notifier.js";
 import { appendMetric, metricsPath } from "./metrics.js";
 import { rotateIfNeeded } from "./log-rotate.js";
 
@@ -36,6 +36,7 @@ import type { WorktreeInfo } from "./worktree-manager.js";
 import { injectSkillFiles } from "./skill-inject.js";
 import { startHealthServer } from "./health-server.js";
 import type { HealthStatus } from "./health-server.js";
+import { FeishuClient, buildProgressCard } from "./feishu-client.js";
 
 const STATUS_LABELS_DEFAULT = [
   DEFAULT_LABELS.backlog,
@@ -47,6 +48,18 @@ const STATUS_LABELS_DEFAULT = [
 ];
 const ACCEPTED_TODO_ACTIONS = new Set(["mentioned", "directly_addressed"]);
 
+/** In-memory registry of spawned runs (only used when concurrency > 1) */
+const spawnedRuns = new Map<number, { // keyed by issueIid
+  run: SpawnedRun;
+  issue: GitlabIssue;
+  todo: GitlabTodoItem;
+  worktree: WorktreeInfo;
+  startedAt: string;
+  feishuMessageId?: string;
+  feishuOpenId?: string;
+  progressLines?: string[];
+}>();
+
 export interface LocalAgentConfig {
   gitlabHost: string;
   gitlabProjectId?: number;
@@ -63,6 +76,9 @@ export interface LocalAgentConfig {
   agentDefinition?: AgentDefinition;
   skillsDir?: string;
   webhookUrl?: string;
+  feishuAppId?: string;
+  feishuAppSecret?: string;
+  feishuEmailDomain?: string;
 }
 
 export interface ConfigResolutionOptions {
@@ -85,6 +101,8 @@ export interface WatcherDependencies {
   pid?: number;
   /** Override close-detection interval for testing (default: 60000ms) */
   issueCloseCheckIntervalMs?: number;
+  /** Feishu app client for targeted personal notifications */
+  feishuClient?: import("./feishu-client.js").FeishuClient;
 }
 
 export interface WatcherCycleResult {
@@ -284,6 +302,42 @@ export function formatBusyNote(
   return lines.join("\n");
 }
 
+/** Add emoji reaction to the todo's triggering note. Silent on failure. */
+async function addReactionToTodo(
+  client: GitlabClient,
+  todo: GitlabTodoItem,
+  emojiName: string,
+  logger?: Logger | typeof console
+): Promise<void> {
+  if (!todo.noteId || !todo.projectId) return;
+  try {
+    await client.addAwardEmoji(todo.projectId, todo.issueIid, todo.noteId, emojiName);
+  } catch (error) {
+    (logger as Logger | undefined)?.info?.(`Emoji reaction (${emojiName}) skipped: ${String(error).slice(0, 80)}`);
+  }
+}
+
+/** Remove a specific emoji from the todo's triggering note, replace with another. Silent on failure. */
+async function replaceReactionOnTodo(
+  client: GitlabClient,
+  todo: GitlabTodoItem,
+  removeEmoji: string,
+  addEmoji: string,
+  logger?: Logger | typeof console
+): Promise<void> {
+  if (!todo.noteId || !todo.projectId) return;
+  try {
+    const emojis = await client.listAwardEmoji(todo.projectId, todo.issueIid, todo.noteId);
+    const toRemove = emojis.find(e => e.name === removeEmoji);
+    if (toRemove) {
+      await client.removeAwardEmoji(todo.projectId, todo.issueIid, todo.noteId, toRemove.id);
+    }
+    await client.addAwardEmoji(todo.projectId, todo.issueIid, todo.noteId, addEmoji);
+  } catch (error) {
+    (logger as Logger | undefined)?.info?.(`Emoji replace (${removeEmoji}→${addEmoji}) skipped: ${String(error).slice(0, 80)}`);
+  }
+}
+
 export async function runWatcherCycle(
   config: LocalAgentConfig,
   dependencies: WatcherDependencies
@@ -485,8 +539,35 @@ export async function runWatcherCycle(
   }
 
   await updateAgentUserStatus(dependencies, "busy", `#${issue.iid}`);
-  await notifyAccepted(config.agentDefinition?.name ?? "agent", issue.iid, issue.title, config.webhookUrl);
+  await notifyAccepted(config.agentDefinition?.name ?? "agent", issue.iid, issue.title, issue.webUrl || undefined, config.webhookUrl);
+  await addReactionToTodo(dependencies.gitlabClient, candidate, "eyes", logger);
   logger.info(`Starting agent for issue #${issue.iid}: "${issue.title}" branch=${worktree.branch}`);
+
+  // Feishu: send accepted card to the @mention author (single-task path)
+  let singleTaskFeishuMsgId: string | undefined;
+  let singleTaskFeishuOpenId: string | undefined;
+  if (dependencies.feishuClient && candidate.authorUsername && config.feishuEmailDomain) {
+    try {
+      const email = `${candidate.authorUsername}@${config.feishuEmailDomain}`;
+      {
+        const openId = await dependencies.feishuClient.getUserByEmail(email);
+        if (openId) {
+          const card = buildProgressCard({
+            agentName: config.agentDefinition?.name ?? "agent",
+            issueIid: issue.iid,
+            issueTitle: issue.title,
+            issueUrl: issue.webUrl || undefined,
+            status: "accepted",
+          });
+          singleTaskFeishuMsgId = await dependencies.feishuClient.sendCard(openId, card);
+          singleTaskFeishuOpenId = openId;
+        }
+      }
+    } catch (e) {
+      logger.info?.(`Feishu card send skipped: ${String(e).slice(0, 100)}`);
+    }
+  }
+
   const agentStartTime = Date.now();
 
   const closeCheckIntervalMs = dependencies.issueCloseCheckIntervalMs ?? 60_000;
@@ -523,6 +604,20 @@ export async function runWatcherCycle(
         `⚠️ Issue 在处理过程中被关闭，agent 已停止工作。`
       );
       await updateAgentUserStatus(dependencies, "idle", undefined, config);
+      // Feishu: update card to failed state (issue closed)
+      if (dependencies.feishuClient && singleTaskFeishuMsgId) {
+        const card = buildProgressCard({
+          agentName: config.agentDefinition?.name ?? "agent",
+          issueIid: issue.iid,
+          issueTitle: issue.title,
+          issueUrl: issue.webUrl || undefined,
+          status: "failed",
+          summary: summary.slice(0, 300),
+          duration: `${durationSec}s`,
+        });
+        dependencies.feishuClient.updateCard(singleTaskFeishuMsgId, card).catch(() => {});
+      }
+      await replaceReactionOnTodo(dependencies.gitlabClient, candidate, "eyes", "x", logger);
       await finalizeTodo(config, dependencies, state, candidate, issue, {
         status: "failed",
         summary,
@@ -544,7 +639,24 @@ export async function runWatcherCycle(
     logger.info(`Agent completed issue #${issue.iid} in ${durationSec}s. Summary: ${result.summary.slice(0, 200)}`);
 
     // Agent manages labels and notes itself via glab api — watcher only handles lifecycle
-    await notifyCompleted(config.agentDefinition?.name ?? "agent", issue.iid, issue.title, undefined, config.webhookUrl);
+    // Look up MR URL for notification
+    const mr = issue.projectId ? await dependencies.gitlabClient.findMergeRequestByBranch(issue.projectId, worktree.branch).catch(() => undefined) : undefined;
+    await notifyCompleted(config.agentDefinition?.name ?? "agent", issue.iid, issue.title, mr?.webUrl || issue.webUrl || undefined, config.webhookUrl);
+    // Feishu: update card to completed state
+    if (dependencies.feishuClient && singleTaskFeishuMsgId) {
+      const card = buildProgressCard({
+        agentName: config.agentDefinition?.name ?? "agent",
+        issueIid: issue.iid,
+        issueTitle: issue.title,
+        issueUrl: issue.webUrl || undefined,
+        mrUrl: mr?.webUrl,
+        status: "completed",
+        summary: result.summary.slice(0, 300),
+        duration: `${durationSec}s`,
+      });
+      dependencies.feishuClient.updateCard(singleTaskFeishuMsgId, card).catch(() => {});
+    }
+    await replaceReactionOnTodo(dependencies.gitlabClient, candidate, "eyes", "white_check_mark", logger);
     await updateAgentUserStatus(dependencies, "idle", undefined, config);
     await finalizeTodo(config, dependencies, state, candidate, issue, {
       status: "completed",
@@ -578,6 +690,20 @@ export async function runWatcherCycle(
       `⚠️ Agent 执行失败。\n\n${summary}`
     );
     await notifyFailed(config.agentDefinition?.name ?? "agent", issue.iid, issue.title, summary, config.webhookUrl);
+    // Feishu: update card to failed state
+    if (dependencies.feishuClient && singleTaskFeishuMsgId) {
+      const card = buildProgressCard({
+        agentName: config.agentDefinition?.name ?? "agent",
+        issueIid: issue.iid,
+        issueTitle: issue.title,
+        issueUrl: issue.webUrl || undefined,
+        status: "failed",
+        summary: summary.slice(0, 300),
+        duration: `${durationSec}s`,
+      });
+      dependencies.feishuClient.updateCard(singleTaskFeishuMsgId, card).catch(() => {});
+    }
+    await replaceReactionOnTodo(dependencies.gitlabClient, candidate, "eyes", "x", logger);
     await updateAgentUserStatus(dependencies, "idle", undefined, config);
     await finalizeTodo(config, dependencies, state, candidate, issue, {
       status: "failed",
@@ -594,6 +720,316 @@ export async function runWatcherCycle(
   }
 }
 
+export async function runConcurrentWatcherCycle(
+  config: LocalAgentConfig,
+  dependencies: WatcherDependencies
+): Promise<WatcherCycleResult> {
+  const logger = dependencies.logger ?? console;
+  const state = await dependencies.stateStore.load();
+  const concurrency = config.agentDefinition?.concurrency ?? 1;
+
+  // 1. Collect finished tasks
+  for (const [issueIid, spawned] of spawnedRuns) {
+    const result = await spawned.run.poll();
+    if (!result) continue; // still running
+
+    spawnedRuns.delete(issueIid);
+    removeActiveRun(state, issueIid);
+
+    const durationSec = Math.round((Date.now() - new Date(spawned.startedAt).getTime()) / 1000);
+
+    if (result.error) {
+      // Failed
+      logger.error(`Agent failed issue #${issueIid} after ${durationSec}s. Error: ${result.error.slice(0, 200)}`);
+      try {
+        await dependencies.gitlabClient.updateIssueLabels(
+          spawned.issue.projectId, issueIid,
+          transitionStatusLabels(spawned.issue.labels, getLabelConfig(config).error, getStatusLabelsList(config))
+        );
+        await dependencies.gitlabClient.addIssueNote(
+          spawned.issue.projectId, issueIid,
+          `⚠️ Agent 执行失败。\n\n${result.summary}`
+        );
+      } catch (e) { logger.warn(`Post-run cleanup failed: ${String(e).slice(0, 100)}`); }
+      await notifyFailed(config.agentDefinition?.name ?? "agent", issueIid, spawned.issue.title, result.summary, config.webhookUrl);
+      // Feishu: update card to failed state
+      if (dependencies.feishuClient && spawned.feishuMessageId) {
+        const card = buildProgressCard({
+          agentName: config.agentDefinition?.name ?? "agent",
+          issueIid,
+          issueTitle: spawned.issue.title,
+          issueUrl: spawned.issue.webUrl || undefined,
+          status: "failed",
+          progressLines: spawned.progressLines,
+          summary: result.summary.slice(0, 300),
+          duration: `${durationSec}s`,
+        });
+        dependencies.feishuClient.updateCard(spawned.feishuMessageId, card).catch(() => {});
+      }
+      await replaceReactionOnTodo(dependencies.gitlabClient, spawned.todo, "eyes", "x", logger);
+      await finalizeTodo(config, dependencies, state, spawned.todo, spawned.issue, {
+        status: "failed", summary: result.summary, branch: spawned.worktree.branch, worktreePath: spawned.worktree.worktreePath
+      });
+    } else {
+      // Completed
+      logger.info(`Agent completed issue #${issueIid} in ${durationSec}s. Summary: ${result.summary.slice(0, 200)}`);
+      const mr = spawned.issue.projectId ? await dependencies.gitlabClient.findMergeRequestByBranch(spawned.issue.projectId, spawned.worktree.branch).catch(() => undefined) : undefined;
+      await notifyCompleted(config.agentDefinition?.name ?? "agent", issueIid, spawned.issue.title, mr?.webUrl || spawned.issue.webUrl || undefined, config.webhookUrl);
+      // Feishu: update card to completed state
+      if (dependencies.feishuClient && spawned.feishuMessageId) {
+        const card = buildProgressCard({
+          agentName: config.agentDefinition?.name ?? "agent",
+          issueIid,
+          issueTitle: spawned.issue.title,
+          issueUrl: spawned.issue.webUrl || undefined,
+          mrUrl: mr?.webUrl,
+          status: "completed",
+          progressLines: spawned.progressLines,
+          summary: result.summary.slice(0, 300),
+          duration: `${durationSec}s`,
+        });
+        dependencies.feishuClient.updateCard(spawned.feishuMessageId, card).catch(() => {});
+      }
+      await replaceReactionOnTodo(dependencies.gitlabClient, spawned.todo, "eyes", "white_check_mark", logger);
+      await finalizeTodo(config, dependencies, state, spawned.todo, spawned.issue, {
+        status: "completed", summary: result.summary, branch: spawned.worktree.branch, worktreePath: spawned.worktree.worktreePath
+      });
+    }
+  }
+
+  // 2. Start new tasks if capacity available
+  const activeCount = spawnedRuns.size;
+  if (activeCount >= concurrency) {
+    // At capacity — handle busy notifications
+    logger.info(`All ${concurrency} slots busy (${Array.from(spawnedRuns.keys()).map(i => `#${i}`).join(", ")}).`);
+    // Update status to show all active issues
+    const activeIids = Array.from(spawnedRuns.keys());
+    const statusMsg = activeIids.length === 1
+      ? `#${activeIids[0]}`
+      : `${activeIids.length} issues (${activeIids.map(i => `#${i}`).join(", ")})`;
+    await updateAgentUserStatus(dependencies, "busy", statusMsg);
+    await notifyPendingTodosWhileBusy(config, dependencies, state);
+    await dependencies.stateStore.save(state);
+    return { status: "busy", issueIid: activeIids[0] };
+  }
+
+  // Poll todos
+  const todos = config.gitlabProjectIdExplicit && config.gitlabProjectId
+    ? await dependencies.gitlabClient.listPendingTodos(config.gitlabProjectId)
+    : await dependencies.gitlabClient.listAllPendingTodos();
+  logger.info(`Polled ${todos.length} pending todo(s). Active: ${activeCount}/${concurrency}`);
+
+  const triggers = config.agentDefinition?.triggers;
+  const triggerActions = triggers ? new Set(triggers.actions) : undefined;
+
+  // Try to fill remaining slots
+  let started = 0;
+  const processedInThisCycle = new Set<number>();
+
+  while (spawnedRuns.size < concurrency) {
+    // Filter out todos for issues already being worked on
+    const activeIssueIids = new Set(spawnedRuns.keys());
+    const candidate = pickNextTodo(todos, state, triggerActions, logger, activeIssueIids, processedInThisCycle);
+    if (!candidate) break;
+    processedInThisCycle.add(candidate.id);
+
+    // Skip MR todos and contextual replies in concurrent mode — handle them synchronously
+    const isIssueTodo = candidate.targetType === "Issue";
+    if (!isIssueTodo) {
+      // Mark as processed, skip for now (MR handling stays synchronous)
+      state.processedTodoIds = rememberIds(state.processedTodoIds, candidate.id);
+      try { await dependencies.gitlabClient.markTodoDone(candidate.id); } catch { /* silent */ }
+      continue;
+    }
+
+    const issue = await dependencies.gitlabClient.getIssue(candidate.projectId, candidate.issueIid);
+
+    // Check mention type — contextual replies still run synchronously
+    const mentionType = classifyMention(candidate.body ?? "", issue.title, issue.labels, issue.description);
+    if (mentionType === "contextual" && dependencies.agentRunner.runContextual) {
+      // Run contextual reply synchronously (quick, non-blocking conceptually)
+      try {
+        await dependencies.agentRunner.runContextual(issue, candidate.body ?? "", { todoId: candidate.id });
+        logger.info(`Contextual reply completed for #${issue.iid}`);
+      } catch (e) { logger.warn(`Contextual reply failed: ${String(e).slice(0, 100)}`); }
+      state.processedTodoIds = rememberIds(state.processedTodoIds, candidate.id);
+      try { await dependencies.gitlabClient.markTodoDone(candidate.id); } catch { /* silent */ }
+      continue;
+    }
+
+    // Label trigger check
+    if (triggers && !matchesTriggerLabels(issue.labels, triggers.labels, triggers.exclude_labels)) {
+      logger.info(`Issue #${issue.iid} does not match trigger labels, skipping.`);
+      continue;
+    }
+
+    // Ensure spawn() is available
+    if (!dependencies.agentRunner.spawn) {
+      logger.warn(`AgentRunner does not support spawn(), falling back to single-task mode.`);
+      break;
+    }
+
+    // Prepare and spawn
+    const worktree = await dependencies.worktreeManager.ensureWorktree(issue.iid, issue.title);
+
+    const skills = config.agentDefinition?.skills ?? [];
+    if (skills.length > 0) {
+      try {
+        const injected = await injectSkillFiles(worktree.worktreePath, config.agentProvider, skills, config.skillsDir);
+        logger.info(`Injected ${injected} skill file(s) for #${issue.iid}.`);
+      } catch (err) { logger.warn(`Failed to inject skill files: ${String(err)}`); }
+    }
+
+    const spawnedRun = await dependencies.agentRunner.spawn(issue, worktree, { todoId: candidate.id });
+    const now = new Date().toISOString();
+
+    spawnedRuns.set(issue.iid, {
+      run: spawnedRun,
+      issue,
+      todo: candidate,
+      worktree,
+      startedAt: now,
+    });
+
+    // Feishu: send accepted card to the @mention author
+    if (dependencies.feishuClient && candidate.authorUsername && config.feishuEmailDomain) {
+      try {
+        const email = `${candidate.authorUsername}@${config.feishuEmailDomain}`;
+        {
+          const openId = await dependencies.feishuClient.getUserByEmail(email);
+          if (openId) {
+            const card = buildProgressCard({
+              agentName: config.agentDefinition?.name ?? "agent",
+              issueIid: issue.iid,
+              issueTitle: issue.title,
+              issueUrl: issue.webUrl || undefined,
+              status: "accepted",
+            });
+            const msgId = await dependencies.feishuClient.sendCard(openId, card);
+            const entry = spawnedRuns.get(issue.iid);
+            if (entry && msgId) {
+              entry.feishuMessageId = msgId;
+              entry.feishuOpenId = openId;
+            }
+          }
+        }
+      } catch (e) {
+        logger.info?.(`Feishu card send skipped: ${String(e).slice(0, 100)}`);
+      }
+    }
+
+    // Set up progress callback for webhook and/or feishu card updates
+    if ((config.webhookUrl || dependencies.feishuClient) && spawnedRun.onProgress !== undefined) {
+      const agentName = config.agentDefinition?.name ?? "agent";
+      const issueRef = `#${issue.iid}`;
+      const capturedIssueIid = issue.iid;
+      let lastProgressAt = 0;
+      const THROTTLE_MS = 15_000; // Max one progress update per 15s
+      let pendingReads: string[] = [];
+
+      spawnedRun.onProgress = (event) => {
+        const now2 = Date.now();
+
+        // Accumulate reads, flush every 3 or on throttle
+        if (event.type === "tool_use" && event.tool === "Read") {
+          pendingReads.push(event.detail ?? "");
+          if (pendingReads.length < 3 && now2 - lastProgressAt < THROTTLE_MS) return;
+        }
+
+        // Throttle non-read events
+        if (now2 - lastProgressAt < THROTTLE_MS && event.type !== "tool_use") return;
+
+        let message = "";
+        if (pendingReads.length > 0) {
+          message = `\u{1F4D6} 阅读 ${pendingReads.join(", ")}`;
+          pendingReads = [];
+        } else if (event.type === "tool_use") {
+          const icon = event.tool === "Edit" || event.tool === "Write" ? "\u270F\uFE0F"
+            : event.tool === "Bash" ? "\u{1F527}"
+            : event.tool === "Grep" || event.tool === "Glob" ? "\u{1F50D}"
+            : "\u{1F4CE}";
+          message = `${icon} ${event.tool}: ${event.detail ?? ""}`;
+        } else if (event.type === "text") {
+          message = event.detail?.slice(0, 100) ?? "";
+        }
+
+        if (!message) return;
+        lastProgressAt = now2;
+
+        const spawnedEntry = spawnedRuns.get(capturedIssueIid);
+
+        // Feishu card update (preferred when available)
+        if (dependencies.feishuClient && spawnedEntry?.feishuMessageId) {
+          if (!spawnedEntry.progressLines) spawnedEntry.progressLines = [];
+          spawnedEntry.progressLines.push(message);
+          // Keep last 20 lines to avoid card getting too long
+          if (spawnedEntry.progressLines.length > 20) {
+            spawnedEntry.progressLines = spawnedEntry.progressLines.slice(-20);
+          }
+          const elapsedSec = Math.round((Date.now() - new Date(spawnedEntry.startedAt).getTime()) / 1000);
+          const card = buildProgressCard({
+            agentName,
+            issueIid: capturedIssueIid,
+            issueTitle: spawnedEntry.issue.title,
+            issueUrl: spawnedEntry.issue.webUrl || undefined,
+            status: "running",
+            progressLines: spawnedEntry.progressLines,
+            duration: `${elapsedSec}s`,
+          });
+          dependencies.feishuClient.updateCard(spawnedEntry.feishuMessageId, card).catch(() => {});
+        } else if (config.webhookUrl) {
+          // Fallback to webhook when Feishu is not configured
+          sendWebhook(config.webhookUrl, {
+            title: `\u{1F527} ${agentName} ${issueRef}`,
+            message,
+            status: "accepted",
+          }).catch(() => {});
+        }
+      };
+    }
+
+    addActiveRun(state, {
+      pid: spawnedRun.pid,
+      todoId: candidate.id,
+      issueId: issue.id,
+      issueIid: issue.iid,
+      projectId: issue.projectId,
+      worktreePath: worktree.worktreePath,
+      branch: worktree.branch,
+      startedAt: now,
+    });
+
+    state.notifiedBusyTodoIds = rememberIds(state.notifiedBusyTodoIds, candidate.id);
+    await notifyAccepted(config.agentDefinition?.name ?? "agent", issue.iid, issue.title, issue.webUrl || undefined, config.webhookUrl);
+    await addReactionToTodo(dependencies.gitlabClient, candidate, "eyes", logger);
+    logger.info(`Spawned agent for issue #${issue.iid}: "${issue.title}" (PID ${spawnedRun.pid})`);
+    started++;
+  }
+
+  // Update status
+  if (spawnedRuns.size > 0) {
+    const activeIids = Array.from(spawnedRuns.keys());
+    const activeStatusMsg = activeIids.length === 1
+      ? `#${activeIids[0]}`
+      : `${activeIids.length} issues (${activeIids.map(i => `#${i}`).join(", ")})`;
+    await updateAgentUserStatus(dependencies, "busy", activeStatusMsg);
+  } else {
+    await updateAgentUserStatus(dependencies, "idle", undefined, config);
+  }
+
+  state.lastRun = {
+    status: spawnedRuns.size > 0 ? "running" : "idle",
+    at: new Date().toISOString(),
+    summary: started > 0 ? `Started ${started} new task(s). Active: ${spawnedRuns.size}` : `Active: ${spawnedRuns.size}`
+  };
+  await dependencies.stateStore.save(state);
+
+  return {
+    status: spawnedRuns.size > 0 ? "busy" : "idle",
+    issueIid: spawnedRuns.size > 0 ? Array.from(spawnedRuns.keys())[0] : undefined
+  };
+}
+
 async function finalizeTodo(
   _config: LocalAgentConfig,
   dependencies: WatcherDependencies,
@@ -737,8 +1173,17 @@ async function updateAgentUserStatus(
   try {
     switch (status) {
       case "idle": {
-        const msg = truncateMessage(`Ready${buildSkillsSuffix(config)}`);
-        await dependencies.gitlabClient.updateUserStatus("white_check_mark", msg, "not_set");
+        let idleMsg: string;
+        if (config?.agentDefinition?.description) {
+          // P1: Agent = 员工 — show agent description as identity
+          idleMsg = `Ready | ${config.agentDefinition.description}`;
+          if (idleMsg.length > 100) {
+            idleMsg = idleMsg.slice(0, 97) + "...";
+          }
+        } else {
+          idleMsg = truncateMessage(`Ready${buildSkillsSuffix(config)}`);
+        }
+        await dependencies.gitlabClient.updateUserStatus("white_check_mark", idleMsg, "not_set");
         break;
       }
       case "busy":
@@ -1020,6 +1465,7 @@ async function notifyPendingTodosWhileBusy(
       const position = pendingUnprocessed.indexOf(todo) + 1;
       const note = formatBusyNote(config.agentProvider, activeRun, position, pendingUnprocessed.length);
       await dependencies.gitlabClient.addIssueNote(todo.projectId, todo.issueIid, note);
+      await notifyQueued(config.agentDefinition?.name ?? "agent", todo.issueIid, `#${todo.issueIid}`, position, todo.targetUrl, config.webhookUrl).catch(() => undefined);
       state.notifiedBusyTodoIds = rememberIds(state.notifiedBusyTodoIds, todo.id);
       stateChanged = true;
       logger.info(`Posted busy notification on issue #${todo.issueIid}.`);
@@ -1057,7 +1503,9 @@ function pickNextTodo(
   todos: GitlabTodoItem[],
   state: LocalAgentState,
   triggerActions?: Set<string>,
-  logger?: Logger | typeof console
+  logger?: Logger | typeof console,
+  activeIssueIids?: Set<number>,
+  skipTodoIds?: Set<number>
 ): GitlabTodoItem | undefined {
   const processedTodos = new Set(state.processedTodoIds);
   const acceptedActions = triggerActions ?? ACCEPTED_TODO_ACTIONS;
@@ -1077,6 +1525,15 @@ function pickNextTodo(
       return false;
     }
 
+    if (activeIssueIids?.has(todo.issueIid)) {
+      logger?.info?.(`Todo ${todo.id} (issue #${todo.issueIid}): skipped — already being processed`);
+      return false;
+    }
+
+    if (skipTodoIds?.has(todo.id)) {
+      return false;
+    }
+
     return true;
   });
 
@@ -1220,7 +1677,10 @@ export function loadConfigFromAgentDefinition(
     logPath: agentLogPath(agentRepoPath, def.name),
     agentDefinition: def,
     skillsDir: agentSkillsDir(agentRepoPath),
-    webhookUrl: def.notifications?.webhook_url
+    webhookUrl: def.notifications?.webhook_url,
+    feishuAppId: def.notifications?.feishu_app_id_env ? env[def.notifications.feishu_app_id_env]?.trim() : undefined,
+    feishuAppSecret: def.notifications?.feishu_app_secret_env ? env[def.notifications.feishu_app_secret_env]?.trim() : undefined,
+    feishuEmailDomain: def.notifications?.feishu_email_domain,
   };
 }
 
@@ -1329,6 +1789,15 @@ export async function main(argv: string[] = process.argv.slice(2)): Promise<void
   const logger = createLogger("watcher", agentName, logFormat);
   const dependencies = createDependencies(config, logger);
 
+  // Create FeishuClient if feishu app credentials are configured
+  if (config.feishuAppId && config.feishuAppSecret) {
+    dependencies.feishuClient = new FeishuClient({
+      appId: config.feishuAppId,
+      appSecret: config.feishuAppSecret,
+    });
+    logger.info("Feishu app client initialized for targeted personal notifications.");
+  }
+
   // Validate token at startup and fetch bot identity (hard fail if token is invalid)
   try {
     const botUser = await dependencies.gitlabClient.getCurrentUser();
@@ -1350,7 +1819,18 @@ export async function main(argv: string[] = process.argv.slice(2)): Promise<void
   logger.info(`Watcher started. mode=${mode} provider=${config.agentProvider} host=${config.gitlabHost}${config.gitlabProjectId ? ` project=${config.gitlabProjectId}${config.gitlabProjectIdExplicit ? "" : " (inferred, todo polling unfiltered)"}` : " project=auto (from todos)"}`);
 
   if (mode === "run-once") {
-    await runWatcherCycle(config, dependencies);
+    const concurrency = config.agentDefinition?.concurrency ?? 1;
+    if (concurrency > 1) {
+      // Run one concurrent cycle, then poll until all spawned tasks finish
+      await runConcurrentWatcherCycle(config, dependencies);
+      // Wait for spawned tasks to complete
+      while (spawnedRuns.size > 0) {
+        await sleep(2000);
+        await runConcurrentWatcherCycle(config, dependencies);
+      }
+    } else {
+      await runWatcherCycle(config, dependencies);
+    }
     return;
   }
 
@@ -1438,7 +1918,10 @@ export async function main(argv: string[] = process.argv.slice(2)): Promise<void
     }
 
     try {
-      const cycleResult = await runWatcherCycle(config, dependencies);
+      const concurrency = config.agentDefinition?.concurrency ?? 1;
+      const cycleResult = concurrency > 1
+        ? await runConcurrentWatcherCycle(config, dependencies)
+        : await runWatcherCycle(config, dependencies);
       circuitBreaker.recordSuccess();
       cycleCount++;
       healthState.cycleCount = cycleCount;
@@ -1456,7 +1939,8 @@ export async function main(argv: string[] = process.argv.slice(2)): Promise<void
           if (config.webhookUrl) {
             await sendWebhook(config.webhookUrl, {
               title: `⚠️ ${agentName} Token 可能已过期`,
-              message: `Token validation failed: ${tokenErrMsg.slice(0, 100)}`
+              message: `Token validation failed: ${tokenErrMsg.slice(0, 100)}`,
+              status: "failed"
             });
           }
           lastTokenCheckAt = Date.now(); // Don't spam notifications