taskplane 0.22.11 → 0.22.13

package/bin/rpc-wrapper.mjs

@@ -28,8 +28,8 @@
  */
 
 import { spawn } from "node:child_process";
-import { readFileSync, writeFileSync, appendFileSync, mkdirSync } from "node:fs";
-import { dirname, resolve } from "node:path";
+import { readFileSync, writeFileSync, appendFileSync, mkdirSync, readdirSync, renameSync } from "node:fs";
+import { dirname, resolve, join, basename } from "node:path";
 import { StringDecoder } from "node:string_decoder";
 
 // ── CLI Argument Parsing ─────────────────────────────────────────────
@@ -45,6 +45,7 @@ function parseArgs(argv) {
 		extensions: [],
 		passthrough: [],
 		help: false,
+		mailboxDir: null,
 	};
 
 	let i = 2; // skip "node" and script path
@@ -74,6 +75,9 @@ function parseArgs(argv) {
 		} else if (arg === "--extensions" && i + 1 < argv.length) {
 			args.extensions = argv[++i].split(",").map((e) => e.trim()).filter(Boolean);
 			i++;
+		} else if (arg === "--mailbox-dir" && i + 1 < argv.length) {
+			args.mailboxDir = argv[++i];
+			i++;
 		} else if (arg === "--") {
 			args.passthrough = argv.slice(i + 1);
 			break;
@@ -103,6 +107,7 @@ Optional:
   --system-prompt-file <path>  Path to system prompt file
   --tools <t1,t2,...>          Comma-separated tool names
   --extensions <e1,e2,...>     Comma-separated extension paths
+  --mailbox-dir <path>         Mailbox directory for agent steering (TP-089)
   -h, --help                   Show this help
 `
 	);
@@ -487,6 +492,160 @@ function createSingleWriteGuard(writer) {
 	};
 }
 
+// ── Agent Mailbox Check (TP-089) ─────────────────────────────────────
+
+/**
+ * Valid mailbox message types (must match MailboxMessageType in types.ts).
+ */
+const MAILBOX_MESSAGE_TYPES = new Set(["steer", "query", "abort", "info", "reply", "escalate"]);
+
+/**
+ * Check the agent's mailbox inbox for pending messages and inject them
+ * into the pi process via the `steer` RPC command.
+ *
+ * Called on every `message_end` event when `--mailbox-dir` is provided.
+ * Messages are validated (batchId, to, shape), sorted deterministically,
+ * injected via steer, and moved from inbox/ to ack/.
+ *
+ * @param {string} mailboxDir - Session mailbox directory (e.g., .pi/mailbox/{batchId}/{session})
+ * @param {object} proc - The spawned pi process (must have writable stdin)
+ * @returns {{ delivered: number, skipped: number }} Delivery stats
+ */
+function checkMailboxAndSteer(mailboxDir, proc) {
+	const stats = { delivered: 0, skipped: 0 };
+
+	// Derive expected values from path structure:
+	// mailboxDir = .pi/mailbox/{batchId}/{sessionName}
+	const expectedSessionName = basename(mailboxDir);
+	const expectedBatchId = basename(dirname(mailboxDir));
+
+	const inboxDir = join(mailboxDir, "inbox");
+
+	// Read inbox — ENOENT is quiet no-op (inbox may not exist yet)
+	let entries;
+	try {
+		entries = readdirSync(inboxDir);
+	} catch (err) {
+		if (err.code === "ENOENT") return stats;
+		process.stderr.write(`\n[STEERING] WARNING: failed to read inbox: ${err.message}\n`);
+		return stats;
+	}
+
+	// Filter: only *.msg.json files (excludes .msg.json.tmp temp files)
+	const msgFiles = entries.filter(f => f.endsWith(".msg.json") && !f.endsWith(".msg.json.tmp"));
+	if (msgFiles.length === 0) return stats;
+
+	// Read and validate all messages
+	const validMessages = [];
+
+	for (const filename of msgFiles) {
+		const filePath = join(inboxDir, filename);
+		let raw;
+		try {
+			raw = readFileSync(filePath, "utf-8");
+		} catch (err) {
+			process.stderr.write(`\n[STEERING] WARNING: failed to read ${filename}: ${err.message}\n`);
+			stats.skipped++;
+			continue;
+		}
+
+		let msg;
+		try {
+			msg = JSON.parse(raw);
+		} catch {
+			process.stderr.write(`\n[STEERING] WARNING: malformed JSON in ${filename}, skipping\n`);
+			stats.skipped++;
+			continue;
+		}
+
+		// Validate shape
+		if (!isValidMailboxMessageShape(msg)) {
+			process.stderr.write(`\n[STEERING] WARNING: invalid message shape in ${filename}, skipping\n`);
+			stats.skipped++;
+			continue;
+		}
+
+		// Validate batchId (derived from path, not message content)
+		if (msg.batchId !== expectedBatchId) {
+			process.stderr.write(`\n[STEERING] WARNING: batchId mismatch in ${filename} (expected ${expectedBatchId}, got ${msg.batchId}), skipping\n`);
+			stats.skipped++;
+			continue;
+		}
+
+		// Validate to (no misdelivery)
+		if (msg.to !== expectedSessionName) {
+			process.stderr.write(`\n[STEERING] WARNING: misdelivery in ${filename} (to=${msg.to}, expected ${expectedSessionName}), skipping\n`);
+			stats.skipped++;
+			continue;
+		}
+
+		validMessages.push({ filename, message: msg });
+	}
+
+	// Sort: primary by timestamp ascending, tie-break by filename lexical
+	validMessages.sort((a, b) => {
+		const tsDiff = a.message.timestamp - b.message.timestamp;
+		if (tsDiff !== 0) return tsDiff;
+		return a.filename.localeCompare(b.filename);
+	});
+
+	// Inject each message via steer RPC command and move to ack/
+	for (const { filename, message } of validMessages) {
+		try {
+			// Precondition: stdin must be available for injection.
+			// If stdin is closed/destroyed, keep message in inbox (no false ack).
+			if (!proc.stdin || proc.stdin.destroyed) {
+				stats.skipped++;
+				continue;
+			}
+
+			// Inject via steer RPC command
+			proc.stdin.write(JSON.stringify({ type: "steer", message: message.content }) + "\n");
+
+			// Move to ack/ (delivery proof)
+			const ackDir = join(mailboxDir, "ack");
+			try { mkdirSync(ackDir, { recursive: true }); } catch { /* exists */ }
+			try {
+				renameSync(join(inboxDir, filename), join(ackDir, filename));
+			} catch (err) {
+				// ENOENT race is harmless (another process acked it)
+				if (err.code !== "ENOENT") {
+					process.stderr.write(`\n[STEERING] WARNING: failed to ack ${filename}: ${err.message}\n`);
+				}
+			}
+
+			stats.delivered++;
+			process.stderr.write(`\n[STEERING] Delivered message ${message.id}\n`);
+		} catch (err) {
+			process.stderr.write(`\n[STEERING] WARNING: failed to deliver ${filename}: ${err.message}\n`);
+			stats.skipped++;
+		}
+	}
+
+	return stats;
+}
+
+/**
+ * Runtime validation for mailbox message shape in rpc-wrapper.
+ * Mirrors isValidMailboxMessage() from mailbox.ts but as a standalone
+ * function (rpc-wrapper.mjs is a plain .mjs module, not TypeScript).
+ *
+ * @param {any} obj - Parsed JSON value
+ * @returns {boolean} true if valid shape
+ */
+function isValidMailboxMessageShape(obj) {
+	if (!obj || typeof obj !== "object") return false;
+	return (
+		typeof obj.id === "string" &&
+		typeof obj.batchId === "string" &&
+		typeof obj.from === "string" &&
+		typeof obj.to === "string" &&
+		typeof obj.timestamp === "number" && Number.isFinite(obj.timestamp) &&
+		typeof obj.type === "string" && MAILBOX_MESSAGE_TYPES.has(obj.type) &&
+		typeof obj.content === "string"
+	);
+}
+
 // ── Exports for Testing ──────────────────────────────────────────────
 
 // Export pure functions so tests can import them without triggering side effects.
@@ -503,6 +662,9 @@ export {
 	applyEvent,
 	buildExitSummary,
 	createSingleWriteGuard,
+	checkMailboxAndSteer,
+	isValidMailboxMessageShape,
+	MAILBOX_MESSAGE_TYPES,
 };
 
 // ── Main ─────────────────────────────────────────────────────────────
@@ -602,6 +764,15 @@ const proc = spawn("pi", piArgs, {
 const promptCmd = { type: "prompt", message: promptContent };
 proc.stdin.write(JSON.stringify(promptCmd) + "\n");
 
+// ── Agent Mailbox Steering Setup (TP-089) ────────────────────────────
+// When mailbox-dir is provided, set steering mode to "all" so queued
+// steering messages are delivered together at the next turn boundary.
+// Must be sent after prompt but before any agent processing begins.
+if (args.mailboxDir) {
+	proc.stdin.write(JSON.stringify({ type: "set_steering_mode", mode: "all" }) + "\n");
+	process.stderr.write(`[rpc-wrapper] mailbox enabled: ${args.mailboxDir}\n`);
+}
+
 // ── Stdin Lifecycle ──────────────────────────────────────────────────
 
 /**
@@ -677,6 +848,16 @@ function handleEvent(event) {
 			// Falls back gracefully: older pi versions ignore the command
 			// or return a response without contextUsage — state.contextUsage stays null.
 			querySessionStats();
+			// Check mailbox for pending steering messages (TP-089).
+			// Only active when --mailbox-dir is provided (backward compatible).
+			if (args.mailboxDir) {
+				try {
+					checkMailboxAndSteer(args.mailboxDir, proc);
+				} catch (err) {
+					// Never crash on mailbox I/O errors
+					process.stderr.write(`\n[STEERING] ERROR: ${err.message}\n`);
+				}
+			}
 			break;
 
 		case "tool_execution_start":

package/dashboard/public/app.js

@@ -621,6 +621,58 @@ function renderLanesTasks(batch, tmuxSessions) {
 
 // ─── Render: Merge Agents ───────────────────────────────────────────────────
 
+/** Build full telemetry HTML for a merge agent (parity with worker stats).
+ *  Shows: elapsed, tool count, context %, cost, current tool, retry/compaction badges.
+ *  Returns empty string if no meaningful telemetry exists.
+ */
+function mergeTelemetryHtml(tel, alive) {
+  if (!tel) return '<span class="merge-no-data">—</span>';
+  const hasData = (tel.inputTokens || 0) > 0 || (tel.outputTokens || 0) > 0 ||
+    (tel.toolCalls || 0) > 0 || (tel.cost || 0) > 0;
+  if (!hasData) return '<span class="merge-no-data">—</span>';
+
+  let html = '<div class="merge-stats">';
+
+  // Elapsed time
+  if (tel.startedAt) {
+    const elapsed = Date.now() - tel.startedAt;
+    html += `<span class="worker-stat" title="Merge elapsed">⏱ ${formatDuration(elapsed)}</span>`;
+  }
+
+  // Tool calls
+  if (tel.toolCalls > 0) {
+    html += `<span class="worker-stat" title="Tool calls">🔧 ${tel.toolCalls}</span>`;
+  }
+
+  // Context %
+  if (tel.contextPct > 0) {
+    html += `<span class="worker-stat" title="Context window used">📊 ${Math.round(tel.contextPct)}%</span>`;
+  }
+
+  // Tokens + cost
+  const inp = (tel.inputTokens || 0) + (tel.cacheReadTokens || 0);
+  const out = tel.outputTokens || 0;
+  const cost = tel.cost || 0;
+  if (inp > 0 || out > 0) {
+    let tokenStr = `↑${formatTokens(inp)} ↓${formatTokens(out)}`;
+    if (cost > 0) tokenStr += ` ${formatCost(cost)}`;
+    html += `<span class="worker-stat" title="Tokens">🪙 ${tokenStr}</span>`;
+  }
+
+  // Current tool (if alive/active) or last tool (completed merges)
+  if (alive && tel.currentTool) {
+    html += `<span class="worker-stat worker-last-tool" title="Current tool">${escapeHtml(tel.currentTool)}</span>`;
+  } else if (!alive && tel.lastTool) {
+    html += `<span class="worker-stat worker-last-tool" title="Last tool">${escapeHtml(tel.lastTool)}</span>`;
+  }
+
+  // Retry/compaction badges (reuse shared helper)
+  html += telemetryBadgesHtml(tel);
+
+  html += '</div>';
+  return html;
+}
+
 function renderMergeAgents(batch, tmuxSessions) {
   const mergeResults = batch?.mergeResults || [];
   const tmuxSet = new Set(tmuxSessions || []);
@@ -642,8 +694,8 @@ function renderMergeAgents(batch, tmuxSessions) {
       mergePrefix = laneMatch[1] + "-merge";
     }
   }
-  // Helper: get merge session name for a lane number
-  const getMergeSessionName = (laneNum) => `${mergePrefix}-${laneNum}`;
+  // Helper: get merge session name for a merge number
+  const getMergeSessionName = (mergeNum) => `${mergePrefix}-${mergeNum}`;
 
   if (mergeResults.length === 0 && mergeSessions.length === 0) {
     $mergeBody.innerHTML = '<div class="empty-state">No merge agents active</div>';
@@ -671,49 +723,64 @@ function renderMergeAgents(batch, tmuxSessions) {
       : mr.status === "partial" ? "status-stalled"
       : "status-failed";
 
-    // Look for matching tmux merge sessions for this wave result.
-    // Merge sessions follow the naming pattern: {prefix}-{opId}-merge-{laneNumber}
-    // (e.g., "orch-henrylach-merge-1"). Find any alive merge sessions.
-    const waveMergeSessions = mergeSessions.filter(s => tmuxSet.has(s));
-    const sessionName = waveMergeSessions.length > 0 ? waveMergeSessions[0] : null;
-    const alive = sessionName !== null;
-    if (alive) shownSessions.add(sessionName);
+    // Merge session mapping: derive from lane numbers involved in this wave.
+    // Merge sessions are named by lane number (e.g., ...-merge-1), not wave index.
+    // Extract lane numbers from repoResults or from batch tasks for this wave.
+    const waveLaneNums = new Set();
+    const repoResults2 = mr.repoResults || [];
+    for (const rr of repoResults2) {
+      for (const ln of (rr.laneNumbers || [])) waveLaneNums.add(ln);
+    }
+    // Fallback: find lane numbers from tasks assigned to this wave
+    if (waveLaneNums.size === 0 && batch.wavePlan && batch.wavePlan[mr.waveIndex]) {
+      const waveTaskIds = new Set(batch.wavePlan[mr.waveIndex]);
+      for (const t of (batch.tasks || [])) {
+        if (waveTaskIds.has(t.taskId) && t.laneNumber != null) {
+          waveLaneNums.add(t.laneNumber);
+        }
+      }
+    }
+    // Find alive merge sessions matching the wave's lane numbers
+    let effectiveSession = null;
+    for (const ln of waveLaneNums) {
+      const candidate = getMergeSessionName(ln);
+      if (tmuxSet.has(candidate) && !shownSessions.has(candidate)) {
+        effectiveSession = candidate;
+        break;
+      }
+    }
+    // Fallback: any unshown alive merge session
+    if (!effectiveSession) {
+      effectiveSession = mergeSessions.find(s => tmuxSet.has(s) && !shownSessions.has(s)) || null;
+    }
+    const effectiveAlive = !!effectiveSession;
+    if (effectiveSession) shownSessions.add(effectiveSession);
 
-    // Look for merge telemetry data — check all merge sessions
+    // Find merge telemetry: try sessions by lane number first
     let mergeTel = null;
-    for (const ms of mergeSessions) {
-      if (telemetry[ms]) { mergeTel = telemetry[ms]; break; }
+    for (const ln of waveLaneNums) {
+      const candidate = getMergeSessionName(ln);
+      if (telemetry[candidate]) { mergeTel = telemetry[candidate]; break; }
     }
+    // Fallback: effective session telemetry or any merge session
+    if (!mergeTel && effectiveSession) mergeTel = telemetry[effectiveSession] || null;
+    if (!mergeTel) mergeTel = mergeSessions.reduce((found, ms) => found || telemetry[ms] || null, null);
 
     html += `<tr>`;
-    html += `<td style="font-family:var(--font-mono);">Wave ${mr.waveIndex + 1}</td>`;
+    html += `<td class="merge-wave-cell">Wave ${mr.waveIndex + 1}</td>`;
     html += `<td><span class="status-badge ${statusCls}">${mr.status}</span></td>`;
-    html += `<td style="font-family:var(--font-mono);font-size:0.8rem;">${alive ? escapeHtml(sessionName) : "—"}</td>`;
-    // Telemetry cell
-    html += `<td style="font-size:0.75rem;">`;
-    if (mergeTel) {
-      const totalTok = (mergeTel.inputTokens || 0) + (mergeTel.outputTokens || 0);
-      const cost = mergeTel.cost || 0;
-      if (totalTok > 0 || cost > 0) {
-        html += `<span style="color:var(--text-muted);">${totalTok > 0 ? totalTok.toLocaleString() + " tok" : ""}`;
-        if (cost > 0) html += ` · $${cost.toFixed(4)}`;
-        html += `</span>`;
-      } else {
-        html += '<span style="color:var(--text-faint);">—</span>';
-      }
-    } else {
-      html += '<span style="color:var(--text-faint);">—</span>';
-    }
-    html += `</td>`;
+    html += `<td class="merge-session-cell">${effectiveAlive ? escapeHtml(effectiveSession) : "—"}</td>`;
+    // Full telemetry cell
+    html += `<td class="merge-telemetry-cell">${mergeTelemetryHtml(mergeTel, effectiveAlive)}</td>`;
     html += `<td>`;
-    if (alive) {
-      const cmd = `tmux attach -t ${sessionName}`;
-      html += `<span class="tmux-cmd" data-tmux="${escapeHtml(sessionName)}" onclick="copyTmuxCmd('${escapeHtml(sessionName)}')" title="Click to copy">${escapeHtml(cmd)}</span>`;
+    if (effectiveAlive) {
+      const cmd = `tmux attach -t ${effectiveSession}`;
+      html += `<span class="tmux-cmd" data-tmux="${escapeHtml(effectiveSession)}" onclick="copyTmuxCmd('${escapeHtml(effectiveSession)}')" title="Click to copy">${escapeHtml(cmd)}</span>`;
     } else {
-      html += '<span style="color:var(--text-faint);">—</span>';
+      html += '<span class="merge-no-data">—</span>';
     }
     html += `</td>`;
-    html += `<td style="font-size:0.8rem;color:var(--text-muted);">${mr.failureReason ? escapeHtml(mr.failureReason) : "—"}</td>`;
+    html += `<td class="merge-detail-cell">${mr.failureReason ? escapeHtml(mr.failureReason) : "—"}</td>`;
     html += `</tr>`;
 
     // Per-repo sub-rows: show when workspace mode has repo results
@@ -732,10 +799,10 @@ function renderMergeAgents(batch, tmuxSessions) {
         html += `<tr class="merge-repo-row">`;
         html += `<td>${repoBadgeHtml(rr.repoId)}</td>`;
         html += `<td><span class="status-badge ${rrStatusCls}">${rr.status}</span></td>`;
-        html += `<td style="font-family:var(--font-mono);font-size:0.75rem;color:var(--text-faint);">${rrLanes}</td>`;
+        html += `<td class="merge-session-cell">${rrLanes}</td>`;
         html += `<td></td>`; /* telemetry placeholder */
         html += `<td></td>`; /* attach placeholder */
-        html += `<td style="font-size:0.75rem;color:var(--text-faint);">${rrDetail}</td>`;
+        html += `<td class="merge-detail-cell">${rrDetail}</td>`;
         html += `</tr>`;
       }
     }
@@ -748,25 +815,11 @@ function renderMergeAgents(batch, tmuxSessions) {
     const sessTel = telemetry[sess] || null;
     const cmd = `tmux attach -t ${sess}`;
     html += `<tr>`;
-    html += `<td style="font-family:var(--font-mono);">—</td>`;
+    html += `<td class="merge-wave-cell">—</td>`;
     html += `<td><span class="status-badge status-running"><span class="status-dot running"></span> merging</span></td>`;
-    html += `<td style="font-family:var(--font-mono);font-size:0.8rem;">${escapeHtml(sess)}</td>`;
-    // Telemetry cell for active merge session
-    html += `<td style="font-size:0.75rem;">`;
-    if (sessTel) {
-      const totalTok = (sessTel.inputTokens || 0) + (sessTel.outputTokens || 0);
-      const cost = sessTel.cost || 0;
-      if (totalTok > 0 || cost > 0) {
-        html += `<span style="color:var(--text-muted);">${totalTok > 0 ? totalTok.toLocaleString() + " tok" : ""}`;
-        if (cost > 0) html += ` · $${cost.toFixed(4)}`;
-        html += `</span>`;
-      } else {
-        html += '<span style="color:var(--text-faint);">—</span>';
-      }
-    } else {
-      html += '<span style="color:var(--text-faint);">—</span>';
-    }
-    html += `</td>`;
+    html += `<td class="merge-session-cell">${escapeHtml(sess)}</td>`;
+    // Full telemetry cell for active merge session
+    html += `<td class="merge-telemetry-cell">${mergeTelemetryHtml(sessTel, true)}</td>`;
     html += `<td><span class="tmux-cmd" data-tmux="${escapeHtml(sess)}" onclick="copyTmuxCmd('${escapeHtml(sess)}')" title="Click to copy">${escapeHtml(cmd)}</span></td>`;
     html += `<td>—</td>`;
     html += `</tr>`;

package/dashboard/public/style.css

@@ -712,6 +712,24 @@ body {
 .merge-table tr:last-child td { border-bottom: none; }
 .merge-table tr:hover td { background: var(--bg-surface-hover); }
 
+.merge-wave-cell { font-family: var(--font-mono); }
+.merge-session-cell { font-family: var(--font-mono); font-size: 0.8rem; }
+.merge-detail-cell { font-size: 0.8rem; color: var(--text-muted); }
+.merge-no-data { color: var(--text-faint); }
+
+.merge-stats {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 4px 8px;
+  align-items: center;
+  font-size: 0.75rem;
+}
+
+.merge-telemetry-cell {
+  font-size: 0.75rem;
+  min-width: 120px;
+}
+
 /* ─── Terminal Panel ────────────────────────────────────────────────────── */
 
 .terminal-panel .panel-header {

package/dashboard/server.cjs

@@ -427,8 +427,9 @@ function loadTelemetryData(batchState) {
       const fresh = {
         inputTokens: 0, outputTokens: 0, cacheReadTokens: 0,
         cacheWriteTokens: 0, cost: 0, toolCalls: 0,
-        lastTool: "", retries: 0, retryActive: false,
+        lastTool: "", currentTool: "", retries: 0, retryActive: false,
         lastRetryError: "", compactions: 0, latestTotalTokens: 0,
+        contextPct: 0, startedAt: 0,
       };
       telemetryAccumulators.set(prefix, fresh);
       // Also reset tail states for ALL files of this prefix to re-read from beginning
@@ -450,8 +451,9 @@ function loadTelemetryData(batchState) {
     if (ts && ts.wasReset) {
       acc.inputTokens = 0; acc.outputTokens = 0; acc.cacheReadTokens = 0;
       acc.cacheWriteTokens = 0; acc.cost = 0; acc.toolCalls = 0;
-      acc.lastTool = ""; acc.retries = 0; acc.retryActive = false;
+      acc.lastTool = ""; acc.currentTool = ""; acc.retries = 0; acc.retryActive = false;
       acc.lastRetryError = ""; acc.compactions = 0; acc.latestTotalTokens = 0;
+      acc.contextPct = 0; acc.startedAt = 0;
       ts.wasReset = false;
     }
     for (const event of events) {
@@ -497,7 +499,31 @@ function loadTelemetryData(batchState) {
               }
             }
           }
-          acc.lastTool = argPreview ? `${toolDesc} ${argPreview}` : toolDesc;
+          const toolLabel = argPreview ? `${toolDesc} ${argPreview}` : toolDesc;
+          acc.lastTool = toolLabel;
+          acc.currentTool = toolLabel;
+          break;
+        }
+        case "tool_execution_end": {
+          acc.currentTool = "";
+          break;
+        }
+        case "agent_start": {
+          if (event.ts && !acc.startedAt) {
+            acc.startedAt = event.ts;
+          }
+          break;
+        }
+        case "response": {
+          // Extract context usage from get_session_stats responses
+          const ctxUsage = event.data?.contextUsage;
+          if (ctxUsage) {
+            // Support both percent (current) and percentUsed (legacy pi versions)
+            const pct = typeof ctxUsage.percent === "number" ? ctxUsage.percent
+              : typeof ctxUsage.percentUsed === "number" ? ctxUsage.percentUsed
+              : null;
+            if (pct !== null) acc.contextPct = pct;
+          }
           break;
         }
         case "auto_retry_start": {