@klaudworks/rmr 0.4.4 → 1.0.0

package/dist/index.js

@@ -9616,26 +9616,6 @@ function String2(descriptor, ...args) {
     return StringPositional(descriptor);
   }
 }
-// src/lib/config.ts
-import { mkdir } from "node:fs/promises";
-import { resolve } from "node:path";
-async function loadConfig(workspaceRoot = process.cwd()) {
-  const root = resolve(workspaceRoot);
-  const rexDir = resolve(root, ".rmr");
-  const config = {
-    workspaceRoot: root,
-    rexDir,
-    runsDir: resolve(rexDir, "runs"),
-    workflowsDir: resolve(rexDir, "workflows")
-  };
-  await Promise.all([
-    mkdir(config.rexDir, { recursive: true }),
-    mkdir(config.runsDir, { recursive: true }),
-    mkdir(config.workflowsDir, { recursive: true })
-  ]);
-  return config;
-}
-
 // src/lib/errors.ts
 class RmrError extends Error {
   code;
@@ -9674,1173 +9654,1618 @@ class StorageError extends RmrError {
   }
 }
 
-// src/lib/completions.ts
-import { access, readdir } from "node:fs/promises";
-import { resolve as resolve2 } from "node:path";
-function matchesPartial(value, partial) {
-  if (!partial) {
-    return true;
+// node_modules/chalk/source/vendor/ansi-styles/index.js
+var ANSI_BACKGROUND_OFFSET = 10;
+var wrapAnsi16 = (offset = 0) => (code) => `\x1B[${code + offset}m`;
+var wrapAnsi256 = (offset = 0) => (code) => `\x1B[${38 + offset};5;${code}m`;
+var wrapAnsi16m = (offset = 0) => (red, green, blue) => `\x1B[${38 + offset};2;${red};${green};${blue}m`;
+var styles = {
+  modifier: {
+    reset: [0, 0],
+    bold: [1, 22],
+    dim: [2, 22],
+    italic: [3, 23],
+    underline: [4, 24],
+    overline: [53, 55],
+    inverse: [7, 27],
+    hidden: [8, 28],
+    strikethrough: [9, 29]
+  },
+  color: {
+    black: [30, 39],
+    red: [31, 39],
+    green: [32, 39],
+    yellow: [33, 39],
+    blue: [34, 39],
+    magenta: [35, 39],
+    cyan: [36, 39],
+    white: [37, 39],
+    blackBright: [90, 39],
+    gray: [90, 39],
+    grey: [90, 39],
+    redBright: [91, 39],
+    greenBright: [92, 39],
+    yellowBright: [93, 39],
+    blueBright: [94, 39],
+    magentaBright: [95, 39],
+    cyanBright: [96, 39],
+    whiteBright: [97, 39]
+  },
+  bgColor: {
+    bgBlack: [40, 49],
+    bgRed: [41, 49],
+    bgGreen: [42, 49],
+    bgYellow: [43, 49],
+    bgBlue: [44, 49],
+    bgMagenta: [45, 49],
+    bgCyan: [46, 49],
+    bgWhite: [47, 49],
+    bgBlackBright: [100, 49],
+    bgGray: [100, 49],
+    bgGrey: [100, 49],
+    bgRedBright: [101, 49],
+    bgGreenBright: [102, 49],
+    bgYellowBright: [103, 49],
+    bgBlueBright: [104, 49],
+    bgMagentaBright: [105, 49],
+    bgCyanBright: [106, 49],
+    bgWhiteBright: [107, 49]
   }
-  return value.startsWith(partial);
-}
-async function listRunIdCompletions(config, partial = "") {
-  const entries = await readdir(config.runsDir, { withFileTypes: true });
-  return entries.filter((entry) => entry.isFile() && entry.name.endsWith(".json")).map((entry) => entry.name.slice(0, -".json".length)).filter((id) => matchesPartial(id, partial)).sort();
-}
-async function listWorkflowCompletions(config, partial = "") {
-  const entries = await readdir(config.workflowsDir, { withFileTypes: true });
-  const workflows = [];
-  for (const entry of entries) {
-    if (!entry.isDirectory()) {
-      continue;
+};
+var modifierNames = Object.keys(styles.modifier);
+var foregroundColorNames = Object.keys(styles.color);
+var backgroundColorNames = Object.keys(styles.bgColor);
+var colorNames = [...foregroundColorNames, ...backgroundColorNames];
+function assembleStyles() {
+  const codes = new Map;
+  for (const [groupName, group] of Object.entries(styles)) {
+    for (const [styleName, style] of Object.entries(group)) {
+      styles[styleName] = {
+        open: `\x1B[${style[0]}m`,
+        close: `\x1B[${style[1]}m`
+      };
+      group[styleName] = styles[styleName];
+      codes.set(style[0], style[1]);
     }
-    const workflowYaml = resolve2(config.workflowsDir, entry.name, "workflow.yaml");
-    const workflowYml = resolve2(config.workflowsDir, entry.name, "workflow.yml");
-    try {
-      await access(workflowYaml);
-      workflows.push(workflowYaml);
-      continue;
-    } catch {}
-    try {
-      await access(workflowYml);
-      workflows.push(workflowYml);
-    } catch {}
-  }
-  return workflows.filter((filePath) => matchesPartial(filePath, partial)).sort();
-}
-
-// src/commands/complete.ts
-function parseTarget(value) {
-  if (value === "run-id" || value === "workflow") {
-    return value;
+    Object.defineProperty(styles, groupName, {
+      value: group,
+      enumerable: false
+    });
   }
-  throw new UserInputError(`Invalid completion target "${value}".`);
-}
-
-class CompleteCommand extends Command {
-  static paths = [["complete"]];
-  target = exports_options.String({
-    name: "target"
-  });
-  partial = exports_options.String({
-    required: false,
-    name: "partial"
+  Object.defineProperty(styles, "codes", {
+    value: codes,
+    enumerable: false
   });
-  async execute() {
-    const config = await loadConfig();
-    const target = parseTarget(this.target);
-    const query = this.partial ?? "";
-    const suggestions = target === "run-id" ? await listRunIdCompletions(config, query) : await listWorkflowCompletions(config, query);
-    for (const value of suggestions) {
-      process.stdout.write(`${value}
-`);
+  styles.color.close = "\x1B[39m";
+  styles.bgColor.close = "\x1B[49m";
+  styles.color.ansi = wrapAnsi16();
+  styles.color.ansi256 = wrapAnsi256();
+  styles.color.ansi16m = wrapAnsi16m();
+  styles.bgColor.ansi = wrapAnsi16(ANSI_BACKGROUND_OFFSET);
+  styles.bgColor.ansi256 = wrapAnsi256(ANSI_BACKGROUND_OFFSET);
+  styles.bgColor.ansi16m = wrapAnsi16m(ANSI_BACKGROUND_OFFSET);
+  Object.defineProperties(styles, {
+    rgbToAnsi256: {
+      value(red, green, blue) {
+        if (red === green && green === blue) {
+          if (red < 8) {
+            return 16;
+          }
+          if (red > 248) {
+            return 231;
+          }
+          return Math.round((red - 8) / 247 * 24) + 232;
+        }
+        return 16 + 36 * Math.round(red / 255 * 5) + 6 * Math.round(green / 255 * 5) + Math.round(blue / 255 * 5);
+      },
+      enumerable: false
+    },
+    hexToRgb: {
+      value(hex) {
+        const matches = /[a-f\d]{6}|[a-f\d]{3}/i.exec(hex.toString(16));
+        if (!matches) {
+          return [0, 0, 0];
+        }
+        let [colorString] = matches;
+        if (colorString.length === 3) {
+          colorString = [...colorString].map((character) => character + character).join("");
+        }
+        const integer = Number.parseInt(colorString, 16);
+        return [
+          integer >> 16 & 255,
+          integer >> 8 & 255,
+          integer & 255
+        ];
+      },
+      enumerable: false
+    },
+    hexToAnsi256: {
+      value: (hex) => styles.rgbToAnsi256(...styles.hexToRgb(hex)),
+      enumerable: false
+    },
+    ansi256ToAnsi: {
+      value(code) {
+        if (code < 8) {
+          return 30 + code;
+        }
+        if (code < 16) {
+          return 90 + (code - 8);
+        }
+        let red;
+        let green;
+        let blue;
+        if (code >= 232) {
+          red = ((code - 232) * 10 + 8) / 255;
+          green = red;
+          blue = red;
+        } else {
+          code -= 16;
+          const remainder = code % 36;
+          red = Math.floor(code / 36) / 5;
+          green = Math.floor(remainder / 6) / 5;
+          blue = remainder % 6 / 5;
+        }
+        const value = Math.max(red, green, blue) * 2;
+        if (value === 0) {
+          return 30;
+        }
+        let result = 30 + (Math.round(blue) << 2 | Math.round(green) << 1 | Math.round(red));
+        if (value === 2) {
+          result += 60;
+        }
+        return result;
+      },
+      enumerable: false
+    },
+    rgbToAnsi: {
+      value: (red, green, blue) => styles.ansi256ToAnsi(styles.rgbToAnsi256(red, green, blue)),
+      enumerable: false
+    },
+    hexToAnsi: {
+      value: (hex) => styles.ansi256ToAnsi(styles.hexToAnsi256(hex)),
+      enumerable: false
     }
-    return 0;
-  }
+  });
+  return styles;
 }
+var ansiStyles = assembleStyles();
+var ansi_styles_default = ansiStyles;
 
-// src/commands/completion.ts
-function parseShell(value) {
-  if (value === "bash" || value === "zsh" || value === "fish") {
-    return value;
-  }
-  throw new UserInputError(`Unsupported shell "${value}". Use bash, zsh, or fish.`);
-}
-function bashScript() {
-  return [
-    "_rex_complete() {",
-    "  local cur prev",
-    "  COMPREPLY=()",
-    '  cur="${COMP_WORDS[COMP_CWORD]}"',
-    '  prev="${COMP_WORDS[COMP_CWORD-1]}"',
-    "",
-    "  if [[ ${COMP_CWORD} -eq 1 ]]; then",
-    '    COMPREPLY=( $(compgen -W "install run continue complete completion --help --version" -- "${cur}") )',
-    "    return 0",
-    "  fi",
-    "",
-    '  if [[ "${prev}" == "continue" ]]; then',
-    '    COMPREPLY=( $(rmr complete run-id "${cur}") )',
-    "    return 0",
-    "  fi",
-    "",
-    '  if [[ "${prev}" == "run" ]]; then',
-    '    COMPREPLY=( $(rmr complete workflow "${cur}") )',
-    "    return 0",
-    "  fi",
-    "",
-    '  if [[ "${prev}" == "install" ]]; then',
-    '    COMPREPLY=( $(compgen -W "feature-dev" -- "${cur}") )',
-    "    return 0",
-    "  fi",
-    "}",
-    "complete -F _rex_complete rmr"
-  ].join(`
-`);
-}
-function zshScript() {
-  return [
-    "#compdef rmr",
-    "_rex_complete() {",
-    "  local -a subcommands",
-    "  subcommands=(install run continue complete completion)",
-    "",
-    "  if (( CURRENT == 2 )); then",
-    "    _describe 'command' subcommands",
-    "    return",
-    "  fi",
-    "",
-    "  if [[ ${words[2]} == continue && $CURRENT -eq 3 ]]; then",
-    '    compadd -- $(rmr complete run-id "${words[CURRENT]}")',
-    "    return",
-    "  fi",
-    "",
-    "  if [[ ${words[2]} == run && $CURRENT -eq 3 ]]; then",
-    '    compadd -- $(rmr complete workflow "${words[CURRENT]}")',
-    "    return",
-    "  fi",
-    "",
-    "  if [[ ${words[2]} == install && $CURRENT -eq 3 ]]; then",
-    "    compadd -- feature-dev",
-    "    return",
-    "  fi",
-    "}",
-    "compdef _rex_complete rmr"
-  ].join(`
-`);
+// node_modules/chalk/source/vendor/supports-color/index.js
+import process2 from "node:process";
+import os from "node:os";
+import tty2 from "node:tty";
+function hasFlag(flag, argv = globalThis.Deno ? globalThis.Deno.args : process2.argv) {
+  const prefix = flag.startsWith("-") ? "" : flag.length === 1 ? "-" : "--";
+  const position = argv.indexOf(prefix + flag);
+  const terminatorPosition = argv.indexOf("--");
+  return position !== -1 && (terminatorPosition === -1 || position < terminatorPosition);
 }
-function fishScript() {
-  return [
-    "function __rex_complete_run_id",
-    "  rmr complete run-id (commandline -ct)",
-    "end",
-    "",
-    "function __rex_complete_workflow",
-    "  rmr complete workflow (commandline -ct)",
-    "end",
-    "",
-    "complete -c rmr -f",
-    "complete -c rmr -n '__fish_use_subcommand' -a 'install run continue complete completion'",
-    "complete -c rmr -n '__fish_seen_subcommand_from continue' -a '(__rex_complete_run_id)'",
-    "complete -c rmr -n '__fish_seen_subcommand_from run' -a '(__rex_complete_workflow)'",
-    "complete -c rmr -n '__fish_seen_subcommand_from install' -a 'feature-dev'"
-  ].join(`
-`);
+var { env } = process2;
+var flagForceColor;
+if (hasFlag("no-color") || hasFlag("no-colors") || hasFlag("color=false") || hasFlag("color=never")) {
+  flagForceColor = 0;
+} else if (hasFlag("color") || hasFlag("colors") || hasFlag("color=true") || hasFlag("color=always")) {
+  flagForceColor = 1;
 }
-
-class CompletionCommand extends Command {
-  static paths = [["completion"]];
-  static usage = Command.Usage({
-    category: "Workflow",
-    description: "Print optional shell completion setup script.",
-    details: "Generates completion script text for your shell. Source the output in your shell profile to enable command and dynamic argument completion.",
-    examples: [
-      ["Show Bash completion script", "$0 completion bash"],
-      ["Show Zsh completion script", "$0 completion zsh"],
-      ["Show Fish completion script", "$0 completion fish"]
-    ]
-  });
-  shell = exports_options.String({
-    name: "shell"
-  });
-  async execute() {
-    const shell = parseShell(this.shell);
-    const script = shell === "bash" ? bashScript() : shell === "zsh" ? zshScript() : fishScript();
-    process.stdout.write(`${script}
-`);
-    return 0;
+function envForceColor() {
+  if ("FORCE_COLOR" in env) {
+    if (env.FORCE_COLOR === "true") {
+      return 1;
+    }
+    if (env.FORCE_COLOR === "false") {
+      return 0;
+    }
+    return env.FORCE_COLOR.length === 0 ? 1 : Math.min(Number.parseInt(env.FORCE_COLOR, 10), 3);
   }
 }
-
-// src/lib/run-state.ts
-import { readFile, writeFile } from "node:fs/promises";
-import { resolve as resolve3 } from "node:path";
-function pad(input) {
-  return String(input).padStart(2, "0");
-}
-function generateRunId(now = new Date) {
-  const yyyy = now.getUTCFullYear();
-  const mm = pad(now.getUTCMonth() + 1);
-  const dd = pad(now.getUTCDate());
-  const hh = pad(now.getUTCHours());
-  const min = pad(now.getUTCMinutes());
-  const sec = pad(now.getUTCSeconds());
-  return `${yyyy}${mm}${dd}-${hh}${min}${sec}Z`;
-}
-function runFilePath(config, runId) {
-  return resolve3(config.runsDir, `${runId}.json`);
-}
-function createInitialRunState(options) {
-  const firstStep = options.workflow.steps[0];
-  if (!firstStep) {
-    throw new StorageError("Cannot create run state without at least one workflow step.");
+function translateLevel(level) {
+  if (level === 0) {
+    return false;
   }
   return {
-    run_id: options.runId,
-    workflow_path: options.workflowPath,
-    status: "running",
-    current_step: firstStep.id,
-    context: {
-      task: options.task,
-      ...options.vars
-    },
-    last_harness: {
-      name: resolveHarnessForStep(options.workflow, firstStep.agent),
-      binary: resolveHarnessForStep(options.workflow, firstStep.agent),
-      session_id: null
-    },
-    step_history: [],
-    updated_at: new Date().toISOString()
+    level,
+    hasBasic: true,
+    has256: level >= 2,
+    has16m: level >= 3
   };
 }
-function resolveHarnessForStep(workflow, stepAgentId) {
-  const agent = workflow.agents.find((item) => item.id === stepAgentId);
-  if (!agent) {
-    throw new StorageError(`Cannot resolve harness for unknown agent "${stepAgentId}".`);
+function _supportsColor(haveStream, { streamIsTTY, sniffFlags = true } = {}) {
+  const noFlagForceColor = envForceColor();
+  if (noFlagForceColor !== undefined) {
+    flagForceColor = noFlagForceColor;
   }
-  return agent.harness;
-}
-async function saveRunState(config, state) {
-  const path = runFilePath(config, state.run_id);
-  const payload = JSON.stringify({
-    ...state,
-    updated_at: new Date().toISOString()
-  }, null, 2);
-  await writeFile(path, `${payload}
-`, "utf8");
-  return path;
-}
-async function loadRunState(config, runId) {
-  const path = runFilePath(config, runId);
-  try {
-    const raw = await readFile(path, "utf8");
-    const parsed = JSON.parse(raw);
-    if (!parsed || typeof parsed !== "object" || parsed.run_id !== runId) {
-      throw new StorageError(`Run state file is invalid for run id "${runId}".`);
-    }
-    if (!Array.isArray(parsed.step_history)) {
-      parsed.step_history = [];
+  const forceColor = sniffFlags ? flagForceColor : noFlagForceColor;
+  if (forceColor === 0) {
+    return 0;
+  }
+  if (sniffFlags) {
+    if (hasFlag("color=16m") || hasFlag("color=full") || hasFlag("color=truecolor")) {
+      return 3;
     }
-    return parsed;
-  } catch (error) {
-    if (error instanceof StorageError) {
-      throw error;
+    if (hasFlag("color=256")) {
+      return 2;
     }
-    throw new StorageError(`Failed to load run state for "${runId}".`);
   }
-}
-
-// src/lib/prompt-composer.ts
-import { readFile as readFile2 } from "node:fs/promises";
-import { dirname, resolve as resolve4 } from "node:path";
-function stripFrontmatter(content) {
-  const match = content.match(/^---\r?\n[\s\S]*?\r?\n---\r?\n?/);
-  return match ? content.slice(match[0].length) : content;
-}
-async function loadAgentPrompt(workflowPath, promptFileName) {
-  const promptPath = resolve4(dirname(workflowPath), promptFileName);
-  try {
-    const raw = await readFile2(promptPath, "utf8");
-    return stripFrontmatter(raw);
-  } catch {
-    throw new ConfigError(`Agent prompt file not found: ${promptPath}`);
+  if ("TF_BUILD" in env && "AGENT_NAME" in env) {
+    return 1;
   }
-}
-function composePrompt(agentPrompt, stepInput) {
-  return `${agentPrompt.trimEnd()}
-
-${stepInput.trim()}`;
-}
-
-// src/lib/harness-adapters.ts
-function createPassthroughParser() {
-  return (line) => ({ text: line + `
-` });
-}
-function withModelArgs(model, args) {
-  if (!model) {
-    return args;
+  if (haveStream && !streamIsTTY && forceColor === undefined) {
+    return 0;
   }
-  return [...args, "--model", model];
-}
-function claudeStreamFlags() {
-  return ["--output-format", "stream-json", "--verbose", "--include-partial-messages"];
-}
-function createClaudeStreamParser() {
-  let currentToolName = null;
-  let currentToolInput = "";
-  let currentBlockIndex = null;
-  return (line) => {
-    if (!line.trim()) {
-      return null;
+  const min = forceColor || 0;
+  if (env.TERM === "dumb") {
+    return min;
+  }
+  if (process2.platform === "win32") {
+    const osRelease = os.release().split(".");
+    if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
+      return Number(osRelease[2]) >= 14931 ? 3 : 2;
     }
-    let obj;
-    try {
-      obj = JSON.parse(line);
-    } catch {
-      return null;
+    return 1;
+  }
+  if ("CI" in env) {
+    if (["GITHUB_ACTIONS", "GITEA_ACTIONS", "CIRCLECI"].some((key) => (key in env))) {
+      return 3;
     }
-    const type = obj.type;
-    const sessionId = typeof obj.session_id === "string" ? obj.session_id : undefined;
-    if (type === "stream_event") {
-      const event = obj.event;
-      const index = typeof event?.index === "number" ? event.index : null;
-      if (event?.type === "content_block_start") {
-        const block = event.content_block;
-        if (block?.type === "tool_use" && typeof block.name === "string") {
-          currentToolName = block.name;
-          currentToolInput = "";
-          currentBlockIndex = index;
-          return sessionId ? { text: "", sessionId } : null;
+    if (["TRAVIS", "APPVEYOR", "GITLAB_CI", "BUILDKITE", "DRONE"].some((sign) => (sign in env)) || env.CI_NAME === "codeship") {
+      return 1;
+    }
+    return min;
+  }
+  if ("TEAMCITY_VERSION" in env) {
+    return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0;
+  }
+  if (env.COLORTERM === "truecolor") {
+    return 3;
+  }
+  if (env.TERM === "xterm-kitty") {
+    return 3;
+  }
+  if (env.TERM === "xterm-ghostty") {
+    return 3;
+  }
+  if (env.TERM === "wezterm") {
+    return 3;
+  }
+  if ("TERM_PROGRAM" in env) {
+    const version = Number.parseInt((env.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
+    switch (env.TERM_PROGRAM) {
+      case "iTerm.app": {
+        return version >= 3 ? 3 : 2;
+      }
+      case "Apple_Terminal": {
+        return 2;
+      }
+    }
+  }
+  if (/-256(color)?$/i.test(env.TERM)) {
+    return 2;
+  }
+  if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) {
+    return 1;
+  }
+  if ("COLORTERM" in env) {
+    return 1;
+  }
+  return min;
+}
+function createSupportsColor(stream, options = {}) {
+  const level = _supportsColor(stream, {
+    streamIsTTY: stream && stream.isTTY,
+    ...options
+  });
+  return translateLevel(level);
+}
+var supportsColor = {
+  stdout: createSupportsColor({ isTTY: tty2.isatty(1) }),
+  stderr: createSupportsColor({ isTTY: tty2.isatty(2) })
+};
+var supports_color_default = supportsColor;
+
+// node_modules/chalk/source/utilities.js
+function stringReplaceAll(string, substring, replacer) {
+  let index = string.indexOf(substring);
+  if (index === -1) {
+    return string;
+  }
+  const substringLength = substring.length;
+  let endIndex = 0;
+  let returnValue = "";
+  do {
+    returnValue += string.slice(endIndex, index) + substring + replacer;
+    endIndex = index + substringLength;
+    index = string.indexOf(substring, endIndex);
+  } while (index !== -1);
+  returnValue += string.slice(endIndex);
+  return returnValue;
+}
+function stringEncaseCRLFWithFirstIndex(string, prefix, postfix, index) {
+  let endIndex = 0;
+  let returnValue = "";
+  do {
+    const gotCR = string[index - 1] === "\r";
+    returnValue += string.slice(endIndex, gotCR ? index - 1 : index) + prefix + (gotCR ? `\r
+` : `
+`) + postfix;
+    endIndex = index + 1;
+    index = string.indexOf(`
+`, endIndex);
+  } while (index !== -1);
+  returnValue += string.slice(endIndex);
+  return returnValue;
+}
+
+// node_modules/chalk/source/index.js
+var { stdout: stdoutColor, stderr: stderrColor } = supports_color_default;
+var GENERATOR = Symbol("GENERATOR");
+var STYLER = Symbol("STYLER");
+var IS_EMPTY = Symbol("IS_EMPTY");
+var levelMapping = [
+  "ansi",
+  "ansi",
+  "ansi256",
+  "ansi16m"
+];
+var styles2 = Object.create(null);
+var applyOptions = (object, options = {}) => {
+  if (options.level && !(Number.isInteger(options.level) && options.level >= 0 && options.level <= 3)) {
+    throw new Error("The `level` option should be an integer from 0 to 3");
+  }
+  const colorLevel = stdoutColor ? stdoutColor.level : 0;
+  object.level = options.level === undefined ? colorLevel : options.level;
+};
+var chalkFactory = (options) => {
+  const chalk = (...strings) => strings.join(" ");
+  applyOptions(chalk, options);
+  Object.setPrototypeOf(chalk, createChalk.prototype);
+  return chalk;
+};
+function createChalk(options) {
+  return chalkFactory(options);
+}
+Object.setPrototypeOf(createChalk.prototype, Function.prototype);
+for (const [styleName, style] of Object.entries(ansi_styles_default)) {
+  styles2[styleName] = {
+    get() {
+      const builder = createBuilder(this, createStyler(style.open, style.close, this[STYLER]), this[IS_EMPTY]);
+      Object.defineProperty(this, styleName, { value: builder });
+      return builder;
+    }
+  };
+}
+styles2.visible = {
+  get() {
+    const builder = createBuilder(this, this[STYLER], true);
+    Object.defineProperty(this, "visible", { value: builder });
+    return builder;
+  }
+};
+var getModelAnsi = (model, level, type, ...arguments_) => {
+  if (model === "rgb") {
+    if (level === "ansi16m") {
+      return ansi_styles_default[type].ansi16m(...arguments_);
+    }
+    if (level === "ansi256") {
+      return ansi_styles_default[type].ansi256(ansi_styles_default.rgbToAnsi256(...arguments_));
+    }
+    return ansi_styles_default[type].ansi(ansi_styles_default.rgbToAnsi(...arguments_));
+  }
+  if (model === "hex") {
+    return getModelAnsi("rgb", level, type, ...ansi_styles_default.hexToRgb(...arguments_));
+  }
+  return ansi_styles_default[type][model](...arguments_);
+};
+var usedModels = ["rgb", "hex", "ansi256"];
+for (const model of usedModels) {
+  styles2[model] = {
+    get() {
+      const { level } = this;
+      return function(...arguments_) {
+        const styler = createStyler(getModelAnsi(model, levelMapping[level], "color", ...arguments_), ansi_styles_default.color.close, this[STYLER]);
+        return createBuilder(this, styler, this[IS_EMPTY]);
+      };
+    }
+  };
+  const bgModel = "bg" + model[0].toUpperCase() + model.slice(1);
+  styles2[bgModel] = {
+    get() {
+      const { level } = this;
+      return function(...arguments_) {
+        const styler = createStyler(getModelAnsi(model, levelMapping[level], "bgColor", ...arguments_), ansi_styles_default.bgColor.close, this[STYLER]);
+        return createBuilder(this, styler, this[IS_EMPTY]);
+      };
+    }
+  };
+}
+var proto = Object.defineProperties(() => {}, {
+  ...styles2,
+  level: {
+    enumerable: true,
+    get() {
+      return this[GENERATOR].level;
+    },
+    set(level) {
+      this[GENERATOR].level = level;
+    }
+  }
+});
+var createStyler = (open, close, parent) => {
+  let openAll;
+  let closeAll;
+  if (parent === undefined) {
+    openAll = open;
+    closeAll = close;
+  } else {
+    openAll = parent.openAll + open;
+    closeAll = close + parent.closeAll;
+  }
+  return {
+    open,
+    close,
+    openAll,
+    closeAll,
+    parent
+  };
+};
+var createBuilder = (self, _styler, _isEmpty) => {
+  const builder = (...arguments_) => applyStyle(builder, arguments_.length === 1 ? "" + arguments_[0] : arguments_.join(" "));
+  Object.setPrototypeOf(builder, proto);
+  builder[GENERATOR] = self;
+  builder[STYLER] = _styler;
+  builder[IS_EMPTY] = _isEmpty;
+  return builder;
+};
+var applyStyle = (self, string) => {
+  if (self.level <= 0 || !string) {
+    return self[IS_EMPTY] ? "" : string;
+  }
+  let styler = self[STYLER];
+  if (styler === undefined) {
+    return string;
+  }
+  const { openAll, closeAll } = styler;
+  if (string.includes("\x1B")) {
+    while (styler !== undefined) {
+      string = stringReplaceAll(string, styler.close, styler.open);
+      styler = styler.parent;
+    }
+  }
+  const lfIndex = string.indexOf(`
+`);
+  if (lfIndex !== -1) {
+    string = stringEncaseCRLFWithFirstIndex(string, closeAll, openAll, lfIndex);
+  }
+  return openAll + string + closeAll;
+};
+Object.defineProperties(createChalk.prototype, styles2);
+var chalk = createChalk();
+var chalkStderr = createChalk({ level: stderrColor ? stderrColor.level : 0 });
+var source_default = chalk;
+
+// src/lib/ui.ts
+import * as readline from "node:readline";
+
+// src/lib/binary-name.ts
+import { basename } from "node:path";
+function detectBinaryName() {
+  const invokedPath = process.argv[1];
+  const invokedName = invokedPath ? basename(invokedPath) : "";
+  if (invokedName !== "" && !invokedName.endsWith(".js") && !invokedName.endsWith(".ts")) {
+    return invokedName;
+  }
+  return "rmr";
+}
+var binaryName = detectBinaryName();
+
+// src/lib/ui.ts
+var isTTY = process.stdout.isTTY === true;
+function getTerminalWidth() {
+  return process.stdout.columns ?? 80;
+}
+function getBoxWidth() {
+  const termWidth = getTerminalWidth();
+  return Math.max(40, termWidth - 2);
+}
+function truncate(text, maxLength) {
+  if (text.length <= maxLength) {
+    return text;
+  }
+  return text.slice(0, maxLength - 3) + "...";
+}
+function wrapText(text, maxWidth) {
+  if (text.length <= maxWidth) {
+    return [text];
+  }
+  const lines = [];
+  let remaining = text;
+  while (remaining.length > maxWidth) {
+    let breakAt = remaining.lastIndexOf(" ", maxWidth);
+    if (breakAt <= 0) {
+      breakAt = maxWidth;
+    }
+    lines.push(remaining.slice(0, breakAt));
+    remaining = remaining.slice(breakAt).trimStart();
+  }
+  if (remaining) {
+    lines.push(remaining);
+  }
+  return lines;
+}
+function stripAnsi(text) {
+  return text.replace(/\x1b\[[0-?]*[ -/]*[@-~]/g, "").replace(/\x1b\][^\x07]*(?:\x07|\x1b\\)/g, "");
+}
+function displayWidth(text) {
+  return Array.from(text).length;
+}
+var ui = {
+  get isTTY() {
+    return isTTY;
+  },
+  workflowHeader(info) {
+    const line = isTTY ? "─" : "-";
+    const corner = {
+      tl: isTTY ? "╭" : "+",
+      tr: isTTY ? "╮" : "+",
+      bl: isTTY ? "╰" : "+",
+      br: isTTY ? "╯" : "+"
+    };
+    const width = getBoxWidth();
+    const contentWidth = width - 4;
+    const border = line.repeat(width - 2);
+    const labelWidth = 10;
+    const valueWidth = contentWidth - labelWidth;
+    const formatLine = (label, value) => {
+      const paddedLabel = label ? `${label}:`.padEnd(labelWidth) : " ".repeat(labelWidth);
+      const truncatedValue = truncate(value, valueWidth);
+      return `${paddedLabel}${truncatedValue}`.padEnd(contentWidth);
+    };
+    process.stdout.write(`
+`);
+    process.stdout.write(isTTY ? source_default.cyan(`${corner.tl}${line} ${info.title} ${border.slice(info.title.length + 3)}${corner.tr}
+`) : `${corner.tl}${line} ${info.title} ${border.slice(info.title.length + 3)}${corner.tr}
+`);
+    process.stdout.write(isTTY ? source_default.dim(`│ ${formatLine("workflow", info.workflow)} │
+`) : `│ ${formatLine("workflow", info.workflow)} │
+`);
+    process.stdout.write(isTTY ? source_default.dim(`│ ${formatLine("run-id", info.runId)} │
+`) : `│ ${formatLine("run-id", info.runId)} │
+`);
+    const taskLines = info.task.split(`
+`).flatMap((line2) => {
+      if (line2 === "") {
+        return [""];
+      }
+      return wrapText(line2, valueWidth);
+    });
+    for (let i = 0;i < taskLines.length; i++) {
+      const label = i === 0 ? "task" : "";
+      const content = formatLine(label, taskLines[i] ?? "");
+      process.stdout.write(isTTY ? source_default.dim(`│ ${content} │
+`) : `│ ${content} │
+`);
+    }
+    process.stdout.write(isTTY ? source_default.cyan(`${corner.bl}${border}${corner.br}
+`) : `${corner.bl}${border}${corner.br}
+`);
+    process.stdout.write(`
+`);
+  },
+  stepStart(stepNumber, stepId, harness, model) {
+    const line = isTTY ? "─" : "-";
+    const corner = { tl: isTTY ? "┌" : "+", tr: isTTY ? "┐" : "+" };
+    const label = ` Step ${stepNumber}: ${stepId} `;
+    const width = getBoxWidth();
+    const remaining = Math.max(0, width - label.length - 2);
+    const border = line.repeat(remaining);
+    process.stdout.write(`
+`);
+    process.stdout.write(isTTY ? source_default.cyan.bold(`${corner.tl}${line}${label}${border}${corner.tr}
+`) : `${corner.tl}${line}${label}${border}${corner.tr}
+`);
+    const metaLine = `  harness: ${harness}    model: ${model ?? "(default)"}`;
+    process.stdout.write(isTTY ? source_default.dim(`${metaLine}
+`) : `${metaLine}
+`);
+    process.stdout.write(`
+`);
+  },
+  stepEnd() {
+    const line = isTTY ? "─" : "-";
+    const corner = { bl: isTTY ? "└" : "+", br: isTTY ? "┘" : "+" };
+    const width = getBoxWidth();
+    const border = line.repeat(width - 2);
+    process.stdout.write(`
+`);
+    process.stdout.write(isTTY ? source_default.cyan(`${corner.bl}${border}${corner.br}
+`) : `${corner.bl}${border}${corner.br}
+`);
+  },
+  printToolCall(toolName, toolInput) {
+    const width = getBoxWidth();
+    const maxInputLength = width - 10;
+    const truncatedInput = truncate(toolInput, maxInputLength);
+    if (isTTY) {
+      process.stderr.write(source_default.cyan(`  ${toolName} `) + source_default.dim(truncatedInput) + `
+`);
+    } else {
+      process.stderr.write(`  ${toolName} ${truncatedInput}
+`);
+    }
+  },
+  stepOutputs(values) {
+    const entries = Object.entries(values);
+    if (entries.length === 0) {
+      return;
+    }
+    const width = getBoxWidth();
+    const labelPrefix = "  ";
+    const separator = ": ";
+    process.stdout.write(`
+`);
+    for (const [key, value] of entries) {
+      const label = `rmr:${key}`;
+      const firstLineIndent = labelPrefix.length + label.length + separator.length;
+      const continuationIndent = " ".repeat(firstLineIndent);
+      const maxValueWidth = width - firstLineIndent;
+      const valueLines = value.split(`
+`);
+      const wrappedLines = [];
+      for (const vline of valueLines) {
+        if (vline.length <= maxValueWidth) {
+          wrappedLines.push(vline);
+        } else {
+          let remaining = vline;
+          while (remaining.length > maxValueWidth) {
+            let breakAt = remaining.lastIndexOf(" ", maxValueWidth);
+            if (breakAt <= 0) {
+              breakAt = maxValueWidth;
+            }
+            wrappedLines.push(remaining.slice(0, breakAt));
+            remaining = remaining.slice(breakAt).trimStart();
+          }
+          if (remaining) {
+            wrappedLines.push(remaining);
+          }
         }
       }
-      if (event?.type === "content_block_delta") {
-        const delta = event.delta;
-        if (delta?.type === "text_delta" && typeof delta.text === "string") {
-          return { text: delta.text, sessionId };
-        }
-        if (delta?.type === "input_json_delta" && typeof delta.partial_json === "string") {
-          currentToolInput += delta.partial_json;
-          return sessionId ? { text: "", sessionId } : null;
-        }
-        return sessionId ? { text: "", sessionId } : null;
+      const firstLine = wrappedLines[0] ?? "";
+      if (isTTY) {
+        process.stdout.write(source_default.cyan(`${labelPrefix}${label}`) + source_default.dim(`${separator}${firstLine}`) + `
+`);
+      } else {
+        process.stdout.write(`${labelPrefix}${label}${separator}${firstLine}
+`);
       }
-      if (event?.type === "content_block_stop") {
-        if (currentToolName && index === currentBlockIndex) {
-          const result = {
-            text: "",
-            sessionId,
-            toolName: currentToolName,
-            toolInput: currentToolInput || undefined
-          };
-          currentToolName = null;
-          currentToolInput = "";
-          currentBlockIndex = null;
-          return result;
+      for (let i = 1;i < wrappedLines.length; i++) {
+        if (isTTY) {
+          process.stdout.write(source_default.dim(`${continuationIndent}${wrappedLines[i]}`) + `
+`);
+        } else {
+          process.stdout.write(`${continuationIndent}${wrappedLines[i]}
+`);
         }
       }
-      return sessionId ? { text: "", sessionId } : null;
-    }
-    if (type === "result") {
-      return sessionId ? { text: "", sessionId } : null;
-    }
-    if (type === "system") {
-      return sessionId ? { text: "", sessionId } : null;
-    }
-    return null;
-  };
-}
-var adapters = {
-  claude: {
-    name: "claude",
-    buildRunCommand(prompt, options) {
-      const allowArgs = options.allowAll ? ["--dangerously-skip-permissions"] : [];
-      const base = ["-p", prompt, ...claudeStreamFlags()];
-      return { binary: "claude", args: withModelArgs(options.model, [...allowArgs, ...base]) };
-    },
-    buildResumeCommand(sessionId, prompt, options) {
-      const allowArgs = options.allowAll ? ["--dangerously-skip-permissions"] : [];
-      const base = [...allowArgs, "--resume", sessionId, "-p", prompt, ...claudeStreamFlags()];
-      return { binary: "claude", args: withModelArgs(options.model, base) };
-    },
-    createStreamParser: createClaudeStreamParser,
-    resumeTemplate(sessionId) {
-      return `claude --resume ${sessionId}`;
     }
   },
-  opencode: {
-    name: "opencode",
-    buildRunCommand(prompt, options) {
-      const args = ["run", prompt];
-      return { binary: "opencode", args: withModelArgs(options.model, args) };
-    },
-    buildResumeCommand(sessionId, prompt, options) {
-      const args = ["--resume", sessionId, "run", prompt];
-      return { binary: "opencode", args: withModelArgs(options.model, args) };
-    },
-    createStreamParser: createPassthroughParser,
-    resumeTemplate(sessionId) {
-      return `opencode --resume ${sessionId}`;
-    }
+  content(text) {
+    process.stdout.write(text);
   },
-  codex: {
-    name: "codex",
-    buildRunCommand(prompt, options) {
-      const auto = options.allowAll ? ["--full-auto"] : [];
-      const args = [...auto, "exec", prompt];
-      return { binary: "codex", args: withModelArgs(options.model, args) };
-    },
-    buildResumeCommand(sessionId, prompt, options) {
-      const args = ["exec", "resume", sessionId, prompt];
-      return { binary: "codex", args: withModelArgs(options.model, args) };
-    },
-    createStreamParser: createPassthroughParser,
-    resumeTemplate(sessionId) {
-      return `codex exec resume ${sessionId} "<prompt>"`;
-    }
+  success(text) {
+    const icon = isTTY ? "✓ " : "";
+    process.stdout.write(isTTY ? source_default.green(`${icon}${text}
+`) : `${icon}${text}
+`);
   },
-  copilot: {
-    name: "copilot",
-    buildRunCommand(prompt, options) {
-      const auto = options.allowAll ? ["--allow-all", "--no-ask-user"] : [];
-      const args = [...auto, "-p", prompt];
-      return { binary: "copilot", args: withModelArgs(options.model, args) };
-    },
-    buildResumeCommand(_sessionId, prompt, options) {
-      const args = ["-p", prompt];
-      return { binary: "copilot", args: withModelArgs(options.model, args) };
-    },
-    createStreamParser: createPassthroughParser,
-    resumeTemplate(sessionId) {
-      return `copilot --resume ${sessionId}`;
-    }
-  }
-};
-function getHarnessAdapter(name) {
-  const adapter = adapters[name];
-  if (!adapter) {
-    throw new ValidationError(`Unknown harness "${name}".`);
-  }
-  return adapter;
-}
-
-// node_modules/chalk/source/vendor/ansi-styles/index.js
-var ANSI_BACKGROUND_OFFSET = 10;
-var wrapAnsi16 = (offset = 0) => (code) => `\x1B[${code + offset}m`;
-var wrapAnsi256 = (offset = 0) => (code) => `\x1B[${38 + offset};5;${code}m`;
-var wrapAnsi16m = (offset = 0) => (red, green, blue) => `\x1B[${38 + offset};2;${red};${green};${blue}m`;
-var styles = {
-  modifier: {
-    reset: [0, 0],
-    bold: [1, 22],
-    dim: [2, 22],
-    italic: [3, 23],
-    underline: [4, 24],
-    overline: [53, 55],
-    inverse: [7, 27],
-    hidden: [8, 28],
-    strikethrough: [9, 29]
+  warning(text) {
+    const icon = isTTY ? "⚠ " : "";
+    process.stderr.write(isTTY ? source_default.yellow(`${icon}${text}
+`) : `${icon}${text}
+`);
   },
-  color: {
-    black: [30, 39],
-    red: [31, 39],
-    green: [32, 39],
-    yellow: [33, 39],
-    blue: [34, 39],
-    magenta: [35, 39],
-    cyan: [36, 39],
-    white: [37, 39],
-    blackBright: [90, 39],
-    gray: [90, 39],
-    grey: [90, 39],
-    redBright: [91, 39],
-    greenBright: [92, 39],
-    yellowBright: [93, 39],
-    blueBright: [94, 39],
-    magentaBright: [95, 39],
-    cyanBright: [96, 39],
-    whiteBright: [97, 39]
+  error(text) {
+    const icon = isTTY ? "✗ " : "";
+    process.stderr.write(isTTY ? source_default.red(`${icon}${text}
+`) : `${icon}${text}
+`);
   },
-  bgColor: {
-    bgBlack: [40, 49],
-    bgRed: [41, 49],
-    bgGreen: [42, 49],
-    bgYellow: [43, 49],
-    bgBlue: [44, 49],
-    bgMagenta: [45, 49],
-    bgCyan: [46, 49],
-    bgWhite: [47, 49],
-    bgBlackBright: [100, 49],
-    bgGray: [100, 49],
-    bgGrey: [100, 49],
-    bgRedBright: [101, 49],
-    bgGreenBright: [102, 49],
-    bgYellowBright: [103, 49],
-    bgBlueBright: [104, 49],
-    bgMagentaBright: [105, 49],
-    bgCyanBright: [106, 49],
-    bgWhiteBright: [107, 49]
-  }
-};
-var modifierNames = Object.keys(styles.modifier);
-var foregroundColorNames = Object.keys(styles.color);
-var backgroundColorNames = Object.keys(styles.bgColor);
-var colorNames = [...foregroundColorNames, ...backgroundColorNames];
-function assembleStyles() {
-  const codes = new Map;
-  for (const [groupName, group] of Object.entries(styles)) {
-    for (const [styleName, style] of Object.entries(group)) {
-      styles[styleName] = {
-        open: `\x1B[${style[0]}m`,
-        close: `\x1B[${style[1]}m`
-      };
-      group[styleName] = styles[styleName];
-      codes.set(style[0], style[1]);
-    }
-    Object.defineProperty(styles, groupName, {
-      value: group,
-      enumerable: false
+  info(text) {
+    process.stdout.write(`${text}
+`);
+  },
+  dim(text) {
+    process.stdout.write(isTTY ? source_default.gray(text) : text);
+  },
+  pauseInstructions(info) {
+    process.stderr.write(`
+`);
+    ui.warning(`Paused: ${info.reason}`);
+    process.stderr.write(`
+`);
+    process.stdout.write(isTTY ? source_default.dim(`Resume workflow:
+`) : `Resume workflow:
+`);
+    process.stdout.write(`  ${binaryName} continue ${info.runId}
+`);
+    process.stdout.write(`
+`);
+    process.stdout.write(isTTY ? source_default.dim(`Resume with a hint:
+`) : `Resume with a hint:
+`);
+    process.stdout.write(`  ${binaryName} continue ${info.runId} --hint "your guidance here"
+`);
+    process.stdout.write(`
+`);
+    process.stdout.write(isTTY ? source_default.dim(`Resume agent session directly:
+`) : `Resume agent session directly:
+`);
+    process.stdout.write(`  ${info.resumeCommand}
+`);
+    process.stdout.write(`
+`);
+  },
+  prompt(message) {
+    return new Promise((resolve) => {
+      const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout
+      });
+      const styledMessage = isTTY ? source_default.cyan(message) : message;
+      rl.question(styledMessage, (answer) => {
+        rl.close();
+        resolve(answer);
+      });
     });
-  }
-  Object.defineProperty(styles, "codes", {
-    value: codes,
-    enumerable: false
-  });
-  styles.color.close = "\x1B[39m";
-  styles.bgColor.close = "\x1B[49m";
-  styles.color.ansi = wrapAnsi16();
-  styles.color.ansi256 = wrapAnsi256();
-  styles.color.ansi16m = wrapAnsi16m();
-  styles.bgColor.ansi = wrapAnsi16(ANSI_BACKGROUND_OFFSET);
-  styles.bgColor.ansi256 = wrapAnsi256(ANSI_BACKGROUND_OFFSET);
-  styles.bgColor.ansi16m = wrapAnsi16m(ANSI_BACKGROUND_OFFSET);
-  Object.defineProperties(styles, {
-    rgbToAnsi256: {
-      value(red, green, blue) {
-        if (red === green && green === blue) {
-          if (red < 8) {
-            return 16;
-          }
-          if (red > 248) {
-            return 231;
+  },
+  multilinePrompt(message) {
+    return new Promise((resolve) => {
+      const input = process.stdin;
+      const output = process.stdout;
+      const supportsRawMode = input.isTTY && typeof input.setRawMode === "function";
+      const styledMessage = isTTY ? source_default.cyan(message) : message;
+      const linePrompt = isTTY ? source_default.cyan("> ") : "> ";
+      const promptWidth = displayWidth(stripAnsi(linePrompt));
+      let buffer = "";
+      let cursor = 0;
+      let settled = false;
+      let renderedRowCount = 0;
+      if (!supportsRawMode) {
+        const rl = readline.createInterface({
+          input,
+          output
+        });
+        rl.question(`${styledMessage} `, (answer) => {
+          rl.close();
+          resolve(answer);
+        });
+        return;
+      }
+      const cleanup = () => {
+        input.off("data", onData);
+        input.off("error", onError);
+        input.setRawMode(false);
+        input.pause();
+      };
+      const finish = (value) => {
+        if (settled) {
+          return;
+        }
+        settled = true;
+        cleanup();
+        resolve(value);
+      };
+      const clearRenderedBuffer = () => {
+        if (renderedRowCount === 0) {
+          return;
+        }
+        readline.cursorTo(output, 0);
+        if (renderedRowCount > 1) {
+          readline.moveCursor(output, 0, -(renderedRowCount - 1));
+        }
+        readline.clearScreenDown(output);
+      };
+      const getRenderedRowCount = (lines) => {
+        const columns = Math.max(1, getTerminalWidth());
+        let rows = 0;
+        for (const line of lines) {
+          const lineWidth = promptWidth + displayWidth(line);
+          rows += Math.max(1, Math.ceil(lineWidth / columns));
+        }
+        return rows;
+      };
+      const getCursorPosition = () => {
+        const textBeforeCursor = buffer.slice(0, cursor);
+        const linesBeforeCursor = textBeforeCursor.split(`
+`);
+        const line = linesBeforeCursor.length - 1;
+        const col = linesBeforeCursor[line]?.length ?? 0;
+        return { line, col };
+      };
+      const getLineStart = (lineNum) => {
+        const lines = buffer.split(`
+`);
+        let idx = 0;
+        for (let i = 0;i < lineNum && i < lines.length; i++) {
+          idx += (lines[i]?.length ?? 0) + 1;
+        }
+        return idx;
+      };
+      const getLineEnd = (lineNum) => {
+        const lines = buffer.split(`
+`);
+        if (lineNum >= lines.length) {
+          return buffer.length;
+        }
+        return getLineStart(lineNum) + (lines[lineNum]?.length ?? 0);
+      };
+      const renderBuffer = () => {
+        clearRenderedBuffer();
+        const lines = buffer.split(`
+`);
+        for (let i = 0;i < lines.length; i++) {
+          output.write(`${linePrompt}${lines[i] ?? ""}`);
+          if (i < lines.length - 1) {
+            output.write(`
+`);
           }
-          return Math.round((red - 8) / 247 * 24) + 232;
         }
-        return 16 + 36 * Math.round(red / 255 * 5) + 6 * Math.round(green / 255 * 5) + Math.round(blue / 255 * 5);
-      },
-      enumerable: false
-    },
-    hexToRgb: {
-      value(hex) {
-        const matches = /[a-f\d]{6}|[a-f\d]{3}/i.exec(hex.toString(16));
-        if (!matches) {
-          return [0, 0, 0];
+        renderedRowCount = getRenderedRowCount(lines);
+        const { line: cursorLine, col: cursorCol } = getCursorPosition();
+        const columns = Math.max(1, getTerminalWidth());
+        let rowsFromEnd = 0;
+        for (let i = lines.length - 1;i > cursorLine; i--) {
+          const lineWidth = promptWidth + displayWidth(lines[i] ?? "");
+          rowsFromEnd += Math.max(1, Math.ceil(lineWidth / columns));
+        }
+        const cursorLineWidth = promptWidth + cursorCol;
+        const totalLineWidth = promptWidth + displayWidth(lines[cursorLine] ?? "");
+        const totalRowsInCursorLine = Math.max(1, Math.ceil(totalLineWidth / columns));
+        const cursorRowInLine = Math.floor(cursorLineWidth / columns);
+        const rowsAfterCursorInLine = totalRowsInCursorLine - cursorRowInLine - 1;
+        rowsFromEnd += rowsAfterCursorInLine;
+        if (rowsFromEnd > 0) {
+          readline.moveCursor(output, 0, -rowsFromEnd);
+        }
+        readline.cursorTo(output, cursorLineWidth % columns);
+      };
+      const insertText = (text) => {
+        const normalized = text.replace(/\r\n/g, `
+`).replace(/\r/g, `
+`);
+        if (!normalized) {
+          return;
         }
-        let [colorString] = matches;
-        if (colorString.length === 3) {
-          colorString = [...colorString].map((character) => character + character).join("");
+        buffer = buffer.slice(0, cursor) + normalized + buffer.slice(cursor);
+        cursor += normalized.length;
+        renderBuffer();
+      };
+      const submit = () => {
+        const lines = buffer.split(`
+`);
+        const lastLineIdx = lines.length - 1;
+        const columns = Math.max(1, getTerminalWidth());
+        const { line: cursorLine } = getCursorPosition();
+        let rowsToEnd = 0;
+        for (let i = cursorLine + 1;i < lines.length; i++) {
+          const lineWidth = promptWidth + displayWidth(lines[i] ?? "");
+          rowsToEnd += Math.max(1, Math.ceil(lineWidth / columns));
+        }
+        const cursorLineWidth = promptWidth + displayWidth(lines[cursorLine] ?? "");
+        const totalRowsInCursorLine = Math.max(1, Math.ceil(cursorLineWidth / columns));
+        const { col: cursorCol } = getCursorPosition();
+        const cursorRowInLine = Math.floor((promptWidth + cursorCol) / columns);
+        rowsToEnd += totalRowsInCursorLine - cursorRowInLine - 1;
+        if (rowsToEnd > 0) {
+          readline.moveCursor(output, 0, rowsToEnd);
+        }
+        const lastLineWidth = promptWidth + displayWidth(lines[lastLineIdx] ?? "");
+        readline.cursorTo(output, lastLineWidth % columns);
+        output.write(`
+`);
+        finish(buffer);
+      };
+      const cancel = () => {
+        output.write(`
+`);
+        finish("");
+      };
+      const onError = () => {
+        finish(buffer);
+      };
+      const onData = (chunk) => {
+        const value = typeof chunk === "string" ? chunk : chunk.toString("utf8");
+        if (value === "\x03") {
+          cancel();
+          return;
         }
-        const integer = Number.parseInt(colorString, 16);
-        return [
-          integer >> 16 & 255,
-          integer >> 8 & 255,
-          integer & 255
-        ];
-      },
-      enumerable: false
-    },
-    hexToAnsi256: {
-      value: (hex) => styles.rgbToAnsi256(...styles.hexToRgb(hex)),
-      enumerable: false
-    },
-    ansi256ToAnsi: {
-      value(code) {
-        if (code < 8) {
-          return 30 + code;
+        if (value === "\x04") {
+          submit();
+          return;
         }
-        if (code < 16) {
-          return 90 + (code - 8);
+        if (value === "\x01") {
+          const { line } = getCursorPosition();
+          cursor = getLineStart(line);
+          renderBuffer();
+          return;
         }
-        let red;
-        let green;
-        let blue;
-        if (code >= 232) {
-          red = ((code - 232) * 10 + 8) / 255;
-          green = red;
-          blue = red;
-        } else {
-          code -= 16;
-          const remainder = code % 36;
-          red = Math.floor(code / 36) / 5;
-          green = Math.floor(remainder / 6) / 5;
-          blue = remainder % 6 / 5;
+        if (value === "\x05") {
+          const { line } = getCursorPosition();
+          cursor = getLineEnd(line);
+          renderBuffer();
+          return;
         }
-        const value = Math.max(red, green, blue) * 2;
-        if (value === 0) {
-          return 30;
+        if (value === "\x15") {
+          const { line } = getCursorPosition();
+          const lineStart = getLineStart(line);
+          buffer = buffer.slice(0, lineStart) + buffer.slice(cursor);
+          cursor = lineStart;
+          renderBuffer();
+          return;
         }
-        let result = 30 + (Math.round(blue) << 2 | Math.round(green) << 1 | Math.round(red));
-        if (value === 2) {
-          result += 60;
+        if (value === "\x17") {
+          if (cursor === 0) {
+            return;
+          }
+          let newCursor = cursor - 1;
+          while (newCursor > 0 && /\s/.test(buffer[newCursor] ?? "")) {
+            newCursor--;
+          }
+          while (newCursor > 0 && !/\s/.test(buffer[newCursor - 1] ?? "")) {
+            newCursor--;
+          }
+          buffer = buffer.slice(0, newCursor) + buffer.slice(cursor);
+          cursor = newCursor;
+          renderBuffer();
+          return;
         }
-        return result;
-      },
-      enumerable: false
-    },
-    rgbToAnsi: {
-      value: (red, green, blue) => styles.ansi256ToAnsi(styles.rgbToAnsi256(red, green, blue)),
-      enumerable: false
-    },
-    hexToAnsi: {
-      value: (hex) => styles.ansi256ToAnsi(styles.hexToAnsi256(hex)),
-      enumerable: false
-    }
-  });
-  return styles;
-}
-var ansiStyles = assembleStyles();
-var ansi_styles_default = ansiStyles;
-
-// node_modules/chalk/source/vendor/supports-color/index.js
-import process2 from "node:process";
-import os from "node:os";
-import tty2 from "node:tty";
-function hasFlag(flag, argv = globalThis.Deno ? globalThis.Deno.args : process2.argv) {
-  const prefix = flag.startsWith("-") ? "" : flag.length === 1 ? "-" : "--";
-  const position = argv.indexOf(prefix + flag);
-  const terminatorPosition = argv.indexOf("--");
-  return position !== -1 && (terminatorPosition === -1 || position < terminatorPosition);
-}
-var { env } = process2;
-var flagForceColor;
-if (hasFlag("no-color") || hasFlag("no-colors") || hasFlag("color=false") || hasFlag("color=never")) {
-  flagForceColor = 0;
-} else if (hasFlag("color") || hasFlag("colors") || hasFlag("color=true") || hasFlag("color=always")) {
-  flagForceColor = 1;
-}
-function envForceColor() {
-  if ("FORCE_COLOR" in env) {
-    if (env.FORCE_COLOR === "true") {
-      return 1;
-    }
-    if (env.FORCE_COLOR === "false") {
-      return 0;
-    }
-    return env.FORCE_COLOR.length === 0 ? 1 : Math.min(Number.parseInt(env.FORCE_COLOR, 10), 3);
-  }
-}
-function translateLevel(level) {
-  if (level === 0) {
-    return false;
-  }
-  return {
-    level,
-    hasBasic: true,
-    has256: level >= 2,
-    has16m: level >= 3
-  };
-}
-function _supportsColor(haveStream, { streamIsTTY, sniffFlags = true } = {}) {
-  const noFlagForceColor = envForceColor();
-  if (noFlagForceColor !== undefined) {
-    flagForceColor = noFlagForceColor;
-  }
-  const forceColor = sniffFlags ? flagForceColor : noFlagForceColor;
-  if (forceColor === 0) {
-    return 0;
-  }
-  if (sniffFlags) {
-    if (hasFlag("color=16m") || hasFlag("color=full") || hasFlag("color=truecolor")) {
-      return 3;
-    }
-    if (hasFlag("color=256")) {
-      return 2;
-    }
-  }
-  if ("TF_BUILD" in env && "AGENT_NAME" in env) {
-    return 1;
-  }
-  if (haveStream && !streamIsTTY && forceColor === undefined) {
-    return 0;
-  }
-  const min = forceColor || 0;
-  if (env.TERM === "dumb") {
-    return min;
-  }
-  if (process2.platform === "win32") {
-    const osRelease = os.release().split(".");
-    if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
-      return Number(osRelease[2]) >= 14931 ? 3 : 2;
-    }
-    return 1;
+        if (value === "\r" || value === `
+`) {
+          insertText(`
+`);
+          return;
+        }
+        if (value === "" || value === "\b") {
+          if (cursor > 0) {
+            buffer = buffer.slice(0, cursor - 1) + buffer.slice(cursor);
+            cursor--;
+            renderBuffer();
+          }
+          return;
+        }
+        if (value.length > 1) {
+          const withoutBracketedPasteMarkers = value.replace(/\x1b\[200~/g, "").replace(/\x1b\[201~/g, "");
+          if (withoutBracketedPasteMarkers.startsWith("\x1B")) {
+            const seq = withoutBracketedPasteMarkers;
+            if (seq === "\x1B[D") {
+              if (cursor > 0) {
+                cursor--;
+                renderBuffer();
+              }
+              return;
+            }
+            if (seq === "\x1B[C") {
+              if (cursor < buffer.length) {
+                cursor++;
+                renderBuffer();
+              }
+              return;
+            }
+            if (seq === "\x1B[A") {
+              const { line, col } = getCursorPosition();
+              if (line > 0) {
+                const prevLineStart = getLineStart(line - 1);
+                const prevLineEnd = getLineEnd(line - 1);
+                const prevLineLen = prevLineEnd - prevLineStart;
+                cursor = prevLineStart + Math.min(col, prevLineLen);
+                renderBuffer();
+              }
+              return;
+            }
+            if (seq === "\x1B[B") {
+              const lines = buffer.split(`
+`);
+              const { line, col } = getCursorPosition();
+              if (line < lines.length - 1) {
+                const nextLineStart = getLineStart(line + 1);
+                const nextLineEnd = getLineEnd(line + 1);
+                const nextLineLen = nextLineEnd - nextLineStart;
+                cursor = nextLineStart + Math.min(col, nextLineLen);
+                renderBuffer();
+              }
+              return;
+            }
+            if (seq === "\x1B[H" || seq === "\x1B[1~" || seq === "\x1BOH") {
+              const { line } = getCursorPosition();
+              cursor = getLineStart(line);
+              renderBuffer();
+              return;
+            }
+            if (seq === "\x1B[F" || seq === "\x1B[4~" || seq === "\x1BOF") {
+              const { line } = getCursorPosition();
+              cursor = getLineEnd(line);
+              renderBuffer();
+              return;
+            }
+            if (!/[\r\n]/.test(withoutBracketedPasteMarkers)) {
+              return;
+            }
+          }
+          insertText(withoutBracketedPasteMarkers);
+          return;
+        }
+        if (value >= " ") {
+          insertText(value);
+        }
+      };
+      output.write(styledMessage);
+      output.write(`
+`);
+      input.setRawMode(true);
+      input.setEncoding("utf8");
+      input.resume();
+      input.on("data", onData);
+      input.on("error", onError);
+      renderBuffer();
+    });
   }
-  if ("CI" in env) {
-    if (["GITHUB_ACTIONS", "GITEA_ACTIONS", "CIRCLECI"].some((key) => (key in env))) {
-      return 3;
-    }
-    if (["TRAVIS", "APPVEYOR", "GITLAB_CI", "BUILDKITE", "DRONE"].some((sign) => (sign in env)) || env.CI_NAME === "codeship") {
-      return 1;
+};
+
+// src/commands/base.ts
+class BaseCommand extends Command {
+  async catch(error) {
+    if (error instanceof RmrError) {
+      ui.error(error.message);
+      process.exitCode = 1;
+      return;
     }
-    return min;
-  }
-  if ("TEAMCITY_VERSION" in env) {
-    return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0;
-  }
-  if (env.COLORTERM === "truecolor") {
-    return 3;
-  }
-  if (env.TERM === "xterm-kitty") {
-    return 3;
-  }
-  if (env.TERM === "xterm-ghostty") {
-    return 3;
+    throw error;
   }
-  if (env.TERM === "wezterm") {
-    return 3;
+}
+
+// src/lib/config.ts
+import { mkdir } from "node:fs/promises";
+import { resolve } from "node:path";
+async function loadConfig(workspaceRoot = process.cwd()) {
+  const root = resolve(workspaceRoot);
+  const rexDir = resolve(root, ".rmr");
+  const config = {
+    workspaceRoot: root,
+    rexDir,
+    runsDir: resolve(rexDir, "runs"),
+    workflowsDir: resolve(rexDir, "workflows")
+  };
+  await Promise.all([
+    mkdir(config.rexDir, { recursive: true }),
+    mkdir(config.runsDir, { recursive: true }),
+    mkdir(config.workflowsDir, { recursive: true })
+  ]);
+  return config;
+}
+
+// src/lib/completions.ts
+import { access, readdir } from "node:fs/promises";
+import { resolve as resolve2 } from "node:path";
+function matchesPartial(value, partial) {
+  if (!partial) {
+    return true;
   }
-  if ("TERM_PROGRAM" in env) {
-    const version = Number.parseInt((env.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
-    switch (env.TERM_PROGRAM) {
-      case "iTerm.app": {
-        return version >= 3 ? 3 : 2;
-      }
-      case "Apple_Terminal": {
-        return 2;
-      }
+  return value.startsWith(partial);
+}
+async function listRunIdCompletions(config, partial = "") {
+  const entries = await readdir(config.runsDir, { withFileTypes: true });
+  return entries.filter((entry) => entry.isFile() && entry.name.endsWith(".json")).map((entry) => entry.name.slice(0, -".json".length)).filter((id) => matchesPartial(id, partial)).sort();
+}
+async function listWorkflowCompletions(config, partial = "") {
+  const entries = await readdir(config.workflowsDir, { withFileTypes: true });
+  const workflows = [];
+  for (const entry of entries) {
+    if (!entry.isDirectory()) {
+      continue;
     }
+    const workflowYaml = resolve2(config.workflowsDir, entry.name, "workflow.yaml");
+    const workflowYml = resolve2(config.workflowsDir, entry.name, "workflow.yml");
+    try {
+      await access(workflowYaml);
+      workflows.push(workflowYaml);
+      continue;
+    } catch {}
+    try {
+      await access(workflowYml);
+      workflows.push(workflowYml);
+    } catch {}
   }
-  if (/-256(color)?$/i.test(env.TERM)) {
-    return 2;
-  }
-  if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) {
-    return 1;
-  }
-  if ("COLORTERM" in env) {
-    return 1;
+  return workflows.filter((filePath) => matchesPartial(filePath, partial)).sort();
+}
+
+// src/commands/complete.ts
+function parseTarget(value) {
+  if (value === "run-id" || value === "workflow") {
+    return value;
   }
-  return min;
+  throw new UserInputError(`Invalid completion target "${value}".`);
 }
-function createSupportsColor(stream, options = {}) {
-  const level = _supportsColor(stream, {
-    streamIsTTY: stream && stream.isTTY,
-    ...options
+
+class CompleteCommand extends BaseCommand {
+  static paths = [["complete"]];
+  target = exports_options.String({
+    name: "target"
   });
-  return translateLevel(level);
+  partial = exports_options.String({
+    required: false,
+    name: "partial"
+  });
+  async execute() {
+    const config = await loadConfig();
+    const target = parseTarget(this.target);
+    const query = this.partial ?? "";
+    const suggestions = target === "run-id" ? await listRunIdCompletions(config, query) : await listWorkflowCompletions(config, query);
+    for (const value of suggestions) {
+      process.stdout.write(`${value}
+`);
+    }
+    return 0;
+  }
 }
-var supportsColor = {
-  stdout: createSupportsColor({ isTTY: tty2.isatty(1) }),
-  stderr: createSupportsColor({ isTTY: tty2.isatty(2) })
-};
-var supports_color_default = supportsColor;
 
-// node_modules/chalk/source/utilities.js
-function stringReplaceAll(string, substring, replacer) {
-  let index = string.indexOf(substring);
-  if (index === -1) {
-    return string;
+// src/commands/completion.ts
+function parseShell(value) {
+  if (value === "bash" || value === "zsh" || value === "fish") {
+    return value;
   }
-  const substringLength = substring.length;
-  let endIndex = 0;
-  let returnValue = "";
-  do {
-    returnValue += string.slice(endIndex, index) + substring + replacer;
-    endIndex = index + substringLength;
-    index = string.indexOf(substring, endIndex);
-  } while (index !== -1);
-  returnValue += string.slice(endIndex);
-  return returnValue;
+  throw new UserInputError(`Unsupported shell "${value}". Use bash, zsh, or fish.`);
 }
-function stringEncaseCRLFWithFirstIndex(string, prefix, postfix, index) {
-  let endIndex = 0;
-  let returnValue = "";
-  do {
-    const gotCR = string[index - 1] === "\r";
-    returnValue += string.slice(endIndex, gotCR ? index - 1 : index) + prefix + (gotCR ? `\r
-` : `
-`) + postfix;
-    endIndex = index + 1;
-    index = string.indexOf(`
-`, endIndex);
-  } while (index !== -1);
-  returnValue += string.slice(endIndex);
-  return returnValue;
+function bashScript() {
+  return [
+    "_rex_complete() {",
+    "  local cur prev",
+    "  COMPREPLY=()",
+    '  cur="${COMP_WORDS[COMP_CWORD]}"',
+    '  prev="${COMP_WORDS[COMP_CWORD-1]}"',
+    "",
+    "  if [[ ${COMP_CWORD} -eq 1 ]]; then",
+    '    COMPREPLY=( $(compgen -W "install run continue complete completion --help --version" -- "${cur}") )',
+    "    return 0",
+    "  fi",
+    "",
+    '  if [[ "${prev}" == "continue" ]]; then',
+    `    COMPREPLY=( $(${binaryName} complete run-id "\${cur}") )`,
+    "    return 0",
+    "  fi",
+    "",
+    '  if [[ "${prev}" == "run" ]]; then',
+    `    COMPREPLY=( $(${binaryName} complete workflow "\${cur}") )`,
+    "    return 0",
+    "  fi",
+    "",
+    '  if [[ "${prev}" == "install" ]]; then',
+    '    COMPREPLY=( $(compgen -W "feature-dev" -- "${cur}") )',
+    "    return 0",
+    "  fi",
+    "}",
+    `complete -F _rex_complete ${binaryName}`
+  ].join(`
+`);
+}
+function zshScript() {
+  return [
+    `#compdef ${binaryName}`,
+    "_rex_complete() {",
+    "  local -a subcommands",
+    "  subcommands=(install run continue complete completion)",
+    "",
+    "  if (( CURRENT == 2 )); then",
+    "    _describe 'command' subcommands",
+    "    return",
+    "  fi",
+    "",
+    "  if [[ ${words[2]} == continue && $CURRENT -eq 3 ]]; then",
+    `    compadd -- $(${binaryName} complete run-id "\${words[CURRENT]}")`,
+    "    return",
+    "  fi",
+    "",
+    "  if [[ ${words[2]} == run && $CURRENT -eq 3 ]]; then",
+    `    compadd -- $(${binaryName} complete workflow "\${words[CURRENT]}")`,
+    "    return",
+    "  fi",
+    "",
+    "  if [[ ${words[2]} == install && $CURRENT -eq 3 ]]; then",
+    "    compadd -- feature-dev",
+    "    return",
+    "  fi",
+    "}",
+    `compdef _rex_complete ${binaryName}`
+  ].join(`
+`);
+}
+function fishScript() {
+  return [
+    "function __rex_complete_run_id",
+    `  ${binaryName} complete run-id (commandline -ct)`,
+    "end",
+    "",
+    "function __rex_complete_workflow",
+    `  ${binaryName} complete workflow (commandline -ct)`,
+    "end",
+    "",
+    `complete -c ${binaryName} -f`,
+    `complete -c ${binaryName} -n '__fish_use_subcommand' -a 'install run continue complete completion'`,
+    `complete -c ${binaryName} -n '__fish_seen_subcommand_from continue' -a '(__rex_complete_run_id)'`,
+    `complete -c ${binaryName} -n '__fish_seen_subcommand_from run' -a '(__rex_complete_workflow)'`,
+    `complete -c ${binaryName} -n '__fish_seen_subcommand_from install' -a 'feature-dev'`
+  ].join(`
+`);
+}
+
+class CompletionCommand extends BaseCommand {
+  static paths = [["completion"]];
+  static usage = Command.Usage({
+    category: "Workflow",
+    description: "Print optional shell completion setup script.",
+    details: "Generates completion script text for your shell. Source the output in your shell profile to enable command and dynamic argument completion.",
+    examples: [
+      ["Show Bash completion script", "$0 completion bash"],
+      ["Show Zsh completion script", "$0 completion zsh"],
+      ["Show Fish completion script", "$0 completion fish"]
+    ]
+  });
+  shell = exports_options.String({
+    name: "shell"
+  });
+  async execute() {
+    const shell = parseShell(this.shell);
+    const script = shell === "bash" ? bashScript() : shell === "zsh" ? zshScript() : fishScript();
+    process.stdout.write(`${script}
+`);
+    return 0;
+  }
 }
 
-// node_modules/chalk/source/index.js
-var { stdout: stdoutColor, stderr: stderrColor } = supports_color_default;
-var GENERATOR = Symbol("GENERATOR");
-var STYLER = Symbol("STYLER");
-var IS_EMPTY = Symbol("IS_EMPTY");
-var levelMapping = [
-  "ansi",
-  "ansi",
-  "ansi256",
-  "ansi16m"
-];
-var styles2 = Object.create(null);
-var applyOptions = (object, options = {}) => {
-  if (options.level && !(Number.isInteger(options.level) && options.level >= 0 && options.level <= 3)) {
-    throw new Error("The `level` option should be an integer from 0 to 3");
-  }
-  const colorLevel = stdoutColor ? stdoutColor.level : 0;
-  object.level = options.level === undefined ? colorLevel : options.level;
-};
-var chalkFactory = (options) => {
-  const chalk = (...strings) => strings.join(" ");
-  applyOptions(chalk, options);
-  Object.setPrototypeOf(chalk, createChalk.prototype);
-  return chalk;
-};
-function createChalk(options) {
-  return chalkFactory(options);
+// src/lib/run-state.ts
+import { readFile, writeFile } from "node:fs/promises";
+import { resolve as resolve3 } from "node:path";
+function pad(input) {
+  return String(input).padStart(2, "0");
 }
-Object.setPrototypeOf(createChalk.prototype, Function.prototype);
-for (const [styleName, style] of Object.entries(ansi_styles_default)) {
-  styles2[styleName] = {
-    get() {
-      const builder = createBuilder(this, createStyler(style.open, style.close, this[STYLER]), this[IS_EMPTY]);
-      Object.defineProperty(this, styleName, { value: builder });
-      return builder;
-    }
-  };
+function generateRunId(now = new Date) {
+  const yyyy = now.getUTCFullYear();
+  const mm = pad(now.getUTCMonth() + 1);
+  const dd = pad(now.getUTCDate());
+  const hh = pad(now.getUTCHours());
+  const min = pad(now.getUTCMinutes());
+  const sec = pad(now.getUTCSeconds());
+  return `${yyyy}${mm}${dd}-${hh}${min}${sec}Z`;
 }
-styles2.visible = {
-  get() {
-    const builder = createBuilder(this, this[STYLER], true);
-    Object.defineProperty(this, "visible", { value: builder });
-    return builder;
-  }
-};
-var getModelAnsi = (model, level, type, ...arguments_) => {
-  if (model === "rgb") {
-    if (level === "ansi16m") {
-      return ansi_styles_default[type].ansi16m(...arguments_);
-    }
-    if (level === "ansi256") {
-      return ansi_styles_default[type].ansi256(ansi_styles_default.rgbToAnsi256(...arguments_));
-    }
-    return ansi_styles_default[type].ansi(ansi_styles_default.rgbToAnsi(...arguments_));
-  }
-  if (model === "hex") {
-    return getModelAnsi("rgb", level, type, ...ansi_styles_default.hexToRgb(...arguments_));
-  }
-  return ansi_styles_default[type][model](...arguments_);
-};
-var usedModels = ["rgb", "hex", "ansi256"];
-for (const model of usedModels) {
-  styles2[model] = {
-    get() {
-      const { level } = this;
-      return function(...arguments_) {
-        const styler = createStyler(getModelAnsi(model, levelMapping[level], "color", ...arguments_), ansi_styles_default.color.close, this[STYLER]);
-        return createBuilder(this, styler, this[IS_EMPTY]);
-      };
-    }
-  };
-  const bgModel = "bg" + model[0].toUpperCase() + model.slice(1);
-  styles2[bgModel] = {
-    get() {
-      const { level } = this;
-      return function(...arguments_) {
-        const styler = createStyler(getModelAnsi(model, levelMapping[level], "bgColor", ...arguments_), ansi_styles_default.bgColor.close, this[STYLER]);
-        return createBuilder(this, styler, this[IS_EMPTY]);
-      };
-    }
-  };
+function runFilePath(config, runId) {
+  return resolve3(config.runsDir, `${runId}.json`);
 }
-var proto = Object.defineProperties(() => {}, {
-  ...styles2,
-  level: {
-    enumerable: true,
-    get() {
-      return this[GENERATOR].level;
-    },
-    set(level) {
-      this[GENERATOR].level = level;
-    }
-  }
-});
-var createStyler = (open, close, parent) => {
-  let openAll;
-  let closeAll;
-  if (parent === undefined) {
-    openAll = open;
-    closeAll = close;
-  } else {
-    openAll = parent.openAll + open;
-    closeAll = close + parent.closeAll;
+function createInitialRunState(options) {
+  const firstStep = options.workflow.steps[0];
+  if (!firstStep) {
+    throw new StorageError("Cannot create run state without at least one workflow step.");
   }
   return {
-    open,
-    close,
-    openAll,
-    closeAll,
-    parent
+    run_id: options.runId,
+    workflow_path: options.workflowPath,
+    status: "running",
+    current_step: firstStep.id,
+    context: {
+      task: options.task,
+      ...options.vars
+    },
+    last_harness: {
+      name: firstStep.harness,
+      binary: firstStep.harness,
+      session_id: null
+    },
+    step_history: [],
+    updated_at: new Date().toISOString()
   };
-};
-var createBuilder = (self, _styler, _isEmpty) => {
-  const builder = (...arguments_) => applyStyle(builder, arguments_.length === 1 ? "" + arguments_[0] : arguments_.join(" "));
-  Object.setPrototypeOf(builder, proto);
-  builder[GENERATOR] = self;
-  builder[STYLER] = _styler;
-  builder[IS_EMPTY] = _isEmpty;
-  return builder;
-};
-var applyStyle = (self, string) => {
-  if (self.level <= 0 || !string) {
-    return self[IS_EMPTY] ? "" : string;
-  }
-  let styler = self[STYLER];
-  if (styler === undefined) {
-    return string;
-  }
-  const { openAll, closeAll } = styler;
-  if (string.includes("\x1B")) {
-    while (styler !== undefined) {
-      string = stringReplaceAll(string, styler.close, styler.open);
-      styler = styler.parent;
+}
+async function saveRunState(config, state) {
+  const path = runFilePath(config, state.run_id);
+  const payload = JSON.stringify({
+    ...state,
+    updated_at: new Date().toISOString()
+  }, null, 2);
+  await writeFile(path, `${payload}
+`, "utf8");
+  return path;
+}
+async function loadRunState(config, runId) {
+  const path = runFilePath(config, runId);
+  try {
+    const raw = await readFile(path, "utf8");
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object" || parsed.run_id !== runId) {
+      throw new StorageError(`Run state file is invalid for run id "${runId}".`);
     }
+    if (!Array.isArray(parsed.step_history)) {
+      parsed.step_history = [];
+    }
+    return parsed;
+  } catch (error) {
+    if (error instanceof StorageError) {
+      throw error;
+    }
+    throw new StorageError(`Failed to load run state for "${runId}".`);
   }
-  const lfIndex = string.indexOf(`
-`);
-  if (lfIndex !== -1) {
-    string = stringEncaseCRLFWithFirstIndex(string, closeAll, openAll, lfIndex);
-  }
-  return openAll + string + closeAll;
-};
-Object.defineProperties(createChalk.prototype, styles2);
-var chalk = createChalk();
-var chalkStderr = createChalk({ level: stderrColor ? stderrColor.level : 0 });
-var source_default = chalk;
-
-// src/lib/ui.ts
-var isTTY = process.stdout.isTTY === true;
-function getTerminalWidth() {
-  return process.stdout.columns ?? 80;
 }
-function getBoxWidth() {
-  const termWidth = getTerminalWidth();
-  return Math.max(40, termWidth - 2);
+
+// src/lib/prompt-composer.ts
+import { readFile as readFile2 } from "node:fs/promises";
+import { dirname, resolve as resolve4 } from "node:path";
+function stripFrontmatter(content) {
+  const match = content.match(/^---\r?\n[\s\S]*?\r?\n---\r?\n?/);
+  return match ? content.slice(match[0].length) : content;
 }
-function truncate(text, maxLength) {
-  if (text.length <= maxLength) {
-    return text;
+async function loadPromptFile(workflowPath, promptFileName) {
+  const promptPath = resolve4(dirname(workflowPath), promptFileName);
+  try {
+    const raw = await readFile2(promptPath, "utf8");
+    return stripFrontmatter(raw);
+  } catch {
+    throw new ConfigError(`Prompt file not found: ${promptPath}`);
   }
-  return text.slice(0, maxLength - 3) + "...";
 }
-function wrapText(text, maxWidth) {
-  if (text.length <= maxWidth) {
-    return [text];
+function composePrompt(promptFile, promptInline) {
+  const parts = [];
+  if (promptFile) {
+    parts.push(promptFile.trimEnd());
   }
-  const lines = [];
-  let remaining = text;
-  while (remaining.length > maxWidth) {
-    let breakAt = remaining.lastIndexOf(" ", maxWidth);
-    if (breakAt <= 0) {
-      breakAt = maxWidth;
-    }
-    lines.push(remaining.slice(0, breakAt));
-    remaining = remaining.slice(breakAt).trimStart();
+  if (promptInline) {
+    parts.push(promptInline.trimEnd());
   }
-  if (remaining) {
-    lines.push(remaining);
+  return parts.join(`
+
+`);
+}
+
+// src/lib/harness-adapters.ts
+function createPassthroughParser() {
+  return (line) => ({ text: line + `
+` });
+}
+function withModelArgs(model, args) {
+  if (!model) {
+    return args;
   }
-  return lines;
+  return [...args, "--model", model];
 }
-var ui = {
-  get isTTY() {
-    return isTTY;
-  },
-  workflowHeader(info) {
-    const line = isTTY ? "─" : "-";
-    const corner = {
-      tl: isTTY ? "╭" : "+",
-      tr: isTTY ? "╮" : "+",
-      bl: isTTY ? "╰" : "+",
-      br: isTTY ? "╯" : "+"
-    };
-    const width = getBoxWidth();
-    const contentWidth = width - 4;
-    const border = line.repeat(width - 2);
-    const labelWidth = 10;
-    const valueWidth = contentWidth - labelWidth;
-    const formatLine = (label, value) => {
-      const paddedLabel = label ? `${label}:`.padEnd(labelWidth) : " ".repeat(labelWidth);
-      const truncatedValue = truncate(value, valueWidth);
-      return `${paddedLabel}${truncatedValue}`.padEnd(contentWidth);
-    };
-    process.stdout.write(`
-`);
-    process.stdout.write(isTTY ? source_default.cyan(`${corner.tl}${line} ${info.title} ${border.slice(info.title.length + 3)}${corner.tr}
-`) : `${corner.tl}${line} ${info.title} ${border.slice(info.title.length + 3)}${corner.tr}
-`);
-    process.stdout.write(isTTY ? source_default.dim(`│ ${formatLine("workflow", info.workflow)} │
-`) : `│ ${formatLine("workflow", info.workflow)} │
-`);
-    process.stdout.write(isTTY ? source_default.dim(`│ ${formatLine("run-id", info.runId)} │
-`) : `│ ${formatLine("run-id", info.runId)} │
-`);
-    process.stdout.write(isTTY ? source_default.dim(`│ ${formatLine("step", info.currentStep)} │
-`) : `│ ${formatLine("step", info.currentStep)} │
-`);
-    const taskLines = wrapText(info.task, valueWidth);
-    for (let i = 0;i < taskLines.length; i++) {
-      const label = i === 0 ? "task" : "";
-      const content = formatLine(label, taskLines[i] ?? "");
-      process.stdout.write(isTTY ? source_default.dim(`│ ${content} │
-`) : `│ ${content} │
-`);
+function opencodePermissionEnv() {
+  return {
+    OPENCODE_PERMISSION: JSON.stringify({
+      "*": "allow",
+      external_directory: "allow",
+      doom_loop: "allow"
+    })
+  };
+}
+function claudeStreamFlags() {
+  return ["--output-format", "stream-json", "--verbose", "--include-partial-messages"];
+}
+function createOpenCodeStreamParser() {
+  return (line) => {
+    if (!line.trim()) {
+      return null;
     }
-    process.stdout.write(isTTY ? source_default.cyan(`${corner.bl}${border}${corner.br}
-`) : `${corner.bl}${border}${corner.br}
-`);
-    process.stdout.write(`
-`);
-  },
-  stepStart(stepNumber, stepId, agentId) {
-    const line = isTTY ? "─" : "-";
-    const corner = { tl: isTTY ? "┌" : "+", tr: isTTY ? "┐" : "+" };
-    const label = ` Step ${stepNumber}: ${stepId} (${agentId}) `;
-    const width = getBoxWidth();
-    const remaining = Math.max(0, width - label.length - 2);
-    const border = line.repeat(remaining);
-    process.stdout.write(`
-`);
-    process.stdout.write(isTTY ? source_default.cyan.bold(`${corner.tl}${line}${label}${border}${corner.tr}
-`) : `${corner.tl}${line}${label}${border}${corner.tr}
-`);
-    process.stdout.write(`
-`);
-  },
-  stepEnd() {
-    const line = isTTY ? "─" : "-";
-    const corner = { bl: isTTY ? "└" : "+", br: isTTY ? "┘" : "+" };
-    const width = getBoxWidth();
-    const border = line.repeat(width - 2);
-    process.stdout.write(`
-`);
-    process.stdout.write(isTTY ? source_default.cyan(`${corner.bl}${border}${corner.br}
-`) : `${corner.bl}${border}${corner.br}
-`);
-  },
-  printToolCall(toolName, toolInput) {
-    const width = getBoxWidth();
-    const maxInputLength = width - 10;
-    const truncatedInput = truncate(toolInput, maxInputLength);
-    if (isTTY) {
-      process.stderr.write(source_default.cyan(`  ${toolName} `) + source_default.dim(truncatedInput) + `
-`);
-    } else {
-      process.stderr.write(`  ${toolName} ${truncatedInput}
-`);
+    let obj;
+    try {
+      obj = JSON.parse(line);
+    } catch {
+      return null;
     }
-  },
-  stepOutputs(values) {
-    const entries = Object.entries(values);
-    if (entries.length === 0) {
-      return;
+    const type = obj.type;
+    const sessionId = typeof obj.sessionID === "string" ? obj.sessionID : undefined;
+    if (type === "text") {
+      const part = obj.part;
+      const text = typeof part?.text === "string" ? part.text : "";
+      return { text, sessionId };
+    }
+    if (type === "tool_use") {
+      const part = obj.part;
+      const toolName = typeof part?.tool === "string" ? part.tool : undefined;
+      const state = part?.state;
+      const input = state?.input;
+      const toolInput = input ? JSON.stringify(input) : undefined;
+      return { text: "", sessionId, toolName, toolInput };
+    }
+    if (sessionId) {
+      return { text: "", sessionId };
     }
-    const width = getBoxWidth();
-    const labelPrefix = "  ";
-    const separator = ": ";
-    process.stdout.write(`
-`);
-    for (const [key, value] of entries) {
-      const label = `rmr:${key}`;
-      const firstLineIndent = labelPrefix.length + label.length + separator.length;
-      const continuationIndent = " ".repeat(firstLineIndent);
-      const maxValueWidth = width - firstLineIndent;
-      const valueLines = value.split(`
-`);
-      const wrappedLines = [];
-      for (const vline of valueLines) {
-        if (vline.length <= maxValueWidth) {
-          wrappedLines.push(vline);
-        } else {
-          let remaining = vline;
-          while (remaining.length > maxValueWidth) {
-            let breakAt = remaining.lastIndexOf(" ", maxValueWidth);
-            if (breakAt <= 0) {
-              breakAt = maxValueWidth;
-            }
-            wrappedLines.push(remaining.slice(0, breakAt));
-            remaining = remaining.slice(breakAt).trimStart();
-          }
-          if (remaining) {
-            wrappedLines.push(remaining);
-          }
+    return null;
+  };
+}
+function createCodexStreamParser() {
+  return (line) => {
+    if (!line.trim()) {
+      return null;
+    }
+    let obj;
+    try {
+      obj = JSON.parse(line);
+    } catch {
+      return null;
+    }
+    const type = obj.type;
+    if (type === "thread.started") {
+      const sessionId = typeof obj.thread_id === "string" ? obj.thread_id : undefined;
+      return sessionId ? { text: "", sessionId } : null;
+    }
+    if (type === "item.completed") {
+      const item = obj.item;
+      if (!item) {
+        return null;
+      }
+      if (item.type === "agent_message") {
+        const text = typeof item.text === "string" ? item.text : "";
+        return { text };
+      }
+      if (item.type === "command_execution") {
+        const command = typeof item.command === "string" ? item.command : "shell";
+        return { text: "", toolName: "shell", toolInput: command };
+      }
+      return null;
+    }
+    if (type === "item.started") {
+      const item = obj.item;
+      if (item?.type === "command_execution") {
+        const command = typeof item.command === "string" ? item.command : "shell";
+        return { text: "", toolName: "shell", toolInput: command };
+      }
+      return null;
+    }
+    return null;
+  };
+}
+function createClaudeStreamParser() {
+  let currentToolName = null;
+  let currentToolInput = "";
+  let currentBlockIndex = null;
+  return (line) => {
+    if (!line.trim()) {
+      return null;
+    }
+    let obj;
+    try {
+      obj = JSON.parse(line);
+    } catch {
+      return null;
+    }
+    const type = obj.type;
+    const sessionId = typeof obj.session_id === "string" ? obj.session_id : undefined;
+    if (type === "stream_event") {
+      const event = obj.event;
+      const index = typeof event?.index === "number" ? event.index : null;
+      if (event?.type === "content_block_start") {
+        const block = event.content_block;
+        if (block?.type === "tool_use" && typeof block.name === "string") {
+          currentToolName = block.name;
+          currentToolInput = "";
+          currentBlockIndex = index;
+          return sessionId ? { text: "", sessionId } : null;
         }
       }
-      const firstLine = wrappedLines[0] ?? "";
-      if (isTTY) {
-        process.stdout.write(source_default.cyan(`${labelPrefix}${label}`) + source_default.dim(`${separator}${firstLine}`) + `
-`);
-      } else {
-        process.stdout.write(`${labelPrefix}${label}${separator}${firstLine}
-`);
+      if (event?.type === "content_block_delta") {
+        const delta = event.delta;
+        if (delta?.type === "text_delta" && typeof delta.text === "string") {
+          return { text: delta.text, sessionId };
+        }
+        if (delta?.type === "input_json_delta" && typeof delta.partial_json === "string") {
+          currentToolInput += delta.partial_json;
+          return sessionId ? { text: "", sessionId } : null;
+        }
+        return sessionId ? { text: "", sessionId } : null;
       }
-      for (let i = 1;i < wrappedLines.length; i++) {
-        if (isTTY) {
-          process.stdout.write(source_default.dim(`${continuationIndent}${wrappedLines[i]}`) + `
-`);
-        } else {
-          process.stdout.write(`${continuationIndent}${wrappedLines[i]}
-`);
+      if (event?.type === "content_block_stop") {
+        if (currentToolName && index === currentBlockIndex) {
+          const result = {
+            text: "",
+            sessionId,
+            toolName: currentToolName,
+            toolInput: currentToolInput || undefined
+          };
+          currentToolName = null;
+          currentToolInput = "";
+          currentBlockIndex = null;
+          return result;
         }
       }
+      return sessionId ? { text: "", sessionId } : null;
+    }
+    if (type === "result") {
+      return sessionId ? { text: "", sessionId } : null;
+    }
+    if (type === "system") {
+      return sessionId ? { text: "", sessionId } : null;
+    }
+    return null;
+  };
+}
+var adapters = {
+  claude: {
+    name: "claude",
+    buildRunCommand(prompt, options) {
+      const allowArgs = options.allowAll ? ["--dangerously-skip-permissions"] : [];
+      const base = ["-p", prompt, ...claudeStreamFlags()];
+      return { binary: "claude", args: withModelArgs(options.model, [...allowArgs, ...base]) };
+    },
+    buildResumeCommand(sessionId, prompt, options) {
+      const allowArgs = options.allowAll ? ["--dangerously-skip-permissions"] : [];
+      const base = [...allowArgs, "--resume", sessionId, "-p", prompt, ...claudeStreamFlags()];
+      return { binary: "claude", args: withModelArgs(options.model, base) };
+    },
+    createStreamParser: createClaudeStreamParser,
+    resumeTemplate(sessionId) {
+      return `claude --resume ${sessionId}`;
     }
   },
-  content(text) {
-    process.stdout.write(text);
-  },
-  success(text) {
-    const icon = isTTY ? "✓ " : "";
-    process.stdout.write(isTTY ? source_default.green(`${icon}${text}
-`) : `${icon}${text}
-`);
-  },
-  warning(text) {
-    const icon = isTTY ? "⚠ " : "";
-    process.stderr.write(isTTY ? source_default.yellow(`${icon}${text}
-`) : `${icon}${text}
-`);
-  },
-  error(text) {
-    const icon = isTTY ? "✗ " : "";
-    process.stderr.write(isTTY ? source_default.red(`${icon}${text}
-`) : `${icon}${text}
-`);
-  },
-  info(text) {
-    process.stdout.write(`${text}
-`);
+  opencode: {
+    name: "opencode",
+    buildRunCommand(prompt, options) {
+      const args = ["run", "--format", "json", prompt];
+      return {
+        binary: "opencode",
+        args: withModelArgs(options.model, args),
+        ...options.allowAll ? { env: opencodePermissionEnv() } : {}
+      };
+    },
+    buildResumeCommand(sessionId, prompt, options) {
+      const args = ["run", "--format", "json", "--session", sessionId, prompt];
+      return {
+        binary: "opencode",
+        args: withModelArgs(options.model, args),
+        ...options.allowAll ? { env: opencodePermissionEnv() } : {}
+      };
+    },
+    createStreamParser: createOpenCodeStreamParser,
+    resumeTemplate(sessionId) {
+      return `opencode run --session ${sessionId}`;
+    }
   },
-  dim(text) {
-    process.stdout.write(isTTY ? source_default.gray(text) : text);
+  codex: {
+    name: "codex",
+    buildRunCommand(prompt, options) {
+      const auto = options.allowAll ? ["--dangerously-bypass-approvals-and-sandbox"] : [];
+      const args = ["exec", "--json", ...auto, prompt];
+      return { binary: "codex", args: withModelArgs(options.model, args) };
+    },
+    buildResumeCommand(sessionId, prompt, options) {
+      const auto = options.allowAll ? ["--dangerously-bypass-approvals-and-sandbox"] : [];
+      const args = ["exec", "resume", "--json", ...auto, sessionId, prompt];
+      return { binary: "codex", args: withModelArgs(options.model, args) };
+    },
+    createStreamParser: createCodexStreamParser,
+    resumeTemplate(sessionId) {
+      return `codex exec resume ${sessionId} "<prompt>"`;
+    }
   },
-  pauseInstructions(info) {
-    process.stderr.write(`
-`);
-    ui.warning(`Paused: ${info.reason}`);
-    process.stderr.write(`
-`);
-    process.stdout.write(isTTY ? source_default.dim(`Resume workflow:
-`) : `Resume workflow:
-`);
-    process.stdout.write(`  rmr continue ${info.runId}
-`);
-    process.stdout.write(`
-`);
-    process.stdout.write(isTTY ? source_default.dim(`Resume agent session directly:
-`) : `Resume agent session directly:
-`);
-    process.stdout.write(`  ${info.resumeCommand}
-`);
-    process.stdout.write(`
-`);
+  copilot: {
+    name: "copilot",
+    buildRunCommand(prompt, options) {
+      const auto = options.allowAll ? ["--allow-all", "--no-ask-user"] : [];
+      const args = [...auto, "-p", prompt];
+      return { binary: "copilot", args: withModelArgs(options.model, args) };
+    },
+    buildResumeCommand(_sessionId, prompt, options) {
+      const args = ["-p", prompt];
+      return { binary: "copilot", args: withModelArgs(options.model, args) };
+    },
+    createStreamParser: createPassthroughParser,
+    resumeTemplate(sessionId) {
+      return `copilot --resume ${sessionId}`;
+    }
   }
 };
-
-// src/lib/process-runner.ts
-async function consumeStream(stream, onText) {
-  if (!stream) {
-    return "";
-  }
-  const reader = stream.getReader();
-  const decoder = new TextDecoder;
-  let fullText = "";
-  while (true) {
-    const { done, value } = await reader.read();
-    if (done) {
-      break;
-    }
-    const chunk = decoder.decode(value, { stream: true });
-    fullText += chunk;
-    onText(chunk);
+function getHarnessAdapter(name) {
+  const adapter = adapters[name];
+  if (!adapter) {
+    throw new ValidationError(`Unknown harness "${name}".`);
   }
-  fullText += decoder.decode();
-  return fullText;
+  return adapter;
 }
+
+// src/lib/process-runner.ts
+import { spawn } from "node:child_process";
 function formatToolInput(toolInput) {
   try {
     const parsed = JSON.parse(toolInput);
@@ -10858,95 +11283,84 @@ function formatToolInput(toolInput) {
     return toolInput.length > 100 ? toolInput.slice(0, 97) + "..." : toolInput;
   }
 }
-async function consumeStreamParsed(stream, parser) {
-  if (!stream) {
-    return { rawOutput: "", displayText: "", sessionId: null };
-  }
-  const reader = stream.getReader();
-  const decoder = new TextDecoder;
-  let rawOutput = "";
-  let displayText = "";
-  let sessionId = null;
-  let lineBuf = "";
-  let lastTextWasContent = false;
-  function processLine(line) {
-    const parsed = parser(line);
-    if (!parsed) {
-      return;
-    }
-    if (parsed.toolName) {
-      if (lastTextWasContent) {
-        process.stderr.write(`
+async function runHarnessCommand(command, parseStreamLine) {
+  return new Promise((resolve5, reject) => {
+    const child = spawn(command.binary, command.args, {
+      stdio: ["ignore", "pipe", "pipe"],
+      ...command.env ? { env: { ...process.env, ...command.env } } : {}
+    });
+    child.on("error", (err) => {
+      if (err.code === "ENOENT") {
+        reject(new StorageError(`Harness binary "${command.binary}" not found. ` + `Make sure it is installed and available on your PATH.`));
+      } else if (err.code === "EACCES") {
+        reject(new StorageError(`Permission denied when trying to run "${command.binary}". ` + `Check that the binary is executable.`));
+      } else {
+        reject(new StorageError(`Failed to launch harness binary "${command.binary}": ${err.message}`));
+      }
+    });
+    let interrupted = false;
+    const onSigint = () => {
+      interrupted = true;
+    };
+    process.on("SIGINT", onSigint);
+    let displayText = "";
+    let sessionId = null;
+    let stderrText = "";
+    let stdoutLineBuf = "";
+    let lastTextWasContent = false;
+    function processLine(line) {
+      const parsed = parseStreamLine(line);
+      if (!parsed) {
+        return;
+      }
+      if (parsed.toolName) {
+        if (lastTextWasContent) {
+          process.stderr.write(`
 `);
-        lastTextWasContent = false;
+          lastTextWasContent = false;
+        }
+        const inputDisplay = parsed.toolInput ? formatToolInput(parsed.toolInput) : "";
+        ui.printToolCall(parsed.toolName, inputDisplay);
+      }
+      if (parsed.text) {
+        displayText += parsed.text;
+        ui.content(parsed.text);
+        lastTextWasContent = true;
+      }
+      if (parsed.sessionId) {
+        sessionId = parsed.sessionId;
       }
-      const inputDisplay = parsed.toolInput ? formatToolInput(parsed.toolInput) : "";
-      ui.printToolCall(parsed.toolName, inputDisplay);
-    }
-    if (parsed.text) {
-      displayText += parsed.text;
-      ui.content(parsed.text);
-      lastTextWasContent = true;
-    }
-    if (parsed.sessionId) {
-      sessionId = parsed.sessionId;
-    }
-  }
-  while (true) {
-    const { done, value } = await reader.read();
-    if (done) {
-      break;
     }
-    const chunk = decoder.decode(value, { stream: true });
-    rawOutput += chunk;
-    lineBuf += chunk;
-    const lines = lineBuf.split(`
+    child.stdout.on("data", (chunk) => {
+      const text = chunk.toString();
+      stdoutLineBuf += text;
+      const lines = stdoutLineBuf.split(`
 `);
-    lineBuf = lines.pop() ?? "";
-    for (const line of lines) {
-      processLine(line);
-    }
-  }
-  rawOutput += decoder.decode();
-  if (lineBuf.trim()) {
-    processLine(lineBuf);
-  }
-  return { rawOutput, displayText, sessionId };
-}
-async function runHarnessCommand(command, parseStreamLine) {
-  let processRef;
-  try {
-    processRef = Bun.spawn({
-      cmd: [command.binary, ...command.args],
-      stdin: "ignore",
-      stdout: "pipe",
-      stderr: "pipe"
+      stdoutLineBuf = lines.pop() ?? "";
+      for (const line of lines) {
+        processLine(line);
+      }
+    });
+    child.stderr.on("data", (chunk) => {
+      const text = chunk.toString();
+      stderrText += text;
+      process.stderr.write(text);
+    });
+    child.on("close", (code) => {
+      if (stdoutLineBuf.trim()) {
+        processLine(stdoutLineBuf);
+      }
+      process.removeListener("SIGINT", onSigint);
+      const exitCode = interrupted && code === 0 ? 130 : code ?? 1;
+      resolve5({
+        exitCode,
+        stdout: displayText,
+        stderr: stderrText,
+        combinedOutput: `${displayText}${stderrText}`,
+        sessionId
+      });
     });
-  } catch {
-    throw new StorageError(`Failed to launch harness binary "${command.binary}".`);
-  }
-  let interrupted = false;
-  const onSigint = () => {
-    interrupted = true;
-  };
-  process.on("SIGINT", onSigint);
-  const stdoutPromise = consumeStreamParsed(processRef.stdout, parseStreamLine);
-  const stderrPromise = consumeStream(processRef.stderr, (chunk) => {
-    process.stderr.write(chunk);
   });
-  const [exitCode, stdoutResult, stderr] = await Promise.all([
-    processRef.exited,
-    stdoutPromise,
-    stderrPromise
-  ]);
-  process.removeListener("SIGINT", onSigint);
-  return {
-    exitCode: interrupted && exitCode === 0 ? 130 : exitCode,
-    stdout: stdoutResult.displayText,
-    stderr,
-    combinedOutput: `${stdoutResult.displayText}${stderr}`,
-    sessionId: stdoutResult.sessionId
-  };
 }
 
 // src/lib/rmr-output-parser.ts
@@ -11025,6 +11439,20 @@ function outputSnippet(output) {
   const compact = trimmed.replace(/\s+/g, " ");
   return compact.length > 220 ? `${compact.slice(0, 220)}...` : compact;
 }
+function harnessExitReason(params) {
+  const stderrSnippet = outputSnippet(params.stderr);
+  const outputPreview = outputSnippet(params.combinedOutput);
+  const details = [`harness=${params.harness}`];
+  if (params.model) {
+    details.push(`model=${params.model}`);
+  }
+  if (stderrSnippet !== "(no output)") {
+    details.push(`stderr=${stderrSnippet}`);
+  } else if (outputPreview !== "(no output)") {
+    details.push(`output=${outputPreview}`);
+  }
+  return `Harness exited with code ${params.exitCode} at step "${params.stepId}" (${details.join("; ")}).`;
+}
 async function pauseRun(config, runState, reason, harnessName, sessionId) {
   runState.status = "paused_human";
   await saveRunState(config, runState);
@@ -11036,12 +11464,12 @@ async function pauseRun(config, runState, reason, harnessName, sessionId) {
     resumeCommand: adapter.resumeTemplate(resolvedSession)
   });
 }
-function applyOutputToContext(context, agentId, values) {
+function applyOutputToContext(context, stepId, values) {
   for (const [key, value] of Object.entries(values)) {
     if (key === "status" || key === "next_state") {
       continue;
     }
-    context[`${agentId}.${key}`] = value;
+    context[`${stepId}.${key}`] = value;
   }
 }
 async function runWorkflow(config, workflow, runState, options) {
@@ -11056,27 +11484,23 @@ async function runWorkflow(config, workflow, runState, options) {
       await pauseRun(config, runState, `Current step "${runState.current_step}" not found in workflow.`, runState.last_harness?.name ?? "claude", runState.last_harness?.session_id ?? null);
       return runState;
     }
-    const agent = workflow.agents.find((item) => item.id === step.agent);
-    if (!agent) {
-      await pauseRun(config, runState, `Unknown agent "${step.agent}" for step "${step.id}".`, runState.last_harness?.name ?? "claude", runState.last_harness?.session_id ?? null);
-      return runState;
-    }
     const stepStartedAt = new Date().toISOString();
-    ui.stepStart(stepNumber, step.id, agent.id);
     try {
-      assertRequiredInputs(step.input_required, runState.context);
-      const resolvedInput = resolveTemplate(step.input, runState.context);
+      assertRequiredInputs(step.requires.inputs, runState.context);
+      const fileContent = step.prompt_file ? await loadPromptFile(runState.workflow_path, step.prompt_file) : undefined;
+      const rawPrompt = composePrompt(fileContent, step.prompt);
+      const resolvedPrompt = resolveTemplate(rawPrompt, runState.context);
       const injectedHint = isFirstIteration && typeof options.overrides?.hint === "string" ? options.overrides.hint.trim() : "";
-      const renderedInput = injectedHint ? `${resolvedInput}
+      const prompt = injectedHint ? `${resolvedPrompt}
 
-Note: ${injectedHint}` : resolvedInput;
-      const agentPrompt = await loadAgentPrompt(runState.workflow_path, agent.prompt);
-      const prompt = composePrompt(agentPrompt, renderedInput);
-      const harness = options.overrides?.harness ?? agent.harness;
+Note: ${injectedHint}` : resolvedPrompt;
+      const harness = step.harness;
       const adapter = getHarnessAdapter(harness);
-      const effectiveModel = options.overrides?.model ?? agent.model;
+      const effectiveModel = step.model;
       const adapterOptions = typeof effectiveModel === "string" ? { allowAll: options.allowAll, model: effectiveModel } : { allowAll: options.allowAll };
-      const selectedSessionId = isFirstIteration && options.overrides?.sessionId ? options.overrides.sessionId : runState.last_harness?.session_id;
+      ui.stepStart(stepNumber, step.id, harness, effectiveModel);
+      const lastSessionMatchesHarness = runState.last_harness?.name === harness ? runState.last_harness.session_id : null;
+      const selectedSessionId = isFirstIteration && options.overrides?.sessionId ? options.overrides.sessionId : lastSessionMatchesHarness;
       const command = isFirstIteration && selectedSessionId ? adapter.buildResumeCommand(selectedSessionId, prompt, {
         ...adapterOptions
       }) : adapter.buildRunCommand(prompt, {
@@ -11092,7 +11516,14 @@ Note: ${injectedHint}` : resolvedInput;
         runState.last_harness.session_id = result.sessionId;
       }
       if (result.exitCode !== 0) {
-        await pauseRun(config, runState, `Harness exited with code ${result.exitCode} at step "${step.id}".`, harness, runState.last_harness.session_id);
+        await pauseRun(config, runState, harnessExitReason({
+          stepId: step.id,
+          harness,
+          exitCode: result.exitCode,
+          stderr: result.stderr,
+          combinedOutput: result.combinedOutput,
+          ...effectiveModel ? { model: effectiveModel } : {}
+        }), harness, runState.last_harness.session_id);
         return runState;
       }
       if (result.combinedOutput.includes(HUMAN_SENTINEL)) {
@@ -11102,15 +11533,15 @@ Note: ${injectedHint}` : resolvedInput;
       let stepOutput;
       try {
         stepOutput = parseRmrOutput(result.combinedOutput);
-        validateRequiredOutputKeys(stepOutput, step.outputs.required);
+        validateRequiredOutputKeys(stepOutput, step.requires.outputs);
       } catch (error) {
         const message = error instanceof Error ? error.message : "Failed to parse step output.";
-        await pauseRun(config, runState, `${message} Raw output snippet: ${outputSnippet(result.combinedOutput)}`, harness, runState.last_harness.session_id);
+        await pauseRun(config, runState, message, harness, runState.last_harness.session_id);
         return runState;
       }
       ui.stepOutputs(stepOutput.values);
       applyOutputToContext(runState.context, step.id, stepOutput.values);
-      const nextState = stepOutput.next_state ?? step.default_next;
+      const nextState = stepOutput.next_state ?? step.next_step;
       if (!isValidTarget(workflow, nextState)) {
         await pauseRun(config, runState, `Invalid next_state "${nextState}" at step "${step.id}".`, harness, runState.last_harness.session_id);
         return runState;
@@ -11122,7 +11553,6 @@ Note: ${injectedHint}` : resolvedInput;
       const stepExecution = {
         step_number: stepNumber,
         step_id: step.id,
-        agent_id: agent.id,
         session_id: runState.last_harness?.session_id ?? null,
         started_at: stepStartedAt,
         completed_at: new Date().toISOString()
@@ -11142,25 +11572,13 @@ Note: ${injectedHint}` : resolvedInput;
       isFirstIteration = false;
     } catch (error) {
       const reason = error instanceof Error ? error.message : "Unknown execution error.";
-      await pauseRun(config, runState, `${reason} (step "${step.id}")`, options.overrides?.harness ?? agent.harness, runState.last_harness?.session_id ?? null);
+      await pauseRun(config, runState, `${reason} (step "${step.id}")`, step.harness, runState.last_harness?.session_id ?? null);
       return runState;
     }
   }
   return runState;
 }
 
-// src/lib/types.ts
-var HARNESSES = ["claude", "opencode", "codex", "copilot"];
-function parseHarnessOverride(value) {
-  if (!value) {
-    return;
-  }
-  if (!HARNESSES.includes(value)) {
-    throw new UserInputError(`Invalid harness override "${value}". Expected one of: ${HARNESSES.join(", ")}.`);
-  }
-  return value;
-}
-
 // src/lib/version.ts
 import { readFileSync } from "node:fs";
 import { dirname as dirname2, resolve as resolve5 } from "node:path";
@@ -11336,81 +11754,85 @@ async function loadWorkflowDefinition(workflowPath) {
   const id = ensureString(parsed.id, "id");
   const name = ensureString(parsed.name, "name");
   const version = typeof parsed.version === "string" ? parsed.version : undefined;
-  if (!Array.isArray(parsed.agents) || parsed.agents.length === 0) {
-    throw new ValidationError("Workflow must define a non-empty agents array.");
+  let topLevelHarness;
+  if (typeof parsed.harness === "string" && parsed.harness.trim() !== "") {
+    const h = parsed.harness.trim();
+    if (!SUPPORTED_HARNESSES.has(h)) {
+      throw new ValidationError(`Unsupported top-level harness "${h}".`);
+    }
+    topLevelHarness = h;
   }
+  const topLevelModel = typeof parsed.model === "string" && parsed.model.trim() !== "" ? parsed.model.trim() : undefined;
   if (!Array.isArray(parsed.steps) || parsed.steps.length === 0) {
     throw new ValidationError("Workflow must define a non-empty steps array.");
   }
-  const agents = parsed.agents.map((rawAgent, index) => {
-    if (!rawAgent || typeof rawAgent !== "object") {
-      throw new ValidationError(`Invalid agents[${index}] definition.`);
-    }
-    const agent = rawAgent;
-    const agentId = ensureString(agent.id, `agents[${index}].id`);
-    const harness = ensureString(agent.harness, `agents[${index}].harness`);
-    if (!SUPPORTED_HARNESSES.has(harness)) {
-      throw new ValidationError(`Unsupported harness "${harness}" for agent "${agentId}".`);
+  const steps = parsed.steps.map((rawStep, index) => {
+    if (!rawStep || typeof rawStep !== "object") {
+      throw new ValidationError(`Invalid steps[${index}] definition.`);
     }
-    const prompt = ensureString(agent.prompt, `agents[${index}].prompt`);
-    const model = agent.model;
+    const step = rawStep;
+    const stepId = ensureString(step.id, `steps[${index}].id`);
+    let harness;
+    if (typeof step.harness === "string" && step.harness.trim() !== "") {
+      harness = step.harness.trim();
+      if (!SUPPORTED_HARNESSES.has(harness)) {
+        throw new ValidationError(`Unsupported harness "${harness}" for step "${stepId}".`);
+      }
+    } else if (topLevelHarness) {
+      harness = topLevelHarness;
+    } else {
+      throw new ValidationError(`Step "${stepId}" has no harness and no top-level harness default is defined.`);
+    }
+    const stepModel = step.model;
+    const effectiveModel = typeof stepModel === "string" && stepModel.trim() !== "" ? stepModel : topLevelModel;
+    const hasPromptFile = typeof step.prompt_file === "string" && step.prompt_file.trim() !== "";
+    const hasPrompt = typeof step.prompt === "string" && step.prompt.trim() !== "";
+    if (!hasPromptFile && !hasPrompt) {
+      throw new ValidationError(`Step "${stepId}" must define at least one of "prompt_file" or "prompt".`);
+    }
+    const requires = step.requires;
+    const requiresInputs = requires && Array.isArray(requires.inputs) ? ensureStringArray(requires.inputs, `steps[${index}].requires.inputs`) : [];
+    const requiresOutputs = requires && Array.isArray(requires.outputs) ? ensureStringArray(requires.outputs, `steps[${index}].requires.outputs`) : [];
     const normalized = {
-      id: agentId,
+      id: stepId,
       harness,
-      prompt
+      next_step: ensureString(step.next_step, `steps[${index}].next_step`),
+      requires: {
+        inputs: requiresInputs,
+        outputs: requiresOutputs
+      }
     };
-    if (typeof model === "string" && model.trim() !== "") {
-      return {
-        ...normalized,
-        model
-      };
+    if (hasPromptFile) {
+      normalized.prompt_file = step.prompt_file.trim();
     }
-    return normalized;
-  });
-  const steps = parsed.steps.map((rawStep, index) => {
-    if (!rawStep || typeof rawStep !== "object") {
-      throw new ValidationError(`Invalid steps[${index}] definition.`);
+    if (hasPrompt) {
+      normalized.prompt = step.prompt;
     }
-    const step = rawStep;
-    const outputs = step.outputs;
-    if (!outputs || typeof outputs !== "object") {
-      throw new ValidationError(`Invalid step field "steps[${index}].outputs": expected object.`);
+    if (effectiveModel) {
+      normalized.model = effectiveModel;
     }
-    return {
-      id: ensureString(step.id, `steps[${index}].id`),
-      agent: ensureString(step.agent, `steps[${index}].agent`),
-      default_next: ensureString(step.default_next, `steps[${index}].default_next`),
-      input_required: ensureStringArray(step.input_required, `steps[${index}].input_required`),
-      outputs: {
-        required: ensureStringArray(outputs.required, `steps[${index}].outputs.required`)
-      },
-      input: ensureString(step.input, `steps[${index}].input`)
-    };
+    return normalized;
   });
-  validateUniqueness(agents.map((agent) => agent.id), "agent");
   validateUniqueness(steps.map((step) => step.id), "step");
-  const knownAgents = new Set(agents.map((agent) => agent.id));
   const knownSteps = new Set(steps.map((step) => step.id));
   for (const step of steps) {
-    if (!knownAgents.has(step.agent)) {
-      throw new ValidationError(`Unknown agent "${step.agent}" referenced by step "${step.id}".`);
-    }
     const validTransitionTargets = new Set([...knownSteps, "done", "human_intervention"]);
-    if (!validTransitionTargets.has(step.default_next)) {
-      throw new ValidationError(`Invalid default_next "${step.default_next}" in step "${step.id}".`);
+    if (!validTransitionTargets.has(step.next_step)) {
+      throw new ValidationError(`Invalid next_step "${step.next_step}" in step "${step.id}".`);
     }
   }
   return {
     id,
     name,
     ...version && { version },
-    agents,
+    ...topLevelHarness && { harness: topLevelHarness },
+    ...topLevelModel && { model: topLevelModel },
     steps
   };
 }
 
 // src/commands/continue.ts
-class ContinueCommand extends Command {
+class ContinueCommand extends BaseCommand {
   static paths = [["continue"]];
   static usage = Command.Usage({
     category: "Workflow",
@@ -11424,8 +11846,8 @@ class ContinueCommand extends Command {
         '$0 continue 20260316-153210Z --hint "Plan mode only: read and propose changes, do not edit files."'
       ],
       [
-        "Force harness/session override",
-        "$0 continue 20260316-153210Z --harness claude --session-id abc123"
+        "Force session override",
+        "$0 continue 20260316-153210Z --session-id abc123"
       ]
     ]
   });
@@ -11436,10 +11858,6 @@ class ContinueCommand extends Command {
     required: false,
     description: "Override current step id before resuming."
   });
-  harness = exports_options.String("--harness", {
-    required: false,
-    description: "Override harness for the resumed step."
-  });
   sessionId = exports_options.String("--session-id", {
     required: false,
     description: "Force harness session id for resume attempt."
@@ -11448,35 +11866,36 @@ class ContinueCommand extends Command {
     required: false,
     description: "Inject a one-time hint into the resumed harness prompt."
   });
+  allowAll = exports_options.Boolean("--allow-all", true, {
+    description: "Enable harness auto-approval flags when supported (default: true)."
+  });
+  noAllowAll = exports_options.Boolean("--no-allow-all", false, {
+    description: "Disable harness auto-approval flags."
+  });
   async execute() {
     const showUpdateNotice = startUpdateCheck();
     const config = await loadConfig();
     const runState = await loadRunState(config, this.runId);
     const workflow = await loadWorkflowDefinition(runState.workflow_path);
-    const harnessOverride = parseHarnessOverride(this.harness);
     runState.status = "running";
     if (this.step) {
       runState.current_step = this.step;
     }
+    const effectiveAllowAll = this.noAllowAll ? false : this.allowAll;
     ui.workflowHeader({
-      title: "rmr continue",
+      title: `${binaryName} continue`,
       workflow: runState.workflow_path,
       workflowId: workflow.id,
       task: runState.context["task"] ?? "(continuing)",
       runId: this.runId,
-      currentStep: runState.current_step,
       runFile: "",
-      allowAll: true,
-      harness: this.harness,
+      allowAll: effectiveAllowAll,
       varsCount: 0
     });
     const overrides = {};
     if (this.step) {
       overrides.stepId = this.step;
     }
-    if (harnessOverride) {
-      overrides.harness = harnessOverride;
-    }
     if (this.sessionId) {
       overrides.sessionId = this.sessionId;
     }
@@ -11484,7 +11903,7 @@ class ContinueCommand extends Command {
       overrides.hint = this.hint;
     }
     await runWorkflow(config, workflow, runState, {
-      allowAll: true,
+      allowAll: effectiveAllowAll,
       overrides
     });
     showUpdateNotice();
@@ -11508,7 +11927,7 @@ function getExamplesWorkflowsDir() {
   return fromSrc;
 }
 
-class InstallCommand extends Command {
+class InstallCommand extends BaseCommand {
   static paths = [["install"]];
   static usage = Command.Usage({
     category: "Setup",
@@ -11534,76 +11953,191 @@ class InstallCommand extends Command {
     }
     if (existsSync(destinationDir)) {
       ui.info(`Workflow already installed at .rmr/workflows/${this.workflowName}/`);
-      ui.info(`Run it with: rmr run .rmr/workflows/${this.workflowName}/workflow.yaml --task "Describe your task"`);
+      ui.info(`Run it with: ${binaryName} run .rmr/workflows/${this.workflowName}/workflow.yaml --task "Describe your task"`);
       return 0;
     }
     await cp(sourceDir, destinationDir, { recursive: true, force: false, errorOnExist: true });
     ui.success(`installed .rmr/workflows/${this.workflowName}/`);
-    ui.info(`Run it with: rmr run .rmr/workflows/${this.workflowName}/workflow.yaml --task "Describe your task"`);
+    ui.info(`Run it with: ${binaryName} run .rmr/workflows/${this.workflowName}/workflow.yaml --task "Describe your task"`);
+    return 0;
+  }
+}
+
+// src/commands/list.ts
+import { readdir as readdir3 } from "node:fs/promises";
+import { existsSync as existsSync2 } from "node:fs";
+import { dirname as dirname4, resolve as resolve8 } from "node:path";
+import { fileURLToPath as fileURLToPath3 } from "node:url";
+function getExamplesWorkflowsDir2() {
+  const thisDir = dirname4(fileURLToPath3(import.meta.url));
+  const fromDist = resolve8(thisDir, "..", "examples", "workflows");
+  const fromSrc = resolve8(thisDir, "..", "..", "examples", "workflows");
+  if (existsSync2(fromDist))
+    return fromDist;
+  if (existsSync2(fromSrc))
+    return fromSrc;
+  return fromSrc;
+}
+async function getInstalledWorkflows(workflowsDir) {
+  if (!existsSync2(workflowsDir)) {
+    return [];
+  }
+  const entries = await readdir3(workflowsDir, { withFileTypes: true });
+  const workflows = [];
+  for (const entry of entries) {
+    if (!entry.isDirectory())
+      continue;
+    const workflowPath = resolve8(workflowsDir, entry.name, "workflow.yaml");
+    if (!existsSync2(workflowPath))
+      continue;
+    try {
+      const workflow = await loadWorkflowDefinition(workflowPath);
+      workflows.push({
+        id: workflow.id,
+        name: workflow.name,
+        path: `.rmr/workflows/${entry.name}/workflow.yaml`
+      });
+    } catch {
+      workflows.push({
+        id: entry.name,
+        name: "(invalid workflow.yaml)",
+        path: `.rmr/workflows/${entry.name}/workflow.yaml`
+      });
+    }
+  }
+  return workflows.sort((a, b) => a.id.localeCompare(b.id));
+}
+async function getBundledWorkflows(examplesDir) {
+  if (!existsSync2(examplesDir)) {
+    return [];
+  }
+  const entries = await readdir3(examplesDir, { withFileTypes: true });
+  const workflows = [];
+  for (const entry of entries) {
+    if (!entry.isDirectory())
+      continue;
+    const workflowPath = resolve8(examplesDir, entry.name, "workflow.yaml");
+    if (!existsSync2(workflowPath))
+      continue;
+    try {
+      const workflow = await loadWorkflowDefinition(workflowPath);
+      workflows.push({
+        id: workflow.id,
+        name: workflow.name,
+        path: entry.name
+      });
+    } catch {
+      workflows.push({
+        id: entry.name,
+        name: "(invalid workflow.yaml)",
+        path: entry.name
+      });
+    }
+  }
+  return workflows.sort((a, b) => a.id.localeCompare(b.id));
+}
+
+class ListCommand extends BaseCommand {
+  static paths = [["list"]];
+  static usage = Command.Usage({
+    category: "Setup",
+    description: "List installed and available workflows.",
+    details: "Shows workflows installed in `.rmr/workflows/` and bundled workflows available for installation.",
+    examples: [["List all workflows", "$0 list"]]
+  });
+  async execute() {
+    const config = await loadConfig();
+    const examplesDir = getExamplesWorkflowsDir2();
+    const installed = await getInstalledWorkflows(config.workflowsDir);
+    const bundled = await getBundledWorkflows(examplesDir);
+    const installedIds = new Set(installed.map((w) => w.id));
+    if (installed.length > 0) {
+      ui.info("Installed workflows:");
+      for (const workflow of installed) {
+        ui.info(`  ${workflow.id.padEnd(16)} ${workflow.name.padEnd(24)} ${workflow.path}`);
+      }
+      ui.info("");
+    }
+    const available = bundled.filter((w) => !installedIds.has(w.id));
+    if (available.length > 0) {
+      ui.info("Available to install:");
+      for (const workflow of available) {
+        ui.info(`  ${workflow.id.padEnd(16)} ${binaryName} install ${workflow.path}`);
+      }
+      ui.info("");
+    }
+    if (installed.length === 0 && bundled.length > 0) {
+      ui.info("No workflows installed yet. Install one with:");
+      ui.info(`  ${binaryName} install ${bundled[0]?.path}`);
+      ui.info("");
+    }
+    if (installed.length === 0 && bundled.length === 0) {
+      ui.info("No workflows found.");
+    }
     return 0;
   }
 }
 
 // src/commands/root.ts
-import { basename } from "node:path";
+import { basename as basename2 } from "node:path";
 function detectShell() {
   const raw = process.env.SHELL;
   if (!raw) {
     return null;
   }
-  const shell = basename(raw);
+  const shell = basename2(raw);
   if (shell === "bash" || shell === "zsh" || shell === "fish") {
     return shell;
   }
   return null;
 }
 
-class RootCommand extends Command {
+class RootCommand extends BaseCommand {
   static paths = [Command.Default];
   async execute() {
     const shell = detectShell();
-    process.stdout.write(`rmr ${getVersion()} - multi-step coding workflows for AI agents
+    process.stdout.write(`${binaryName} ${getVersion()} - multi-step coding workflows for AI agents
 
 `);
     process.stdout.write(`Setup
 `);
-    process.stdout.write(`  rmr install <name>      Install bundled workflow into .rmr/workflows/
+    process.stdout.write(`  ${binaryName} install <name>      Install bundled workflow into .rmr/workflows/
 
 `);
     process.stdout.write(`Workflow
 `);
-    process.stdout.write(`  rmr run <workflow-path>  Start a new workflow run (requires --task/-t or --task-file/-f)
+    process.stdout.write(`  ${binaryName} run <workflow-path>  Start a new workflow run (requires --task/-t or --task-file/-f)
 `);
-    process.stdout.write(`  rmr continue <run-id>   Resume a paused or interrupted run
+    process.stdout.write(`  ${binaryName} continue <run-id>   Resume a paused or interrupted run
 
 `);
     process.stdout.write(`Shell Completion (optional)
 `);
     if (shell === "fish") {
-      process.stdout.write(`  rmr completion fish > ~/.config/fish/completions/rmr.fish
+      process.stdout.write(`  ${binaryName} completion fish > ~/.config/fish/completions/${binaryName}.fish
 
 `);
     } else if (shell) {
       const rcFile = shell === "zsh" ? "~/.zshrc" : "~/.bashrc";
-      process.stdout.write(`  echo 'eval "$(rmr completion ${shell})"' >> ${rcFile}
+      process.stdout.write(`  echo 'eval "$(${binaryName} completion ${shell})"' >> ${rcFile}
 `);
       process.stdout.write(`  source ${rcFile}
 
 `);
     } else {
-      process.stdout.write(`  echo 'eval "$(rmr completion zsh)"' >> ~/.zshrc && source ~/.zshrc
+      process.stdout.write(`  echo 'eval "$(${binaryName} completion zsh)"' >> ~/.zshrc && source ~/.zshrc
 `);
-      process.stdout.write(`  echo 'eval "$(rmr completion bash)"' >> ~/.bashrc && source ~/.bashrc
+      process.stdout.write(`  echo 'eval "$(${binaryName} completion bash)"' >> ~/.bashrc && source ~/.bashrc
 `);
-      process.stdout.write(`  rmr completion fish > ~/.config/fish/completions/rmr.fish
+      process.stdout.write(`  ${binaryName} completion fish > ~/.config/fish/completions/${binaryName}.fish
 
 `);
     }
     process.stdout.write(`More
 `);
-    process.stdout.write(`  rmr --help              Show full help with all options
+    process.stdout.write(`  ${binaryName} --help              Show full help with all options
 `);
-    process.stdout.write(`  rmr <command> --help    Show help for a specific command
+    process.stdout.write(`  ${binaryName} <command> --help    Show help for a specific command
 `);
     return 0;
   }
@@ -11645,8 +12179,8 @@ var logger = {
 };
 
 // src/commands/run.ts
-import { readFile as readFile4 } from "node:fs/promises";
-import { resolve as resolve8 } from "node:path";
+import { readFile as readFile4, stat } from "node:fs/promises";
+import { resolve as resolve9 } from "node:path";
 function parseVar(input) {
   const index = input.indexOf("=");
   if (index < 1 || index === input.length - 1) {
@@ -11657,8 +12191,57 @@ function parseVar(input) {
     value: input.slice(index + 1).trim()
   };
 }
+function getErrorMessage(error) {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  if (typeof error === "string") {
+    return error;
+  }
+  try {
+    return JSON.stringify(error);
+  } catch {
+    return "Unknown error";
+  }
+}
+function isErrnoLike(error) {
+  return typeof error === "object" && error !== null;
+}
+async function resolveWorkflowPath(inputPath) {
+  const absolutePath = resolve9(inputPath);
+  try {
+    const pathStat = await stat(absolutePath);
+    if (!pathStat.isDirectory()) {
+      return absolutePath;
+    }
+    const yamlPath = resolve9(absolutePath, "workflow.yaml");
+    try {
+      const yamlStat = await stat(yamlPath);
+      if (yamlStat.isFile()) {
+        return yamlPath;
+      }
+    } catch {}
+    const ymlPath = resolve9(absolutePath, "workflow.yml");
+    try {
+      const ymlStat = await stat(ymlPath);
+      if (ymlStat.isFile()) {
+        return ymlPath;
+      }
+    } catch {}
+    throw new UserInputError(`Workflow directory does not contain workflow.yaml or workflow.yml: ${absolutePath}`);
+  } catch (error) {
+    if (isErrnoLike(error) && error.code === "ENOENT") {
+      const hint = absolutePath.includes(`${resolve9(".rmr")}/workflow/`) ? " Did you mean .rmr/workflows/?" : "";
+      throw new UserInputError(`Workflow does not exist: ${absolutePath}${hint}`);
+    }
+    if (error instanceof UserInputError) {
+      throw error;
+    }
+    throw new UserInputError(`Failed to access workflow path "${absolutePath}": ${getErrorMessage(error)}`);
+  }
+}
 
-class RunCommand extends Command {
+class RunCommand extends BaseCommand {
   static paths = [["run"]];
   static usage = Command.Usage({
     category: "Workflow",
@@ -11670,14 +12253,6 @@ class RunCommand extends Command {
         '$0 run .rmr/workflows/feature-dev/workflow.yaml --task "Implement auth middleware"'
       ],
       ["Run with task file", "$0 run .rmr/workflows/feature-dev/workflow.yaml --task-file task.md"],
-      [
-        "Override harness",
-        '$0 run .rmr/workflows/feature-dev/workflow.yaml --task "Fix bug" --harness opencode'
-      ],
-      [
-        "Override model",
-        '$0 run .rmr/workflows/feature-dev/workflow.yaml --task "Fix bug" --model openai/gpt-5.3-codex-high'
-      ],
       [
         "Run with extra variables",
         '$0 run .rmr/workflows/feature-dev/workflow.yaml --task "Ship feature" --var issue_id=123 --var env=staging'
@@ -11699,14 +12274,6 @@ class RunCommand extends Command {
     required: false,
     description: "Path to file containing task description."
   });
-  harness = exports_options.String("--harness", {
-    required: false,
-    description: "Override harness for all workflow steps."
-  });
-  model = exports_options.String("--model", {
-    required: false,
-    description: "Override model for all workflow steps (e.g., openai/gpt-5.3-codex-high)."
-  });
   vars = exports_options.Array("--var", [], {
     description: "Inject initial variables as key=value (repeatable)."
   });
@@ -11722,7 +12289,7 @@ class RunCommand extends Command {
     }
     if (this.taskFile) {
       try {
-        const content = await readFile4(resolve8(this.taskFile), "utf-8");
+        const content = await readFile4(resolve9(this.taskFile), "utf-8");
         const task = content.trim();
         return { task, displayTask: `(file: ${this.taskFile})` };
       } catch (error) {
@@ -11733,18 +12300,34 @@ class RunCommand extends Command {
     if (this.taskFlag) {
       return { task: this.taskFlag, displayTask: this.taskFlag };
     }
+    if (process.stdin.isTTY) {
+      ui.warning("No task provided. Enter your task below. Press Ctrl+D to submit.");
+      const task = await ui.multilinePrompt("Task: ");
+      const trimmedTask = task.trim();
+      if (!trimmedTask) {
+        throw new UserInputError("Task cannot be empty.");
+      }
+      return { task: trimmedTask, displayTask: trimmedTask };
+    }
     throw new UserInputError("No task provided. Use --task/-t or --task-file/-f.");
   }
   async execute() {
     const showUpdateNotice = startUpdateCheck();
     const config = await loadConfig();
-    const { task, displayTask } = await this.resolveTask();
-    const harnessOverride = parseHarnessOverride(this.harness);
     const parsedVars = this.vars.map(parseVar);
     const effectiveAllowAll = this.noAllowAll ? false : this.allowAll;
     const varsObject = Object.fromEntries(parsedVars.map((entry) => [entry.key, entry.value]));
-    const workflowPath = resolve8(this.workflowPath);
-    const workflow = await loadWorkflowDefinition(workflowPath);
+    const workflowPath = await resolveWorkflowPath(this.workflowPath);
+    let workflow;
+    try {
+      workflow = await loadWorkflowDefinition(workflowPath);
+    } catch (error) {
+      if (isErrnoLike(error) && error.code === "ENOENT") {
+        throw new UserInputError(`Workflow does not exist: ${workflowPath}`);
+      }
+      throw new UserInputError(`Failed to load workflow "${workflowPath}": ${getErrorMessage(error)}`);
+    }
+    const { task, displayTask } = await this.resolveTask();
     const runId = generateRunId();
     const runState = createInitialRunState({
       runId,
@@ -11755,28 +12338,17 @@ class RunCommand extends Command {
     });
     const runPath = await saveRunState(config, runState);
     ui.workflowHeader({
-      title: "rmr config",
+      title: `${binaryName} config`,
       workflow: workflowPath,
       workflowId: workflow.id,
       task: displayTask,
       runId: runState.run_id,
-      currentStep: runState.current_step,
       runFile: runPath,
       allowAll: effectiveAllowAll,
-      harness: this.harness,
-      model: this.model,
       varsCount: parsedVars.length
     });
-    const overrides = {};
-    if (harnessOverride) {
-      overrides.harness = harnessOverride;
-    }
-    if (this.model) {
-      overrides.model = this.model;
-    }
     await runWorkflow(config, workflow, runState, {
-      allowAll: effectiveAllowAll,
-      ...Object.keys(overrides).length > 0 && { overrides }
+      allowAll: effectiveAllowAll
     });
     showUpdateNotice();
     return 0;
@@ -11786,7 +12358,7 @@ class RunCommand extends Command {
 // src/index.ts
 var [, , ...args] = process.argv;
 var cli = new Cli({
-  binaryName: "rmr",
+  binaryName,
   binaryVersion: getVersion(),
   enableColors: false
 });
@@ -11794,13 +12366,14 @@ cli.register(exports_builtins.HelpCommand);
 cli.register(exports_builtins.VersionCommand);
 cli.register(RootCommand);
 cli.register(InstallCommand);
+cli.register(ListCommand);
 cli.register(RunCommand);
 cli.register(ContinueCommand);
 cli.register(CompleteCommand);
 cli.register(CompletionCommand);
 try {
   const exitCode = await cli.run(args);
-  process.exitCode = exitCode;
+  process.exitCode = Math.max(process.exitCode ?? 0, exitCode);
 } catch (error) {
   if (error instanceof RmrError) {
     logger.error(`${error.code}: ${error.message}`);