pi-umbra 0.2.0 → 0.3.0

package/README.md

@@ -2,25 +2,26 @@
 
 Every pi-umbra package in one install: seven dark themes, tool calls drawn as cards, a
 status footer, an input bar with the session name, a working line that names the running
-tool, and the `/umb-*` commands.
+tool, parallel read-only branches with a live panel, and the `/umb-*` commands.
 
-![Tool cards, the working line, a question from the model and the card settings](https://raw.githubusercontent.com/grknbyk/pi-umbra/main/assets/carousel.webp)
+![A one-minute tour: tool cards and diffs, the working line, a question from the model, parallel branches, the card settings and the seven themes](https://raw.githubusercontent.com/grknbyk/pi-umbra/main/assets/demo.webp)
 
 ```sh
 pi install npm:pi-umbra
 ```
 
-The nine packages ship bundled inside this one tarball. Two of them patch pi's bundle, so
-run both scripts once now and again after every pi update, then restart pi:
+The ten packages ship bundled inside this one tarball. Three of them patch pi's bundle, so
+run the three scripts once now and again after every pi update, then restart pi:
 
 ```sh
 node ~/.pi/agent/npm/node_modules/pi-umbra/node_modules/pi-umbra-shimmer/patch.mjs
 node ~/.pi/agent/npm/node_modules/pi-umbra/node_modules/pi-umbra-skill-matcher/patch.mjs
+node ~/.pi/agent/npm/node_modules/pi-umbra/node_modules/pi-umbra-subagents/patch.mjs
 ```
 
 | Package | What it adds |
 |---|---|
-| [pi-umbra-theme](https://www.npmjs.com/package/pi-umbra-theme) | seven themes, terminal background, footer, gutter, tool cards, working line |
+| [pi-umbra-theme](https://www.npmjs.com/package/pi-umbra-theme) | seven themes, terminal background, footer, gutter, tool cards, image viewer, working line |
 | [pi-umbra-inputbar](https://www.npmjs.com/package/pi-umbra-inputbar) | `❯` prompt, session name on the input border, `/umb-color` |
 | [pi-umbra-ask](https://www.npmjs.com/package/pi-umbra-ask) | a tool the model calls to ask you a question and wait |
 | [pi-umbra-shimmer](https://www.npmjs.com/package/pi-umbra-shimmer) | a wave of colour through the working line, `/umb-shimmer` |
@@ -29,6 +30,7 @@ node ~/.pi/agent/npm/node_modules/pi-umbra/node_modules/pi-umbra-skill-matcher/p
 | [pi-umbra-copy-chat](https://www.npmjs.com/package/pi-umbra-copy-chat) | `/umb-copy-chat`, the session on the clipboard |
 | [pi-umbra-preview](https://www.npmjs.com/package/pi-umbra-preview) | `/umb-preview`, render a document in the browser |
 | [pi-umbra-help](https://www.npmjs.com/package/pi-umbra-help) | `/umb-help` and `/umb-doctor` |
+| [pi-umbra-subagents](https://www.npmjs.com/package/pi-umbra-subagents) | parallel read-only pi branches with a live panel, `/umb-fan`, `/umb-loop` |
 
 Full documentation: [github.com/grknbyk/pi-umbra](https://github.com/grknbyk/pi-umbra).
 

package/node_modules/pi-umbra-help/README.md

@@ -22,6 +22,7 @@ Reports the faults that give no error of their own:
 |---|---|
 | a bundle patch is missing | after a pi update, the shimmer and the mid-sentence skill menu stop without a word |
 | two skills share a name | `~/.pi/agent/skills`, `<project>/.pi/skills` and `~/.agents/skills` are read in that order and the first copy wins, even when a later one is newer |
+| the terminal kept its own background | the theme is not shown in full; it says where to set the colour in your terminal |
 | no truecolor announced | `COLORTERM` is not set and the terminal is not a known truecolor one, so colours may band |
 | the theme is not an umbra one | only a note; everything still works |
 

package/node_modules/pi-umbra-help/checks/umbra-help.check.ts

@@ -87,6 +87,13 @@ const offTheme = diagnose(at({ theme: "dark" }));
 assert.equal(offTheme[0]!.level, "note", "another theme is a remark, not a fault");
 assert.equal(diagnose(at({ theme: "umbra-ember-ash" })).length, 0);
 
+// A background the terminal kept is reported with the terminal's own fix; one it took, or one it
+// never answered about, says nothing.
+const kept = diagnose(at({ background: { wanted: "#0b0e14", ignored: true, howTo: "VS Code: add it." } }));
+assert.equal(kept.length, 1);
+assert.match(kept[0]!.detail, /#0b0e14.*VS Code: add it\./);
+assert.equal(diagnose(at({ background: { wanted: "#0b0e14", ignored: false, howTo: "" } })).length, 0);
+
 // --- help ----------------------------------------------------------------------------------
 // Only umb- rows, sorted, with pi's own descriptions - so the list cannot drift from the commands.
 const help = renderHelp(

package/node_modules/pi-umbra-help/extensions/umbra-help.ts

@@ -38,7 +38,7 @@ export const PROBES: Probe[] = [
 		id: "loop",
 		marker: "globalThis.__piSubmit",
 		feature: "the /umb-loop resubmit",
-		without: "the loop arms itself and then never submits anything",
+		without: "/umb-loop refuses to start",
 		command: "umb-loop",
 	},
 	{
@@ -58,6 +58,8 @@ export type Facts = {
 	skillRoots: { root: string; names: string[] }[];
 	truecolor: boolean;
 	theme: string;
+	/** Set by umbra-background once the terminal has answered; absent when it never did. */
+	background?: { wanted: string; ignored: boolean; howTo: string };
 };
 
 export type Finding = { level: "warn" | "note"; title: string; detail: string };
@@ -106,6 +108,14 @@ export const diagnose = (facts: Facts): Finding[] => {
 		});
 	}
 
+	if (facts.background?.ignored) {
+		findings.push({
+			level: "warn",
+			title: "the terminal kept its own background",
+			detail: `It did not take ${facts.background.wanted}, so the theme is not shown in full. ${facts.background.howTo}`,
+		});
+	}
+
 	// A note rather than a warning: plenty of terminals handle 24-bit colour without announcing
 	// it, so this is a guess that has to earn its line rather than cry wolf on every run.
 	if (!facts.truecolor) {
@@ -208,6 +218,7 @@ export const gather = (cwd: string, theme: string, commands: Command[]): Facts =
 		skillRoots: roots.map((root) => ({ root, names: namesIn(root) })).filter((entry) => entry.names.length > 0),
 		truecolor: announcesTruecolor(process.env),
 		theme,
+		background: (globalThis as { __umbraBackground?: Facts["background"] }).__umbraBackground,
 	};
 };
 

package/node_modules/pi-umbra-help/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-umbra-help",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "description": "Two commands over the pi-umbra family: /umb-help lists what is installed and how to configure it, /umb-doctor reports the faults that would otherwise stay silent.",
   "keywords": [
     "pi-package",

package/node_modules/pi-umbra-inputbar/extensions/umbra-inputbar.ts

@@ -130,7 +130,8 @@ export class InputBar extends CustomEditor {
 		const blank = " ".repeat(gutter);
 		return lines.map((line, i) => {
 			if (i === 0 || i === shown + 1) return edge + line;
-			if (i === 1) return this.borderColor(CHEVRON) + blank.slice(1) + line;
+			// The chevron is part of what you type into, so it takes the text colour, not the border's.
+			if (i === 1) return CHEVRON + blank.slice(1) + line;
 			return blank + line;
 		});
 	}

package/node_modules/pi-umbra-inputbar/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-umbra-inputbar",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "description": "pi's input bar, rebuilt: a chevron prompt, the session name on the border, a colour you pick, and a command to rename the session.",
   "keywords": [
     "pi-package",

package/node_modules/pi-umbra-shimmer/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-umbra-shimmer",
-  "version": "0.1.4",
+  "version": "0.1.5",
   "description": "A wave of colour running through pi's working indicator, over both the spinner and the text. Needs the umbra bundle patches; without them it does nothing.",
   "keywords": [
     "pi-package",

package/node_modules/pi-umbra-shimmer/patch.mjs

@@ -10,20 +10,34 @@
 // Nothing here is destructive. Each patch is additive, a patch whose text no longer matches is
 // reported instead of forced, and reinstalling pi returns the bundle to stock. A pi upgrade
 // replaces the bundle and drops every patch silently, which is what --check is for.
+import { execSync } from "node:child_process";
 import { createRequire } from "node:module";
-import { existsSync, readdirSync, readFileSync, writeFileSync } from "node:fs";
+import { existsSync, realpathSync, readdirSync, readFileSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { dirname, join } from "node:path";
 
-// PI_UMBRA_PI points this at another pi tree. Otherwise pi is resolved from wherever this
-// package was installed, since it is a peer dependency, and the bun global path is the last resort.
+// PI_UMBRA_PI points this at another pi tree. Otherwise the pi that runs is the one to patch:
+// the `pi` on PATH, followed through its symlink. Windows puts a .cmd shim there instead, so
+// npm's global root (%APPDATA%\npm\node_modules) comes next, then bun's. The copy npm installs
+// beside this package as a peer dependency is last: pi never runs it. The first that has a built
+// bundle wins.
 const resolvePi = () => {
 	if (process.env.PI_UMBRA_PI) return process.env.PI_UMBRA_PI;
+	const quiet = { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], timeout: 20_000 };
+	const candidates = [];
 	try {
-		return dirname(createRequire(import.meta.url).resolve("@earendil-works/pi-coding-agent/package.json"));
-	} catch {
-		return join(homedir(), ".bun/install/global/node_modules/@earendil-works/pi-coding-agent");
-	}
+		const bin = execSync(process.platform === "win32" ? "where pi" : "command -v pi", quiet).split(/\r?\n/)[0].trim();
+		for (let dir = dirname(realpathSync(bin)); dir !== dirname(dir); dir = dirname(dir)) candidates.push(dir);
+	} catch {}
+	try {
+		const root = execSync("npm root -g", quiet).trim();
+		if (root) candidates.push(join(root, "@earendil-works", "pi-coding-agent"));
+	} catch {}
+	candidates.push(join(homedir(), ".bun", "install", "global", "node_modules", "@earendil-works", "pi-coding-agent"));
+	try {
+		candidates.push(dirname(createRequire(import.meta.url).resolve("@earendil-works/pi-coding-agent/package.json")));
+	} catch {}
+	return candidates.find((dir) => existsSync(join(dir, "dist", "bundle"))) ?? candidates[0];
 };
 
 const BUNDLE = join(resolvePi(), "dist/bundle");

package/node_modules/pi-umbra-skill-matcher/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-umbra-skill-matcher",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "description": "Type /huh and reach skill:huh. pi lists every skill under its bare name, which is not the name that dispatches.",
   "keywords": [
     "pi-package",

package/node_modules/pi-umbra-skill-matcher/patch.mjs

@@ -10,20 +10,34 @@
 // Nothing here is destructive. Each patch is additive, a patch whose text no longer matches is
 // reported instead of forced, and reinstalling pi returns the bundle to stock. A pi upgrade
 // replaces the bundle and drops every patch silently, which is what --check is for.
+import { execSync } from "node:child_process";
 import { createRequire } from "node:module";
-import { existsSync, readdirSync, readFileSync, writeFileSync } from "node:fs";
+import { existsSync, realpathSync, readdirSync, readFileSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { dirname, join } from "node:path";
 
-// PI_UMBRA_PI points this at another pi tree. Otherwise pi is resolved from wherever this
-// package was installed, since it is a peer dependency, and the bun global path is the last resort.
+// PI_UMBRA_PI points this at another pi tree. Otherwise the pi that runs is the one to patch:
+// the `pi` on PATH, followed through its symlink. Windows puts a .cmd shim there instead, so
+// npm's global root (%APPDATA%\npm\node_modules) comes next, then bun's. The copy npm installs
+// beside this package as a peer dependency is last: pi never runs it. The first that has a built
+// bundle wins.
 const resolvePi = () => {
 	if (process.env.PI_UMBRA_PI) return process.env.PI_UMBRA_PI;
+	const quiet = { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], timeout: 20_000 };
+	const candidates = [];
 	try {
-		return dirname(createRequire(import.meta.url).resolve("@earendil-works/pi-coding-agent/package.json"));
-	} catch {
-		return join(homedir(), ".bun/install/global/node_modules/@earendil-works/pi-coding-agent");
-	}
+		const bin = execSync(process.platform === "win32" ? "where pi" : "command -v pi", quiet).split(/\r?\n/)[0].trim();
+		for (let dir = dirname(realpathSync(bin)); dir !== dirname(dir); dir = dirname(dir)) candidates.push(dir);
+	} catch {}
+	try {
+		const root = execSync("npm root -g", quiet).trim();
+		if (root) candidates.push(join(root, "@earendil-works", "pi-coding-agent"));
+	} catch {}
+	candidates.push(join(homedir(), ".bun", "install", "global", "node_modules", "@earendil-works", "pi-coding-agent"));
+	try {
+		candidates.push(dirname(createRequire(import.meta.url).resolve("@earendil-works/pi-coding-agent/package.json")));
+	} catch {}
+	return candidates.find((dir) => existsSync(join(dir, "dist", "bundle"))) ?? candidates[0];
 };
 
 const BUNDLE = join(resolvePi(), "dist/bundle");

package/node_modules/pi-umbra-subagents/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 grkn
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/node_modules/pi-umbra-subagents/README.md

@@ -0,0 +1,101 @@
+# pi-umbra-subagents
+
+Parallel, read-only pi branches you can watch while they work. A branch is a separate `pi -p`
+process with an empty context; a live list above the input box shows what each one is doing,
+and their answers come back to the session when the last one ends. Also `/umb-loop`, which
+sends a prompt again after every reply, on a count or a timer.
+
+![Three branches running under the input box](https://raw.githubusercontent.com/grknbyk/pi-umbra/main/assets/subagents.webp)
+
+```sh
+pi install npm:pi-umbra-subagents
+node ~/.pi/agent/npm/node_modules/pi-umbra-subagents/patch.mjs
+```
+
+Restart pi after the patch. Only `/umb-loop` needs it; the branches work without it.
+
+Nothing is added to the model's prompt and no tool is registered. The model starts a run by
+ending its answer with a fenced `fan` block, which the bundled `fan` skill teaches it:
+
+````
+```fan
+name: weather-map
+desc: Map the weather API
+# Map
+routes: List every route in src/server.ts with file:line.
+upstream: List what src/forecast.ts fetches, with file:line.
+# Plan
+design: Given the Map results, propose the change.
+```
+````
+
+`# Title` starts a phase. Phases run in order; the branches inside one run at the same time.
+`label@provider/model: task` picks a model for one branch, otherwise it runs on the session's
+model. The results arrive as a follow-up message at the start of the next turn.
+
+## Commands and keys
+
+| Command or key | Effect |
+|---|---|
+| `/umb-fan [spec]` | start a run yourself; with no argument an editor opens with a template |
+| `/umb-agents`, `alt+a` | open the agent panel |
+| `↓` from the last input line | move the `❯` from `main` into the agent list under the input box |
+| `↑` `↓`, then `enter` in that list | pick an agent and open the panel on it; `↑` past the first agent or `esc` goes back |
+| `↑` `↓` in the panel | move between phases, or between the agents of one phase |
+| `→` `←` in the panel | go into a phase's agents, and back out to the phases |
+| `x` in the panel | stop the selected phase, or the selected agent |
+| `esc` in the panel | back to the input box, unsent text kept |
+| `/umb-loop [count\|duration] [prompt]` | send the prompt again after each reply; run it again to stop |
+
+`/umb-loop 5 fix the next failing test` runs five times, `/umb-loop 10m continue` for ten
+minutes, `/umb-loop 0 …` until stopped. Without a prompt it sends `Continue.`. Escape cancels
+one round and keeps the loop.
+
+## Skills
+
+| Skill | Use |
+|---|---|
+| `fan` | the fenced block above; the extension owns the branches |
+| `delegate` | the same branches started from a bash call (`dstart`, `branch`, `dwait`), for runs the model wants to read back itself, or continue with `dresume` after a branch asks a question |
+
+Both write every branch's answer to `.pi-out/<run>/<phase>-<name>.md` and its errors to the
+matching `.err`. Add `.pi-out/` to `.gitignore`. Quitting pi stops the branches; what they
+wrote stays on disk.
+
+## Settings
+
+| Variable | Default | Effect |
+|---|---|---|
+| `FAN_MODEL` | the session's model | model for `fan` branches that do not name one |
+| `FAN_TOOLS` | `read,grep,find,ls` | tools a branch may use |
+| `FAN_LOAD` | `$LOAD` from `delegate.env` | extra `-e <path>` flags; branches start with `--no-extensions`, so a provider that comes from an extension has to be listed here |
+| `FAN_TIMEOUT_MS` | `$DELEGATE_TIMEOUT` × 1000, else `300000` | a branch still running after this long is cut off |
+
+Both ways in share one settings file: the packaged `delegate.env`, then
+`~/.pi/agent/delegate.env`, which wins.
+
+A branch starts without extensions, so a model that only an extension provides is not there
+for it. When no branch can start on its model, you get a warning and the model is told to ask
+you which one to use. The suggestions are your scoped models (`enabledModels`) that a branch
+can reach; if none can, free models; if there are none, the first few a branch can reach.
+Name the choice per branch with `label@provider/model`, set `FAN_MODEL`, or load the extension
+through `LOAD`.
+
+A model id may carry a colon, as in `label@openrouter/some-model:free: task`; the key ends at
+the first colon followed by a space.
+
+## The patch
+
+`/umb-loop` sends its prompt the way the input box does, and the extension API has no way to
+do that. `patch.mjs` makes one small additive edit to pi's installed bundle that exposes it. A
+pi update removes the patch without any error, so run the script again after every update.
+
+| Command | Effect |
+|---|---|
+| `node .../patch.mjs` | apply the patch; a part already applied is skipped |
+| `node .../patch.mjs --check` | change nothing, exit 1 if the patch is missing |
+
+The script patches the `pi` on your PATH. Set `PI_UMBRA_PI` to the `pi-coding-agent`
+directory to patch another one.
+
+MIT.

package/node_modules/pi-umbra-subagents/extensions/umbra-loop.ts

@@ -0,0 +1,102 @@
+import type { ExtensionAPI, ExtensionCommandContext, ExtensionContext } from "@earendil-works/pi-coding-agent";
+
+// The editor's submit path is not on the extension API, so repatch.mjs publishes it.
+const submit = (text: string) => (globalThis as any).__piSubmit?.(text);
+
+const DEFAULT_PROMPT = "Continue.";
+const UNIT_MS: Record<string, number> = { h: 3_600_000, m: 60_000, s: 1000 };
+// "90s", "10 min", "1h30m" — a run of number+unit pairs at the very start of the args. A unit
+// ends at any non-letter, not at \b, which never falls between "h" and "30".
+const DURATION = /^(?:\d+\s*(?:hours?|hrs?|h|minutes?|mins?|m|seconds?|secs?|s)(?![a-z])\s*)+/i;
+const COUNT = /^(\d+)\s*/;
+const RESUBMIT_DELAY_MS = 50;
+
+type Loop = { prompt: string; iterations?: number; deadline?: number; done: number };
+
+const durationMs = (text: string) =>
+	[...text.matchAll(/(\d+)\s*([a-z]+)/gi)].reduce(
+		(sum, [, amount, unit]) => sum + Number(amount) * UNIT_MS[unit[0].toLowerCase()],
+		0,
+	);
+
+const parse = (args: string): Loop => {
+	const trimmed = args.trim();
+	const rest = (from: string) => trimmed.slice(from.length).trim() || DEFAULT_PROMPT;
+
+	const duration = trimmed.match(DURATION);
+	if (duration) return { prompt: rest(duration[0]), deadline: Date.now() + durationMs(duration[0]), done: 0 };
+
+	const count = trimmed.match(COUNT);
+	if (count) {
+		// 0 means "no limit". Either branch strips the number from the prompt, so
+		// "/umb-loop 0 fix the tests" submits "fix the tests", not "0 fix the tests".
+		const iterations = Number(count[1]);
+		return iterations > 0
+			? { prompt: rest(count[0]), iterations, done: 0 }
+			: { prompt: rest(count[0]), done: 0 };
+	}
+
+	return { prompt: trimmed || DEFAULT_PROMPT, done: 0 };
+};
+
+export default function (pi: ExtensionAPI) {
+	let loop: Loop | undefined;
+	let cancelled = false;
+
+	const describe = () => {
+		if (!loop) return undefined;
+		if (loop.iterations) return `loop ${loop.done}/${loop.iterations}`;
+		if (loop.deadline) return `loop ${Math.max(0, Math.round((loop.deadline - Date.now()) / 1000))}s`;
+		return `loop ${loop.done}`;
+	};
+
+	const stop = (ctx: ExtensionContext, reason: string) => {
+		loop = undefined;
+		ctx.ui.setStatus("loop", undefined);
+		ctx.ui.notify(reason);
+	};
+
+	pi.registerCommand("umb-loop", {
+		description: "Toggle automatic resubmission after each yield: /umb-loop [count|duration] [prompt]",
+		handler: async (args: string, ctx: ExtensionCommandContext) => {
+			if (loop) return stop(ctx, "loop off");
+			// Without the patch nothing would ever be sent, while the status claimed a running loop.
+			if (!(globalThis as any).__piSubmit) {
+				return ctx.ui.notify("umb-loop needs its patch: run pi-umbra-subagents/patch.mjs, then restart pi", "warning");
+			}
+
+			loop = parse(args);
+			cancelled = false;
+			ctx.ui.setStatus("loop", describe());
+			ctx.ui.notify(`loop on — "${loop.prompt}"`);
+			if (ctx.isIdle()) {
+				loop.done++;
+				submit(loop.prompt);
+			}
+		},
+	});
+
+	// An aborted run (Escape) keeps the loop armed but skips this yield, so the turn comes back to
+	// the user. Read from how the run ended, not from the Escape key: an Escape that only closed a
+	// panel or an autocomplete list aborts nothing and must not stall the loop.
+	pi.on("agent_end", (event) => {
+		const last = [...event.messages].reverse().find((message) => message.role === "assistant");
+		if (loop && last && "stopReason" in last && last.stopReason === "aborted") cancelled = true;
+	});
+
+	pi.on("agent_settled", (_event, ctx) => {
+		if (!loop) return;
+		if (cancelled) {
+			cancelled = false;
+			ctx.ui.notify("loop: iteration cancelled");
+			return;
+		}
+		if (loop.deadline && Date.now() >= loop.deadline) return stop(ctx, "loop done (time up)");
+		if (loop.iterations && loop.done >= loop.iterations) return stop(ctx, "loop done");
+
+		loop.done++;
+		ctx.ui.setStatus("loop", describe());
+		const prompt = loop.prompt;
+		setTimeout(() => loop && submit(prompt), RESUBMIT_DELAY_MS);
+	});
+}