omp-conductor 0.15.12 → 0.15.13

package/src/wizard-ui.ts

@@ -36,8 +36,9 @@ export interface WizardUi {
   /** Single-line text prompt. `undefined` dismisses it; an empty submit accepts
    *  the placeholder. */
   input(title: string, placeholder?: string): Promise<string | undefined>;
-  /** Numbered single-choice list. Resolves the chosen option's label, or
-   *  `undefined` when dismissed. */
+  /** Single-choice list. On an interactive TTY the current option is rendered
+   *  inline and moved with ↑/↓ or j/k; on a pipe it stays the numbered wall.
+   *  Resolves the chosen option's label, or `undefined` when dismissed. */
   select(
     title: string,
     options: { label: string; description?: string }[],
@@ -62,6 +63,17 @@ import type { Readable, Writable } from "node:stream";
  * as long as the wizard, and {@link TerminalUi.close} releases it once, from the
  * caller's `finally`.
  *
+ * The one exception is {@link TerminalUi.select} on a real TTY, which takes the
+ * terminal over in raw mode. A live readline interface echoes every typed
+ * character back to the output and folds Enter into a `line` event, so it would
+ * smear the inline option row with pressed keys and drop stray lines into the
+ * buffer underneath it. That prompt closes the interface, reads the terminal
+ * byte by byte, and then re-creates the interface so the line protocol is still
+ * alive for the next prompt. The re-opening works on a TTY (the stream itself
+ * is untouched; closing only pauses it, and it is resumed), and the closed
+ * interface's key listeners are dropped, so nothing leaks across repeated
+ * passes of a menu.
+ *
  * Dismissal is the interface's own `close`: `rl.question()` on an exhausted
  * stream never settles on its own, so EOF (a script that ran out of answers) and
  * Ctrl-C both close the interface, and the line reader turns that into the
@@ -78,18 +90,18 @@ export interface TerminalUi extends WizardUi {
 export function terminalUi(io: { input?: Readable; output?: Writable } = {}): TerminalUi {
   const input = io.input ?? stdin;
   const output = io.output ?? stdout;
-  const rl: Interface = createInterface({ input, output });
+  let rl: Interface = createInterface({ input, output });
   let closed = false;
-  const close = (): void => {
-    if (closed) return;
-    closed = true;
-    rl.close();
+  let buffered: string[] = [];
+  let waiting: ((value: string | undefined) => void) | undefined;
+  let ended = false;
+  const deliver = (value: string | undefined): boolean => {
+    const resolve = waiting;
+    if (resolve === undefined) return false;
+    waiting = undefined;
+    resolve(value);
+    return true;
   };
-  // Ctrl-C is a cancel, not a signal to the whole process: closing the interface
-  // makes every pending and subsequent prompt resolve `undefined`, which the
-  // wizard already turns into `Cancelled`.
-  rl.once("SIGINT", close);
-
   // Lines are buffered as they arrive rather than read on demand, because on a
   // non-TTY stdin readline drains the whole pipe at once and emits `line` for
   // every one of them immediately. `rl.question()` only captures the line that
@@ -97,23 +109,40 @@ export function terminalUi(io: { input?: Readable; output?: Writable } = {}): Te
   // already flown past and then hit EOF — three prompts resolving `undefined`
   // and a wizard that cancelled itself. Buffering makes a pipe and a terminal
   // behave the same: nothing is read before it is asked for, nothing is lost.
-  const buffered: string[] = [];
-  let waiting: ((value: string | undefined) => void) | undefined;
-  let ended = false;
-  const deliver = (value: string | undefined): boolean => {
-    const resolve = waiting;
-    if (resolve === undefined) return false;
+  const attach = (iface: Interface): void => {
+    // Ctrl-C on the line protocol is a cancel, not a signal to the whole
+    // process: closing the interface (on SIGINT or on EOF) makes every pending
+    // and subsequent prompt resolve `undefined`, which the wizard already turns
+    // into `Cancelled`. The raw-mode select handles Ctrl-C itself; every other
+    // prompt relies on this.
+    iface.once("SIGINT", close);
+    iface.on("line", (text: string) => {
+      if (!deliver(text)) buffered.push(text);
+    });
+    iface.once("close", () => {
+      ended = true;
+      deliver(undefined);
+    });
+  };
+  const close = (): void => {
+    if (closed) return;
+    closed = true;
+    rl.close();
+  };
+  // The line protocol runs on the *current* interface. An interactive select
+  // takes the terminal over in raw mode, so the interface that was echoing
+  // keystrokes and folding Enter into lines has to be closed out of the way and
+  // a fresh one opened for the prompts that follow (see the lifecycle comment
+  // at the top of the interface declaration).
+  const reopen = (): void => {
+    rl.close();
+    buffered = [];
     waiting = undefined;
-    resolve(value);
-    return true;
+    ended = false;
+    rl = createInterface({ input, output });
+    attach(rl);
   };
-  rl.on("line", (text: string) => {
-    if (!deliver(text)) buffered.push(text);
-  });
-  rl.once("close", () => {
-    ended = true;
-    deliver(undefined);
-  });
+  attach(rl);
 
   /** One line, or `undefined` when the operator dismissed the prompt. */
   const line = async (query: string): Promise<string | undefined> => {
@@ -127,6 +156,37 @@ export function terminalUi(io: { input?: Readable; output?: Writable } = {}): Te
     });
   };
 
+  // -------- the interactive select: raw keys, one changing row --------
+  //
+  // On a real TTY the numbered wall is replaced by a single row that shows the
+  // option under the cursor and follows ↑/↓ or j/k. The keys are read from the
+  // raw stream byte by byte rather than through readline's keypress decode:
+  // readline only emits a lone Escape after its own escape-sequence timeout,
+  // and CSI sequences split across chunks have to be reassembled anyway. The
+  // terminal is taken over only for the duration of the prompt and restored on
+  // every exit path.
+  type TtyInput = Readable & {
+    isTTY: boolean;
+    isRaw?: boolean;
+    setRawMode(mode: boolean): void;
+  };
+  const asTty = (stream: Readable): TtyInput | undefined => {
+    const candidate = stream as Readable & Partial<TtyInput>;
+    return candidate.isTTY === true && typeof candidate.setRawMode === "function"
+      ? (candidate as TtyInput)
+      : undefined;
+  };
+
+  const ESC = 27;
+  const ENTERS = new Set([13, 10]);
+  const CTRL_C = 3;
+  const UP = 65; // CSI A after ESC [
+  const DOWN = 66; // CSI B after ESC [
+  const KEY_J = 106; // lower-case j: down
+  const KEY_K = 107; // lower-case k: up
+  const KEY_J_UP = 74; // J
+  const KEY_K_UP = 75; // K
+
   return {
     close,
     notify(message) {
@@ -156,25 +216,178 @@ export function terminalUi(io: { input?: Readable; output?: Writable } = {}): Te
       return answer.trim().length === 0 ? (placeholder ?? "") : answer;
     },
     async select(title, options, dialogOptions) {
-      output.write(`${title}\n`);
-      options.forEach((o, i) => {
-        output.write(`  ${i + 1}. ${o.label}${o.description !== undefined ? ` — ${o.description}` : ""}\n`);
-      });
-      const initial = dialogOptions?.initialIndex ?? 0;
-      const defaultLabel = options[initial]?.label ?? "";
-      for (;;) {
-        const answer = await line(
-          `Select 1-${options.length} [${initial + 1} = ${defaultLabel}] (Enter keeps it, Ctrl-C cancels): `,
-        );
-        if (answer === undefined) return undefined;
-        const a = answer.trim();
-        if (a === "") return defaultLabel; // a bare Enter re-affirms the current row
-        const n = Number(a);
-        if (Number.isInteger(n)) {
-          const picked = options[n - 1];
-          if (picked !== undefined) return picked.label;
+      const tty = asTty(input);
+      if (tty === undefined) {
+        // Non-TTY stdin (a pipe, a test harness, CI): the numbered wall, kept
+        // byte-identical so the scripted protocol cannot drift.
+        output.write(`${title}\n`);
+        options.forEach((o, i) => {
+          output.write(`  ${i + 1}. ${o.label}${o.description !== undefined ? ` — ${o.description}` : ""}\n`);
+        });
+        const initial = dialogOptions?.initialIndex ?? 0;
+        const defaultLabel = options[initial]?.label ?? "";
+        for (;;) {
+          const answer = await line(
+            `Select 1-${options.length} [${initial + 1} = ${defaultLabel}] (Enter keeps it, Ctrl-C cancels): `,
+          );
+          if (answer === undefined) return undefined;
+          const a = answer.trim();
+          if (a === "") return defaultLabel; // a bare Enter re-affirms the current row
+          const n = Number(a);
+          if (Number.isInteger(n)) {
+            const picked = options[n - 1];
+            if (picked !== undefined) return picked.label;
+          }
+          output.write(`Please enter a number between 1 and ${options.length}.\n`);
+        }
+      }
+      if (options.length === 0) return undefined;
+      // Clamp rather than wrap: the row is the operator's place in the list and
+      // pressing past an edge should not fly from bottom to top (or the other
+      // way); a bare Enter is "keep the current row", so the position is a
+      // setting, not a spinner.
+      const bound = (index: number): number => Math.max(0, Math.min(index, options.length - 1));
+      let index = bound(dialogOptions?.initialIndex ?? 0);
+      const row = (at: number): string => {
+        const o = options[at];
+        return `  › ${o?.label ?? ""}${o?.description !== undefined ? ` — ${o.description}` : ""}`;
+      };
+      let prevLen = 0;
+      const paint = (): void => {
+        const text = row(index);
+        output.write(`\r${" ".repeat(prevLen)}\r${text}`);
+        prevLen = text.length;
+      };
+      let settled: ((value: string | undefined) => void) | undefined;
+      let failed: ((err: unknown) => void) | undefined;
+      let escapeState: "idle" | "esc" | "seq" = "idle";
+      let escapeTimer: ReturnType<typeof setTimeout> | undefined;
+      const clearEscape = (): void => {
+        if (escapeTimer !== undefined) {
+          clearTimeout(escapeTimer);
+          escapeTimer = undefined;
+        }
+      };
+      // Escape sequences arrive byte by byte and a lone ESC cannot be told
+      // apart from the start of `ESC [ A` until the next byte lands; reading
+      // the whole chunk at once handles the common atomic write, and a short
+      // timer turns an unfinished sequence into a plain Escape.
+      const armEscape = (): void => {
+        if (escapeTimer !== undefined) return;
+        escapeTimer = setTimeout(() => {
+          escapeTimer = undefined;
+          escapeState = "idle";
+          settled?.(undefined);
+        }, 30);
+      };
+      const onData = (chunk: Buffer): void => {
+        try {
+          for (const byte of chunk) {
+            switch (escapeState) {
+              case "esc": {
+                clearEscape();
+                if (byte === 91 || byte === 79) {
+                  // ESC [ … or ESC O … — wait for the direction letter.
+                  escapeState = "seq";
+                  armEscape();
+                  continue;
+                }
+                // ESC followed by anything else: a plain Escape press.
+                escapeState = "idle";
+                settled?.(undefined);
+                continue;
+              }
+              case "seq": {
+                clearEscape();
+                escapeState = "idle";
+                if (byte === 65) index = bound(index - 1);
+                else if (byte === 66) index = bound(index + 1);
+                else continue; // an unknown CSI sequence is not a key we know
+                paint();
+                continue;
+              }
+              case "idle": {
+                if (ENTERS.has(byte)) {
+                  settled?.(options[index]?.label);
+                  continue;
+                }
+                if (byte === CTRL_C) {
+                  settled?.(undefined);
+                  continue;
+                }
+                if (byte === ESC) {
+                  escapeState = "esc";
+                  armEscape();
+                  continue;
+                }
+                if (byte === KEY_J || byte === KEY_J_UP) {
+                  index = bound(index + 1);
+                  paint();
+                  continue;
+                }
+                if (byte === KEY_K || byte === KEY_K_UP) {
+                  index = bound(index - 1);
+                  paint();
+                  continue;
+                }
+                // Any other byte (typos, mouse reports) is ignored.
+                continue;
+              }
+            }
+          }
+        } catch (err) {
+          failed?.(err);
         }
-        output.write(`Please enter a number between 1 and ${options.length}.\n`);
+      };
+      const onSignal = (signal: NodeJS.Signals): void => {
+        // A real signal (not the Ctrl-C byte, which raw mode turns into the
+        // cancel above) still kills the process — but only after the terminal
+        // has been handed back, so the operator's shell is never left raw.
+        clearEscape();
+        input.removeListener("data", onData);
+        tty.setRawMode(wasRaw);
+        process.removeListener("SIGINT", onSignal);
+        process.removeListener("SIGTERM", onSignal);
+        process.removeListener("SIGHUP", onSignal);
+        process.kill(process.pid, signal);
+      };
+      let wasRaw = false;
+      try {
+        // Take the terminal over. The shared interface would echo every pressed
+        // key back into the row and fold Enter into a `line` the next prompt
+        // would swallow, so it is closed for the duration and re-opened below.
+        rl.close();
+        input.resume();
+        // Captured *after* the close: while the interface is alive it keeps the
+        // terminal raw (bun's readline does), and restoring to that state would
+        // leave the operator's shell raw after a signal.
+        wasRaw = tty.isRaw ?? false;
+        tty.setRawMode(true);
+        output.write(`${title}\n`);
+        output.write("  (↑/↓ or j/k to move · Enter accepts · Ctrl-C or Esc cancels)\n");
+        paint();
+        const done = new Promise<string | undefined>((resolve, reject) => {
+          settled = resolve;
+          failed = reject;
+        });
+        input.on("data", onData);
+        process.once("SIGINT", onSignal);
+        process.once("SIGTERM", onSignal);
+        process.once("SIGHUP", onSignal);
+        const picked = await done;
+        output.write("\n");
+        return picked;
+      } finally {
+        // Every exit path — accept, cancel, an exception in rendering, a signal
+        // that did not kill us — restores the terminal exactly as it was found
+        // and re-opens the line interface for the prompts that follow.
+        clearEscape();
+        input.removeListener("data", onData);
+        tty.setRawMode(wasRaw);
+        process.removeListener("SIGINT", onSignal);
+        process.removeListener("SIGTERM", onSignal);
+        process.removeListener("SIGHUP", onSignal);
+        reopen();
       }
     },
   };
@@ -209,7 +422,9 @@ export function terminalUi(io: { input?: Readable; output?: Writable } = {}): Te
 export interface ScriptedAnswers {
   input?: Record<string, string>;
   confirm?: Record<string, boolean | boolean[] | null>;
-  select?: Record<string, string | number | null>;
+  /** The array variant is what lets one script drive a repeated menu (#417):
+   *  the review loop's consent menu can be answered "decline, then apply". */
+  select?: Record<string, string | number | null | (string | number | null)[]>;
 }
 
 export function scriptedUi(script: ScriptedAnswers = {}): WizardUi {

package/src/worker.ts

@@ -61,6 +61,17 @@ export const RESUME_PROMPT =
   "re-check the outcome of your last action before repeating it, then keep working your original " +
   "brief to the same report contract.";
 
+/**
+ * What an orphan-resumed worker is told instead of re-sending its brief. One
+ * literal so tests can pin it (#536): the original brief is already in the
+ * resumed transcript, and re-sending it is how a resumed worker ends up
+ * re-doing the work it just did.
+ */
+export const ORPHAN_RESUME_PROMPT =
+  "Your previous process was interrupted by a daemon restart. Review the transcript's final state before acting, " +
+  "then continue exactly where you left off: re-check the outcome of your last action before repeating it, and keep " +
+  "working your original brief to the same report contract.";
+
 export interface WorkerOpts {
   brief: string;
   cwd: string;
@@ -74,6 +85,15 @@ export interface WorkerOpts {
    * location; either way the real path comes back on {@link WorkerResult}.
    */
   sessionDir?: string;
+  /**
+   * Continue the most recent transcript in `sessionDir` instead of opening a
+   * blank session (#536). The daemon sets it only for an orphan-clean
+   * continuation, after verifying the prior transcript and worktree still
+   * exist — the harness's own `continueRecent` is the backstop, and a silent
+   * fallback to a fresh session is surfaced by the `sessionFile` lineage
+   * compare at the dispatch site, never left quiet.
+   */
+  resume?: boolean;
   /**
    * Model pattern for this session, in omp's model/role syntax. Omitted leaves
    * the harness to pick, which is what an unconfigured project wants.
@@ -266,6 +286,7 @@ export async function runWorker(
       cwd: o.cwd,
       ...(o.sessionDir === undefined ? {} : { sessionDir: o.sessionDir }),
       ...(o.model === undefined ? {} : { model: o.model }),
+      ...(o.resume === undefined ? {} : { resume: o.resume }),
       // Prevention half of #24: as a worker, structured file tools cannot leave
       // this worktree, and no release grant can ever reach this session (#122).
       role: "worker",