@dungle-scrubs/harness-cli-normalizer 0.6.0 → 0.6.1

package/src/execution/stream-turn.ts

@@ -8,39 +8,39 @@
  * evidence, not diagnostics. An abandoned turn (consumer breaks early)
  * closes backpressure, disposes output, stops the child, and awaits both
  * pumps before it returns.
+ *
+ * The supervising policies - stall clock, signal escalation, stderr
+ * classification, question detection at close - are the turn supervisor's
+ * (RFC-02 change 5); this runner composes it and owns only what is
+ * particular to one-shot turns: the wall-clock deadline, the exit
+ * classification, and the identity-first event buffer.
  */
 import {
-  buildLaunchArgv,
-  buildResumeArgv,
+  buildSpawnArgv,
   type LaunchOptions,
+  promptTextOf,
   streamingGranularityOf,
+  withPromptText,
 } from "../interpretation/argv.js";
-import { stdinPolicyOf } from "../interpretation/dimensions.js";
-import {
-  detectAuthFailureInLine,
-  detectLimitInLine,
-  detectTransportInLine,
-  detectUnavailableInLine,
-} from "../interpretation/limits.js";
-import {
-  composeEscalatedPrompt,
-  detectQuestionBlock,
-  type QuestionMode,
-} from "../interpretation/question.js";
+import { detectTransportInLine, detectUnavailableInLine } from "../interpretation/limits.js";
+import { composeEscalatedPrompt, type QuestionMode } from "../interpretation/question.js";
 import { ArgvRefusalError } from "../interpretation/refusal.js";
 import type { HarnessDescriptor } from "../knowledge/descriptor.js";
 import { matcherOverridesOf } from "../knowledge/overrides.js";
 import { AsyncChannel } from "./channel.js";
 import { decodeLine, freshDecodeState } from "./decode.js";
 import type { RunnerDeps, SpawnedProcess } from "./deps.js";
-import type { EscalationDetection, ExitCause, HarnessEvent } from "./events.js";
+import {
+  DROPPABLE_KINDS,
+  type EscalationDetection,
+  type ExitCause,
+  type HarnessEvent,
+} from "./events.js";
 import type { FailureSummary } from "./failure.js";
 import {
-  failureFromAuth,
   failureFromLimit,
   failureFromNative,
   failureFromRejected,
-  failureFromTask,
   failureFromTerminalError,
   failureFromTimeout,
   failureFromTransport,
@@ -48,15 +48,14 @@ import {
   reduceFailures,
 } from "./failure.js";
 import { LineBuffer } from "./lines.js";
+import { StderrTail, superviseTurn } from "./supervisor.js";
 
 /** Fallback correlation when the host does not mint turn ids: monotonic per
  * process. Hosts that need cross-process uniqueness pass deps.turnId. */
 let turnCounter = 0;
 
-/** SIGTERM -> SIGKILL escalation budget for a child that ignores the first
- * signal, and the grace allowed for pipes still held open (by a grandchild)
- * after the process itself exited. */
-export const KILL_GRACE_MS = 5_000;
+/** The grace allowed for pipes still held open (by a grandchild) after the
+ * process itself exited. */
 export const PIPE_GRACE_MS = 2_000;
 
 const OUTPUT_STREAMS = ["stdout", "stderr"] as const;
@@ -83,25 +82,6 @@ export const redactArgv = (argv: readonly string[], prompt?: string): string[] =
   });
 };
 
-/** Bounded tail of unmatched stderr - the crash context a nonzero exit is
- * explained by (v1 kept the turn's output slice for exactly this). Shared
- * with the session runner. */
-export class StderrTail {
-  private readonly lines: string[] = [];
-  private bytes = 0;
-  push(line: string): void {
-    this.lines.push(line);
-    this.bytes += line.length;
-    while (this.lines.length > 20 || (this.bytes > 4096 && this.lines.length > 1)) {
-      const dropped = this.lines.shift();
-      this.bytes -= dropped?.length ?? 0;
-    }
-  }
-  snapshot(): readonly string[] {
-    return [...this.lines];
-  }
-}
-
 export interface TurnRunOptions extends LaunchOptions {
   /** Resume this session id instead of launching fresh - the turn spawns
    * with the descriptor's resume grammar, and identity decoding treats a
@@ -136,11 +116,9 @@ export async function* streamTurn(
   const questionMode: QuestionMode = opts.questions ?? "ask";
   const effective: TurnRunOptions = {
     ...opts,
-    prompt: composeEscalatedPrompt(opts.prompt, questionMode),
+    prompt: withPromptText(opts.prompt, composeEscalatedPrompt(promptTextOf(opts), questionMode)),
   };
-  // The turn's last assistant message - where the protocol says the
-  // hcn-question block lives. Tracked only when detection is armed.
-  let lastAssistantText: string | null = null;
+  const promptText = promptTextOf(effective);
   let asked = false;
   let escalationDetection: EscalationDetection = "none";
 
@@ -166,7 +144,7 @@ export async function* streamTurn(
           harness: h.name,
           issue: refusal.issue,
           supported: refusal.supported,
-          argv: redactArgv([], effective.prompt),
+          argv: redactArgv([], promptText),
         });
         yield { kind: "failure", ...failure };
         yield {
@@ -184,19 +162,7 @@ export async function* streamTurn(
   let argv: string[];
   let granularity: import("../knowledge/descriptor.js").StreamingGranularity;
   try {
-    argv =
-      effective.resume === undefined
-        ? buildLaunchArgv(h, effective)
-        : buildResumeArgv(h, { ...effective, sessionId: effective.resume });
-    if (effective.passthrough !== undefined && effective.passthrough.length > 0) {
-      argv = [...argv, "--", ...effective.passthrough];
-    }
-    // issue #38: claude/codex render the skills allowlist as complement-off
-    // tokens at the argv tail (claude: settings JSON; codex: -c skills.config).
-    const skillTokens = (opts as unknown as { __skillTokens?: string[] }).__skillTokens;
-    if (skillTokens !== undefined && skillTokens.length > 0) {
-      argv = [...argv, ...skillTokens];
-    }
+    argv = buildSpawnArgv(h, effective);
     granularity = streamingGranularityOf(h, argv);
   } catch (e) {
     if (e instanceof ArgvRefusalError) {
@@ -212,7 +178,7 @@ export async function* streamTurn(
       // No process spawned on a refusal - log rejected instead of spawn
       let argvForLog: string[] = [];
       try {
-        argvForLog = redactArgv([], effective.prompt);
+        argvForLog = redactArgv([], promptText);
       } catch {}
       log({
         event: "rejected",
@@ -243,7 +209,7 @@ export async function* streamTurn(
     event: "spawn",
     turnId,
     harness: h.name,
-    argv: redactArgv(argv, effective.prompt),
+    argv: redactArgv(argv, promptText),
     granularity,
     ...(matcherOverrides ? { matcherOverrides } : {}),
     ...(envKeys?.length ? { envKeys } : {}),
@@ -260,7 +226,7 @@ export async function* streamTurn(
   let proc: SpawnedProcess;
   try {
     proc = deps.spawn(argv, {
-      stdin: stdinPolicyOf(h) === "close-required" ? "close" : "inherit",
+      stdin: h.stdin === "close-required" ? "close" : "inherit",
       ...(effective.cwd !== undefined ? { cwd: effective.cwd } : {}),
       ...(effective.env !== undefined ? { env: effective.env } : {}),
     });
@@ -303,34 +269,6 @@ export async function* streamTurn(
   let cancelled = false;
   let terminalEventReached = false;
 
-  const safeSignal = (sig: "SIGTERM" | "SIGKILL"): void => {
-    if (!exited) deps.signal(proc, sig);
-  };
-  let escalationTimer: number | null = null;
-  const escalate = (): void => {
-    if (exited || escalationTimer !== null) return;
-    safeSignal("SIGTERM");
-    escalationTimer = deps.clock.setTimeout(() => {
-      escalationTimer = null;
-      safeSignal("SIGKILL");
-    }, KILL_GRACE_MS);
-  };
-  let abortHandler: (() => void) | null = null;
-  if (opts.signal) {
-    const onAbort = (): void => {
-      if (killedByAbort) return;
-      killedByAbort = true;
-      escalate();
-    };
-    if (opts.signal.aborted) {
-      killedByAbort = true;
-      escalate();
-    } else {
-      opts.signal.addEventListener("abort", onAbort, { once: true });
-      abortHandler = onAbort;
-    }
-  }
-
   const failures: FailureSummary[] = [];
   const pushFailure = async (f: FailureSummary): Promise<void> => {
     // Suppress a failure identical in class and message to the previous one
@@ -340,19 +278,26 @@ export async function* streamTurn(
     await queue.push({ kind: "failure", ...f });
   };
 
-  let watchdog: number | null = null;
+  // The wall-clock deadline is this runner's own: a session has none.
   let turnDeadline: number | null = null;
   let watchdogReason: "inactivity" | "turn-deadline" | null = null;
-  const disarm = (): void => {
-    if (watchdog !== null) deps.clock.clearTimeout(watchdog);
-    watchdog = null;
+  const disarmDeadline = (): void => {
     if (turnDeadline !== null) deps.clock.clearTimeout(turnDeadline);
     turnDeadline = null;
   };
-  const rearm = (): void => {
-    if (deps.stallMs === undefined) return;
-    if (watchdog !== null) deps.clock.clearTimeout(watchdog);
-    watchdog = deps.clock.setTimeout(() => {
+
+  const sup = superviseTurn(h, questionMode, {
+    clock: deps.clock,
+    stallMs: deps.stallMs,
+    signal: (sig) => deps.signal(proc, sig),
+    emit: async (event) => {
+      // A wall read on stderr counts like one decoded from stdout.
+      if (event.kind === "limit") state.limitSeen = true;
+      await queue.push(event);
+    },
+    fail: pushFailure,
+    tail: stderrTail,
+    onStall: () => {
       killedByWatchdog = true;
       watchdogReason = "inactivity";
       log({
@@ -363,15 +308,31 @@ export async function* streamTurn(
         budgetMs: deps.stallMs,
       });
       // Disarm the other budget
-      if (turnDeadline !== null) {
-        deps.clock.clearTimeout(turnDeadline);
-        turnDeadline = null;
-      }
-      escalate();
-    }, deps.stallMs);
-  };
+      disarmDeadline();
+    },
+    onQuestion: (options) => {
+      log({ event: "question", turnId, harness: h.name, options });
+    },
+  });
+
+  let abortHandler: (() => void) | null = null;
+  if (opts.signal) {
+    const onAbort = (): void => {
+      if (killedByAbort) return;
+      killedByAbort = true;
+      sup.escalate();
+    };
+    if (opts.signal.aborted) {
+      killedByAbort = true;
+      sup.escalate();
+    } else {
+      opts.signal.addEventListener("abort", onAbort, { once: true });
+      abortHandler = onAbort;
+    }
+  }
+
   // Arm both budgets
-  rearm();
+  sup.beginTurn();
   if (deps.turnTimeoutMs !== undefined) {
     turnDeadline = deps.clock.setTimeout(() => {
       killedByWatchdog = true;
@@ -383,11 +344,8 @@ export async function* streamTurn(
         reason: "turn-deadline",
         budgetMs: deps.turnTimeoutMs,
       });
-      if (watchdog !== null) {
-        deps.clock.clearTimeout(watchdog);
-        watchdog = null;
-      }
-      escalate();
+      sup.disarm();
+      sup.escalate();
     }, deps.turnTimeoutMs);
   }
 
@@ -395,11 +353,11 @@ export async function* streamTurn(
   void proc.exited.then((code) => {
     exited = true;
     exitCode = code;
-    if (escalationTimer !== null) deps.clock.clearTimeout(escalationTimer);
-    escalationTimer = null;
-    // The process is gone: the watchdog has nothing left to kill, and a
-    // fire after this point would flip a completed turn to "stall".
-    disarm();
+    // The process is gone: no signal, no pending escalation, no stall
+    // clock - a fire after this point would flip a completed turn to
+    // "stall".
+    sup.settle();
+    disarmDeadline();
     // Pipes held open past exit (a grandchild inherited the fd) must not
     // hang the turn forever - close out with the exit code in hand.
     if (cancelled) return;
@@ -414,8 +372,6 @@ export async function* streamTurn(
     let identitySeen = false;
     const droppableBuffer: HarnessEvent[] = [];
     const BUFFER_CAP = 256;
-    const isDroppable = (kind: string): boolean =>
-      kind === "progress" || kind === "token" || kind === "context";
     const flushDroppable = async (): Promise<void> => {
       for (const e of droppableBuffer) await queue.push(e);
       droppableBuffer.length = 0;
@@ -428,7 +384,7 @@ export async function* streamTurn(
           await flushDroppable();
           return;
         }
-        if (isDroppable(event.kind)) {
+        if (DROPPABLE_KINDS.has(event.kind)) {
           if (droppableBuffer.length >= BUFFER_CAP) droppableBuffer.shift();
           droppableBuffer.push(event);
           return;
@@ -453,15 +409,13 @@ export async function* streamTurn(
         if (event.terminal === true) await pushFailure(failureFromTerminalError(h, event.message));
         return;
       }
-      if (questionMode === "ask" && event.kind === "message" && event.role === "assistant") {
-        lastAssistantText = event.text;
-      }
+      sup.noteEvent(event);
       await queue.push(event);
     };
     for await (const chunk of proc.stdout) {
       if (cancelled) break;
       // Any output chunk rearms the inactivity budget, but not the wall-clock deadline
-      if (deps.stallMs !== undefined) rearm();
+      sup.rearm();
       for (const line of lines.push(chunk)) {
         for (const event of decodeLine(h, line, state, opts.model ?? "", granularity)) {
           await handleEvent(event);
@@ -480,75 +434,12 @@ export async function* streamTurn(
     }
   };
 
-  /** issue #41: scan the last assistant message for the hcn-question
-   * block. Structured-first - the block's fields become the event; no
-   * prose parsing. Runs after the pumps settle (the last message is only
-   * last then) and only when detection is armed (questions ask).
-   * A malformed block surfaces as an error event, never a silent
-   * no-op. */
-  const emitQuestionIfAsked = async (): Promise<void> => {
-    if (questionMode !== "ask" || lastAssistantText === null) {
-      escalationDetection = "none";
-      return;
-    }
-    const detection = detectQuestionBlock(lastAssistantText);
-    if (detection === null) {
-      escalationDetection = "none";
-      return;
-    }
-    if ("malformed" in detection) {
-      escalationDetection = "malformed";
-      await queue.push({ kind: "error", message: detection.malformed });
-      await pushFailure(failureFromTask(`malformed hcn-question block: ${detection.malformed}`));
-      return;
-    }
-    escalationDetection = "block";
-    log({
-      event: "question",
-      turnId,
-      harness: h.name,
-      options: detection.block.options.length,
-    });
-    asked = true;
-    await queue.push({
-      kind: "question",
-      question: detection.block.question,
-      options: detection.block.options,
-      ...(detection.block.recommended !== undefined
-        ? { recommended: detection.block.recommended }
-        : {}),
-    });
-  };
-
   const pumpStderr = async (): Promise<void> => {
     const lines = new LineBuffer();
     for await (const chunk of proc.stderr) {
       if (cancelled) break;
-      if (deps.stallMs !== undefined) rearm();
-      for (const line of lines.push(chunk)) {
-        const limit = detectLimitInLine(h, line);
-        if (limit !== null) {
-          state.limitSeen = true;
-          const failure = failureFromLimit(limit);
-          // Emit both limit (for 0.1.3 compat) and failure
-          await queue.push({
-            kind: "limit",
-            code: limit,
-            message: `limit wall detected (${limit})`,
-          });
-          await pushFailure(failure);
-          continue;
-        }
-        const auth = detectAuthFailureInLine(h, line);
-        if (auth !== null) {
-          const failure = failureFromAuth(auth);
-          await pushFailure(failure);
-          // Emit error alongside failure for 0.1.3 compat
-          await queue.push({ kind: "error", message: `auth wall: ${auth}` });
-          continue;
-        }
-        stderrTail.push(line);
-      }
+      sup.rearm();
+      for (const line of lines.push(chunk)) await sup.stderrLine(line);
     }
   };
 
@@ -568,7 +459,7 @@ export async function* streamTurn(
       });
       await queue.push({ kind: "error", message: pumpFailureMessage(stream, cause) });
       await pushFailure(failureFromTransport(pumpFailureMessage(stream, cause)));
-      escalate();
+      sup.escalate();
       await proc.exited;
       proc.disposeOutput();
     }
@@ -577,8 +468,14 @@ export async function* streamTurn(
     observePump("stdout", pumpStdout()),
     observePump("stderr", pumpStderr()),
   ]);
+  // issue #41: the turn closes after the pumps settle (the last message is
+  // only last then); the supervisor detects the block and emits it.
   void Promise.all([proc.exited, pumpSettlements])
-    .then(() => emitQuestionIfAsked())
+    .then(() => {
+      const close = sup.close();
+      escalationDetection = close.detection;
+      asked = close.asked;
+    })
     .then(() => queue.close());
 
   try {
@@ -709,18 +606,18 @@ export async function* streamTurn(
     const abandoned = !terminalEventReached;
     cancelled = true;
     queue.close();
-    disarm();
+    sup.disarm();
+    disarmDeadline();
     if (abandoned) {
       log({ event: "abandoned", turnId, harness: h.name });
-      if (!exited) escalate();
+      if (!exited) sup.escalate();
     }
     proc.disposeOutput();
     const [settledExit] = await Promise.all([proc.exited, pumpSettlements]);
     exitCode = settledExit;
     if (pipeGrace !== null) deps.clock.clearTimeout(pipeGrace);
     pipeGrace = null;
-    if (escalationTimer !== null) deps.clock.clearTimeout(escalationTimer);
-    escalationTimer = null;
+    sup.settle();
     if (abandoned) {
       log({
         event: "abandonment_settled",

package/src/execution/supervisor.ts

@@ -0,0 +1,199 @@
+/**
+ * The turn supervisor: the one owner of the supervising policies
+ * CONTEXT.md names (RFC-02 change 5), composed by both runners instead of
+ * written into each. It owns the stall clock, the SIGTERM-then-SIGKILL
+ * escalation, the classification of every stderr line, the tracking of
+ * the last assistant message, and the turn close that turns a detected
+ * hcn-question block into events. It emits through the callbacks its
+ * runner hands it and knows nothing about channels or turns.
+ */
+import { detectAuthFailureInLine, detectLimitInLine } from "../interpretation/limits.js";
+import {
+  type QuestionDetectionKind,
+  type QuestionMode,
+  questionEventOf,
+} from "../interpretation/question.js";
+import type { HarnessDescriptor } from "../knowledge/descriptor.js";
+import type { Clock, SignalName, TimerHandle } from "./deps.js";
+import type { HarnessEvent } from "./events.js";
+import {
+  type FailureSummary,
+  failureFromAuth,
+  failureFromLimit,
+  failureFromTask,
+} from "./failure.js";
+
+/** SIGTERM -> SIGKILL escalation budget for a child that ignores the first
+ * signal. */
+export const KILL_GRACE_MS = 5_000;
+
+/** Bounded tail of unmatched stderr - the crash context a nonzero exit is
+ * explained by (v1 kept the turn's output slice for exactly this). */
+export class StderrTail {
+  private readonly lines: string[] = [];
+  private bytes = 0;
+  push(line: string): void {
+    this.lines.push(line);
+    this.bytes += line.length;
+    while (this.lines.length > 20 || (this.bytes > 4096 && this.lines.length > 1)) {
+      const dropped = this.lines.shift();
+      this.bytes -= dropped?.length ?? 0;
+    }
+  }
+  snapshot(): readonly string[] {
+    return [...this.lines];
+  }
+}
+
+export interface SupervisorIo {
+  readonly clock: Clock;
+  /** Inactivity budget; undefined means no stall clock at all. */
+  readonly stallMs: number | undefined;
+  /** Signal the supervised process. The supervisor never signals after
+   * `settle()`. */
+  readonly signal: (sig: SignalName) => void;
+  /** Deliver an event to the turn's consumer. */
+  readonly emit: (event: HarnessEvent) => Promise<void>;
+  /** Record a failure for the turn's done AND deliver it as an event. */
+  readonly fail: (summary: FailureSummary) => Promise<void>;
+  /** Where unclassified stderr goes. */
+  readonly tail: StderrTail;
+  /** The stall clock fired: the runner records its own cause and ends the
+   * turn; the supervisor has already begun escalation. */
+  readonly onStall: () => void;
+  /** A question was detected at close, with its option count (for the
+   * runner's boundary log). */
+  readonly onQuestion: (optionCount: number) => void;
+}
+
+export interface TurnClose {
+  readonly detection: QuestionDetectionKind;
+  /** True when the turn ended by asking: a successful turn, cause
+   * awaiting-input. */
+  readonly asked: boolean;
+}
+
+export interface TurnSupervisor {
+  /** Start a turn: reset per-turn state and arm the stall clock. */
+  beginTurn(): void;
+  /** Any output chunk arrived: restart the inactivity budget, if a turn is
+   * open and a budget exists. */
+  rearm(): void;
+  /** The turn ended, or the process did: stop the stall clock. */
+  disarm(): void;
+  /** SIGTERM now, SIGKILL after KILL_GRACE_MS unless the process exits.
+   * Idempotent while an escalation is pending. */
+  escalate(): void;
+  /** The process is gone: no further signals, no pending escalation, no
+   * stall clock. */
+  settle(): void;
+  /** Classify one stderr line: a limit wall becomes a limit event plus a
+   * failure, an auth wall a failure plus an error event, anything else
+   * goes to the tail. Returns the limit code when the line was a limit. */
+  stderrLine(line: string): Promise<void>;
+  /** A decoded event passed by: the last assistant message is where the
+   * protocol says the hcn-question block lives (tracked in ask mode). */
+  noteEvent(event: HarnessEvent): void;
+  /** At turn end: detect the block in the last assistant message, emit the
+   * question (or the malformation as an error plus a task failure), and
+   * report what was found. Synchronous: the events are enqueued, not
+   * awaited, so a runner can close a turn from a timer callback. */
+  close(): TurnClose;
+}
+
+export const superviseTurn = (
+  h: HarnessDescriptor,
+  questionMode: QuestionMode,
+  io: SupervisorIo,
+): TurnSupervisor => {
+  let settled = false;
+  let killTimer: TimerHandle | null = null;
+  let stallTimer: TimerHandle | null = null;
+  let turnOpen = false;
+  let lastAssistantText: string | null = null;
+
+  const signal = (sig: SignalName): void => {
+    if (!settled) io.signal(sig);
+  };
+
+  const disarm = (): void => {
+    if (stallTimer !== null) io.clock.clearTimeout(stallTimer);
+    stallTimer = null;
+    turnOpen = false;
+  };
+
+  const escalate = (): void => {
+    if (settled || killTimer !== null) return;
+    signal("SIGTERM");
+    killTimer = io.clock.setTimeout(() => {
+      killTimer = null;
+      signal("SIGKILL");
+    }, KILL_GRACE_MS);
+  };
+
+  const armStall = (): void => {
+    if (io.stallMs === undefined || !turnOpen) return;
+    if (stallTimer !== null) io.clock.clearTimeout(stallTimer);
+    stallTimer = io.clock.setTimeout(() => {
+      stallTimer = null;
+      // The turn may have ended between the timer firing and this callback
+      // running; a closed turn is never reported as a stall.
+      if (!turnOpen) return;
+      io.onStall();
+      escalate();
+    }, io.stallMs);
+  };
+
+  return {
+    beginTurn(): void {
+      lastAssistantText = null;
+      turnOpen = true;
+      armStall();
+    },
+    rearm(): void {
+      armStall();
+    },
+    disarm,
+    escalate,
+    settle(): void {
+      settled = true;
+      if (killTimer !== null) io.clock.clearTimeout(killTimer);
+      killTimer = null;
+      disarm();
+    },
+    async stderrLine(line: string): Promise<void> {
+      const limit = detectLimitInLine(h, line);
+      if (limit !== null) {
+        await io.emit({ kind: "limit", code: limit, message: `limit wall detected (${limit})` });
+        await io.fail(failureFromLimit(limit));
+        return;
+      }
+      const auth = detectAuthFailureInLine(h, line);
+      if (auth !== null) {
+        await io.fail(failureFromAuth(auth));
+        await io.emit({ kind: "error", message: `auth wall: ${auth}` });
+        return;
+      }
+      io.tail.push(line);
+    },
+    noteEvent(event: HarnessEvent): void {
+      if (questionMode === "ask" && event.kind === "message" && event.role === "assistant") {
+        lastAssistantText = event.text;
+      }
+    },
+    close(): TurnClose {
+      const found = questionEventOf(lastAssistantText, questionMode);
+      if (found.detection === "malformed") {
+        void io.emit({ kind: "error", message: found.malformed });
+        void io.fail(failureFromTask(`malformed hcn-question block: ${found.malformed}`));
+        return { detection: "malformed", asked: false };
+      }
+      if (found.detection === "block") {
+        io.onQuestion(found.event.options.length);
+        void io.emit(found.event);
+        return { detection: "block", asked: true };
+      }
+      return { detection: "none", asked: false };
+    },
+  };
+};