@whyshu/argent-engine 0.7.5 → 0.7.7

package/engine/scripts/appointment_grab.py

@@ -8,11 +8,12 @@
 """
 import argparse
 import asyncio
+import time
 import json
 import os
+import signal
 import sys
-import time
-from datetime import date, datetime, timedelta
+from datetime import date, datetime, timedelta, timezone
 from pathlib import Path
 from types import SimpleNamespace
 
@@ -86,7 +87,48 @@ def load_task() -> dict:
 
 
 def iso_day(d) -> date:
-    return datetime.fromisoformat(str(d)[:10]).date()
+    # 任务日期由服务端按 Asia/Shanghai 00:00 存成 UTC（如 10/21 → 10/20T16:00Z）；按中国日期还原，
+    # ⛔ 不能用 str(d)[:10] 直接截 UTC，否则会整体早一天。
+    dt = datetime.fromisoformat(str(d).replace('Z', '+00:00'))
+    if dt.tzinfo is None:
+        dt = dt.replace(tzinfo=timezone.utc)
+    return dt.astimezone(timezone(timedelta(hours=8))).date()
+
+
+async def _close_appointment_tab(orch) -> int:
+    """停止/失败时关闭本任务用的预约标签页；若它是窗口最后 1 个标签，先开一个占位页再关。
+
+    紫鸟窗口守卫要求不能把最后标签关掉（会退出 Chromium 窗口、丢 CDP）。
+    这里用 about:blank 占位保持窗口存活，再关闭预约页，避免用户看到残留任务标签。
+    """
+    closed = 0
+    try:
+        page = getattr(orch.browser, 'page', None)
+        if page is None or page.is_closed():
+            return 0
+        url = str(getattr(page, 'url', '') or '')
+        # 只清理本任务/预约页，避免误关用户主门户标签
+        if ('appointment-v2' not in url) and (str(getattr(orch.state, 'shipment_id', '') or '') not in url):
+            return 0
+        ctx = page.context
+        if len(ctx.pages) <= 1:
+            try:
+                await ctx.new_page()   # 占位，保持窗口不退出
+            except Exception:
+                return 0
+        await page.close()
+        closed = 1
+        orch._log('  🗂️ 已关闭抢预约任务标签页（保留占位页，防窗口退出）')
+    except Exception as e:
+        try: orch._log(f'  ⚠️ 关闭预约标签页失败：{str(e)[:120]}')
+        except Exception: pass
+    return closed
+
+
+def _bump_page_check(orch) -> int:
+    n = int(getattr(orch, '_appt_page_checks', 0)) + 1
+    setattr(orch, '_appt_page_checks', n)
+    return n
 
 
 async def prepare_appointment_page(orch) -> None:
@@ -94,6 +136,7 @@ async def prepare_appointment_page(orch) -> None:
     last = None
     for attempt in range(3):
         try:
+            _bump_page_check(orch)
             await orch.browser.visit_plan_page('appointment-v2', orch.state.shipment_id, step=4)
             if await orch._has_existing_appointment():
                 raise RuntimeError('已有预约存在，不重复抢')
@@ -206,7 +249,24 @@ async def run_task(task: dict) -> dict:
     store = task.get('store') or ''
     if not store:
         return {'status': 'failed', 'summary': '任务缺少店铺'}
+    # 站别守卫：当前预约页/后台是墨西哥站（myaccount.mercadolibre.com.mx）专用。
+    # 巴西/阿根廷等非墨西哥店直接拒绝，避免拿墨西哥后台去找其他站货件。
+    try:
+        info, _dev = O._resolve_store(store)
+        platform = str((info or {}).get('platform') or '')
+    except Exception:
+        platform = ''
+    _pf = str(platform or '').lower()
+    is_mx = (not platform) or any(k in _pf for k in ('墨西哥', 'mexico', 'méxico', 'mlm', 'mercadolibre', 'mercado libre'))
+    if not is_mx:
+        return {'status': 'failed', 'summary': f'抢预约当前仅支持墨西哥站（MLM）；{store} 属于 {platform}，暂未适配，请勿执行'}
     date_mode = task.get('dateMode') or 'range'
+    weekdays = {int(x) for x in (task.get('weekdays') or []) if str(x).isdigit() and 1 <= int(x) <= 7}
+    time_from = str(task.get('timeFrom') or '').strip()
+    time_to = str(task.get('timeTo') or '').strip()
+
+    def weekday_allowed(d: date) -> bool:
+        return (not weekdays) or d.isoweekday() in weekdays
     from_date = iso_day(task['dateFrom']) if date_mode == 'range' else None
     to_date = iso_day(task['dateTo']) if date_mode == 'range' else None
     cfg = O.load_config()
@@ -242,6 +302,7 @@ async def run_task(task: dict) -> dict:
         cycle_no = 0
         last_states = {}
         while True:
+            cycle_started = time.monotonic()
             cycle_no += 1
             if date_mode == 'available_days':
                 need = int(task.get('availableDays') or 0)
@@ -249,18 +310,31 @@ async def run_task(task: dict) -> dict:
                 tomorrow = (today + timedelta(days=1)).isoformat()
                 states = {k: v for k, v in dict(scan['states']).items() if k >= tomorrow}
                 targets = [date.fromisoformat(x) for x in scan['selected']]
+                targets = [d for d in targets if weekday_allowed(d)]
                 if not targets:
-                    print(json.dumps({'event': 'cycle', 'cycle': cycle_no, 'dateStates': states, 'summary': '未发现可选日'}, ensure_ascii=False), flush=True)
+                    print(json.dumps({'event': 'cycle', 'cycle': cycle_no, 'checks': int(getattr(orch, '_appt_page_checks', 0)), 'dateStates': states, 'summary': '未发现可选日'}, ensure_ascii=False), flush=True)
                 for d in targets:
                     offset = (d - today).days
                     try:
+                        _bump_page_check(orch)
                         await orch.browser.visit_plan_page('appointment-v2', orch.state.shipment_id, step=4)
-                        await orch._book_appointment(hour_idx=0, date_offset=offset)
-                        states[d.isoformat()] = 'booked'
-                        return {'status': 'booked', 'date': d.isoformat(), 'slot': 'first', 'dateStates': states, 'summary': f'{d.isoformat()} 预约成功', 'windowMode': 'available_days'}
+                        # 与 FULL 步骤4、其他抢预约任务共用同店预约锁：只串行化“提交预约”，不占整个流程
+                        orch._acquire_store_step4_lock(force=True)
+                        try:
+                            await orch._book_appointment(hour_idx=0, date_offset=offset,
+                                                         time_from=time_from, time_to=time_to)
+                        finally:
+                            orch._release_store_step4_lock()
+                        actual = str(getattr(orch, '_last_booked_date', '') or d.isoformat())
+                        states[actual] = 'booked'
+                        slot = str(getattr(orch, '_last_booked_slot', '') or 'first')
+                        return {'status': 'booked', 'date': actual, 'slot': slot, 'dateStates': states, 'summary': f'{actual} {slot} 预约成功', 'windowMode': 'available_days'}
                     except Exception as exc:
                         msg = str(exc)
-                        if any(k in msg for k in ('可用时段不足', '未渲染出可选时段', '时间选择失败', '未写入日期时间')):
+                        if '不可选' in msg or '目标日期' in msg:
+                            states[d.isoformat()] = 'disabled'
+                        elif any(k in msg for k in ('可用时段不足', '未渲染出可选时段', '时间选择失败', '未写入日期时间',
+                                                     '指定时间范围内无可预约时段')):
                             states[d.isoformat()] = 'selectable_no_slot'
                         else:
                             states[d.isoformat()] = 'selectable_booking_failed'
@@ -269,41 +343,78 @@ async def run_task(task: dict) -> dict:
                 targets = []
                 d = max(from_date, today + timedelta(days=1))
                 while d <= to_date:
-                    targets.append(d); d += timedelta(days=1)
+                    if weekday_allowed(d):
+                        targets.append(d)
+                    d += timedelta(days=1)
                 if not targets:
-                    return {'status': 'failed', 'summary': '日期范围内没有可预约日期（今天及以前不算）'}
+                    return {'status': 'failed', 'summary': '日期范围内没有符合星期条件的可预约日期（今天及以前不算）'}
                 states = {d.isoformat(): 'pending' for d in targets}
+                # 2026-10-21：range 模式也改为**每轮只打开一次日历**。
+                # 先在同一页面上扫完本轮所有目标日期；只有日期可选时才进入预约。
+                # 旧实现每个日期都 prepare_appointment_page() 重新打开页面，导致
+                # 一轮 3 个日期产生 6~10 次页面检查（用户看到的“轮次对不上”根因）。
+                prepared = False
                 for d in targets:
                     offset = (d - today).days
                     try:
-                        await prepare_appointment_page(orch)
+                        if not prepared:
+                            await prepare_appointment_page(orch)
+                            prepared = True
                         info = await find_date_cell(orch, d)
                         if not info.get('found'):
-                            states[d.isoformat()] = 'date_not_found'; continue
+                            states[d.isoformat()] = 'date_not_found'
+                            print(json.dumps({'event': 'progress', 'cycle': cycle_no, 'checks': int(getattr(orch, '_appt_page_checks', 0)), 'dateStates': states}, ensure_ascii=False), flush=True)
+                            continue
                         if info.get('disabled'):
-                            states[d.isoformat()] = 'disabled'; continue
+                            states[d.isoformat()] = 'disabled'
+                            print(json.dumps({'event': 'progress', 'cycle': cycle_no, 'checks': int(getattr(orch, '_appt_page_checks', 0)), 'dateStates': states}, ensure_ascii=False), flush=True)
+                            continue
                     except Exception as exc:
+                        prepared = False
                         states[d.isoformat()] = 'page_error'
-                        orch._log(f'  ⚠️ {d} 分类失败: {str(exc)[:120]}'); continue
+                        orch._log(f'  ⚠️ {d} 分类失败: {str(exc)[:120]}')
+                        print(json.dumps({'event': 'progress', 'cycle': cycle_no, 'checks': int(getattr(orch, '_appt_page_checks', 0)), 'dateStates': states}, ensure_ascii=False), flush=True)
+                        continue
+                    print(json.dumps({'event': 'progress', 'cycle': cycle_no, 'checks': int(getattr(orch, '_appt_page_checks', 0)), 'dateStates': states}, ensure_ascii=False), flush=True)
                     try:
-                        await orch.browser.visit_plan_page('appointment-v2', orch.state.shipment_id, step=4)
-                        await orch._book_appointment(hour_idx=0, date_offset=offset)
+                        # 与 FULL 步骤4、其他抢预约任务共用同店预约锁：只串行化“提交预约”
+                        orch._acquire_store_step4_lock(force=True)
+                        try:
+                            # range 模式严格目标日期：只点运营给的日期，⛔ 不允许 _pick_date 跳到范围外
+                            await orch._book_appointment(hour_idx=0, date_offset=offset, exact_date=d.isoformat(),
+                                                         time_from=time_from, time_to=time_to)
+                        finally:
+                            orch._release_store_step4_lock()
+                        actual = str(getattr(orch, '_last_booked_date', '') or d.isoformat())
+                        if actual != d.isoformat():
+                            raise RuntimeError(f'严格日期校验失败：目标 {d.isoformat()}，实际页面选中 {actual}（不提交）')
                         states[d.isoformat()] = 'booked'
-                        return {'status': 'booked', 'date': d.isoformat(), 'slot': 'first', 'dateStates': states, 'summary': f'{d.isoformat()} 预约成功'}
+                        slot = str(getattr(orch, '_last_booked_slot', '') or 'first')
+                        return {'status': 'booked', 'date': actual, 'slot': slot, 'dateStates': states, 'summary': f'{actual} {slot} 预约成功'}
                     except Exception as exc:
+                        prepared = False
                         msg = str(exc)
-                        if any(k in msg for k in ('可用时段不足', '未渲染出可选时段', '时间选择失败', '未写入日期时间')):
+                        if '不可选' in msg or '目标日期' in msg:
+                            states[d.isoformat()] = 'disabled'
+                        elif any(k in msg for k in ('可用时段不足', '未渲染出可选时段', '时间选择失败', '未写入日期时间',
+                                                     '指定时间范围内无可预约时段')):
                             states[d.isoformat()] = 'selectable_no_slot'
                         else:
                             states[d.isoformat()] = 'selectable_booking_failed'
                         orch._log(f'  ⚠️ {d} 预约失败: {msg[:160]}')
             last_states = states
-            print(json.dumps({'event': 'cycle', 'cycle': cycle_no, 'dateStates': states}, ensure_ascii=False), flush=True)
+            print(json.dumps({'event': 'cycle', 'cycle': cycle_no, 'checks': int(getattr(orch, '_appt_page_checks', 0)), 'dateStates': states}, ensure_ascii=False), flush=True)
             if cycles and cycle_no >= cycles:
                 break
-            await asyncio.sleep(max(10, int(task.get('pollIntervalSec') or 60)))
+            interval = max(30, min(600, int(task.get('pollIntervalSec') or 30)))
+            elapsed = time.monotonic() - cycle_started
+            await asyncio.sleep(max(10, interval - elapsed))
         return {'status': 'failed', 'dateStates': last_states, 'cycles': cycle_no, 'summary': '本轮日期范围内未抢到预约'}
     finally:
+        try:
+            await _close_appointment_tab(orch)
+        except Exception:
+            pass
         try:
             await orch.browser.close()
         except Exception:
@@ -314,10 +425,20 @@ async def run_task(task: dict) -> dict:
             pass
 
 
+def _on_term(signum, frame):
+    # SIGTERM 默认直接退出，不会执行 run_task 的 finally ⇒ 预约标签页残留。
+    # 抛 KeyboardInterrupt 交给 asyncio.run 取消主任务，确保 finally 里的标签页清理执行。
+    raise KeyboardInterrupt
+
+
 def main():
     task = load_task()
+    signal.signal(signal.SIGTERM, _on_term)
+    signal.signal(signal.SIGINT, _on_term)
     try:
         out = asyncio.run(run_task(task))
+    except KeyboardInterrupt:
+        out = {'status': 'stopped', 'summary': '收到停止请求，已关闭预约标签页'}
     except Exception as exc:
         out = {'status': 'failed', 'summary': f'{type(exc).__name__}: {exc}'}
     print(json.dumps(out, ensure_ascii=False), flush=True)

package/engine/scripts/argent-machine-setup.mjs

@@ -0,0 +1,118 @@
+#!/usr/bin/env node
+/**
+ * 本机接入 ERP 机器执行面：从剪贴板读取 machine token → 校验 → 写入 agent-report.json。
+ *
+ * 用法（推荐，token 不进入聊天/命令行历史）：
+ *   node scripts/argent-machine-setup.mjs --check
+ *   node scripts/argent-machine-setup.mjs --from-clipboard
+ *
+ * 其他：
+ *   --config <path>     默认 ~/.dsh/argent/agent-report.json
+ *   --machine-id <id>   覆盖配置里的 machineId
+ *   --app-id <id>       覆盖配置里的 tenantAppId
+ *   --server <url>      覆盖配置里的 serverUrl
+ *   --token <jwt>       ⛔ 不推荐：会进入 shell 历史；仅调试用
+ *
+ * 红线：不打印 token；不改其他字段；写入前备份；配置文件 600。
+ */
+import { execFileSync } from 'node:child_process';
+import { existsSync, readFileSync, writeFileSync, chmodSync, copyFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join, resolve } from 'node:path';
+
+const args = process.argv.slice(2);
+const has = (name) => args.includes(name);
+const val = (name, fallback = '') => {
+  const i = args.indexOf(name);
+  return i >= 0 && args[i + 1] ? String(args[i + 1]) : fallback;
+};
+const CONFIG = resolve(val('--config', join(homedir(), '.dsh', 'argent', 'agent-report.json')));
+const CHECK = has('--check');
+const FROM_CLIPBOARD = has('--from-clipboard');
+const TOKEN_ARG = val('--token');
+
+function fail(message, code = 1) {
+  console.error(`❌ ${message}`);
+  process.exit(code);
+}
+function readConfig() {
+  if (!existsSync(CONFIG)) fail(`配置文件不存在：${CONFIG}`);
+  try { return JSON.parse(readFileSync(CONFIG, 'utf8')); } catch (e) { fail(`配置文件不是合法 JSON：${e.message}`); }
+}
+function clipboard() {
+  try {
+    if (process.platform === 'darwin') return execFileSync('pbpaste', [], { encoding: 'utf8' }).trim();
+    if (process.platform === 'win32') return execFileSync('powershell.exe', ['-NoProfile', '-Command', 'Get-Clipboard'], { encoding: 'utf8' }).trim();
+    try { return execFileSync('wl-paste', [], { encoding: 'utf8' }).trim(); } catch { /* try xclip */ }
+    return execFileSync('xclip', ['-selection', 'clipboard', '-o'], { encoding: 'utf8' }).trim();
+  } catch { fail('读取剪贴板失败；请确认已复制 token，或使用 --token（不推荐）'); }
+}
+function decodeJwt(token) {
+  const parts = String(token).split('.');
+  if (parts.length !== 3) fail('token 不是 JWT 格式');
+  try {
+    const payload = JSON.parse(Buffer.from(parts[1].replace(/-/g, '+').replace(/_/g, '/'), 'base64').toString('utf8'));
+    return payload;
+  } catch { fail('token payload 解析失败'); }
+}
+async function verify({ token, serverUrl, appId, machineId }) {
+  let res;
+  try {
+    res = await fetch(`${serverUrl.replace(/\/+$/, '')}/api/argent/v1/tenants/${encodeURIComponent(appId)}/machines/${encodeURIComponent(machineId)}/commands?limit=1`, {
+      headers: { authorization: `Bearer ${token}`, 'content-type': 'application/json' },
+    });
+  } catch (e) { fail(`无法连接 ERP：${e.message}`); }
+  if (res.status === 401) fail('token 无效或已过期');
+  if (res.status === 403) fail('token 与机器/租户不匹配，或机器已被吊销');
+  if (!res.ok) fail(`ERP 校验失败：HTTP ${res.status}`);
+}
+
+const cfg = readConfig();
+const machineId = String(val('--machine-id', cfg.machineId || '')).trim();
+const appId = String(val('--app-id', cfg.tenantAppId || '')).trim();
+const serverUrl = String(val('--server', cfg.serverUrl || 'https://whyshu.com')).replace(/\/+$/, '');
+if (!machineId || !appId || !serverUrl) fail('配置缺少 machineId / tenantAppId / serverUrl，请先用 --machine-id/--app-id/--server 补齐');
+
+let token = '';
+if (CHECK) {
+  token = String(cfg.machineToken || cfg.runnerToken || '').trim();
+  if (!token) fail('当前配置没有 machineToken/runnerToken');
+} else if (FROM_CLIPBOARD) {
+  token = clipboard();
+  if (!token) fail('剪贴板为空；请先在 ERP 复制新 token');
+} else if (TOKEN_ARG) {
+  token = String(TOKEN_ARG).trim();
+} else {
+  fail('请用 --from-clipboard（推荐）或 --token；详见脚本注释');
+}
+
+const claims = decodeJwt(token);
+if (claims.scope !== 'machine') fail(`token scope 不是 machine（实际：${claims.scope || '空'}）`);
+if (claims.appId && claims.appId !== appId) fail(`token appId=${claims.appId} 与配置 ${appId} 不一致`);
+if (claims.machineId && claims.machineId !== machineId) fail(`token machineId=${claims.machineId} 与配置 ${machineId} 不一致`);
+if (claims.exp && Number(claims.exp) * 1000 <= Date.now()) fail('token 已过期，请重新签发');
+
+await verify({ token, serverUrl, appId, machineId });
+if (CHECK) {
+  console.log(`✅ token 有效：${appId} / ${machineId}，配置无需修改`);
+  process.exit(0);
+}
+
+const backup = `${CONFIG}.bak-${new Date().toISOString().replace(/[:.]/g, '-')}`;
+try { copyFileSync(CONFIG, backup); } catch { /* 配置不存在时无需备份 */ }
+const next = {
+  ...cfg,
+  serverUrl,
+  tenantAppId: appId,
+  machineId,
+  machineToken: token,
+  enabled: true,
+  chatEnabled: true,
+};
+delete next.runnerToken;
+writeFileSync(CONFIG, `${JSON.stringify(next, null, 2)}\n`, { mode: 0o600 });
+chmodSync(CONFIG, 0o600);
+console.log(`✅ 已写入 ${CONFIG}（600）`);
+console.log(`✅ 已校验：${appId} / ${machineId}`);
+console.log(`📦 旧配置备份：${backup}`);
+console.log('下一步：手动重启本机 dsh（脚本不重启服务），然后在 ERP 确认机器在线。');

package/engine/scripts/argent-runner.mjs

@@ -61,6 +61,8 @@ function loadConfig() {
     leaseSec: Number(cfg.leaseSec) || 90,
     pollWaitMs: Number(cfg.pollWaitMs) || 20000,
     execTimeoutSec: Number(cfg.execTimeoutSec) || 900,
+    batchExecTimeoutSec: Number(process.env.ARGENT_RUNNER_BATCH_TIMEOUT_SEC || cfg.batchExecTimeoutSec) || 43200,
+    batchIdleTimeoutSec: Number(process.env.ARGENT_RUNNER_BATCH_IDLE_TIMEOUT_SEC || cfg.batchIdleTimeoutSec) || 1800,
     runnerId: String(cfg.runnerId || `runner-${hostname().toLowerCase().replace(/[^a-z0-9-]/g, '-')}`),
   };
   for (const k of ['serverUrl', 'tenantAppId', 'runnerToken']) {
@@ -132,28 +134,54 @@ async function executeJob(cfg, job) {
   }
   log('job.task.running', { jobId: String(job._id), taskId });
 
-  const deadline = Date.now() + cfg.execTimeoutSec * 1000;
-  while (Date.now() < deadline) {
+  const isBatch = /--records\b/.test(String(job.prompt || ''));
+  const timeoutSec = isBatch ? Math.max(Number(cfg.execTimeoutSec) || 900, Number(cfg.batchExecTimeoutSec) || 43200) : (Number(cfg.execTimeoutSec) || 900);
+  const startedAt = Date.now();
+  const hardDeadline = startedAt + timeoutSec * 1000;
+  let lastProgressAt = startedAt;
+  let lastServerPollAt = 0;
+  while (Date.now() < hardDeadline) {
     await sleep(2000);
     const state = await tbState(cfg);
     const task = (state.tasks || []).find((t) => t.id === taskId);
     if (!task) continue;
+    // 本地任务自身更新也视为活跃
+    if (task.updatedAt) {
+      const t = new Date(task.updatedAt).getTime();
+      if (Number.isFinite(t) && t > lastProgressAt) lastProgressAt = t;
+    }
     const execs = task.executions || [];
     const latest = execs[execs.length - 1];
     if (latest && latest.endedAt) {
       const outcome = latest.result === 'succeeded' ? 'succeeded' : 'failed';
       return { outcome, summary: latest.error ? String(latest.error).slice(0, 500) : '', sessionRef: latest.sessionId || '', taskId };
     }
+    if (isBatch && Date.now() - lastServerPollAt > 15000) {
+      lastServerPollAt = Date.now();
+      try {
+        const p = await serverCall(cfg, `/jobs/${job._id}/progress`);
+        const at = p?.data?.lastProgressAt ? new Date(p.data.lastProgressAt).getTime() : 0;
+        if (Number.isFinite(at) && at > lastProgressAt) lastProgressAt = at;
+      } catch { /* 进度探针暂不可用不判失败 */ }
+    }
+    if (isBatch) {
+      const idleSec = Number(cfg.batchIdleTimeoutSec) || 1800;
+      if (Date.now() - lastProgressAt > idleSec * 1000) {
+        return { outcome: 'failed', summary: `批任务无步骤进度超过 ${Math.round(idleSec / 60)} 分钟（lastProgress=${new Date(lastProgressAt).toISOString()}）`, taskId };
+      }
+    }
   }
-  return { outcome: 'failed', summary: `执行超时（>${cfg.execTimeoutSec}s）`, taskId };
+  return { outcome: 'failed', summary: `执行超过硬上限（>${Math.round(timeoutSec / 60)} 分钟）`, taskId };
 }
 
-async function runOnce(cfg) {
+async function claimJob(cfg) {
   const claim = await serverCall(cfg, '/jobs/claim', { method: 'POST', body: { runnerId: cfg.runnerId, waitMs: ONCE ? 0 : cfg.pollWaitMs, leaseSec: cfg.leaseSec } });
-  const job = claim?.data?.job;
-  if (!job) return { claimed: false };
+  return claim?.data?.job || null;
+}
+
+async function runJob(cfg, job) {
   log('job.claimed', { jobId: String(job._id), preset: job.preset, attempts: job.attempts, runnerId: cfg.runnerId });
-  if (DRY_RUN) { log('job.dry-run', { jobId: String(job._id) }); return { claimed: true, dryRun: true }; }
+  if (DRY_RUN) { log('job.dry-run', { jobId: String(job._id) }); return { outcome: 'skipped', dryRun: true }; }
 
   // 心跳续租（执行期间每 30s）
   let heartbeatTimer = null;
@@ -193,6 +221,13 @@ async function runOnce(cfg) {
   }
 }
 
+async function runOnce(cfg) {
+  const job = await claimJob(cfg);
+  if (!job) return { claimed: false };
+  if (DRY_RUN) { log('job.dry-run', { jobId: String(job._id) }); return { claimed: true, dryRun: true }; }
+  return runJob(cfg, job);
+}
+
 async function health(cfg) {
   const out = { server: false, dshWeb: false, tenantAppId: cfg.tenantAppId, runnerId: cfg.runnerId };
   try {
@@ -215,9 +250,27 @@ async function main() {
   let stopping = false;
   process.on('SIGINT', () => { stopping = true; log('runner.stop', {}); process.exit(0); });
   process.on('SIGTERM', () => { stopping = true; log('runner.stop', {}); process.exit(0); });
-  do {
-    try { await runOnce(cfg); } catch (error) { log('runner.error', { message: error.message }); await sleep(3000); }
-  } while (!ONCE && !stopping);
+  const concurrency = Math.max(1, Math.min(5, Number(process.env.ARGENT_RUNNER_CONCURRENCY || cfg.concurrency || 2) || 2));
+  log('runner.concurrency', { runnerId: cfg.runnerId, concurrency });
+  if (ONCE) {
+    try { await runOnce(cfg); } catch (error) { log('runner.error', { message: error.message }); }
+    return;
+  }
+  const active = new Set();
+  for (;;) {
+    while (active.size < concurrency) {
+      let job;
+      try { job = await claimJob(cfg); } catch (error) { log('runner.error', { message: error.message }); await sleep(3000); break; }
+      if (!job) break;
+      const p = runJob(cfg, job)
+        .catch((error) => log('runner.error', { jobId: String(job._id), message: error.message }))
+        .finally(() => active.delete(p));
+      active.add(p);
+    }
+    if (!active.size) await sleep(3000);
+    else await Promise.race([...active, sleep(3000)]);
+    if (stopping) process.exit(0);
+  }
 }
 
 main().catch((error) => { console.error(`❌ runner 失败: ${error.message}`); process.exit(1); });