@xtalpi/agentic-lab-skills 0.0.8 → 0.0.10

package/skills/lab-flow-designer/testing/test-processer.mjs

@@ -356,6 +356,34 @@ function validateCompleteResult(result) {
   return errors;
 }
 
+function validateRunResult(result) {
+  const errors = [];
+  if (typeof result !== 'object' || result === null) {
+    errors.push('run() must return an object, got ' + (result === null ? 'null' : typeof result));
+    return errors;
+  }
+  if (result.new_tickets !== undefined) {
+    if (!Array.isArray(result.new_tickets)) {
+      errors.push(`run().new_tickets must be array, got ${typeof result.new_tickets}`);
+    } else {
+      for (let i = 0; i < Math.min(result.new_tickets.length, 3); i++) {
+        const t = result.new_tickets[i];
+        if (typeof t.flow_id !== 'number') errors.push(`new_tickets[${i}].flow_id must be number, got ${typeof t.flow_id}`);
+        if (typeof t.pool_id !== 'number') errors.push(`new_tickets[${i}].pool_id must be number, got ${typeof t.pool_id}`);
+        if (typeof t.order_id !== 'number') errors.push(`new_tickets[${i}].order_id must be number, got ${typeof t.order_id}`);
+        if (typeof t.detail !== 'object' || t.detail === null) errors.push(`new_tickets[${i}].detail must be object`);
+        if (typeof t.status !== 'string') errors.push(`new_tickets[${i}].status must be string, got ${typeof t.status}`);
+      }
+    }
+  }
+  for (const key of Object.keys(result)) {
+    if (CAMEL_CASE_PATTERN.test(key)) {
+      errors.push(`run() return key "${key}" is camelCase — must be snake_case`);
+    }
+  }
+  return errors;
+}
+
 // ─── Script loader via vm ──────────────────────────────────────────
 
 function loadProcesserClass(scriptContent, filename) {
@@ -621,8 +649,10 @@ function formatTicketsTable(tickets, maxDetailKeys) {
 
 function formatPreviewReport(trace) {
   const { scriptPath, valveName, valveConfig, pools, dataSource,
-          inputTickets, startResult, startError, startTraceLog, startDetailDiffs,
-          completeTickets, completeResult, completeError, completeTraceLog, completeDetailDiffs } = trace;
+          inputTickets, isAutoTrigger,
+          startResult, startError, startTraceLog, startDetailDiffs,
+          completeTickets, completeResult, completeError, completeTraceLog, completeDetailDiffs,
+          runResult, runError, runTraceLog, runDetailDiffs } = trace;
 
   const lines = [];
   const push = (...args) => lines.push(...args);
@@ -638,108 +668,176 @@ function formatPreviewReport(trace) {
   push(`- 入口池: ${inputPoolNames}`);
   push(`- 出口池: ${outputPoolNames}`);
   push(`- 数据来源: ${dataSource}`);
-  push(`- tickets 数: ${inputTickets.length}`, '');
+  push(`- tickets 数: ${inputTickets.length}`);
+  push(`- 触发方式: ${isAutoTrigger ? '自动触发 (run)' : '人工触发 (start/complete)'}`, '');
+
+  if (isAutoTrigger) {
+    // run() trace
+    push('## run() 执行追踪', '');
+    push(`### 输入数据 (${inputTickets.length} 条 tickets)`, '');
+    push(formatTicketsTable(inputTickets));
+
+    push('### SDK 调用链', '');
+    for (const entry of (runTraceLog || [])) {
+      const paramStr = JSON.stringify(entry.params);
+      push(`${entry.seq + 1}. \`${entry.method}(${paramStr === '{}' ? '' : paramStr})\` → ${entry.returnSummary}`);
+    }
+    push('');
 
-  // start() trace
-  push('## start() 执行追踪', '');
-  push(`### 输入数据 (${inputTickets.length} 条 tickets)`, '');
-  push(formatTicketsTable(inputTickets));
+    if (runDetailDiffs && runDetailDiffs.length > 0) {
+      push('### ticket.detail 变更 (run 阶段)', '');
+      push('| ticket | 字段 | 变更前 | 变更后 |');
+      push('|--------|------|--------|--------|');
+      for (const d of runDetailDiffs) {
+        for (const c of d.changes) {
+          push(`| #${d.ticketId} | ${c.key} | ${c.before} | ${c.after} |`);
+        }
+      }
+      push('');
+    }
 
-  push('### SDK 调用链', '');
-  for (const entry of startTraceLog) {
-    const paramStr = JSON.stringify(entry.params);
-    push(`${entry.seq + 1}. \`${entry.method}(${paramStr === '{}' ? '' : paramStr})\` → ${entry.returnSummary}`);
-  }
-  push('');
-
-  if (startDetailDiffs.length > 0) {
-    push('### ticket.detail 变更 (start 阶段)', '');
-    push('| ticket | 字段 | 变更前 | 变更后 |');
-    push('|--------|------|--------|--------|');
-    for (const d of startDetailDiffs) {
-      for (const c of d.changes) {
-        push(`| #${d.ticketId} | ${c.key} | ${c.before} | ${c.after} |`);
+    if (runError) {
+      push(`### run() 错误`, '');
+      push(`\`\`\`\n${runError}\n\`\`\``, '');
+    } else if (runResult) {
+      push('### 数据路由', '');
+      if (runResult.new_tickets && runResult.new_tickets.length > 0) {
+        const routeMap = new Map();
+        for (const nt of runResult.new_tickets) {
+          const poolId = nt.pool_id;
+          if (!routeMap.has(poolId)) routeMap.set(poolId, []);
+          routeMap.get(poolId).push(nt);
+        }
+        push('| 目标池 | pool_id | 数量 | status |');
+        push('|--------|---------|------|--------|');
+        for (const [poolId, nts] of routeMap) {
+          const poolName = valveConfig.output_pools.find((_, i) => 100 + i === poolId)?.name || `pool_${poolId}`;
+          push(`| ${poolName} | ${poolId} | ${nts.length} | ${nts[0]?.status || '-'} |`);
+        }
+        push('');
+      } else {
+        push('(无 new_tickets 返回)', '');
       }
     }
-    push('');
-  }
 
-  if (startError) {
-    push(`### start() 错误`, '');
-    push(`\`\`\`\n${startError}\n\`\`\``, '');
-  } else if (startResult) {
-    push('### 返回值', '');
-    push(`- orbit_link: \`${startResult.orbit_link}\``);
-    push(`- ticket_ids: [${(startResult.ticket_ids || []).join(', ')}]`);
-    push('');
-  }
+    // Summary
+    push('## 执行摘要', '');
+    const usedMethods = new Set((runTraceLog || []).map(c => c.method));
+    const allMethods = ['ticket.list', 'ticket.update', 'ticket.append', 'pool.getNext',
+      'compound.getStockFromXfcSh', 'process.list', 'process.execute', 'station.list'];
+    const unused = allMethods.filter(m => !usedMethods.has(m));
 
-  // complete() trace
-  push('## complete() 执行追踪', '');
-  push(`### 输入 tickets (${(completeTickets || []).length} 条)`, '');
+    const runStatus = runError
+      ? `✗ 失败: ${runError.split('\n')[0]}`
+      : `✓ 成功 (${(runTraceLog || []).length} SDK 调用, ${(runResult?.new_tickets || []).length} new_tickets)`;
 
-  push('### SDK 调用链', '');
-  for (const entry of completeTraceLog) {
-    const paramStr = JSON.stringify(entry.params);
-    push(`${entry.seq + 1}. \`${entry.method}(${paramStr === '{}' ? '' : paramStr})\` → ${entry.returnSummary}`);
-  }
-  push('');
-
-  if (completeDetailDiffs.length > 0) {
-    push('### ticket.detail 变更 (complete 阶段)', '');
-    push('| ticket | 字段 | 变更前 | 变更后 |');
-    push('|--------|------|--------|--------|');
-    for (const d of completeDetailDiffs) {
-      for (const c of d.changes) {
-        push(`| #${d.ticketId} | ${c.key} | ${c.before} | ${c.after} |`);
-      }
+    push(`- run: ${runStatus}`);
+    if (unused.length > 0) {
+      push(`- 未调用的 SDK 方法: ${unused.join(', ')}`);
+    }
+    push('');
+  } else {
+    // start() trace
+    push('## start() 执行追踪', '');
+    push(`### 输入数据 (${inputTickets.length} 条 tickets)`, '');
+    push(formatTicketsTable(inputTickets));
+
+    push('### SDK 调用链', '');
+    for (const entry of startTraceLog) {
+      const paramStr = JSON.stringify(entry.params);
+      push(`${entry.seq + 1}. \`${entry.method}(${paramStr === '{}' ? '' : paramStr})\` → ${entry.returnSummary}`);
     }
     push('');
-  }
 
-  if (completeError) {
-    push(`### complete() 错误`, '');
-    push(`\`\`\`\n${completeError}\n\`\`\``, '');
-  } else if (completeResult) {
-    push('### 数据路由', '');
-    if (completeResult.new_tickets && completeResult.new_tickets.length > 0) {
-      const routeMap = new Map();
-      for (const nt of completeResult.new_tickets) {
-        const poolId = nt.pool_id;
-        if (!routeMap.has(poolId)) routeMap.set(poolId, []);
-        routeMap.get(poolId).push(nt);
+    if (startDetailDiffs.length > 0) {
+      push('### ticket.detail 变更 (start 阶段)', '');
+      push('| ticket | 字段 | 变更前 | 变更后 |');
+      push('|--------|------|--------|--------|');
+      for (const d of startDetailDiffs) {
+        for (const c of d.changes) {
+          push(`| #${d.ticketId} | ${c.key} | ${c.before} | ${c.after} |`);
+        }
       }
-      push('| 目标池 | pool_id | 数量 | status |');
-      push('|--------|---------|------|--------|');
-      for (const [poolId, nts] of routeMap) {
-        const poolName = valveConfig.output_pools.find((_, i) => 100 + i === poolId)?.name || `pool_${poolId}`;
-        push(`| ${poolName} | ${poolId} | ${nts.length} | ${nts[0]?.status || '-'} |`);
+      push('');
+    }
+
+    if (startError) {
+      push(`### start() 错误`, '');
+      push(`\`\`\`\n${startError}\n\`\`\``, '');
+    } else if (startResult) {
+      push('### 返回值', '');
+      push(`- orbit_link: \`${startResult.orbit_link}\``);
+      push(`- ticket_ids: [${(startResult.ticket_ids || []).join(', ')}]`);
+      push('');
+    }
+
+    // complete() trace
+    push('## complete() 执行追踪', '');
+    push(`### 输入 tickets (${(completeTickets || []).length} 条)`, '');
+
+    push('### SDK 调用链', '');
+    for (const entry of completeTraceLog) {
+      const paramStr = JSON.stringify(entry.params);
+      push(`${entry.seq + 1}. \`${entry.method}(${paramStr === '{}' ? '' : paramStr})\` → ${entry.returnSummary}`);
+    }
+    push('');
+
+    if (completeDetailDiffs.length > 0) {
+      push('### ticket.detail 变更 (complete 阶段)', '');
+      push('| ticket | 字段 | 变更前 | 变更后 |');
+      push('|--------|------|--------|--------|');
+      for (const d of completeDetailDiffs) {
+        for (const c of d.changes) {
+          push(`| #${d.ticketId} | ${c.key} | ${c.before} | ${c.after} |`);
+        }
       }
       push('');
-    } else {
-      push('(无 new_tickets 返回)', '');
     }
-  }
 
-  // Summary
-  push('## 执行摘要', '');
-  const allCalls = [...startTraceLog, ...completeTraceLog];
-  const usedMethods = new Set(allCalls.map(c => c.method));
-  const allMethods = ['ticket.list', 'ticket.update', 'ticket.append', 'pool.getNext',
-    'compound.getStockFromXfcSh', 'process.list', 'process.execute', 'station.list'];
-  const unused = allMethods.filter(m => !usedMethods.has(m));
-
-  const startStatus = startError ? `✗ 失败: ${startError.split('\n')[0]}` : `✓ 成功 (${startTraceLog.length} SDK 调用, ${inputTickets.length} tickets)`;
-  const completeStatus = completeError
-    ? `✗ 失败: ${completeError.split('\n')[0]}`
-    : `✓ 成功 (${completeTraceLog.length} SDK 调用, ${(completeResult?.new_tickets || []).length} new_tickets)`;
-
-  push(`- start: ${startStatus}`);
-  push(`- complete: ${completeStatus}`);
-  if (unused.length > 0) {
-    push(`- 未调用的 SDK 方法: ${unused.join(', ')}`);
+    if (completeError) {
+      push(`### complete() 错误`, '');
+      push(`\`\`\`\n${completeError}\n\`\`\``, '');
+    } else if (completeResult) {
+      push('### 数据路由', '');
+      if (completeResult.new_tickets && completeResult.new_tickets.length > 0) {
+        const routeMap = new Map();
+        for (const nt of completeResult.new_tickets) {
+          const poolId = nt.pool_id;
+          if (!routeMap.has(poolId)) routeMap.set(poolId, []);
+          routeMap.get(poolId).push(nt);
+        }
+        push('| 目标池 | pool_id | 数量 | status |');
+        push('|--------|---------|------|--------|');
+        for (const [poolId, nts] of routeMap) {
+          const poolName = valveConfig.output_pools.find((_, i) => 100 + i === poolId)?.name || `pool_${poolId}`;
+          push(`| ${poolName} | ${poolId} | ${nts.length} | ${nts[0]?.status || '-'} |`);
+        }
+        push('');
+      } else {
+        push('(无 new_tickets 返回)', '');
+      }
+    }
+
+    // Summary
+    push('## 执行摘要', '');
+    const allCalls = [...startTraceLog, ...completeTraceLog];
+    const usedMethods = new Set(allCalls.map(c => c.method));
+    const allMethods = ['ticket.list', 'ticket.update', 'ticket.append', 'pool.getNext',
+      'compound.getStockFromXfcSh', 'process.list', 'process.execute', 'station.list'];
+    const unused = allMethods.filter(m => !usedMethods.has(m));
+
+    const startStatus = startError ? `✗ 失败: ${startError.split('\n')[0]}` : `✓ 成功 (${startTraceLog.length} SDK 调用, ${inputTickets.length} tickets)`;
+    const completeStatus = completeError
+      ? `✗ 失败: ${completeError.split('\n')[0]}`
+      : `✓ 成功 (${completeTraceLog.length} SDK 调用, ${(completeResult?.new_tickets || []).length} new_tickets)`;
+
+    push(`- start: ${startStatus}`);
+    push(`- complete: ${completeStatus}`);
+    if (unused.length > 0) {
+      push(`- 未调用的 SDK 方法: ${unused.join(', ')}`);
+    }
+    push('');
   }
-  push('');
 
   return lines.join('\n');
 }
@@ -787,59 +885,85 @@ async function runPreview(args) {
   }
 
   const inputPoolIds = valveConfig.input_pools.map((_, i) => i + 1);
+  const proto = ProcesserClass.prototype;
+  const isAutoTrigger = typeof proto.run === 'function' && typeof proto.start !== 'function';
+
   const trace = {
-    scriptPath, valveName, valveConfig, pools, dataSource, inputTickets,
+    scriptPath, valveName, valveConfig, pools, dataSource, inputTickets, isAutoTrigger,
     startResult: null, startError: null, startTraceLog: [], startDetailDiffs: [],
     completeTickets: null, completeResult: null, completeError: null, completeTraceLog: [], completeDetailDiffs: [],
+    runResult: null, runError: null, runTraceLog: [], runDetailDiffs: [],
   };
 
-  // Run start()
-  {
+  if (isAutoTrigger) {
+    // Auto-trigger: run()
     const tc = createTracingContext(pools, valveConfig, inputTickets);
     let processer;
     try {
       processer = new ProcesserClass(tc.context);
     } catch (e) {
-      trace.startError = `constructor threw: ${e.message}\n${e.stack}`;
+      trace.runError = `constructor threw: ${e.message}\n${e.stack}`;
       console.log(formatPreviewReport(trace));
       process.exit(1);
     }
 
     try {
-      trace.startResult = await processer.start({ valve_id: 1, pool_ids: inputPoolIds });
+      trace.runResult = await processer.run({ valve_id: 1, pool_ids: inputPoolIds });
     } catch (e) {
-      trace.startError = `${e.constructor.name}: ${e.message}\n${e.stack}`;
+      trace.runError = `${e.constructor.name}: ${e.message}\n${e.stack}`;
     }
-    trace.startTraceLog = tc.traceLog;
-    trace.startDetailDiffs = tc.detailDiffs;
-  }
-
-  // Run complete()
-  {
-    const completeTickets = inputTickets.map(t => ({ ...t, status: 'created' }));
-    trace.completeTickets = completeTickets;
+    trace.runTraceLog = tc.traceLog;
+    trace.runDetailDiffs = tc.detailDiffs;
+  } else {
+    // Manual-trigger: start() + complete()
+    // Run start()
+    {
+      const tc = createTracingContext(pools, valveConfig, inputTickets);
+      let processer;
+      try {
+        processer = new ProcesserClass(tc.context);
+      } catch (e) {
+        trace.startError = `constructor threw: ${e.message}\n${e.stack}`;
+        console.log(formatPreviewReport(trace));
+        process.exit(1);
+      }
 
-    const tc = createTracingContext(pools, valveConfig, completeTickets);
-    let processer;
-    try {
-      processer = new ProcesserClass(tc.context);
-    } catch (e) {
-      trace.completeError = `constructor threw: ${e.message}\n${e.stack}`;
-      console.log(formatPreviewReport(trace));
-      process.exit(1);
+      try {
+        trace.startResult = await processer.start({ valve_id: 1, pool_ids: inputPoolIds });
+      } catch (e) {
+        trace.startError = `${e.constructor.name}: ${e.message}\n${e.stack}`;
+      }
+      trace.startTraceLog = tc.traceLog;
+      trace.startDetailDiffs = tc.detailDiffs;
     }
 
-    try {
-      trace.completeResult = await processer.complete({ valve_id: 1, tickets: completeTickets });
-    } catch (e) {
-      trace.completeError = `${e.constructor.name}: ${e.message}\n${e.stack}`;
+    // Run complete()
+    {
+      const completeTickets = inputTickets.map(t => ({ ...t, status: 'created' }));
+      trace.completeTickets = completeTickets;
+
+      const tc = createTracingContext(pools, valveConfig, completeTickets);
+      let processer;
+      try {
+        processer = new ProcesserClass(tc.context);
+      } catch (e) {
+        trace.completeError = `constructor threw: ${e.message}\n${e.stack}`;
+        console.log(formatPreviewReport(trace));
+        process.exit(1);
+      }
+
+      try {
+        trace.completeResult = await processer.complete({ valve_id: 1, tickets: completeTickets });
+      } catch (e) {
+        trace.completeError = `${e.constructor.name}: ${e.message}\n${e.stack}`;
+      }
+      trace.completeTraceLog = tc.traceLog;
+      trace.completeDetailDiffs = tc.detailDiffs;
     }
-    trace.completeTraceLog = tc.traceLog;
-    trace.completeDetailDiffs = tc.detailDiffs;
   }
 
   console.log(formatPreviewReport(trace));
-  const hasError = trace.startError || trace.completeError;
+  const hasError = isAutoTrigger ? trace.runError : (trace.startError || trace.completeError);
   process.exit(hasError ? 1 : 0);
 }
 
@@ -856,7 +980,7 @@ async function runTests(args) {
     script: scriptPath,
     phases: {
       syntax: { pass: false },
-      structure: { pass: false, hasConstructor: false, hasStart: false, hasComplete: false },
+      structure: { pass: false, hasConstructor: false, hasStart: false, hasComplete: false, hasRun: false },
       normalRun: {
         start: { pass: false, returnValid: false, errors: [] },
         complete: { pass: false, returnValid: false, errors: [] },
@@ -914,18 +1038,23 @@ async function runTests(args) {
   result.phases.structure.hasConstructor = typeof ProcesserClass === 'function';
   result.phases.structure.hasStart = typeof proto.start === 'function';
   result.phases.structure.hasComplete = typeof proto.complete === 'function';
+  result.phases.structure.hasRun = typeof proto.run === 'function';
   result.phases.structure.pass =
     result.phases.structure.hasConstructor &&
-    result.phases.structure.hasStart &&
-    result.phases.structure.hasComplete;
+    (
+      (result.phases.structure.hasStart && result.phases.structure.hasComplete) ||
+      result.phases.structure.hasRun
+    );
 
   if (!result.phases.structure.pass) {
-    if (!result.phases.structure.hasStart) result.errors.push('Processer missing start() method');
-    if (!result.phases.structure.hasComplete) result.errors.push('Processer missing complete() method');
+    if (!result.phases.structure.hasRun && !result.phases.structure.hasStart) result.errors.push('Processer missing start() method (manual-trigger) or run() method (auto-trigger)');
+    if (!result.phases.structure.hasRun && !result.phases.structure.hasComplete) result.errors.push('Processer missing complete() method (manual-trigger) or run() method (auto-trigger)');
     result.status = 'fail';
     return result;
   }
 
+  const isAutoTrigger = result.phases.structure.hasRun && !result.phases.structure.hasStart;
+
   // Load pool schemas and valve config
   const pools = loadAllPools(poolsDir);
   const valveConfig = loadValveConfig(valvesDir, valveName);
@@ -938,41 +1067,62 @@ async function runTests(args) {
     try {
       processer = new ProcesserClass(mock.context);
     } catch (e) {
-      result.phases.normalRun.start.errors.push(`constructor threw: ${e.message}`);
+      const phaseKey = isAutoTrigger ? 'run' : 'start';
+      if (!result.phases.normalRun[phaseKey]) result.phases.normalRun[phaseKey] = { pass: false, returnValid: false, errors: [] };
+      result.phases.normalRun[phaseKey].errors.push(`constructor threw: ${e.message}`);
       result.errors.push(`Normal run constructor error: ${e.message}`);
       result.status = 'fail';
       return result;
     }
 
-    // start
-    try {
-      const startResult = await processer.start({ valve_id: 1, pool_ids: inputPoolIds });
-      const startErrors = validateStartResult(startResult);
-      result.phases.normalRun.start.returnValid = startErrors.length === 0;
-      result.phases.normalRun.start.errors = startErrors;
-      result.phases.normalRun.start.pass = startErrors.length === 0;
-      if (startErrors.length > 0) {
-        result.errors.push(...startErrors.map(e => `[normal start] ${e}`));
+    if (isAutoTrigger) {
+      // Auto-trigger: test run()
+      if (!result.phases.normalRun.run) result.phases.normalRun.run = { pass: false, returnValid: false, errors: [] };
+      try {
+        const runResult = await processer.run({ valve_id: 1, pool_ids: inputPoolIds });
+        const runErrors = validateRunResult(runResult);
+        result.phases.normalRun.run.returnValid = runErrors.length === 0;
+        result.phases.normalRun.run.errors = runErrors;
+        result.phases.normalRun.run.pass = runErrors.length === 0;
+        if (runErrors.length > 0) {
+          result.errors.push(...runErrors.map(e => `[normal run] ${e}`));
+        }
+      } catch (e) {
+        result.phases.normalRun.run.errors.push(e.message);
+        result.errors.push(`[normal run] Runtime error: ${e.message}`);
+      }
+    } else {
+      // Manual-trigger: test start() + complete()
+      // start
+      try {
+        const startResult = await processer.start({ valve_id: 1, pool_ids: inputPoolIds });
+        const startErrors = validateStartResult(startResult);
+        result.phases.normalRun.start.returnValid = startErrors.length === 0;
+        result.phases.normalRun.start.errors = startErrors;
+        result.phases.normalRun.start.pass = startErrors.length === 0;
+        if (startErrors.length > 0) {
+          result.errors.push(...startErrors.map(e => `[normal start] ${e}`));
+        }
+      } catch (e) {
+        result.phases.normalRun.start.errors.push(e.message);
+        result.errors.push(`[normal start] Runtime error: ${e.message}`);
       }
-    } catch (e) {
-      result.phases.normalRun.start.errors.push(e.message);
-      result.errors.push(`[normal start] Runtime error: ${e.message}`);
-    }
 
-    // complete — use mock tickets from the start phase (with updated details if any)
-    try {
-      const completeTickets = mock.mockTickets.map(t => ({ ...t, status: 'created' }));
-      const completeResult = await processer.complete({ valve_id: 1, tickets: completeTickets });
-      const completeErrors = validateCompleteResult(completeResult);
-      result.phases.normalRun.complete.returnValid = completeErrors.length === 0;
-      result.phases.normalRun.complete.errors = completeErrors;
-      result.phases.normalRun.complete.pass = completeErrors.length === 0;
-      if (completeErrors.length > 0) {
-        result.errors.push(...completeErrors.map(e => `[normal complete] ${e}`));
+      // complete — use mock tickets from the start phase (with updated details if any)
+      try {
+        const completeTickets = mock.mockTickets.map(t => ({ ...t, status: 'created' }));
+        const completeResult = await processer.complete({ valve_id: 1, tickets: completeTickets });
+        const completeErrors = validateCompleteResult(completeResult);
+        result.phases.normalRun.complete.returnValid = completeErrors.length === 0;
+        result.phases.normalRun.complete.errors = completeErrors;
+        result.phases.normalRun.complete.pass = completeErrors.length === 0;
+        if (completeErrors.length > 0) {
+          result.errors.push(...completeErrors.map(e => `[normal complete] ${e}`));
+        }
+      } catch (e) {
+        result.phases.normalRun.complete.errors.push(e.message);
+        result.errors.push(`[normal complete] Runtime error: ${e.message}`);
       }
-    } catch (e) {
-      result.phases.normalRun.complete.errors.push(e.message);
-      result.errors.push(`[normal complete] Runtime error: ${e.message}`);
     }
 
     result.sdkCalls = [...new Set(mock.callLog.map(c => c.method))];
@@ -998,7 +1148,9 @@ async function runTests(args) {
     }
   }
 
-  const normalPass = result.phases.normalRun.start.pass && result.phases.normalRun.complete.pass;
+  const normalPass = isAutoTrigger
+    ? result.phases.normalRun.run?.pass
+    : result.phases.normalRun.start.pass && result.phases.normalRun.complete.pass;
   if (!normalPass) {
     result.status = 'fail';
   }
@@ -1010,26 +1162,39 @@ async function runTests(args) {
     try {
       processer = new ProcesserClass(mock.context);
     } catch (e) {
-      result.phases.adversarialRun.start.errors.push(`constructor threw: ${e.message}`);
+      const phaseKey = isAutoTrigger ? 'run' : 'start';
+      if (!result.phases.adversarialRun[phaseKey]) result.phases.adversarialRun[phaseKey] = { pass: false, errors: [] };
+      result.phases.adversarialRun[phaseKey].errors.push(`constructor threw: ${e.message}`);
       result.warnings.push(`[adversarial] constructor error: ${e.message}`);
     }
 
     if (processer) {
-      try {
-        await processer.start({ valve_id: 1, pool_ids: inputPoolIds });
-        result.phases.adversarialRun.start.pass = true;
-      } catch (e) {
-        result.phases.adversarialRun.start.errors.push(e.message);
-        result.warnings.push(`[adversarial start] ${e.constructor.name}: ${e.message}`);
-      }
+      if (isAutoTrigger) {
+        if (!result.phases.adversarialRun.run) result.phases.adversarialRun.run = { pass: false, errors: [] };
+        try {
+          await processer.run({ valve_id: 1, pool_ids: inputPoolIds });
+          result.phases.adversarialRun.run.pass = true;
+        } catch (e) {
+          result.phases.adversarialRun.run.errors.push(e.message);
+          result.warnings.push(`[adversarial run] ${e.constructor.name}: ${e.message}`);
+        }
+      } else {
+        try {
+          await processer.start({ valve_id: 1, pool_ids: inputPoolIds });
+          result.phases.adversarialRun.start.pass = true;
+        } catch (e) {
+          result.phases.adversarialRun.start.errors.push(e.message);
+          result.warnings.push(`[adversarial start] ${e.constructor.name}: ${e.message}`);
+        }
 
-      try {
-        const completeTickets = mock.mockTickets.map(t => ({ ...t, status: 'created' }));
-        await processer.complete({ valve_id: 1, tickets: completeTickets });
-        result.phases.adversarialRun.complete.pass = true;
-      } catch (e) {
-        result.phases.adversarialRun.complete.errors.push(e.message);
-        result.warnings.push(`[adversarial complete] ${e.constructor.name}: ${e.message}`);
+        try {
+          const completeTickets = mock.mockTickets.map(t => ({ ...t, status: 'created' }));
+          await processer.complete({ valve_id: 1, tickets: completeTickets });
+          result.phases.adversarialRun.complete.pass = true;
+        } catch (e) {
+          result.phases.adversarialRun.complete.errors.push(e.message);
+          result.warnings.push(`[adversarial complete] ${e.constructor.name}: ${e.message}`);
+        }
       }
 
       result.phases.compliance.warnings.push(