@falai/agent 4.0.0-alpha.8 → 4.0.0

package/dist/core/Runner.js

@@ -7,8 +7,7 @@
  *
  *   begin ─▶ understandRequest ─(Understand)─▶ decide ─▶ advance ─(Speak)─▶ settle ─▶ finish
  */
-import { cloneDeep } from "../utils/clone.js";
-import { parseDuration } from "../utils/duration.js";
+import { isDuration, parseDuration } from "../utils/duration.js";
 import { OUTCOME_MESSAGES } from "../utils/outcomes.js";
 import { coerceField, DEFAULT_MAX_ASKS, extractMode, isKnown, pendingFields } from "../utils/schema.js";
 import { render, renderDeep } from "../utils/template.js";
@@ -64,6 +63,15 @@ function defaultRepeat(kind) {
 function talkKind(step) {
     return step.collect?.length ? "collect" : "prompt";
 }
+/** Everything a flow collects: its own `collect`, then each talk step's, once each. */
+function flowFields(flow) {
+    const fields = new Set(flow.collect);
+    for (const step of flow.steps)
+        if (isTalk(step))
+            for (const field of step.collect ?? [])
+                fields.add(field);
+    return [...fields];
+}
 function kindOf(step) {
     if (!step)
         return "if";
@@ -100,16 +108,29 @@ export class Runner {
     }
     // ── Load + Ingest ─────────────────────────────────────────────────────
     begin(input) {
-        const now = (this.options.clock ?? (() => new Date()))();
+        const now = this.now();
+        const turn = this.open(input, describe(input, now.toISOString()), now);
+        if (turn.what.kind === "wake" && !input.session) {
+            this.ignore(turn, "no-session", turn.what.key);
+            return turn;
+        }
+        turn.ingesting = true;
+        this.ingest(turn);
+        turn.ingesting = false;
+        return turn;
+    }
+    now() {
+        return (this.options.clock ?? (() => new Date()))();
+    }
+    open(input, what, now) {
         const nowIso = now.toISOString();
-        const what = describe(input, nowIso);
         const silenced = typeof input.silenced === "string" ? input.silenced : input.silenced?.reason;
-        const turn = {
+        return {
             input,
             what,
             kind: what.kind,
             triggerKey: what.kind === "message" ? (what.id ?? what.at) : what.key,
-            session: input.session ? cloneDeep(input.session) : freshSession(input.sessionId),
+            session: input.session ? structuredClone(input.session) : freshSession(input.sessionId),
             original: input.session,
             now,
             nowIso,
@@ -117,6 +138,7 @@ export class Runner {
             context: input.context,
             silenced,
             understandAllowed: typeof input.silenced === "object" && input.silenced.understand === true,
+            skipSilenced: typeof input.silenced === "object" && input.silenced.skip === true,
             ignored: false,
             messages: [],
             schedule: [],
@@ -133,14 +155,14 @@ export class Runner {
             speakDone: false,
             queue: [],
         };
-        if (what.kind === "wake" && !input.session) {
-            this.ignore(turn, "no-session", what.key);
-            return turn;
-        }
-        turn.ingesting = true;
-        this.ingest(turn);
-        turn.ingesting = false;
-        return turn;
+    }
+    /** Every wake the session waits on: each parked run's own, then each silence flow's since the assistant last spoke. */
+    pendingWakes(input) {
+        // No input arrives, so nothing reads `what`: the inert wake shape only fills the field.
+        const turn = this.open({ ...input, sessionId: input.session.id }, { kind: "wake", key: "" }, this.now());
+        // `park` always sets both; the type leaves them optional, so a hand-built blob without them has no wake to give.
+        const parked = turn.session.runs.flatMap(({ status, waiting }) => status === "waiting" && waiting?.key && waiting.until ? [{ key: waiting.key, at: new Date(waiting.until) }] : []);
+        return [...parked, ...this.silenceWakes(turn)];
     }
     ingest(turn) {
         const { what, session } = turn;
@@ -221,6 +243,9 @@ export class Runner {
             const branch = step.branches?.find((b) => "if" in b && this.holds(b.if, turn, run));
             const target = branch ? branch.then : step.else;
             this.outcome(turn, run, { kind: "wait", status: "ok", code: "replied", next: nextLabel(target) });
+            // The reply is this run's while it moves, so a stay it reaches answers it.
+            if (!turn.floorFromIngest)
+                turn.floorRunId = run.id;
             this.follow(turn, run, flow, step, target);
             this.takeFloor(turn, run);
         }
@@ -260,8 +285,10 @@ export class Runner {
     /** `silence:<flowId>:<sessionId>:<lastAssistantAtMs>`, honoured only while the blob still shows that silence. */
     silenceWake(turn, key) {
         const rest = key.slice("silence:".length);
-        const flowId = rest.slice(0, rest.indexOf(":"));
         const ms = Number(rest.slice(rest.lastIndexOf(":") + 1));
+        // A flow id may hold a ":" itself, so cut at the session id rather than at the first ":".
+        const cut = rest.lastIndexOf(`:${turn.session.id}:`);
+        const flowId = rest.slice(0, cut === -1 ? rest.indexOf(":") : cut);
         const { lastAssistantAt } = turn.session;
         const flow = this.flows.get(flowId);
         if (!flow) {
@@ -316,13 +343,9 @@ export class Runner {
         };
         if (opts.trigger?.if && !this.holds(opts.trigger.if, turn, run))
             return null;
-        const heldAt = this.claimAt(turn, dedupeKey);
-        if (heldAt !== undefined) {
-            if (typeof repeat === "string")
-                return skip("already-claimed");
-            if (turn.now.getTime() - Date.parse(heldAt) < parseDuration(repeat.cooldown))
-                return skip("cooldown");
-        }
+        const blocked = this.repeatBlocks(turn, dedupeKey, repeat);
+        if (blocked)
+            return skip(blocked);
         if (hop >= MAX_HOP)
             return skip("hop-limit");
         const live = session.runs.find((r) => r.flowId === flow.id && r.anchor === anchor);
@@ -345,9 +368,11 @@ export class Runner {
         }
         session.runs.push(run);
         turn.started.push({ runId: run.id, flowId: flow.id, anchor, dedupeKey });
-        const after = opts.trigger && "event" in opts.trigger ? opts.trigger.after : undefined;
-        if (after) {
-            const at = this.snap(turn, new Date(turn.now.getTime() + parseDuration(after)), opts.trigger && "event" in opts.trigger ? opts.trigger.businessHours : undefined);
+        const eventTrigger = opts.trigger && "event" in opts.trigger ? opts.trigger : undefined;
+        const after = eventTrigger?.after;
+        const at = this.snap(turn, new Date(turn.now.getTime() + (after ? parseDuration(after) : 0)), eventTrigger?.businessHours);
+        // With no `after`, only a closed hour parks the start: inside working hours the snap returns now.
+        if (after || at.getTime() > turn.now.getTime()) {
             this.park(turn, run, { kind: "timer", key: `${run.id}:start:${at.getTime()}` }, at);
             this.outcome(turn, run, { kind: "wait", status: "waiting", code: "awaiting-trigger", until: at.toISOString() });
         }
@@ -369,12 +394,16 @@ export class Runner {
     }
     repeatAllows(turn, flow, trigger, key) {
         const repeat = trigger.repeat ?? defaultRepeat(triggerKind(trigger));
-        const heldAt = this.claimAt(turn, `${flow.id}:${this.anchorOf(turn, flow)}:${repeat === "always" ? key : ""}`);
+        return !this.repeatBlocks(turn, `${flow.id}:${this.anchorOf(turn, flow)}:${repeat === "always" ? key : ""}`, repeat);
+    }
+    /** Why the claim already on `dedupeKey` stops another start, or nothing when there is none or its cooldown has run out. */
+    repeatBlocks(turn, dedupeKey, repeat) {
+        const heldAt = this.claimAt(turn, dedupeKey);
         if (heldAt === undefined)
-            return true;
+            return undefined;
         if (typeof repeat === "string")
-            return false;
-        return turn.now.getTime() - Date.parse(heldAt) >= parseDuration(repeat.cooldown);
+            return "already-claimed";
+        return turn.now.getTime() - Date.parse(heldAt) < parseDuration(repeat.cooldown) ? "cooldown" : undefined;
     }
     /** A run as it would be if started now, for trigger-level predicates. */
     draftRun(turn, flow, kind, key, payload) {
@@ -450,20 +479,31 @@ export class Runner {
         }
         const fields = {};
         const data = turn.session.data;
+        const harvestable = (field) => {
+            const def = this.options.fields[field];
+            return def !== undefined && !isKnown(data[field]) && extractMode(def) === "anywhere";
+        };
         for (const flow of [...(floorFlow ? [floorFlow] : []), ...eligible]) {
-            for (const step of flow.steps) {
-                if (!isTalk(step))
-                    continue;
-                for (const field of step.collect ?? []) {
-                    const def = this.options.fields[field];
-                    if (def && !isKnown(data[field]) && extractMode(def) === "anywhere")
-                        fields[field] = def;
-                }
-            }
+            for (const field of flowFields(flow).filter(harvestable))
+                fields[field] = this.options.fields[field];
         }
-        if (!messageFlows.length && !mentionFlows.length && !branches.length && !Object.keys(fields).length)
+        const judging = messageFlows.length > 0 || mentionFlows.length > 0 || branches.length > 0 || Object.keys(fields).length > 0;
+        // With nobody on the floor the catch-all may take this message, and an opening message often says the most. The
+        // fields its first step asks ride on that step's speak call, so alone they spend no call; a fixed question has no speak call.
+        // ponytail: "first step" is steps[0]; a catch-all that opens with a say or an if pays the call for that step's fields too.
+        const fallback = floorRun ? undefined : this.messageFlows(turn, (list) => list.length === 0)[0];
+        if (fallback) {
+            const first = fallback.steps[0];
+            const free = new Set(first && isTalk(first) && first.question === undefined ? first.collect : []);
+            const own = flowFields(fallback).filter(harvestable);
+            if (judging || own.some((field) => !free.has(field)))
+                for (const field of own)
+                    fields[field] = this.options.fields[field];
+        }
+        if (!judging && !Object.keys(fields).length)
             return null;
         return {
+            sessionId: turn.session.id,
             text: turn.what.text,
             history: this.historyOf(turn),
             context: turn.context,
@@ -527,6 +567,8 @@ export class Runner {
             return;
         turn.llmCalls += understanding?.llmCalls ?? 0;
         turn.usage = addUsage(turn.usage, understanding?.usage);
+        if (understanding?.asks !== undefined)
+            turn.asks = understanding.asks;
         const key = turn.triggerKey;
         const asker = this.asker(turn);
         // Routing is decided before extraction lands so `clearOnStart` runs first, and applied after mention runs.
@@ -570,6 +612,9 @@ export class Runner {
                     turn.floorRunId = run.id;
             }
         }
+        // Unless routing or Ingest moved it, the message is the asker's: written down, so a chain beside it cannot take it.
+        if (asker && !route && !turn.floorFromIngest)
+            turn.floorRunId = asker.id;
         for (const [field, raw] of Object.entries(understanding?.fields ?? {}))
             this.writeField(turn, field, raw);
         if (asker && turn.session.runs.includes(asker) && asker.status === "asking") {
@@ -580,7 +625,13 @@ export class Runner {
         }
     }
     fireBranch(turn, run, flow, step, understanding) {
-        const hit = (branch, index) => "if" in branch ? this.holds(branch.if, turn, run) : understanding?.branches[`${run.id}/${step.id}/${index}`] === true;
+        // Staying, a run does not take an `if` branch back onto a path it has already run: the fact it tests is still true,
+        // so it would re-run that path on every message. A `when` branch is judged on each new message and always counts.
+        // ponytail: "already run" is the target's visit count, so an `if` restart (`{ step, clear }` to a visited step) never fires while staying; write it as a `when`.
+        const ran = (then) => typeof then === "string" ? then === "end" || (run.visits[then] ?? 0) > 0 : "step" in then && (run.visits[then.step] ?? 0) > 0;
+        const hit = (branch, index) => "if" in branch
+            ? !(run.staying && ran(branch.then)) && this.holds(branch.if, turn, run)
+            : understanding?.branches[`${run.id}/${step.id}/${index}`] === true;
         const index = (step.branches ?? []).findIndex(hit);
         if (index < 0)
             return;
@@ -610,10 +661,64 @@ export class Runner {
     async advance(turn) {
         if (turn.ignored)
             return null;
-        this.resumeSuspended(turn);
+        this.resume(turn);
         turn.queue = [...turn.session.runs];
         await this.drain(turn);
-        return this.speaker(turn);
+        // An asker that moved on without a word hands the message to the run it suspended, and that one to the next.
+        // Each pass takes a run off the suspended stack, so the stack's size bounds the loop.
+        for (let left = turn.session.runs.length; left > 0; left--) {
+            if (turn.what.kind !== "message" || turn.silenced !== undefined || turn.talk || turn.spokeBy.size > 0)
+                break;
+            const resumed = this.resume(turn);
+            if (!resumed)
+                break;
+            turn.queue.push(resumed);
+            await this.drain(turn);
+        }
+        const speaker = this.speaker(turn);
+        if (!speaker || "idle" in speaker || !this.fixedDue(speaker))
+            return speaker;
+        // A question the lead asked gets its answer: the step speaks once, answering it and asking the fixed question.
+        // Appending the text word for word after an answer could repeat or contradict it. Unjudged counts as asked,
+        // and so does the retry of a failed answer: a question sent over the lead's own drops it.
+        const answerFirst = turn.what.kind === "message" ? turn.asks !== false : this.retrying(speaker);
+        if (answerFirst && speaker.step.question !== undefined) {
+            speaker.fixedQuestion = render(speaker.step.question, this.scope(turn, speaker.run));
+            return speaker;
+        }
+        this.askFixed(turn, speaker);
+        turn.talk = undefined;
+        return null;
+    }
+    /** The step failed at the provider and runs again on its retry wake: deferTalk left `deferred` as its last line. */
+    retrying({ run, step }) {
+        const last = run.outcomes.at(-1);
+        return last?.status === "deferred" && last.stepId === step.id;
+    }
+    /**
+     * The step's fixed question is due: this is its first ask, with every field it collects still unknown and none asked
+     * yet, and the run is not staying (a staying run answers the lead). Otherwise the AI phrases the ask.
+     */
+    fixedDue({ run, step, pending }) {
+        const { question, collect = [] } = step;
+        if (question === undefined || run.staying)
+            return false;
+        return pending.length === collect.length && pending.every((field) => (run.asked[field] ?? 0) === 0);
+    }
+    /** Send the step's fixed question when it is due. It counts as one ask of each field. */
+    askFixed(turn, talk) {
+        const { run, step, pending } = talk;
+        if (!this.fixedDue(talk) || step.question === undefined)
+            return false;
+        const key = this.stepKey(run, step);
+        turn.messages.push({ text: render(step.question, this.scope(turn, run)), kind: "verbatim", afterMs: turn.afterMs, key, runId: run.id, stepId: step.id });
+        turn.afterMs = 0;
+        turn.spokeBy.add(run.id);
+        turn.spoke = true;
+        for (const field of pending)
+            run.asked[field] = (run.asked[field] ?? 0) + 1;
+        this.outcome(turn, run, { kind: "collect", status: "ok", key, code: "asked-fixed", stepId: step.id });
+        return true;
     }
     /**
      * Everything Speak needs for this turn's one speaker. Instructions are agent,
@@ -636,12 +741,15 @@ export class Runner {
         const instructions = [...(this.options.instructions ?? []), ...own.instructions].filter((ins) => !ins.if || evaluate(ins.if, ctx, conditions));
         const all = this.options.tools ?? [];
         const allowed = own.tools;
+        const retry = !("idle" in talk) && this.retrying(talk);
         return {
+            sessionId: turn.session.id,
             talk,
-            input: turn.what.kind === "message" ? { kind: turn.kind, text: turn.what.text } : { kind: turn.kind },
+            input: turn.what.kind === "message" ? { kind: turn.kind, text: turn.what.text } : { kind: turn.kind, ...(retry ? { retry } : {}) },
             context: turn.context,
             data: turn.session.data,
             history: this.historyOf(turn),
+            said: [...turn.messages],
             now: turn.now,
             instructions,
             tools: allowed ? all.filter((tool) => allowed.includes(tool.id)) : all,
@@ -684,6 +792,11 @@ export class Runner {
         }
         if (!this.premiseHolds(turn, run, flow))
             return;
+        // The flow was edited off 'stay' after this run finished its steps: its new `onEnd` decides now.
+        if (run.staying && flow.onEnd !== "stay") {
+            this.finishFlow(turn, run, flow);
+            return;
+        }
         const resuming = run.status === "asking";
         run.status = "running";
         if (run.stepId === null) {
@@ -726,6 +839,11 @@ export class Runner {
             this.endRun(turn, run, "skipped", "premise-changed");
         return ok;
     }
+    /** `silenced: { skip: true }`: the message this step would send is dropped, and the run takes `then` as if it had gone out. */
+    skipSilenced(turn, run, flow, step, kind) {
+        this.outcome(turn, run, { kind, status: "skipped", key: this.stepKey(run, step), code: "silenced", detail: turn.silenced, next: nextLabel(step.then) });
+        this.follow(turn, run, flow, step, step.then);
+    }
     async execute(turn, run, flow, step, resuming) {
         const data = turn.session.data;
         const key = this.stepKey(run, step);
@@ -734,7 +852,9 @@ export class Runner {
             let pending = [];
             if (step.collect?.length) {
                 pending = pendingFields(step, data, run.asked);
-                if (!pending.length) {
+                // A `stay` run answers even with nothing left to collect: answering is what it stays for. It only runs on a message
+                // (asking runs sit out wakes and events), and on a silenced one the check below keeps it asking.
+                if (!pending.length && !run.staying) {
                     this.reportMaxAsks(turn, run, step);
                     this.outcome(turn, run, resuming
                         ? { kind, status: "ok", key, next: nextLabel(step.then) }
@@ -746,6 +866,8 @@ export class Runner {
             if (turn.silenced !== undefined) {
                 if (resuming)
                     run.status = "asking"; // the gate is closed; it speaks when the gate opens
+                else if (turn.skipSilenced)
+                    this.skipSilenced(turn, run, flow, step, kind);
                 else
                     this.endRun(turn, run, "skipped", "silenced", kind, turn.silenced);
                 return;
@@ -757,13 +879,19 @@ export class Runner {
                 }
             }
             run.status = "asking";
+            // Reached after Speak (settle's drain), a talk step waits for the next message; a fixed question costs no call, so it goes out now, as a say would.
             if (!turn.speakDone)
                 turn.talk = { run, flow, step, pending };
+            else
+                this.askFixed(turn, { run, flow, step, pending });
             return;
         }
         if (isSay(step)) {
             if (turn.silenced !== undefined) {
-                this.endRun(turn, run, "skipped", "silenced", "say", turn.silenced);
+                if (turn.skipSilenced)
+                    this.skipSilenced(turn, run, flow, step, "say");
+                else
+                    this.endRun(turn, run, "skipped", "silenced", "say", turn.silenced);
                 return;
             }
             if (step.once) {
@@ -810,6 +938,13 @@ export class Runner {
                     result = { failed: error instanceof Error ? error.message : String(error) };
                 }
             }
+            // The handler already ran, so a defer that cannot be parsed must not throw
+            // the turn: every replay would repeat the side effect and fail again.
+            if ("defer" in result && !isDuration(String(result.defer))) {
+                result = {
+                    failed: `action "${step.do}" asked to defer by "${String(result.defer)}", which is not a duration. Use a value like "2m" or "1h".`,
+                };
+            }
             if ("ok" in result) {
                 if (result.spoke) {
                     turn.spokeBy.add(run.id);
@@ -901,18 +1036,21 @@ export class Runner {
         }
         if ("step" in target) {
             const data = turn.session.data;
-            for (const field of target.clear ?? [])
+            // Forgetting a field means asking for it from scratch: its ask count goes too, so a fixed question goes out again.
+            for (const field of target.clear ?? []) {
                 delete data[field];
+                delete run.asked[field];
+            }
             this.jump(turn, run, flow, target.step);
             return;
         }
         const childId = render(target.flow, this.scope(turn, run));
         const key = this.stepKey(run, step);
         this.endRun(turn, run, "flow");
-        this.chain(turn, childId, key, target.input ?? run.input, run.hop + 1);
+        this.chain(turn, run, childId, key, target.input ?? run.input, run.hop + 1);
     }
-    /** Start a child flow that holds the floor and moves in this same phase. */
-    chain(turn, flowId, key, input, hop, keepData = false) {
+    /** Start a child flow that moves in this same phase. It inherits the floor when its parent held it, or when nobody did. */
+    chain(turn, parent, flowId, key, input, hop, keepData = false) {
         const child = this.flows.get(flowId);
         if (!child) {
             turn.skipped.push({ flowId, anchor: turn.session.id, triggerKey: key, code: "flow-gone", message: OUTCOME_MESSAGES["flow-gone"] });
@@ -921,9 +1059,11 @@ export class Runner {
         const run = this.startRun(turn, child, "flow", key, { payload: input, hop, keepData });
         if (!run)
             return;
-        turn.floorRunId = run.id;
-        if (turn.ingesting)
-            turn.floorFromIngest = true;
+        if (turn.floorRunId === undefined || turn.floorRunId === parent.id) {
+            turn.floorRunId = run.id;
+            if (turn.ingesting)
+                turn.floorFromIngest = true;
+        }
         turn.queue.push(run);
     }
     jump(turn, run, flow, stepId) {
@@ -938,14 +1078,54 @@ export class Runner {
         run.visits[stepId] = (run.visits[stepId] ?? 0) + 1;
         run.status = "running";
         delete run.waiting;
+        delete run.staying;
+    }
+    /** `onEnd: 'stay'`: the run sits on its last talk step and answers every message from there, each answer a new visit and so a new key. */
+    stayAt(run, step) {
+        this.enter(run, step.id);
+        run.staying = true;
+        run.status = "asking";
+    }
+    /**
+     * Where `stay` answers from: the talk step this run last took, so a branched flow stays on its own path. The flow's last talk step when the log names none.
+     * ponytail: read back from `run.outcomes`, which keeps 50 lines; a tail of 50+ lines after the talk step (a long polling loop) loses it and the run
+     * stays on the flow's last talk step. Upgrade: record the talk step on the run when it talks.
+     */
+    stayStep(run, flow) {
+        for (let i = run.outcomes.length - 1; i >= 0; i--) {
+            const { kind, stepId } = run.outcomes[i];
+            const step = kind === "prompt" || kind === "collect" ? this.stepOf(flow, stepId ?? null) : undefined;
+            if (step && isTalk(step))
+                return step;
+        }
+        return [...flow.steps].reverse().find(isTalk);
     }
     finishFlow(turn, run, flow) {
         const onEnd = flow.onEnd ?? "end";
         const last = flow.steps[flow.steps.length - 1];
-        if (onEnd === "stay" && last) {
-            // "repete o último passo": the run stays live at its last step, re-entered so the repetition mints a new key, and runs it on the next message.
-            this.enter(run, last.id);
-            run.status = "asking";
+        const stay = onEnd === "stay" ? this.stayStep(run, flow) : undefined;
+        if (stay) {
+            // The steps after it ran once, on the way here; staying, it only answers.
+            this.stayAt(run, stay);
+            // One asker at a time. A run the lead's message went to holds the conversation and suspends the other asker;
+            // any other run waits behind that asker and resumes when it is done.
+            const others = turn.session.runs.filter((r) => r !== run && r.status === "asking");
+            if (others.length && !(turn.what.kind === "message" && turn.floorRunId === run.id)) {
+                run.status = "suspended";
+                run.suspendedAt = turn.nowIso;
+                return;
+            }
+            for (const other of others) {
+                other.status = "suspended";
+                other.suspendedAt = turn.nowIso;
+                if (turn.talk?.run === other)
+                    turn.talk = undefined;
+            }
+            // A message nothing has answered yet gets its answer now. Reached in Ingest, the run stays asking: Decide judges its
+            // branches as the asker's, and it answers when it moves.
+            if (!turn.ingesting && turn.what.kind === "message" && turn.silenced === undefined && !turn.speakDone && turn.spokeBy.size === 0) {
+                run.status = "running";
+            }
             return;
         }
         if (onEnd === "reset" && last) {
@@ -953,7 +1133,7 @@ export class Runner {
             // It is a chain into itself, so it costs a hop: a code-only flow that resets forever stops at the hop cap instead of spinning.
             const key = this.stepKey(run, last);
             this.endRun(turn, run, "reset");
-            this.chain(turn, flow.id, key, run.input, run.hop + 1, true);
+            this.chain(turn, run, flow.id, key, run.input, run.hop + 1, true);
             return;
         }
         this.endRun(turn, run, "end");
@@ -975,10 +1155,21 @@ export class Runner {
         run.waiting = { ...waiting, until: at.toISOString(), setAt: turn.nowIso };
         turn.schedule.push({ key: waiting.key, at });
     }
+    /** `resumeSuspended`, and on a message the resumed run's `if` branches are judged before it speaks, as the asker's are in Decide. */
+    resume(turn) {
+        const run = this.resumeSuspended(turn);
+        if (run && turn.what.kind === "message") {
+            const flow = this.flows.get(run.flowId);
+            const step = flow && this.stepOf(flow, run.stepId);
+            if (flow && step && isTalk(step))
+                this.fireBranch(turn, run, flow, step, null);
+        }
+        return run;
+    }
     /** When nobody asks, the most recently suspended run returns to asking. */
     resumeSuspended(turn) {
         if (this.asker(turn))
-            return;
+            return undefined;
         const suspendedAt = (r) => r.suspendedAt ?? r.startedAt;
         const next = turn.session.runs
             .filter((r) => r.status === "suspended")
@@ -987,6 +1178,7 @@ export class Runner {
             next.status = "asking";
             delete next.suspendedAt;
         }
+        return next;
     }
     // ── Settle: the one applier after Speak (design §4.7) ─────────────────
     async settle(turn, outcome) {
@@ -1038,19 +1230,28 @@ export class Runner {
         for (const [field, raw] of Object.entries(spoken.fields))
             this.writeField(turn, field, raw);
         Object.assign(turn.session.data, spoken.data);
-        this.outcome(turn, run, { kind: talkKind(step), status: "ok", key, llmCalls: spoken.llmCalls, stepId: step.id });
+        const fixed = talk.fixedQuestion !== undefined ? { code: "fixed-in-reply" } : {};
+        this.outcome(turn, run, { kind: talkKind(step), status: "ok", key, llmCalls: spoken.llmCalls, stepId: step.id, ...fixed });
         if (!turn.session.runs.includes(run))
             return;
-        if (step.collect?.length) {
-            const pending = pendingFields(step, turn.session.data, run.asked);
-            if (pending.length) {
-                for (const field of pending)
-                    run.asked[field] = (run.asked[field] ?? 0) + 1;
-                run.status = "asking";
-                return;
+        const pending = step.collect?.length ? pendingFields(step, turn.session.data, run.asked) : [];
+        for (const field of pending)
+            run.asked[field] = (run.asked[field] ?? 0) + 1;
+        if (run.staying) {
+            // Each answer is a new visit, so a new key, even while a field is still pending; that field's max-asks is reported once, when it gets there.
+            const maxAsks = step.maxAsks ?? DEFAULT_MAX_ASKS;
+            for (const field of pending) {
+                if (run.asked[field] === maxAsks)
+                    this.outcome(turn, run, { kind: "collect", status: "skipped", key, code: "max-asks", detail: field });
             }
-            this.reportMaxAsks(turn, run, step);
+            this.stayAt(run, step);
+            return;
+        }
+        if (pending.length) {
+            run.status = "asking";
+            return;
         }
+        this.reportMaxAsks(turn, run, step);
         run.status = "running";
         this.follow(turn, run, flow, step, step.then);
         if (turn.session.runs.includes(run) && run.status === "running")
@@ -1087,16 +1288,23 @@ export class Runner {
         const reset = deferred.resetAtMs;
         return new Date(reset !== undefined && reset > ladder ? reset : ladder);
     }
-    /** The assistant spoke last: every silence flow passing `if` and `repeat` gets a wake. */
+    /** The assistant spoke this turn: its silence wakes replace the ones its last words set. */
     armSilence(turn) {
+        const previous = turn.original?.lastAssistantAt;
+        if (turn.session.lastAssistantAt === previous)
+            return;
+        turn.schedule.push(...this.silenceWakes(turn, previous));
+    }
+    /** The assistant spoke last: every silence flow passing `if` and `repeat` gets a wake. */
+    silenceWakes(turn, previous) {
         const { session } = turn;
         const { lastAssistantAt, lastUserAt } = session;
-        if (!lastAssistantAt || lastAssistantAt === turn.original?.lastAssistantAt)
-            return;
+        if (!lastAssistantAt)
+            return [];
         if (lastUserAt && Date.parse(lastUserAt) > Date.parse(lastAssistantAt))
-            return;
+            return [];
         const ms = Date.parse(lastAssistantAt);
-        const previous = turn.original?.lastAssistantAt;
+        const wakes = [];
         for (const flow of this.flows.values()) {
             const trigger = (flow.on ?? []).find((t) => "silence" in t);
             if (!trigger)
@@ -1107,12 +1315,13 @@ export class Runner {
             if (!this.repeatAllows(turn, flow, trigger, key))
                 continue;
             const at = this.snap(turn, new Date(ms + parseDuration(trigger.silence)), trigger.businessHours);
-            turn.schedule.push({
+            wakes.push({
                 key: `silence:${flow.id}:${session.id}:${ms}`,
                 at,
                 ...(previous ? { replaces: `silence:${flow.id}:${session.id}:${Date.parse(previous)}` } : {}),
             });
         }
+        return wakes;
     }
     // ── Return (design §4.8) ──────────────────────────────────────────────
     finish(turn) {