@oh-my-pi/pi-tui 18.14.2 → 18.16.0

package/src/overlays/btw-history.ts

@@ -1,4 +1,5 @@
 import type { ImageContent } from "@oh-my-pi/pi-ai";
+import { sanitizeDisplayText } from "./extensions/display-text";
 
 export interface BtwHistoryTurn {
 	question: string;
@@ -32,6 +33,11 @@ export function getBtwTurns(record: BtwHistoryRecord): readonly BtwHistoryTurn[]
 	return [record, ...(record.followUps ?? [])];
 }
 
+/** Identifies one turn of a topic, its latest by default: a follow-up gets a new key, so per-answer marks reset. */
+export function getBtwTurnKey(record: BtwHistoryRecord, turnIndex = record.followUps?.length ?? 0): string {
+	return `${record.id}:${turnIndex}`;
+}
+
 /** Copy the most recent nonblank answer, preserving its original whitespace. */
 export function getBtwCopyText(record: BtwHistoryRecord): string | undefined {
 	if (record.followUps) {
@@ -42,3 +48,62 @@ export function getBtwCopyText(record: BtwHistoryRecord): string | undefined {
 	}
 	return record.answer.trim() ? record.answer : undefined;
 }
+
+const INJECT_OPEN = "<inject>";
+const INJECT_CLOSE = "</inject>";
+
+/** An answer around its `<inject>` block: the steering prompt a side answer drafted for the main session. */
+export interface BtwInjectParts {
+	before: string;
+	inject: string;
+	after: string;
+	/** False while no opener has a close: the block may still be streaming, so it runs to the end. */
+	closed: boolean;
+}
+
+/**
+ * Split an answer at its last closed `<inject>` block: the last opener that has a close
+ * after it, paired with the first close after it. A tag merely mentioned in prose,
+ * before or after the block, cannot capture it. Without a closed block, the last opener
+ * runs to the end (`closed: false`); display it only while the answer still streams.
+ * Linear: the last opener before the last close is the last one with any close after it.
+ */
+export function splitBtwInject(answer: string): BtwInjectParts | undefined {
+	const lastClose = answer.lastIndexOf(INJECT_CLOSE);
+	const open = lastClose === -1 ? -1 : answer.lastIndexOf(INJECT_OPEN, lastClose - INJECT_OPEN.length);
+	if (open !== -1) {
+		const close = answer.indexOf(INJECT_CLOSE, open + INJECT_OPEN.length);
+		return {
+			before: answer.slice(0, open),
+			inject: answer.slice(open + INJECT_OPEN.length, close),
+			after: answer.slice(close + INJECT_CLOSE.length),
+			closed: true,
+		};
+	}
+	const streaming = answer.lastIndexOf(INJECT_OPEN);
+	if (streaming === -1) return undefined;
+	return {
+		before: answer.slice(0, streaming),
+		inject: answer.slice(streaming + INJECT_OPEN.length),
+		after: "",
+		closed: false,
+	};
+}
+
+/** A block's text as shown and as sent: control sequences stripped, tabs expanded, trimmed. */
+export function formatBtwInjectText(inject: string): string {
+	return sanitizeDisplayText(inject).trim();
+}
+
+/** The steering prompt to send, exactly as the block shows it; undefined while unclosed or blank. */
+export function getBtwInject(answer: string): string | undefined {
+	const parts = splitBtwInject(answer);
+	const text = parts?.closed ? formatBtwInjectText(parts.inject) : "";
+	return text || undefined;
+}
+
+/** A topic's steering prompt: only its latest turn's, once that turn completed. */
+export function getBtwRecordInject(record: BtwHistoryRecord): string | undefined {
+	const latest = getBtwLatestTurn(record);
+	return latest.status === "complete" ? getBtwInject(latest.answer) : undefined;
+}

package/src/overlays/btw-inject.ts

@@ -0,0 +1,91 @@
+import { type Component, Markdown, visibleWidth, wrapTextWithAnsi } from "../index";
+import { getMarkdownTheme, theme } from "../theme/theme";
+import { card, col, md, span, text } from "../native/describe";
+import type { NativeNode } from "../native/node";
+import { type BtwInjectParts, formatBtwInjectText } from "./btw-history";
+import { sanitizeDisplayText } from "./extensions/display-text";
+
+/** Labels a steering prompt that has not been sent yet. */
+export const BTW_INJECT_LABEL = "Inject into main session";
+/** Labels a sent steering prompt. */
+export const BTW_INJECTED_LABEL = "Injected into main session";
+
+/** A displayed `<inject>` block: still sendable, or sent. Blocks in neither state render as plain text. */
+export type BtwInjectState = "pending" | "sent";
+
+/**
+ * Terminal lines for an `<inject>` block: every wrapped line behind a gutter of the `btw.rail`
+ * (pink while pending, green once sent) and the send arrow (`nav.selected`) or blanks as wide,
+ * then the label on the row below. Both states take the same rows and text column, so sending
+ * recolours the block in place.
+ */
+function renderBlockLines(inject: string, width: number, sent: boolean): string[] {
+	const arrow = theme.nav.selected;
+	const color = sent ? "success" : "customMessageLabel";
+	const marker = sent ? arrow : " ".repeat(visibleWidth(arrow));
+	const prefix = `${theme.fg(color, theme.symbol("btw.rail"))} ${theme.bold(marker)} `;
+	const inner = Math.max(1, width - visibleWidth(prefix));
+	const body = formatBtwInjectText(inject)
+		.split("\n")
+		.flatMap(line => (line.trim() ? wrapTextWithAnsi(line, inner) : [""]))
+		.map(line => `${prefix}${line}`);
+	return [...body, `${prefix}${theme.fg(color, sent ? BTW_INJECTED_LABEL : BTW_INJECT_LABEL)}`];
+}
+
+/** Text-mode answer split around its `<inject>` block: prose, the railed block, prose, a blank row apart. */
+export class BtwInjectAnswer implements Component {
+	readonly #inject: string;
+	readonly #sent: boolean;
+	readonly #before: Markdown | undefined;
+	readonly #after: Markdown | undefined;
+
+	constructor(parts: BtwInjectParts, sent: boolean) {
+		this.#inject = parts.inject;
+		this.#sent = sent;
+		this.#before = prose(parts.before);
+		this.#after = prose(parts.after);
+	}
+
+	render(width: number): string[] {
+		return [
+			...(this.#before ? [...this.#before.render(width), ""] : []),
+			...renderBlockLines(this.#inject, width, this.#sent),
+			...(this.#after ? ["", ...this.#after.render(width)] : []),
+		];
+	}
+
+	invalidate(): void {
+		this.#before?.invalidate();
+		this.#after?.invalidate();
+	}
+}
+
+function prose(text: string): Markdown | undefined {
+	const trimmed = text.trim();
+	return trimmed ? new Markdown(sanitizeDisplayText(trimmed), 0, 0, getMarkdownTheme()) : undefined;
+}
+
+/**
+ * The same answer for native surfaces. They wrap text themselves, so a per-row gutter cannot
+ * follow wrapped lines: a card toned like the rail (`user` pending, `success` sent) marks the
+ * whole block instead, with the label as its last row.
+ */
+export function describeBtwInjectAnswer(parts: BtwInjectParts, sent: boolean, stream: boolean): NativeNode {
+	const before = parts.before.trim();
+	const after = parts.after.trim();
+	const label = sent ? `${theme.nav.selected} ${BTW_INJECTED_LABEL}` : BTW_INJECT_LABEL;
+	const block = card({ role: "omp.btw.inject", tone: sent ? "success" : "user" }, [
+		...formatBtwInjectText(parts.inject)
+			.split("\n")
+			.map(line => text(line, { wrap: "word" })),
+		text([span(label, sent ? "success" : "customMessageLabel")]),
+	]);
+	return col(
+		[
+			...(before ? [md(sanitizeDisplayText(before), { stream })] : []),
+			block,
+			...(after ? [md(sanitizeDisplayText(after), { stream })] : []),
+		],
+		{ gap: "sm" },
+	);
+}

package/src/overlays/btw-panel.ts

@@ -5,10 +5,13 @@ import { sanitizeErrorLine } from "../chrome/error-block";
 import { OverlayPanel } from "../chrome/overlay-box";
 import { StreamingPanelContent } from "../chrome/streaming-panel";
 import { boundKeys, interruptKey } from "../chrome/keybinding-hints";
-import { formatKeyHint } from "../app-keybindings";
+import { formatKeyHint, type KeyId } from "../app-keybindings";
 import type { NativeNode } from "../native/node";
 import { col, md, node, span, text } from "../native/describe";
 import { hintsRow, type NativeHint, statusHintsRow } from "../native/overlay";
+import { appBtwInjectKey } from "../keybinding-matchers";
+import { type BtwInjectParts, splitBtwInject } from "./btw-history";
+import { BtwInjectAnswer, describeBtwInjectAnswer } from "./btw-inject";
 
 type BtwPanelState = "running" | "complete" | "branching" | "aborted" | "error";
 
@@ -19,21 +22,28 @@ interface BtwPanelComponentOptions {
 	tui: TUI;
 	canBranch?: () => boolean;
 	canFollowUp?: () => boolean;
+	/**
+	 * Given only while `btw.inject` is on: the answer's `<inject>` block shows apart from its
+	 * prose, and the inject key (`app.btw.inject`) is offered while this returns true.
+	 */
+	canInject?: () => boolean;
 }
 
 export class BtwPanelComponent extends OverlayPanel {
 	#tui: TUI;
 	#canBranch: (() => boolean) | undefined;
 	#canFollowUp: (() => boolean) | undefined;
+	#canInject: (() => boolean) | undefined;
 	#state: BtwPanelState = "running";
 	#answer = "";
 	#errorMessage: string | undefined;
 	#visibleAnswer = "";
 	#closed = false;
 	#copied = false;
+	#injected = false;
 	#baseTitle: string;
 	readonly #content: StreamingPanelContent;
-	#native: { node: NativeNode; canFollowUp: boolean; canBranch: boolean } | undefined;
+	#native: { node: NativeNode; canFollowUp: boolean; canBranch: boolean; injectKey: KeyId | undefined } | undefined;
 
 	constructor(options: BtwPanelComponentOptions) {
 		const baseTitle = replaceTabs(options.title ?? `/btw ${options.question}`);
@@ -42,8 +52,9 @@ export class BtwPanelComponent extends OverlayPanel {
 		this.#tui = options.tui;
 		this.#canBranch = options.canBranch;
 		this.#canFollowUp = options.canFollowUp;
+		this.#canInject = options.canInject;
 		this.#content = new StreamingPanelContent(() => ({
-			sections: [this.#contentComponent()],
+			sections: this.#contentSections(),
 			footer: () => this.#footerLine(),
 		}));
 		this.addChild(this.#content);
@@ -81,6 +92,13 @@ export class BtwPanelComponent extends OverlayPanel {
 		this.#rebuild();
 	}
 
+	/** Shows the answer's steering prompt as sent (send arrows, green), or back to pending when a send failed. */
+	setInjected(injected: boolean): void {
+		if (this.#closed || this.#injected === injected) return;
+		this.#injected = injected;
+		this.#rebuild();
+	}
+
 	#setCopied(copied: boolean): void {
 		this.#copied = copied;
 		this.title = copied ? `${this.#baseTitle} ✓ Copied` : this.#baseTitle;
@@ -123,6 +141,20 @@ export class BtwPanelComponent extends OverlayPanel {
 		return this.#visibleAnswer;
 	}
 
+	/**
+	 * The answer around its `<inject>` block, which displays apart from the prose only while
+	 * streaming or once the tag closed: an unclosed block in a finished answer stays plain text.
+	 */
+	#injectParts(): BtwInjectParts | undefined {
+		const parts = this.#canInject ? splitBtwInject(this.#visibleAnswer) : undefined;
+		return parts && (parts.closed || this.#state === "running") ? parts : undefined;
+	}
+
+	/** The bound inject key while it can send the answer's steering prompt. */
+	#injectKey(): KeyId | undefined {
+		return this.#canInject?.() ? appBtwInjectKey() : undefined;
+	}
+
 	close(): void {
 		this.#closed = true;
 	}
@@ -135,8 +167,10 @@ export class BtwPanelComponent extends OverlayPanel {
 	override describe(): NativeNode {
 		const canFollowUp = this.#canFollowUp?.() ?? false;
 		const canBranch = this.#canBranch?.() ?? this.isBranchable();
+		const injectKey = this.#injectKey();
 		const memo = this.#native;
-		if (memo && memo.canFollowUp === canFollowUp && memo.canBranch === canBranch) return memo.node;
+		if (memo && memo.canFollowUp === canFollowUp && memo.canBranch === canBranch && memo.injectKey === injectKey)
+			return memo.node;
 		// Inline in the dock, styled as a sheet by role: a borderless column headed by the question.
 		// The command word is the accent; the rest of the heading is the question or arguments.
 		const space = this.#baseTitle.indexOf(" ");
@@ -148,12 +182,12 @@ export class BtwPanelComponent extends OverlayPanel {
 			...(live ? [node("spinner", {})] : []),
 			title,
 		]);
-		const described = col([head, this.#describeBody(), this.#describeFooter(canFollowUp, canBranch)], {
+		const described = col([head, this.#describeBody(), this.#describeFooter(canFollowUp, canBranch, injectKey)], {
 			role: this.nativeRole,
 			gap: "sm",
 			tone: this.#state === "error" ? "error" : this.#state === "aborted" ? "warning" : undefined,
 		});
-		this.#native = { node: described, canFollowUp, canBranch };
+		this.#native = { node: described, canFollowUp, canBranch, injectKey };
 		return described;
 	}
 
@@ -162,18 +196,22 @@ export class BtwPanelComponent extends OverlayPanel {
 			return text([span(sanitizeErrorLine(this.#errorMessage ?? "Unknown error"), "error")], { wrap: "word" });
 		}
 		const answer = this.#visibleAnswer;
-		if (answer) return md(answer, { stream: this.#state === "running" });
+		const parts = this.#injectParts();
+		const stream = this.#state === "running";
+		if (parts) return describeBtwInjectAnswer(parts, this.#injected, stream);
+		if (answer) return md(answer, { stream });
 		const waiting = this.#state === "running" ? `${theme.status.pending} Waiting for response…` : "No text returned.";
 		return text([span(waiting, "dim")]);
 	}
 
-	#describeFooter(canFollowUp: boolean, canBranch: boolean): NativeNode {
+	#describeFooter(canFollowUp: boolean, canBranch: boolean, injectKey: KeyId | undefined): NativeNode {
 		const esc: NativeHint = { keys: boundKeys("app.interrupt", ["escape"]).slice(0, 1), label: "to close" };
 		switch (this.#state) {
 			case "running":
 				return hintsRow([{ ...esc, label: "to cancel" }]);
 			case "complete": {
 				const hints: NativeHint[] = [];
+				if (injectKey) hints.push({ keys: [injectKey], label: "to inject" });
 				if (this.isCopyable()) hints.push({ keys: ["c"], label: this.#copied ? "to copy again" : "to copy" });
 				if (canFollowUp) hints.push({ keys: ["f"], label: "to follow up" });
 				if (canBranch) hints.push({ keys: ["b"], label: "to branch" });
@@ -209,6 +247,8 @@ export class BtwPanelComponent extends OverlayPanel {
 			case "complete": {
 				const actions: string[] = [];
 				const copyKey = formatKeyHint("c");
+				const injectKey = this.#injectKey();
+				if (injectKey) actions.push(`${formatKeyHint(injectKey)} to inject`);
 				if (this.isCopyable()) actions.push(this.#copied ? `${copyKey} to copy again` : `${copyKey} to copy`);
 				if (this.#canFollowUp?.()) actions.push(`${formatKeyHint("f")} to follow up`);
 				if (this.#canBranch?.() ?? this.isBranchable()) actions.push(`${formatKeyHint("b")} to branch`);
@@ -227,16 +267,17 @@ export class BtwPanelComponent extends OverlayPanel {
 		}
 	}
 
-	#contentComponent(): Component {
+	#contentSections(): Component[] {
 		if (this.#state === "error") {
-			return new Text(theme.fg("error", sanitizeErrorLine(this.#errorMessage ?? "Unknown error")), 0, 0);
+			return [new Text(theme.fg("error", sanitizeErrorLine(this.#errorMessage ?? "Unknown error")), 0, 0)];
 		}
 		const text = this.#visibleAnswer;
 		if (!text) {
 			const waiting =
 				this.#state === "running" ? `${theme.status.pending} Waiting for response…` : "No text returned.";
-			return new Text(theme.fg("dim", waiting), 0, 0);
+			return [new Text(theme.fg("dim", waiting), 0, 0)];
 		}
-		return new Markdown(text, 0, 0, getMarkdownTheme());
+		const parts = this.#injectParts();
+		return [parts ? new BtwInjectAnswer(parts, this.#injected) : new Markdown(text, 0, 0, getMarkdownTheme())];
 	}
 }

package/src/overlays/hook-editor.ts

@@ -407,6 +407,12 @@ export class HookEditorComponent extends OverlayPanel implements Focusable {
 		else this.#editor.pasteText(text);
 	}
 
+	/** Replace the draft, as Ctrl+R history search does for the main composer. */
+	setText(text: string): void {
+		if (this.#disposed) return;
+		this.#editor.setText(text);
+	}
+
 	/**
 	 * Prompt-style: raw Enter submits; Editor owns newline-producing sequences.
 	 * The follow-up chord (`app.message.followUp` → Ctrl+Q / Ctrl+Enter) also

package/src/overlays/jobs-panel.ts

@@ -26,6 +26,10 @@ export interface JobsPanelJob {
 	readonly type: string;
 	readonly status: "running" | "completed" | "failed" | "cancelled";
 	readonly label: string;
+	/** What the job is for, in the model's words; rows and the detail lead with it over a command `label`. */
+	readonly intent?: string;
+	/** One line on what a command does and when it ends, from the cheap model; the detail shows it under the intent. */
+	readonly caption?: string;
 	readonly startTime: number;
 	readonly endTime?: number;
 	/** Registry id of the agent that owns the job. */
@@ -146,13 +150,14 @@ export class JobsSheet implements Component {
 		const detail = selected && this.#inspect(selected.id);
 		const now = Date.now();
 		// Elapsed nodes tick on their own; list values and the output pane redraw
-		// when a job starts, settles, leaves or moves in the tree, its process
-		// changes, its output grows, or (while one runs) once a second.
+		// when a job starts, settles, leaves or moves in the tree, gets its
+		// caption (it can land after the job settles), its process changes, its
+		// output grows, or (while one runs) once a second.
 		const key = [
 			rows
 				.map(
 					entry =>
-						`${jobTreeGuide(entry, theme)}${entry.kind === "job" ? `${entry.job.id}:${entry.job.status}` : entry.agent.id}`,
+						`${jobTreeGuide(entry, theme)}${entry.kind === "job" ? `${entry.job.id}:${entry.job.status}:${entry.job.caption ?? ""}` : entry.agent.id}`,
 				)
 				.join(","),
 			selected?.id,
@@ -200,15 +205,20 @@ export class JobsSheet implements Component {
 			const cursor = job === selected ? ">" : " ";
 			const age = formatDuration(jobAge(job, now));
 			const agent = entry.agent && entry.agent.id !== job.label ? `${entry.agent.id}: ` : "";
-			lines.push(
-				truncateToWidth(
-					`${cursor} ${guide}${job.status}  ${job.type} ${age}  ${agent}${collapseCommand(job.label)}`,
-					width,
-				),
-			);
+			// The intent is model-written: strip terminal controls and flatten it to one row like the command.
+			const title = shortenEmbeddedPaths(collapseCommand(sanitizeText(job.intent ?? job.label)));
+			lines.push(truncateToWidth(`${cursor} ${guide}${job.status}  ${job.type} ${age}  ${agent}${title}`, width));
 		}
 		const detail = selected && this.#inspect(selected.id);
 		if (detail) {
+			if (selected.caption) {
+				for (const line of wrapTextWithAnsi(
+					shortenEmbeddedPaths(sanitizeText(selected.caption)),
+					Math.max(1, width - 3),
+				)) {
+					lines.push(`   ${theme.fg("muted", line)}`);
+				}
+			}
 			// Rows show the cut label; the selected job's command wraps here,
 			// bounded so a long script never pushes the facts and output off the sheet.
 			if (detail.command) {
@@ -227,7 +237,7 @@ export class JobsSheet implements Component {
 				detail.artifactId && `artifact://${detail.artifactId}`,
 			]);
 			if (facts.length > 0) lines.push(truncateToWidth(`   ${facts.join(" · ")}`, width));
-			if (detail.widget) {
+			if (detail.widget && widgetHasData(detail.widget)) {
 				for (const line of renderJobWidgetLines(detail.widget, Math.max(0, width - 3), theme)) {
 					lines.push(`   ${line}`);
 				}
@@ -331,6 +341,11 @@ function jobAge(job: JobsPanelJob, nowMs: number): number {
 	return Math.max(0, (job.endTime ?? nowMs) - job.startTime);
 }
 
+/** Whether a widget draws more than its title: one without data only repeats the job's heading. */
+function widgetHasData(widget: JobWidgetView): boolean {
+	return widget.blocks.length > 0 || widget.headline !== undefined || Boolean(widget.stage);
+}
+
 /**
  * The last `count` pieces of `text.trimEnd().split("\n")`, found by scanning
  * back from the end so a long running output is never split as a whole.
@@ -373,8 +388,9 @@ function describeJobList(rows: readonly JobTreeRow<JobsPanelJob>[], selected: Jo
 
 /**
  * One list row: the type icon tinted by status, the tree connector, the
- * subagent a task job runs, the one-line label (a process job's command in
- * mono, a task's work in prose) and how long it ran.
+ * subagent a task job runs, the one-line label (what the job is for when the
+ * model said, else a process job's command in mono or a task's work in prose)
+ * and how long it ran.
  */
 function describeJobItem(job: JobsPanelJob, agentName: string | undefined, guide: string, nowMs: number): NativeNode {
 	const status = STATUS_LABEL[job.status];
@@ -383,13 +399,17 @@ function describeJobItem(job: JobsPanelJob, agentName: string | undefined, guide
 		label: compact([
 			guide !== "" && span(guide, "mono dim"),
 			agentName !== undefined && agentName !== job.label && span(`${agentName} `, "strong"),
-			job.type === "task" ? span(job.label) : span(collapseCommand(job.label), "mono"),
+			job.intent
+				? span(job.intent)
+				: job.type === "task"
+					? span(job.label)
+					: span(collapseCommand(job.label), "mono"),
 		]),
 		value: [span(age, "mono")],
 		icon: TYPE_ICON[job.type] ?? "job",
 		tone: STATUS_TONE[job.status],
-		title: `${job.label}\n${status} · ${job.type} · ${job.id}`,
-		aria: `${job.label}, ${status.toLowerCase()}, ${age}`,
+		title: `${job.intent ? `${job.intent}\n` : ""}${job.caption ? `${job.caption}\n` : ""}${job.label}\n${status} · ${job.type} · ${job.id}`,
+		aria: `${job.intent ?? job.label}, ${status.toLowerCase()}, ${age}`,
 	});
 }
 
@@ -422,8 +442,9 @@ function describeEmpty(): NativeNode {
 
 /**
  * The selected job: a status line (pill, live elapsed, type · id, Cancel job
- * when `cancellable`), its task or full command, facts and the output pane (or
- * its empty state).
+ * when `cancellable`), what it is for, what its command does (the cheap
+ * model's caption), its full command, facts, its widget
+ * when it has data to draw and the output pane (or its empty state).
  */
 function describeDetail(
 	job: JobsPanelJob,
@@ -435,6 +456,7 @@ function describeDetail(
 	const exit = detail?.exitCode;
 	const age = Math.round(jobAge(job, nowMs));
 	const command = detail?.command ?? (job.type === "task" ? undefined : job.label);
+	const title = job.intent ?? (command ? undefined : job.label);
 	const pids = detail?.pids ?? [];
 	const facts = compact([
 		job.agentId ? { k: "Agent", v: [span(job.agentId, "mono")] } : undefined,
@@ -464,11 +486,15 @@ function describeDetail(
 			]),
 			{ role: "omp.jobs.status", gap: "sm", align: "center" },
 		),
+		title ? text(title, { role: "omp.jobs.title", wrap: "word" }) : undefined,
+		job.caption ? text([span(job.caption, "muted")], { role: "omp.jobs.caption", wrap: "word" }) : undefined,
 		command
 			? code(command, { lang: "bash", wrap: true, preview: { lines: 4 }, role: "omp.jobs.command" })
-			: text(job.label, { role: "omp.jobs.title", wrap: "word" }),
+			: undefined,
 		facts.length > 0 && node("kv", { items: facts, role: "omp.jobs.facts" }),
-		detail?.widget && node("col", { role: "omp.jobs.widget" }, [describeJobWidget(detail.widget)], "widget"),
+		detail?.widget &&
+			widgetHasData(detail.widget) &&
+			node("col", { role: "omp.jobs.widget" }, [describeJobWidget(detail.widget)], "widget"),
 		node(
 			"col",
 			{ role: "omp.jobs.out", gap: "sm" },