@siuver/omp-debug-mode 0.1.3 → 0.1.4

package/src/debug-mode.ts

@@ -2,6 +2,7 @@ import { Text } from "@oh-my-pi/pi-coding-agent";
 import type { ExtensionAPI, ExtensionContext, MessageRenderer } from "@oh-my-pi/pi-coding-agent";
 import * as fs from "node:fs";
 import * as path from "node:path";
+import { addEvidenceArtifact, describeEvidence, parseEvidencePlan } from "./evidence";
 import { decideGate } from "./gate";
 import {
 	ACTIVE_LOG_FILE,
@@ -11,6 +12,7 @@ import {
 	readJsonlLines,
 	summarizeHypotheses,
 } from "./log-files";
+import { describeLedger, recordProbes, syncLedger } from "./probes";
 import {
 	CLEANUP_CONTRACT,
 	METHODOLOGY,
@@ -21,27 +23,28 @@ import {
 	extractAssistantText,
 	extractReproductionSteps,
 } from "./methodology";
-import { describeLedger, recordProbes, syncLedger } from "./probes";
-import { REVIEW_ABORT, REVIEW_ADD_DETAILS, REVIEW_MARK_FIXED, REVIEW_PROCEED, reviewMenuOptions } from "./review-actions";
 import {
 	DEBUG_CONTEXT_TYPE,
 	DEBUG_ENTRY,
 	type DebugState,
+	type EvidenceObservation,
 	blackboard,
 	compareRunIds,
+	evidenceSummary,
 	freshState,
 	keepLatestCustomType,
 	logFileFor,
+	pendingEvidenceRequests,
+	replaceRoundEvidenceRequests,
 } from "./state";
 import { registerDebugTools } from "./tools";
-import { applyUi, reviewMenuTitle } from "./ui";
+import { applyUi } from "./ui";
 import { debugDirFor, excludeDebugLogsFromGit, pruneDebugRoot } from "./workspace";
 
 const COMMAND_MODE = "debug-mode";
-const COMMAND_MENU = "debug-menu";
 const COMMAND_DONE = "debug-done";
 const COMMAND_PROCEED = "debug-proceed";
-const COMMAND_NOTE = "debug-note";
+const COMMAND_EVIDENCE = "debug-evidence";
 const COMMAND_ABORT = "debug-abort";
 const COMMAND_STATUS = "debug-status";
 
@@ -49,7 +52,6 @@ const COMMAND_STATUS = "debug-status";
 const MESSAGE_SUMMARIES: Record<string, string> = {
 	"debug-mode-start": "debug mode started — hypotheses and instrumentation",
 	"debug-mode-proceed": "proceed — analyzing captured logs",
-	"debug-mode-note": "reproduction details added — analyzing captured logs",
 	"debug-mode-fixed": "marked fixed — removing probes and summarizing",
 };
 
@@ -59,7 +61,6 @@ interface DebugMessageDetails {
 
 export function registerDebugMode(pi: ExtensionAPI): void {
 	const state: DebugState = freshState();
-	let reviewMenuOpen = false;
 	let uiCtx: ExtensionContext | null = null;
 	let watchedLogFile: string | null = null;
 	const lineCounter = new JsonlLineCounter();
@@ -203,8 +204,8 @@ export function registerDebugMode(pi: ExtensionAPI): void {
 		return {
 			message: {
 				customType: DEBUG_CONTEXT_TYPE,
-				content: `${blackboard(state)}\n\n${contract}`,
-				display: false,
+				content: `${blackboard(state, describeEvidence(state))}\n\n${contract}`,
+                display: false,
 			},
 		};
 	});
@@ -229,23 +230,33 @@ export function registerDebugMode(pi: ExtensionAPI): void {
 		if (msg?.role === "assistant") {
 			if (state.phase === "cleanup") state.cleanupReady = true;
 			state.hasRoundContent = true;
-			const steps = extractReproductionSteps(extractAssistantText(msg.content));
+			const text = extractAssistantText(msg.content);
+			const steps = extractReproductionSteps(text);
 			if (steps.length > 0) state.reproductionSteps = steps;
+			if (state.phase === "round") {
+				const plan = parseEvidencePlan(text, state.round);
+				if (plan.found) {
+					replaceRoundEvidenceRequests(state, state.round, plan.valid ? plan.requests : []);
+					pi.appendEntry(DEBUG_ENTRY, { ...state });
+				}
+			}
 		}
 	});
 
 	pi.on("session_stop", async (_event, ctx) => {
 		if (!state.active) return;
 		if (state.phase === "cleanup") {
-			// Cleanup turn settled: keep fixes and remove the temporary logs.
 			if (state.cleanupReady) await teardown(ctx, "finished");
 			return;
 		}
+		// Ordinary editor messages while waiting are conversational only. Only an
+		// explicit debug command advances the run or leaves the gate.
 		if (state.phase !== "round" || !state.hasRoundContent) return;
-
 		const probesThisRound = state.probes.filter(p => p.round === state.round).length;
+		const hasEvidencePlan = state.evidenceRequests.some(request => request.round === state.round);
 		const decision = decideGate({
 			hasReproductionSteps: state.reproductionSteps.length > 0,
+			hasEvidencePlan,
 			probesThisRound,
 			nudgesUsed: state.gateNudges,
 		});
@@ -254,29 +265,47 @@ export function registerDebugMode(pi: ExtensionAPI): void {
 			state.gateNudges += 1;
 			return { continue: true, additionalContext: decision.context };
 		}
-		enterGate(ctx, probesThisRound, decision.missingSteps);
+		enterGate(ctx, probesThisRound, decision.missingSteps, decision.missingEvidencePlan);
 	});
 
-	function enterGate(ctx: ExtensionContext, probesThisRound: number, missingSteps: boolean): void {
-		state.phase = "waiting";
-		pi.appendEntry(DEBUG_ENTRY, { ...state });
-		refreshUi();
-		watchLogFile();
-		scheduleReviewMenu(ctx);
-		if (probesThisRound === 0) {
-			ctx.ui.notify(
-				`Debug round ${state.round} paused, but it added no probes — this round cannot produce runtime evidence. Use /${COMMAND_MENU} and Proceed to ask for instrumentation.`,
-				"warning",
-			);
-		} else if (missingSteps) {
-			ctx.ui.notify(
-				`Debug round ${state.round} paused without reproduction steps. Exercise the instrumented path, then ${PROCEED_REMINDER}`,
-				"warning",
-			);
-		} else {
-			ctx.ui.notify(`Debug round ${state.round} paused. Reproduce the bug, then ${PROCEED_REMINDER}`, "info");
-		}
+function enterGate(
+	ctx: ExtensionContext,
+	probesThisRound: number,
+	missingSteps: boolean,
+	missingEvidencePlan: boolean,
+): void {
+	state.phase = "waiting";
+	pi.appendEntry(DEBUG_ENTRY, { ...state });
+	refreshUi();
+	watchLogFile();
+	// Commands are the only interaction at the gate: the widget lists them,
+	// the user picks one. No menu is opened automatically.
+	const pending = pendingEvidenceRequests(state, state.round);
+	const hasValidPlan = state.evidenceRequests.some(request => request.round === state.round);
+	if (probesThisRound === 0 && !hasValidPlan) {
+		ctx.ui.notify(
+			`Debug round ${state.round} paused, but it added no probes and declared no evidence plan — this round cannot produce runtime evidence. Use /${COMMAND_PROCEED} to ask for instrumentation.`,
+			"warning",
+		);
+	} else if (missingSteps) {
+		ctx.ui.notify(
+			`Debug round ${state.round} paused without reproduction steps. Exercise the instrumented path, then ${PROCEED_REMINDER}`,
+			"warning",
+		);
+	} else if (pending.length > 0) {
+		ctx.ui.notify(
+			`Debug round ${state.round} paused. User evidence requested (${pending.length} pending: ${pending.map(r => r.id).join(", ")}) — attach via /${COMMAND_EVIDENCE} <request-id> <path>, then ${PROCEED_REMINDER}`,
+			"info",
+		);
+	} else if (missingEvidencePlan) {
+		ctx.ui.notify(
+			`Debug round ${state.round} paused. The gate is usable, but the next Proceed will ask the model to declare an evidence method.`,
+			"info",
+		);
+	} else {
+		ctx.ui.notify(`Debug round ${state.round} paused. Reproduce the bug, then ${PROCEED_REMINDER}`, "info");
 	}
+}
 
 	// ============================== round transitions ==============================
 
@@ -296,6 +325,9 @@ export function registerDebugMode(pi: ExtensionAPI): void {
 		state.cleanupReady = false;
 		state.reproductionSteps = [];
 		state.gateNudges = 0;
+		state.evidenceRequests = [];
+		state.evidenceArtifacts = [];
+		state.evidenceObservations = [];
 		if (!newRun()) {
 			Object.assign(state, freshState());
 			ctx.ui.notify("debug-mode: could not initialize the run log file; debug mode was not started", "error");
@@ -331,10 +363,13 @@ export function registerDebugMode(pi: ExtensionAPI): void {
 		return true;
 	}
 
-	async function markDebugFixed(ctx: ExtensionContext): Promise<void> {
+    async function markDebugFixed(ctx: ExtensionContext): Promise<void> {
 		if (!ensureWaiting(ctx)) return;
 		const logCount = currentLogCount();
-		if (logCount === 0 && ctx.hasUI) {
+		const hasNonProbeEvidence = state.evidenceRequests.some(
+			request => request.round === state.round && request.method !== "runtime_probe",
+		);
+		if (logCount === 0 && !hasNonProbeEvidence && ctx.hasUI) {
 			const confirmed = await ctx.ui.confirm(
 				"Mark as fixed without runtime logs?",
 				"No runtime observations were captured for this round. Mark the problem as fixed anyway?",
@@ -347,23 +382,30 @@ export function registerDebugMode(pi: ExtensionAPI): void {
 		state.cleanupReady = false;
 		unwatchLogFile();
 		refreshUi();
+		const evidenceJson = JSON.stringify({
+			requests: state.evidenceRequests,
+			observations: state.evidenceObservations,
+			artifacts: state.evidenceArtifacts,
+		});
 		pi.sendMessage(
 			{
 				customType: "debug-mode-fixed",
-				content: buildFixedMessage(JSON.stringify(state.probes)),
-				display: true,
+				content: buildFixedMessage(JSON.stringify(state.probes), evidenceJson),
 				details: { summary: `marked fixed — removing ${state.probes.length} probe(s)` } satisfies DebugMessageDetails,
 			},
 			{ triggerTurn: true },
 		);
-	}
+    }
 
-	async function advanceDebug(ctx: ExtensionContext, reproductionDetails?: string): Promise<void> {
+	async function advanceDebug(ctx: ExtensionContext, userDetails?: string): Promise<void> {
 		if (!ensureWaiting(ctx)) return;
 		refreshLogCounts();
 		const run = state.runId ?? "(none)";
 		const logCount = state.logCounts[run] ?? 0;
-		if (logCount === 0 && !reproductionDetails && ctx.hasUI) {
+		const hasNonProbeEvidence = state.evidenceRequests.some(
+			request => request.round === state.round && request.method !== "runtime_probe",
+		);
+		if (logCount === 0 && !userDetails && !hasNonProbeEvidence && ctx.hasUI) {
 			const confirmed = await ctx.ui.confirm(
 				"Proceed without runtime logs?",
 				"No runtime observations were captured for this round. Continue to log analysis anyway?",
@@ -372,6 +414,34 @@ export function registerDebugMode(pi: ExtensionAPI): void {
 		}
 		if (!state.active || state.phase !== "waiting") return;
 
+		// Persist optional /debug-proceed details as a batched user observation
+		// tied to every current-round user_report request.
+		if (userDetails && userDetails.trim().length > 0) {
+			const reportIds = state.evidenceRequests
+				.filter(request => request.round === state.round && request.method === "user_report")
+				.map(request => request.id);
+			const observation: EvidenceObservation = {
+				id: `observation-${Date.now().toString(36)}`,
+				requestIds: reportIds,
+				text: userDetails.trim(),
+				round: state.round,
+				addedAt: Date.now(),
+			};
+			state.evidenceObservations = [...state.evidenceObservations, observation];
+		}
+		const stillPending = pendingEvidenceRequests(state, state.round);
+		if (stillPending.length > 0 && ctx.hasUI) {
+			const confirmed = await ctx.ui.confirm(
+				"Proceed without all requested evidence?",
+				`${stillPending.length} evidence request(s) still pending (${stillPending.map(r => r.id).join(", ")}). Continue anyway?`,
+			);
+			if (!confirmed) {
+				pi.appendEntry(DEBUG_ENTRY, { ...state });
+				refreshUi();
+				return;
+			}
+		}
+
 		const hypotheses = describeHypotheses(summarizeHypotheses(readRunLines(run)));
 		const previousRound = state.round;
 		const previousSteps = state.reproductionSteps;
@@ -391,13 +461,19 @@ export function registerDebugMode(pi: ExtensionAPI): void {
 		unwatchLogFile();
 		refreshUi();
 
-		const summary = reproductionDetails
-			? `reproduction details added — analyzing run ${run} (${logCount} entries)`
+		const summary = userDetails
+			? `proceed with user details — analyzing run ${run} (${logCount} entries)`
 			: `proceed — analyzing run ${run} (${logCount} entries)`;
 		pi.sendMessage(
 			{
-				customType: reproductionDetails ? "debug-mode-note" : "debug-mode-proceed",
-				content: buildProceedMessage({ run, logCount, reproductionDetails, hypotheses }),
+				customType: "debug-mode-proceed",
+				content: buildProceedMessage({
+					run,
+					logCount,
+					userDetails,
+					hypotheses,
+					evidenceSummary: evidenceSummary(state, previousRound),
+				}),
 				display: true,
 				details: { summary } satisfies DebugMessageDetails,
 			},
@@ -452,50 +528,56 @@ export function registerDebugMode(pi: ExtensionAPI): void {
 	}
 
 	/**
-	 * Open the action menu after `session_stop` has returned. Awaiting it
-	 * inside that handler would hold the agent-loop lock for the whole
-	 * reproduction; the microtask lets the round settle first.
+	 * Attach one user-provided evidence file to the current waiting round. The
+	 * file is referenced in place — never copied, moved or deleted — and the
+	 * action stays at the gate: no model-visible message, no agent turn.
 	 */
-	function scheduleReviewMenu(ctx: ExtensionContext): void {
-		if (!ctx.hasUI) return;
-		queueMicrotask(() => {
-			openReviewMenu(ctx).catch(err => {
-				pi.logger.warn("debug-mode: review menu failed to open", { err });
-			});
-		});
-	}
-
-	async function openReviewMenu(ctx: ExtensionContext): Promise<void> {
-		if (!ensureWaiting(ctx)) return;
-		if (!ctx.hasUI) {
-			ctx.ui.notify(`/${COMMAND_MENU} requires an interactive UI; use /${COMMAND_DONE} or /${COMMAND_PROCEED} instead.`, "warning");
-			return;
-		}
-		if (reviewMenuOpen) {
-			ctx.ui.notify("debug-mode: review menu is already open", "info");
-			return;
+	async function attachEvidence(ctx: ExtensionContext, rawPath?: string, requestId: string | null = null): Promise<boolean> {
+		if (!ensureWaiting(ctx)) return false;
+		let input = rawPath?.trim() ?? "";
+		if (!input) {
+			if (!ctx.hasUI) {
+				ctx.ui.notify(`Usage: /${COMMAND_EVIDENCE} <path>`, "error");
+				return false;
+			}
+			input = (await ctx.ui.input("Path to debug evidence file", "absolute or cwd-relative path")) ?? "";
+			if (!input.trim()) {
+				ctx.ui.notify("debug-mode: no evidence file path provided", "error");
+				return false;
+			}
 		}
-
-		reviewMenuOpen = true;
-		try {
-			const probesThisRound = state.probes.filter(p => p.round === state.round).length;
-			const title = reviewMenuTitle(state.round, currentLogCount(), probesThisRound);
-			const choice = await ctx.ui.select(title, reviewMenuOptions());
-			if (!choice) return;
-			if (choice === REVIEW_MARK_FIXED) {
-				await markDebugFixed(ctx);
-			} else if (choice === REVIEW_PROCEED) {
-				await advanceDebug(ctx);
-			} else if (choice === REVIEW_ADD_DETAILS) {
-				ctx.ui.setEditorText("/debug-note ");
-				ctx.ui.notify("Add reproduction details in the editor, then submit /debug-note.", "info");
-			} else if (choice === REVIEW_ABORT) {
-				await abortDebug(ctx);
+		const trimmed = input.trim();
+		const cwdRoot = path.resolve(ctx.cwd);
+		const resolved = path.resolve(cwdRoot, trimmed);
+		const outsideCwd = resolved !== cwdRoot && !resolved.startsWith(`${cwdRoot}${path.sep}`);
+		if (outsideCwd) {
+			if (!ctx.hasUI) {
+				ctx.ui.notify(
+					`debug-mode: ${resolved} is outside the session working directory and cannot be confirmed without a UI`,
+					"error",
+				);
+				return false;
 			}
-		} finally {
-			reviewMenuOpen = false;
+			const confirmed = await ctx.ui.confirm(
+				"Attach evidence outside the working directory?",
+				`Record ${resolved} as debug evidence? The file is referenced in place and never modified.`,
+			);
+			if (!confirmed) return false;
 		}
-	}
+		const result = addEvidenceArtifact(state, trimmed, ctx.cwd, requestId);
+		if ("error" in result) {
+			ctx.ui.notify(`debug-mode: evidence rejected — ${result.error}`, "error");
+			return false;
+		}
+		Object.assign(state, result.state);
+		pi.appendEntry(DEBUG_ENTRY, { ...state });
+		refreshUi();
+		ctx.ui.notify(
+			`debug-mode: attached ${result.artifact.id} → ${result.artifact.path} (${result.artifact.size} bytes)`,
+			"info",
+		);
+		return true;
+}
 
 	// ============================== commands ==============================
 
@@ -504,7 +586,7 @@ export function registerDebugMode(pi: ExtensionAPI): void {
 		handler: async (args, ctx) => {
 			uiCtx = ctx;
 			if (state.active) {
-				ctx.ui.notify(`debug-mode: already active (use /${COMMAND_MENU}, /${COMMAND_DONE}, /${COMMAND_PROCEED}, or /${COMMAND_ABORT})`, "error");
+				ctx.ui.notify(`debug-mode: already active (use /${COMMAND_STATUS}, /${COMMAND_DONE}, /${COMMAND_PROCEED}, or /${COMMAND_ABORT})`, "error");
 				return;
 			}
 			const problem = args.trim();
@@ -528,34 +610,44 @@ export function registerDebugMode(pi: ExtensionAPI): void {
 	});
 
 	pi.registerCommand(COMMAND_PROCEED, {
-		description: "Continue with captured logs: evaluate hypotheses, fix only with evidence",
-		handler: async (_args, ctx) => {
+		description: "Continue with captured evidence and optional user details: /debug-proceed [details]",
+		handler: async (args, ctx) => {
 			uiCtx = ctx;
-			await advanceDebug(ctx);
+			const details = args.trim();
+			await advanceDebug(ctx, details || undefined);
 		},
 	});
 
-	pi.registerCommand(COMMAND_MENU, {
-		description: "Open the interactive action menu for a completed debug round",
-		handler: async (_args, ctx) => {
-			uiCtx = ctx;
-			await openReviewMenu(ctx);
-		},
-	});
+	/**
+	 * Parse `/debug-evidence [<request-id>] <path>`: when the first
+	 * whitespace-delimited token names a pending current-round user_artifact
+	 * request, link to it and treat the remainder (spaces intact) as the path;
+	 * otherwise the whole argument is an unlinked path.
+	 */
+	function parseEvidenceArgument(args: string): { requestId: string | null; rawPath: string | undefined } {
+		const trimmed = args.trim();
+		if (!trimmed) return { requestId: null, rawPath: undefined };
+		const firstToken = trimmed.split(/\s+/, 1)[0];
+		const isPending = pendingEvidenceRequests(state, state.round).some(
+			request => request.method === "user_artifact" && request.id === firstToken,
+		);
+		if (isPending) {
+			const rest = trimmed.slice(firstToken.length).trim();
+			return rest ? { requestId: firstToken, rawPath: rest } : { requestId: firstToken, rawPath: undefined };
+		}
+		return { requestId: null, rawPath: trimmed };
+	}
 
-	pi.registerCommand(COMMAND_NOTE, {
-		description: "Add reproduction details and continue: /debug-note <details>",
+	pi.registerCommand(COMMAND_EVIDENCE, {
+		description: "Attach one user-provided evidence file: /debug-evidence [<request-id>] <path> (no argument opens a path prompt)",
 		handler: async (args, ctx) => {
 			uiCtx = ctx;
-			const details = args.trim();
-			if (!details) {
-				ctx.ui.notify("Usage: /debug-note <reproduction details>", "error");
-				return;
-			}
-			await advanceDebug(ctx, details);
+			const { requestId, rawPath } = parseEvidenceArgument(args);
+			await attachEvidence(ctx, rawPath, requestId);
 		},
 	});
 
+
 	pi.registerCommand(COMMAND_ABORT, {
 		description: "Abort debug mode: delete logs (fixes stay in the working diff)",
 		handler: async (_args, ctx) => {
@@ -575,12 +667,28 @@ export function registerDebugMode(pi: ExtensionAPI): void {
 			refreshLogCounts();
 			const scan = await syncLedger(state);
 			const tallies = state.runId ? summarizeHypotheses(readRunLines(state.runId)) : [];
+			const roundRequests = state.evidenceRequests.filter(request => request.round === state.round);
+			const pending = pendingEvidenceRequests(state, state.round);
+			const unavailable = state.evidenceArtifacts.filter(artifact => {
+				try {
+					const stats = fs.statSync(artifact.path);
+					fs.accessSync(artifact.path, fs.constants.R_OK);
+					return !stats.isFile();
+				} catch {
+					return true;
+				}
+			});
 			ctx.ui.notify(
 				`debug-mode: phase=${state.phase} round=${state.round} run=${state.runId}\n` +
 					`${describeLedger(scan)}\n` +
 					`logs: ${state.runHistory.map(r => `${r}=${state.logCounts[r] ?? 0}`).join(", ") || "(none)"}\n` +
 					`this run by hypothesis: ${describeHypotheses(tallies)}\n` +
-					`current log file: ${logFileFor(state) ?? "(not initialized)"}`,
+					`current log file: ${logFileFor(state) ?? "(not initialized)"}\n` +
+					`evidence requests: ${roundRequests.map(r => `${r.id}[${r.method}] ${r.title}`).join("; ") || "(none)"}\n` +
+					`pending: ${pending.map(r => r.id).join(", ") || "(none)"}\n` +
+					`observations: ${state.evidenceObservations.map(o => o.id).join(", ") || "(none)"}\n` +
+					`artifacts: ${state.evidenceArtifacts.map(a => a.id).join(", ") || "(none)"}` +
+					(unavailable.length > 0 ? `\nunavailable artifacts: ${unavailable.map(a => `${a.id} ${a.path}`).join(", ")}` : ""),
 				"info",
 			);
 		},
@@ -601,6 +709,9 @@ export function registerDebugMode(pi: ExtensionAPI): void {
 		if (last?.data?.active) {
 			Object.assign(state, last.data);
 			if (!Array.isArray(state.reproductionSteps)) state.reproductionSteps = [];
+			if (!Array.isArray(state.evidenceRequests)) state.evidenceRequests = [];
+			if (!Array.isArray(state.evidenceArtifacts)) state.evidenceArtifacts = [];
+			if (!Array.isArray(state.evidenceObservations)) state.evidenceObservations = [];
 			if (!Array.isArray(state.runHistory)) state.runHistory = state.runId ? [state.runId] : [];
 			if (typeof state.gateNudges !== "number") state.gateNudges = 0;
 			if (!state.phase) state.phase = "waiting";
@@ -619,13 +730,12 @@ export function registerDebugMode(pi: ExtensionAPI): void {
 			}
 			refreshLogCounts();
 			ctx.ui.notify(
-				`debug-mode resumed: phase=${state.phase} round=${state.round}, log=${currentFile ?? "unavailable"}. Use /${COMMAND_STATUS}, /${COMMAND_MENU}, /${COMMAND_DONE}, /${COMMAND_PROCEED}, or /${COMMAND_ABORT}.`,
+				`debug-mode resumed: phase=${state.phase} round=${state.round}, log=${currentFile ?? "unavailable"}; evidence: ${evidenceSummary(state, state.round)}. Use /${COMMAND_STATUS}, /${COMMAND_EVIDENCE}, /${COMMAND_DONE}, /${COMMAND_PROCEED}, or /${COMMAND_ABORT}.`,
 				"info",
 			);
 		}
 		refreshUi();
 		watchLogFile();
-		if (state.active && state.phase === "waiting") scheduleReviewMenu(ctx);
 	});
 
 	pi.on("turn_start", async () => {