@moxxy/cli 0.7.3 → 0.8.1

package/dist/bin.js

@@ -88109,6 +88109,8 @@ var init_WorkflowsPanel = __esm({
       const [loading, setLoading] = import_react55.default.useState(true);
       const [busy, setBusy] = import_react55.default.useState(false);
       const [status, setStatus] = import_react55.default.useState(null);
+      const [pending, setPending] = import_react55.default.useState(null);
+      const [reply2, setReply] = import_react55.default.useState("");
       const reload = import_react55.default.useCallback(async () => {
         if (!view) {
           setLoading(false);
@@ -88126,7 +88128,7 @@ var init_WorkflowsPanel = __esm({
       import_react55.default.useEffect(() => {
         void reload();
       }, [reload]);
-      const active = !busy && !!view && rows.length > 0;
+      const active = !busy && !pending && !!view && rows.length > 0;
       const run2 = import_react55.default.useCallback(async (wf) => {
         if (!view || busy)
           return;
@@ -88138,6 +88140,17 @@ var init_WorkflowsPanel = __esm({
         setStatus(`running "${wf.name}"\u2026`);
         try {
           const result = await view.run(wf.name);
+          if (result.status === "paused" && result.runId) {
+            const askStep = result.steps.find((s2) => s2.status === "awaiting_input");
+            setPending({
+              runId: result.runId,
+              label: askStep?.id ?? wf.name,
+              prompt: result.output || "The workflow is waiting for your input."
+            });
+            setReply("");
+            setStatus(`\u23F8 "${wf.name}" is waiting for your reply \u2014 type it and press Enter (Esc cancels).`);
+            return;
+          }
           const marks = result.steps.map((s2) => `${stepMark(s2.status)}${s2.id}`).join(" ");
           setStatus(result.ok ? `\u2713 ${wf.name} completed \u2014 ${marks}` : `\u2717 ${wf.name} failed: ${result.error ?? ""} \u2014 ${marks}`);
         } catch (err) {
@@ -88147,6 +88160,35 @@ var init_WorkflowsPanel = __esm({
           void reload();
         }
       }, [view, busy, reload]);
+      const submitReply = import_react55.default.useCallback(async (pendingRun, text) => {
+        if (!view?.resume) {
+          setStatus("resume not supported by this session");
+          return;
+        }
+        const answer = text.trim();
+        if (!answer)
+          return;
+        setPending(null);
+        setReply("");
+        setBusy(true);
+        setStatus(`resuming "${pendingRun.label}"\u2026`);
+        try {
+          const result = await view.resume(pendingRun.runId, answer);
+          if (result.status === "paused" && result.runId) {
+            const askStep = result.steps.find((s2) => s2.status === "awaiting_input");
+            setPending({ runId: result.runId, label: askStep?.id ?? pendingRun.label, prompt: result.output });
+            setStatus("\u23F8 waiting again \u2014 type your reply and press Enter (Esc cancels).");
+          } else {
+            const marks = result.steps.map((s2) => `${stepMark(s2.status)}${s2.id}`).join(" ");
+            setStatus(result.ok ? `\u2713 resumed & completed \u2014 ${marks}` : `\u2717 resume failed: ${result.error ?? ""} \u2014 ${marks}`);
+          }
+        } catch (err) {
+          setStatus(`\u2717 resume errored: ${err instanceof Error ? err.message : String(err)}`);
+        } finally {
+          setBusy(false);
+          void reload();
+        }
+      }, [view, reload]);
       const scroll = useScrollableList({
         total: rows.length,
         windowSize: WINDOW4,
@@ -88172,6 +88214,26 @@ var init_WorkflowsPanel = __esm({
           void run2(wf);
         }
       }, { isActive: active });
+      use_input_default((input, key) => {
+        if (!pending)
+          return;
+        if (key.escape) {
+          setPending(null);
+          setReply("");
+          setStatus("reply cancelled \u2014 the run stays paused (re-run to resume).");
+          return;
+        }
+        if (key.return) {
+          void submitReply(pending, reply2);
+          return;
+        }
+        if (key.backspace || key.delete) {
+          setReply((r2) => r2.slice(0, -1));
+          return;
+        }
+        if (input && !key.ctrl && !key.meta)
+          setReply((r2) => r2 + input);
+      }, { isActive: !busy && !!pending });
       const termWidth = process.stdout.columns ?? 80;
       const descWidth = Math.max(16, termWidth - NAME_COL3 - SCOPE_COL2 - TRIG_COL - 12);
       const slice = rows.slice(scroll.visible.start, scroll.visible.end);
@@ -88181,7 +88243,7 @@ var init_WorkflowsPanel = __esm({
         const absoluteIndex = scroll.visible.start + i2;
         const focused = absoluteIndex === scroll.cursor;
         return (0, import_jsx_runtime27.jsxs)(Box_default, { children: [(0, import_jsx_runtime27.jsx)(Text, { ...focused ? {} : { dimColor: true }, children: focused ? "\u203A " : "  " }), (0, import_jsx_runtime27.jsx)(Text, { color: wf.enabled ? Colors.active : void 0, dimColor: !wf.enabled, children: wf.enabled ? "\u25CF " : "\u25CB " }), (0, import_jsx_runtime27.jsx)(Box_default, { width: NAME_COL3, children: (0, import_jsx_runtime27.jsx)(Text, { bold: focused, children: truncate8(wf.name, NAME_COL3 - 1) }) }), (0, import_jsx_runtime27.jsx)(Box_default, { width: SCOPE_COL2, children: (0, import_jsx_runtime27.jsx)(Text, { dimColor: true, children: wf.scope }) }), (0, import_jsx_runtime27.jsx)(Box_default, { width: TRIG_COL, children: (0, import_jsx_runtime27.jsx)(Text, { dimColor: true, wrap: "truncate", children: wf.triggers }) }), (0, import_jsx_runtime27.jsx)(Box_default, { width: descWidth, children: (0, import_jsx_runtime27.jsx)(Text, { dimColor: true, wrap: "truncate", children: oneLine5(wf.description) }) })] }, wf.name);
-      }), scroll.canScrollDown ? (0, import_jsx_runtime27.jsx)(Text, { dimColor: true, children: `  \u2193 ${rows.length - scroll.visible.end} more below` }) : null, status ? (0, import_jsx_runtime27.jsx)(Box_default, { marginTop: 1, children: (0, import_jsx_runtime27.jsx)(Text, { wrap: "truncate-end", children: status }) }) : null] });
+      }), scroll.canScrollDown ? (0, import_jsx_runtime27.jsx)(Text, { dimColor: true, children: `  \u2193 ${rows.length - scroll.visible.end} more below` }) : null, pending ? (0, import_jsx_runtime27.jsxs)(Box_default, { flexDirection: "column", marginTop: 1, borderStyle: "round", borderColor: Colors.active, paddingX: 1, children: [(0, import_jsx_runtime27.jsxs)(Text, { color: Colors.active, children: ["\u23F8 Workflow waiting \xB7 ", pending.label] }), pending.prompt ? (0, import_jsx_runtime27.jsx)(Text, { wrap: "wrap", children: oneLine5(pending.prompt).slice(0, 280) }) : null, (0, import_jsx_runtime27.jsxs)(Box_default, { marginTop: 1, children: [(0, import_jsx_runtime27.jsx)(Text, { children: "reply \u203A " }), (0, import_jsx_runtime27.jsx)(Text, { children: reply2 || " " })] }), (0, import_jsx_runtime27.jsx)(Text, { dimColor: true, children: "Enter send \xB7 Esc cancel" })] }) : null, status ? (0, import_jsx_runtime27.jsx)(Box_default, { marginTop: 1, children: (0, import_jsx_runtime27.jsx)(Text, { wrap: "truncate-end", children: status }) }) : null] });
     };
   }
 });
@@ -134642,7 +134704,8 @@ function isRunnerUp(socketPath = runnerSocketPath()) {
 
 // ../runner/dist/server.js
 init_dist();
-var RUNNER_PROTOCOL_VERSION = 4;
+var RUNNER_PROTOCOL_VERSION = 5;
+var MIN_COMPATIBLE_PROTOCOL_VERSION = 1;
 var RunnerMethod = {
   /** client->server: handshake; returns the initial info snapshot. */
   Attach: "attach",
@@ -134692,6 +134755,12 @@ var RunnerMethod = {
   WorkflowSave: "workflow.save",
   /** client->server: fetch one saved workflow as canonical YAML (builder). */
   WorkflowGetRun: "workflow.getRun",
+  /**
+   * client->server: answer a paused workflow's `awaitInput` question and resume
+   * the run (human-in-the-loop). v5 — the client gates this on the server's
+   * reported version so an older runner returns an actionable error.
+   */
+  WorkflowResume: "workflow.resume",
   /** server->client: ask this client to decide a tool-call permission. */
   PermissionCheck: "permission.check",
   /** server->client: ask this client to confirm an approval checkpoint. */
@@ -134776,6 +134845,10 @@ var workflowSaveParamsSchema = z.object({
   previousName: z.string().min(1).max(120).optional()
 });
 var workflowGetRunParamsSchema = z.object({ name: z.string().min(1).max(120) });
+var workflowResumeParamsSchema = z.object({
+  runId: z.string().min(1).max(120),
+  reply: z.string().min(1).max(1e5)
+});
 
 // ../runner/dist/server.js
 var RunnerServer = class {
@@ -134855,6 +134928,7 @@ var RunnerServer = class {
     peer.handle(RunnerMethod.WorkflowValidateDraft, (raw) => this.handleWorkflowValidateDraft(raw));
     peer.handle(RunnerMethod.WorkflowSave, (raw) => this.handleWorkflowSave(raw));
     peer.handle(RunnerMethod.WorkflowGetRun, (raw) => this.handleWorkflowGetRun(raw));
+    peer.handle(RunnerMethod.WorkflowResume, (raw) => this.handleWorkflowResume(raw));
     peer.onClose(() => this.onDisconnect(client));
   }
   onDisconnect(client) {
@@ -134866,7 +134940,7 @@ var RunnerServer = class {
   // --- request handlers ----------------------------------------------------
   handleAttach(client, raw) {
     const params = attachParamsSchema.parse(raw);
-    if (params.protocolVersion !== RUNNER_PROTOCOL_VERSION) {
+    if (params.protocolVersion < MIN_COMPATIBLE_PROTOCOL_VERSION) {
       throw new Error(`runner protocol mismatch: server v${RUNNER_PROTOCOL_VERSION}, client v${params.protocolVersion}`);
     }
     client.role = params.role;
@@ -135109,6 +135183,16 @@ var RunnerServer = class {
       throw new Error("workflows builder not supported on this runner");
     return await view.getRun(params.name) ?? null;
   }
+  // --- Workflows human-in-the-loop (resume a paused awaitInput run) ---------
+  // v5. Optional on the view (older hosts lack it), so feature-check and throw a
+  // clear error rather than calling undefined.
+  async handleWorkflowResume(raw) {
+    const params = workflowResumeParamsSchema.parse(raw);
+    const view = this.session.workflows;
+    if (!view?.resume)
+      throw new Error("workflow resume not supported on this runner");
+    return view.resume(params.runId, params.reply);
+  }
   broadcastInfo() {
     this.broadcast(RunnerNotification.InfoChanged, { info: this.session.getInfo() });
   }
@@ -135251,6 +135335,14 @@ var RemoteSession = class {
   permissionResolver = null;
   approvalResolver = null;
   info = null;
+  /**
+   * The protocol version the SERVER reported at attach. Defaults to our own
+   * version until the handshake resolves. Version-specific client methods (the
+   * v4 workflow *builder* family) gate on this so a newer client attached to an
+   * older runner degrades with a clear, actionable error instead of a raw
+   * JSON-RPC method-not-found. Null until attached.
+   */
+  serverProtocolVersion = null;
   constructor(transport) {
     this.peer = new JsonRpcPeer(transport);
     this.peer.on(RunnerNotification.Event, (params) => {
@@ -135319,6 +135411,28 @@ var RemoteSession = class {
       sinceSeq
     });
     this.info = result.info;
+    this.serverProtocolVersion = typeof result.protocolVersion === "number" ? result.protocolVersion : RUNNER_PROTOCOL_VERSION;
+  }
+  /**
+   * The protocol version the attached runner speaks (its own, from the
+   * handshake). Lets a capability-detecting caller (e.g. the desktop's visual
+   * builder, see #146) decide whether a version-gated feature is available on
+   * THIS runner before invoking it. Null until attached.
+   */
+  get runnerProtocolVersion() {
+    return this.serverProtocolVersion;
+  }
+  /**
+   * Guard a method that only exists on a server at/after `minVersion`. Throws a
+   * clear, actionable error (not a raw JSON-RPC method-not-found) when the
+   * attached runner is older — the desktop case after a JS hot-update outran
+   * its bundled CLI.
+   */
+  requireServerProtocol(minVersion, feature) {
+    const server = this.serverProtocolVersion;
+    if (server !== null && server < minVersion) {
+      throw new Error(`${feature} is not supported by this runner (runner protocol v${server}, needs v${minVersion}) \u2014 update the moxxy CLI to continue.`);
+    }
   }
   get id() {
     return this.requireInfo().sessionId;
@@ -135554,12 +135668,37 @@ var RemoteSession = class {
       run: (name) => this.peer.request(RunnerMethod.WorkflowRun, { name }),
       // Builder methods (protocol v4): forward to the runner so the desktop's
       // RemoteSession-backed visual builder can validate/save/load drafts.
-      validateDraft: (yaml) => this.peer.request(RunnerMethod.WorkflowValidateDraft, { yaml }),
-      save: (yaml, previousName) => this.peer.request(RunnerMethod.WorkflowSave, {
-        yaml,
-        ...previousName ? { previousName } : {}
-      }),
-      getRun: (name) => this.peer.request(RunnerMethod.WorkflowGetRun, { name })
+      // Gated on the SERVER's reported version so a v4 client on a v3 runner
+      // (a desktop whose JS hot-update outran its bundled CLI) gets a clear
+      // "update the CLI" error instead of a raw method-not-found.
+      validateDraft: async (yaml) => {
+        this.requireServerProtocol(4, "The workflows builder");
+        return this.peer.request(RunnerMethod.WorkflowValidateDraft, {
+          yaml
+        });
+      },
+      save: async (yaml, previousName) => {
+        this.requireServerProtocol(4, "Saving a workflow from the builder");
+        return this.peer.request(RunnerMethod.WorkflowSave, {
+          yaml,
+          ...previousName ? { previousName } : {}
+        });
+      },
+      getRun: async (name) => {
+        this.requireServerProtocol(4, "Loading a workflow into the builder");
+        return this.peer.request(RunnerMethod.WorkflowGetRun, { name });
+      },
+      // Human-in-the-loop resume (protocol v5). Gated on the SERVER's reported
+      // version so a v5 client attached to a v4 runner (a desktop whose JS
+      // hot-update outran its bundled CLI) gets a clear "update the CLI" error
+      // rather than a raw method-not-found.
+      resume: async (runId, reply2) => {
+        this.requireServerProtocol(5, "Resuming a paused workflow");
+        return this.peer.request(RunnerMethod.WorkflowResume, {
+          runId,
+          reply: reply2
+        });
+      }
     };
   }
 };
@@ -135626,11 +135765,14 @@ async function connectRemoteSession(opts = {}) {
     throw err;
   }
 }
+function isProtocolMismatchError(err) {
+  const msg = err instanceof Error ? err.message : String(err);
+  return /protocol mismatch/i.test(msg);
+}
 async function maybeRecoverFromMismatch(err, socketPath, opts) {
   if (opts.transport || opts.skipMismatchRecovery)
     return;
-  const msg = err instanceof Error ? err.message : String(err);
-  if (!/protocol mismatch/i.test(msg))
+  if (!isProtocolMismatchError(err))
     return;
   try {
     await killAndUnlinkRunner(socketPath, [...DEFAULT_RUNNER_PORTS, ...opts.extraPortsToFree ?? []]);
@@ -135786,7 +135928,13 @@ var REMOTE_ALLOWED_COMMANDS = /* @__PURE__ */ new Set([
   // phone must not rewrite or re-enable the host's workflows.
   "workflows.list",
   "workflows.run",
-  "workflows.getRun"
+  "workflows.getRun",
+  // Answer a paused workflow's awaitInput question. This is RESPOND-only — like
+  // `ask.respond`, the operator answers a question the WORKFLOW asked (the reply
+  // is fed into the paused step and the run continues); it cannot create or
+  // rewrite a workflow. A mobile user answering "ship it" to their own pipeline
+  // is the canonical human-in-the-loop case, so it belongs on the trust surface.
+  "workflows.resume"
 ]);
 var providerName = z.string().regex(/^[a-z][a-z0-9-]{0,63}$/, "invalid provider name");
 var httpUrl = z.string().refine((s2) => {
@@ -135877,6 +136025,12 @@ var ipcInputSchemas = {
     previousName: workflowName.optional()
   }),
   "workflows.getRun": z.object({ name: workflowName }),
+  // Human-in-the-loop resume: bound the run id + the operator reply (the reply
+  // is forwarded into the paused step's child agent, so cap it to avoid OOM).
+  "workflows.resume": z.object({
+    runId: z.string().min(1).max(120),
+    reply: z.string().min(1).max(1e5)
+  }),
   // Security-sensitive: this bypasses the approval sheet, so validate it at
   // the boundary like the other dangerous commands.
   "session.setAutoApprove": z.object({ workspaceId: optionalWorkspace, enabled: z.boolean() }),
@@ -136162,6 +136316,12 @@ var MobileSessionHost = class {
       }
       return await this.session.workflows.getRun(name);
     });
+    this.bus.handle("workflows.resume", async ({ runId, reply: reply2 }) => {
+      if (!this.session.workflows?.resume) {
+        throw new IpcError("not-supported", "workflow resume not supported on this session");
+      }
+      return await this.session.workflows.resume(runId, reply2);
+    });
     this.bus.handle("ask.respond", async ({ requestId, response }) => {
       this.answerAsk(requestId, response);
     });
@@ -142121,10 +142281,11 @@ var stepSchema = z.object({
   format: z.enum(["json", "plain"]).optional(),
   awaitInput: z.boolean().optional()
 }).superRefine((step, ctx) => {
-  if (step.awaitInput) {
+  const isLogic = step.bridge != null || step.condition != null || step.switch != null;
+  if (step.awaitInput && (step.tool != null || step.workflow != null || step.loop != null || isLogic)) {
     ctx.addIssue({
       code: z.ZodIssueCode.custom,
-      message: `step "${step.id}": awaitInput requires the resume channel, which is not available in this build \u2014 a paused run would hang forever. Remove awaitInput (gather the input via an \`inputs\` field or a normal prompt step instead).`,
+      message: `step "${step.id}": awaitInput is only allowed on prompt or skill steps`,
       path: ["awaitInput"]
     });
   }
@@ -142356,6 +142517,13 @@ var workflowSchema = z.object({
         path: ["steps"]
       });
     }
+    if (body.awaitInput) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: `step "${step.id}" is a loop body of "${owner}" and cannot use awaitInput \u2014 a loop body cannot pause mid-iteration. Ask the operator before/after the loop instead.`,
+        path: ["steps"]
+      });
+    }
     if (body.when != null) {
       ctx.addIssue({
         code: z.ZodIssueCode.custom,
@@ -142435,16 +142603,54 @@ function findCycle(steps) {
   }
   return null;
 }
-function formatIssues(error2) {
+function humanizeIssue(iss) {
+  switch (iss.code) {
+    case "too_small": {
+      const min = Number(iss.minimum);
+      if (iss.type === "string")
+        return min === 1 ? "must not be empty" : `must be at least ${min} characters`;
+      if (iss.type === "array")
+        return min === 1 ? "needs at least one entry" : `needs at least ${min} entries`;
+      return `must be at least ${min}`;
+    }
+    case "too_big": {
+      const max = Number(iss.maximum);
+      if (iss.type === "string")
+        return `must be at most ${max} characters`;
+      if (iss.type === "array")
+        return `can have at most ${max} entries`;
+      return `must be at most ${max}`;
+    }
+    case "invalid_type":
+      return iss.received === "undefined" ? "is required" : `should be a ${iss.expected} (got ${iss.received})`;
+    case "invalid_enum_value":
+      return `must be one of: ${iss.options.map((o2) => `"${String(o2)}"`).join(", ")}`;
+    default:
+      return iss.message;
+  }
+}
+function formatIssues(error2, raw) {
+  const steps = raw !== null && typeof raw === "object" && Array.isArray(raw.steps) ? raw.steps : [];
   return error2.issues.map((iss) => {
-    const path61 = iss.path.join(".") || "(root)";
-    return `${path61}: ${iss.message}`;
+    if (iss.code === "custom")
+      return iss.message;
+    const msg = humanizeIssue(iss);
+    const [head, idx, ...rest] = iss.path;
+    if (head === "steps" && typeof idx === "number") {
+      const step = steps[idx];
+      const id = step !== null && typeof step === "object" && typeof step.id === "string" ? step.id : "";
+      const where = id ? `step "${id}"` : `step ${idx + 1}`;
+      const field = rest.join(".");
+      return field ? `${where}: ${field} ${msg}` : `${where} ${msg}`;
+    }
+    const path61 = iss.path.join(".");
+    return path61 ? `${path61} ${msg}` : `workflow ${msg}`;
   });
 }
 function validateWorkflow(raw) {
   const parsed = workflowSchema.safeParse(raw);
   if (!parsed.success)
-    return { ok: false, errors: formatIssues(parsed.error) };
+    return { ok: false, errors: formatIssues(parsed.error, raw) };
   return { ok: true, workflow: parsed.data, errors: [] };
 }
 function parseWorkflowYaml(text) {
@@ -142800,6 +143006,7 @@ function stepsToSkipForBranch(step, selected) {
 // ../plugin-workflows/dist/executor/dag.js
 var DAG_EXECUTOR_NAME = "dag";
 var MAX_NESTING_DEPTH = 5;
+var FINALIZE_REPLY_SUFFIX = "\n\nFinalize now: consolidate the operator's answers into a clear structured response. Include every field the step instructions require. Do not ask further questions.";
 function collectLoopBodyIds(workflow) {
   const ids = /* @__PURE__ */ new Set();
   for (const step of workflow.steps) {
@@ -142876,6 +143083,19 @@ function serializeStates(states) {
   }
   return out;
 }
+function restoreStates(raw) {
+  const states = /* @__PURE__ */ new Map();
+  for (const [id, st3] of Object.entries(raw)) {
+    states.set(id, {
+      status: st3.status,
+      output: st3.output,
+      ...st3.error ? { error: st3.error } : {},
+      startedAt: st3.startedAt,
+      endedAt: st3.endedAt
+    });
+  }
+  return states;
+}
 function buildStepResults(workflow, states) {
   return workflow.steps.map((step) => {
     const st3 = states.get(step.id);
@@ -143005,7 +143225,13 @@ async function runExecutorLoop(ctx) {
         await deps.emit?.("workflow_paused", {
           runId,
           stepId: step.id,
-          childSessionId: outcome.interactionAgentId
+          childSessionId: outcome.interactionAgentId,
+          // Carry the human-facing question so the operator UI is self-contained
+          // (no separate event correlation needed): the workflow name, the step
+          // label, and the prompt/question the paused step asked.
+          workflow: workflow.name,
+          label: step.label ?? step.id,
+          prompt: outcome.output.slice(0, 2e3)
         });
         return buildRunResult(ctx, "paused", true, {
           runId,
@@ -143062,6 +143288,78 @@ async function runExecutor(workflow, deps) {
   }
   return runExecutorLoop(ctx);
 }
+async function resumeWorkflowRun(runId, userMessage, deps, store = defaultWorkflowRunStore) {
+  const checkpoint = await store.load(runId);
+  if (!checkpoint) {
+    return {
+      ok: false,
+      status: "failed",
+      steps: [],
+      output: "",
+      error: `no paused workflow run "${runId}"`
+    };
+  }
+  const depsWithStore = { ...deps, runStore: store };
+  const step = checkpoint.workflow.steps.find((s2) => s2.id === checkpoint.pendingStepId);
+  if (!step) {
+    return {
+      ok: false,
+      status: "failed",
+      steps: buildStepResults(checkpoint.workflow, restoreStates(checkpoint.states)),
+      output: "",
+      error: `paused step "${checkpoint.pendingStepId}" not found`
+    };
+  }
+  const restoredVars = {};
+  const ctx = {
+    workflow: checkpoint.workflow,
+    deps: depsWithStore,
+    inputs: checkpoint.inputs,
+    vars: restoredVars,
+    states: restoreStates(checkpoint.states),
+    now: nowFn(deps),
+    loopBodyIds: collectLoopBodyIds(checkpoint.workflow)
+  };
+  mergeVars(ctx, checkpoint.vars);
+  const st3 = ctx.states.get(step.id);
+  await deps.emit?.("workflow_resumed", { runId, stepId: step.id });
+  if (typeof deps.spawner.continue !== "function") {
+    st3.status = "failed";
+    st3.error = "subagent spawner does not support resume (continue)";
+    st3.endedAt = ctx.now();
+    await deps.emit?.("workflow_step_failed", { id: step.id, error: st3.error });
+    await store.remove(runId);
+    return buildRunResult(ctx, "failed", false, { error: st3.error });
+  }
+  const finalizePrompt = `Operator reply:
+${userMessage.trim()}${FINALIZE_REPLY_SUFFIX}`;
+  try {
+    const child = await deps.spawner.continue({
+      childSessionId: checkpoint.interactionAgentId,
+      prompt: finalizePrompt,
+      label: step.label ?? step.id
+    });
+    if (child.error)
+      throw new Error(child.error.message);
+    st3.status = "completed";
+    st3.output = child.text;
+    st3.endedAt = ctx.now();
+    await deps.emit?.("workflow_step_completed", {
+      id: step.id,
+      preview: child.text.slice(0, 280)
+    });
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    st3.status = "failed";
+    st3.error = message;
+    st3.endedAt = ctx.now();
+    await deps.emit?.("workflow_step_failed", { id: step.id, error: message });
+    await store.remove(runId);
+    return buildRunResult(ctx, "failed", false, { error: message });
+  }
+  await store.remove(runId);
+  return runExecutorLoop(ctx);
+}
 function sinkOutput(workflow, states) {
   const needed = /* @__PURE__ */ new Set();
   for (const step of workflow.steps)
@@ -143414,7 +143712,7 @@ A workflow is a DAG of steps. Schema:
     - when (optional, legacy): simple guards only \u2014 '{{ steps.x.output }} is not empty'. Do NOT use when for semantic decisions (use condition/switch).
     - onError (optional): fail | continue | retry ; retries (optional, 0-3)
 
-IMPORTANT \u2014 no mid-run questions: this build has NO chat-resume channel, so a workflow CANNOT pause to ask the operator something mid-run (\`awaitInput\` is rejected at save time). For any value the operator must supply, declare it as an \`inputs\` field (the operator fills it in before Run); never try to "ask in chat".
+Operator data \u2014 two ways: declare a value the operator can supply UP FRONT as an \`inputs\` field (filled in before Run). To PAUSE mid-run and ask a question whose answer depends on earlier steps, set \`awaitInput: true\` on a prompt or skill step: the workflow pauses, surfaces the step's prompt to the operator, and resumes with their reply once they answer. Prefer \`inputs\` for known-up-front values; use \`awaitInput\` only for genuinely mid-run questions.
 
 Templating: {{ steps.<id>.output }}, {{ inputs.<name> }}, {{ vars.<name> }}, {{ trigger }}, {{ now }}.
 
@@ -143424,8 +143722,8 @@ Ordering: steps whose \`needs\` are all satisfied run in parallel \u2014 chain w
 
 Authoring rules:
 1. Decompose the intent into concrete steps. Multi-phase requests (collect \u2192 act \u2192 summarize \u2192 deliver) need at least 4 steps with a linear or fan-in \`needs\` chain.
-2. Values the operator must supply (search topic, recipient email, brief): declare each as an \`inputs\` field with a clear \`description\` (and a \`default\` when sensible). The operator fills them in before Run; reference them downstream via \`{{ inputs.<name> }}\`. There is NO way to pause and ask mid-run.
-3. Never use \`awaitInput\` \u2014 it is rejected at save time in this build (no resume channel). Do NOT add a prompt/skill step that only says "ask the operator"; that finishes in one turn and just stores the question as output. Use \`inputs\` instead.
+2. Values the operator must supply (search topic, recipient email, brief): declare each as an \`inputs\` field with a clear \`description\` (and a \`default\` when sensible). The operator fills them in before Run; reference them downstream via \`{{ inputs.<name> }}\`.
+3. To ask the operator a mid-run question whose answer depends on earlier steps, set \`awaitInput: true\` on a prompt or skill step \u2014 the run pauses, shows that step's prompt to the operator, and continues with their reply (referenced downstream via \`{{ steps.<id>.output }}\`). awaitInput is ONLY valid on prompt/skill steps (never tool/logic/loop or a loop body). Prefer \`inputs\` for values known before Run.
 4. Research + report + email intents: typical chain \u2014 \`web-research\` skill (over \`{{ inputs.topic }}\`) \u2192 \`write_report\` \u2192 \`send_email\` tool (to \`{{ inputs.recipient }}\`). Put \`topic\` and \`recipient\` in \`inputs\`.
 5. Use ONLY skill/tool names from the catalogs below \u2014 never placeholders like "<< skill-name >>", "TBD", or empty skill/tool fields.
 6. Prefer a listed skill when its description fits; otherwise use a detailed \`prompt\` step.
@@ -143541,6 +143839,31 @@ steps:
       Improve the current draft (start from {{ steps.first_draft.output }} or {{ vars.draft }}).
       Return JSON with vars.draft set to the improved text.
 \`\`\`
+
+Example shape for a mid-run question (awaitInput pause \u2192 operator reply \u2192 continue):
+\`\`\`yaml
+name: draft-with-approval
+description: Draft an announcement, ask the operator to approve or tweak it, then publish.
+enabled: true
+steps:
+  - id: draft
+    label: Draft announcement
+    prompt: |
+      Write a short product announcement.
+  - id: approve
+    needs: [draft]
+    label: Approve or tweak
+    awaitInput: true
+    prompt: |
+      Here is the draft announcement:
+      {{ steps.draft.output }}
+      Reply with "ship it" to approve, or describe any changes you want.
+  - id: publish
+    needs: [approve]
+    label: Publish
+    prompt: |
+      Apply the operator's decision ({{ steps.approve.output }}) and produce the final announcement.
+\`\`\`
 (Replace skill/tool names with ones from the catalog when drafting.)`;
 }
 function formatCatalog(entries, emptyLabel) {
@@ -144195,6 +144518,49 @@ function buildWorkflowsIntegration(args) {
       inFlight.delete(input.name);
     }
   }
+  async function resumeNow(runId, reply2) {
+    const checkpoint = await defaultWorkflowRunStore.load(runId);
+    const turnId = session.startTurn().turnId;
+    const spawner = createSubagentSpawner({
+      parentSession: session,
+      parentTurnId: turnId,
+      parentSignal: session.signal,
+      parentModel: activeModel(session)
+    });
+    const result = await resumeWorkflowRun(
+      runId,
+      reply2,
+      {
+        spawner,
+        tools: session.tools,
+        lookup: {
+          skill: (n2) => session.skills.byName(n2),
+          workflow: (n2) => store.lookup(n2)
+        },
+        signal: session.signal,
+        now: () => Date.now(),
+        emit: (subtype, payload) => void session.log.append({
+          type: "plugin_event",
+          sessionId: session.id,
+          turnId,
+          source: "plugin",
+          pluginId: PLUGIN_ID3,
+          subtype,
+          payload
+        }),
+        ...logger ? { logger } : {}
+      },
+      defaultWorkflowRunStore
+    );
+    if (result.status === "paused") {
+      logger?.warn?.("workflows: run paused again awaiting operator input; not delivering to inbox", {
+        runId: result.runId
+      });
+      return result;
+    }
+    if (checkpoint?.workflow) await deliverToInbox(checkpoint.workflow, result, logger);
+    return result;
+  }
   const view = {
     list: async () => (await store.list()).map((w4) => ({
       name: w4.workflow.name,
@@ -144214,7 +144580,9 @@ function buildWorkflowsIntegration(args) {
         ok: r2.ok,
         output: r2.output,
         ...r2.error ? { error: r2.error } : {},
-        steps: r2.steps.map((s2) => ({ id: s2.id, status: s2.status, ...s2.error ? { error: s2.error } : {} }))
+        steps: r2.steps.map((s2) => ({ id: s2.id, status: s2.status, ...s2.error ? { error: s2.error } : {} })),
+        status: r2.status,
+        ...r2.runId ? { runId: r2.runId } : {}
       };
     },
     // Builder-facing additions (phase 2 GUI): validate a draft YAML, persist a
@@ -144242,6 +144610,18 @@ function buildWorkflowsIntegration(args) {
         path: entry.path,
         yaml: serializeWorkflow(entry.workflow)
       };
+    },
+    // Human-in-the-loop: answer a paused run's awaitInput question and resume.
+    resume: async (runId, reply2) => {
+      const r2 = await resumeNow(runId, reply2);
+      return {
+        ok: r2.ok,
+        output: r2.output,
+        ...r2.error ? { error: r2.error } : {},
+        steps: r2.steps.map((s2) => ({ id: s2.id, status: s2.status, ...s2.error ? { error: s2.error } : {} })),
+        status: r2.status,
+        ...r2.runId ? { runId: r2.runId } : {}
+      };
     }
   };
   async function syncSchedules() {