pi-subagents 0.62.0 → 0.63.0

package/src/workflows/workflow-checklist.ts

@@ -0,0 +1,441 @@
+import type { AsyncJobStep, HostStepNodeV1, WorkflowGraphNode, WorkflowGraphSnapshot, WorkflowPreflightLaneV1, WorkflowPreflightV1 } from "../shared/types.ts";
+import { sanitizeDisplayText } from "../shared/display-text.ts";
+
+export type WorkflowChecklistState = "complete" | "running" | "queued" | "blocked" | "failed" | "paused" | "stopped";
+
+export interface WorkflowChecklistStep {
+	key?: string;
+	workflowKey?: string;
+	runId?: string;
+	label?: string;
+	description?: string;
+	phase?: string;
+	agent?: string;
+	status: string;
+	context?: "fresh" | "fork";
+	activityState?: string;
+	startedAt?: number;
+	endedAt?: number;
+	durationMs?: number;
+	currentTool?: string;
+	currentToolStartedAt?: number;
+	currentPath?: string;
+	turnCount?: number;
+	toolCount?: number;
+	outputName?: string;
+	error?: string;
+	toolBudgetBlocked?: boolean;
+	turnBudgetExceeded?: boolean;
+	timedOut?: boolean;
+	stopped?: boolean;
+	acceptance?: { status?: string; reviewResult?: { status?: string } };
+	review?: { status?: string };
+	watchdog?: { phase?: string };
+}
+
+export interface WorkflowChecklistTraceEntry {
+	operation?: string;
+	key: string;
+	state: string;
+	agent?: string;
+	runId?: string;
+	phase?: string;
+	label?: string;
+	generatedLaneKey?: string;
+	durationMs?: number;
+	error?: string;
+}
+
+export interface WorkflowChecklistItem {
+	key: string;
+	label: string;
+	phase: string;
+	state: WorkflowChecklistState;
+	agent?: string;
+	context?: "fresh" | "fork";
+	startedAt?: number;
+	durationMs?: number;
+	currentTool?: string;
+	currentToolStartedAt?: number;
+	currentPath?: string;
+	toolCount?: number;
+	outputName?: string;
+	error?: string;
+	preflight?: WorkflowPreflightLaneV1;
+	kind?: "child" | "host";
+	monitorKind?: HostStepNodeV1["monitorKind"];
+	provider?: string;
+	role?: string;
+	verdict?: HostStepNodeV1["verdict"];
+	target?: string;
+	reasonCode?: string;
+	stale?: boolean;
+	reportPath?: string;
+}
+
+export interface WorkflowChecklistPhase {
+	key: string;
+	label: string;
+	state: WorkflowChecklistState;
+	items: WorkflowChecklistItem[];
+	total: number;
+	done: number;
+	running: number;
+	queued: number;
+	blocked: number;
+	failed: number;
+	paused: number;
+	stopped: number;
+	parallel: boolean;
+}
+
+export interface WorkflowChecklistProjection {
+	phases: WorkflowChecklistPhase[];
+	total: number;
+	done: number;
+	running: number;
+	queued: number;
+	blocked: number;
+	failed: number;
+	paused: number;
+	stopped: number;
+	bottleneck?: WorkflowChecklistItem;
+}
+
+export interface WorkflowChecklistInput {
+	graph?: WorkflowGraphSnapshot;
+	steps?: readonly WorkflowChecklistStep[] | readonly AsyncJobStep[];
+	hostSteps?: readonly HostStepNodeV1[];
+	preflight?: WorkflowPreflightV1;
+	trace?: readonly WorkflowChecklistTraceEntry[];
+	now?: number;
+}
+
+const MAX_TEXT = 160;
+const TERMINAL_STATES = new Set<WorkflowChecklistState>(["complete", "blocked", "failed", "paused", "stopped"]);
+
+function text(value: unknown, fallback?: string): string | undefined {
+	if (typeof value !== "string") return fallback;
+	const clean = sanitizeDisplayText(value).replace(/\s+/g, " ").trim();
+	return clean ? clean.slice(0, MAX_TEXT) : fallback;
+}
+
+function keyText(value: unknown, fallback: string): string {
+	return text(value, fallback) ?? fallback;
+}
+
+function normalizedStatus(value: unknown): string {
+	return typeof value === "string" ? value.toLowerCase() : "queued";
+}
+
+function finite(value: unknown): number | undefined {
+	return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+
+function count(value: unknown): number | undefined {
+	const number = finite(value);
+	return number !== undefined && number >= 0 ? Math.round(number) : undefined;
+}
+
+function explicitBlocked(source: Pick<WorkflowChecklistStep, "activityState" | "toolBudgetBlocked" | "turnBudgetExceeded" | "timedOut" | "acceptance" | "review" | "watchdog"> & { verdict?: unknown; stale?: unknown }): boolean {
+	const acceptance = normalizedStatus(source.acceptance?.status);
+	const review = normalizedStatus(source.review?.status ?? source.acceptance?.reviewResult?.status);
+	return source.toolBudgetBlocked === true
+		|| source.turnBudgetExceeded === true
+		|| source.activityState === "needs_attention"
+		|| source.timedOut === true
+		|| source.watchdog?.phase === "stale"
+		|| source.stale === true
+		|| source.verdict === "inconclusive"
+		|| acceptance === "rejected"
+		|| acceptance === "blockers"
+		|| review === "blockers"
+		|| review === "review-required";
+}
+
+function checklistState(source: Pick<WorkflowChecklistStep, "status" | "activityState" | "toolBudgetBlocked" | "turnBudgetExceeded" | "timedOut" | "acceptance" | "review" | "watchdog"> & { verdict?: unknown; stale?: unknown }): WorkflowChecklistState {
+	if (explicitBlocked(source)) return "blocked";
+	switch (normalizedStatus(source.status)) {
+		case "complete":
+		case "completed":
+		case "done":
+		case "pass":
+		case "accepted": return "complete";
+		case "running":
+		case "started":
+		case "active": return "running";
+		case "failed":
+		case "error":
+		case "fail": return "failed";
+		case "blocked":
+		case "rejected":
+		case "partial":
+		case "needs_attention": return "blocked";
+		case "paused":
+		case "detached": return "paused";
+		case "stopped":
+		case "cancelled":
+		case "canceled": return "stopped";
+		default: return "queued";
+	}
+}
+
+function duration(step: Pick<WorkflowChecklistStep, "durationMs" | "startedAt" | "endedAt">, now: number | undefined, state: WorkflowChecklistState): number | undefined {
+	const explicit = finite(step.durationMs);
+	const startedAt = finite(step.startedAt);
+	if (explicit !== undefined) return Math.max(0, explicit);
+	if (startedAt === undefined) return undefined;
+	const end = state === "running" ? now : finite(step.endedAt) ?? now;
+	return end === undefined ? undefined : Math.max(0, end - startedAt);
+}
+
+function laneFor(key: string, phase: string, lanes: ReadonlyMap<string, WorkflowPreflightLaneV1>): WorkflowPreflightLaneV1 | undefined {
+	return lanes.get(key) ?? lanes.get(phase) ?? [...lanes.values()].find((lane) => key.startsWith(`${lane.key}.`));
+}
+
+function stepKey(step: WorkflowChecklistStep): string | undefined {
+	return step.key ?? step.workflowKey ?? step.runId;
+}
+
+function stepItem(step: WorkflowChecklistStep, index: number, phase: string, key = stepKey(step) ?? `step-${index + 1}`, label = step.label ?? step.description ?? stepKey(step) ?? step.agent ?? key, preflight?: WorkflowPreflightLaneV1): WorkflowChecklistItem {
+	const state = checklistState(step);
+	return {
+		key: keyText(key, `step-${index + 1}`),
+		label: keyText(label, key),
+		phase,
+		state,
+		...(text(step.agent) ? { agent: text(step.agent) } : {}),
+		...(step.context ? { context: step.context } : {}),
+		...(finite(step.startedAt) !== undefined ? { startedAt: finite(step.startedAt) } : {}),
+		...(duration(step, undefined, state) !== undefined ? { durationMs: duration(step, undefined, state) } : {}),
+		...(text(step.currentTool) ? { currentTool: text(step.currentTool) } : {}),
+		...(finite(step.currentToolStartedAt) !== undefined ? { currentToolStartedAt: finite(step.currentToolStartedAt) } : {}),
+		...(text(step.currentPath) ? { currentPath: text(step.currentPath) } : {}),
+		...(count(step.toolCount) !== undefined ? { toolCount: count(step.toolCount) } : {}),
+		...(text(step.outputName) ? { outputName: text(step.outputName) } : {}),
+		...(text(step.error) ? { error: text(step.error) } : {}),
+		...(preflight ? { preflight } : {}),
+	};
+}
+
+function hostItem(host: HostStepNodeV1, phase: string, key = host.id): WorkflowChecklistItem {
+	const state = checklistState({ status: host.state, verdict: host.verdict, stale: host.freshness?.stale });
+	return {
+		key: keyText(key, "host-step"),
+		label: keyText(host.label, "host step"),
+		phase,
+		state,
+		kind: "host",
+		monitorKind: host.monitorKind,
+		...(text(host.provider) ? { provider: text(host.provider) } : {}),
+		...(text(host.role) ? { role: text(host.role) } : {}),
+		...(host.verdict ? { verdict: host.verdict } : {}),
+		...(text(host.target) ? { target: text(host.target) } : {}),
+		...(text(host.reasonCode) ? { reasonCode: text(host.reasonCode) } : {}),
+		...(text(host.detail) ? { error: text(host.detail) } : {}),
+		...(host.freshness?.stale !== undefined ? { stale: host.freshness.stale } : {}),
+		...(text(host.reportPath) ? { reportPath: text(host.reportPath) } : {}),
+	};
+}
+
+function graphNodes(graph: WorkflowGraphSnapshot | undefined): WorkflowGraphNode[] {
+	const out: WorkflowGraphNode[] = [];
+	const visit = (node: WorkflowGraphNode): void => {
+		if (node.kind === "parallel-group" || node.kind === "dynamic-parallel-group") {
+			for (const child of node.children ?? []) visit(child);
+			if (!node.children?.length) out.push(node);
+		} else {
+			out.push(node);
+		}
+	};
+	for (const node of graph?.nodes ?? []) visit(node);
+	return out;
+}
+
+function traceSources(trace: readonly WorkflowChecklistTraceEntry[] | undefined): WorkflowChecklistTraceEntry[] {
+	const latest = new Map<string, WorkflowChecklistTraceEntry>();
+	for (const entry of trace ?? []) {
+		const state = normalizedStatus(entry.state);
+		if ((entry.operation !== undefined && entry.operation !== "run" && entry.operation !== "host") || !entry.key || state === "delivered" || state === "missed") continue;
+		const existing = latest.get(entry.key);
+		latest.set(entry.key, state === "reused" && existing ? { ...existing, ...entry, state: existing.state } : { ...existing, ...entry });
+	}
+	return [...latest.values()];
+}
+
+function traceItem(entry: WorkflowChecklistTraceEntry, index: number, preflight: WorkflowPreflightLaneV1 | undefined): WorkflowChecklistItem {
+	const phase = keyText(entry.generatedLaneKey ?? entry.phase ?? preflight?.key, "Workflow");
+	const item = stepItem({ key: entry.key, label: entry.label, phase, agent: entry.agent, status: entry.state === "started" ? "running" : entry.state, durationMs: entry.durationMs, error: entry.error }, index, phase, entry.key, entry.label ?? entry.key, preflight);
+	if (entry.operation === "host") item.kind = "host";
+	return item;
+}
+
+function phaseFor(phases: Map<string, WorkflowChecklistPhase>, label: string): WorkflowChecklistPhase {
+	let phase = phases.get(label);
+	if (!phase) {
+		phase = { key: label, label, state: "queued", items: [], total: 0, done: 0, running: 0, queued: 0, blocked: 0, failed: 0, paused: 0, stopped: 0, parallel: false };
+		phases.set(label, phase);
+	}
+	return phase;
+}
+
+function add(phases: Map<string, WorkflowChecklistPhase>, phase: string, item: WorkflowChecklistItem): void {
+	phaseFor(phases, phase).items.push(item);
+}
+
+function mergeNodeStep(node: WorkflowGraphNode, step: WorkflowChecklistStep, phase: string, trace: WorkflowChecklistTraceEntry | undefined, preflight: WorkflowPreflightLaneV1 | undefined): WorkflowChecklistItem {
+	const state = checklistState(step);
+	const nodeState = checklistState({ status: node.status, acceptance: node.acceptanceStatus ? { status: node.acceptanceStatus } : undefined });
+	const status = TERMINAL_STATES.has(nodeState) && !TERMINAL_STATES.has(state)
+		? nodeState
+		: trace && !TERMINAL_STATES.has(state)
+		? (trace.state === "started" ? "running" : trace.state)
+		: normalizedStatus(step.status) === "pending" && normalizedStatus(node.status) !== "pending" ? node.status : step.status;
+	return stepItem({ ...step, status, key: node.id, label: step.label ?? node.label, phase: step.phase ?? phase, agent: step.agent ?? node.agent, outputName: step.outputName ?? node.outputName, error: step.error ?? trace?.error ?? node.error, acceptance: step.acceptance ?? (node.acceptanceStatus ? { status: node.acceptanceStatus } : undefined), durationMs: step.durationMs ?? trace?.durationMs }, node.flatIndex ?? 0, phase, node.id, step.label ?? node.label, preflight);
+}
+
+function priority(item: WorkflowChecklistItem): number {
+	return item.state === "blocked" ? 0 : item.state === "failed" ? 1 : item.state === "running" ? 2 : item.state === "paused" ? 3 : item.state === "stopped" ? 4 : item.state === "queued" ? 5 : 6;
+}
+
+function applyNow(item: WorkflowChecklistItem, now: number | undefined): WorkflowChecklistItem {
+	return item.durationMs === undefined && item.startedAt !== undefined && now !== undefined ? { ...item, durationMs: Math.max(0, now - item.startedAt) } : item;
+}
+
+function finalize(phase: WorkflowChecklistPhase): void {
+	phase.total = phase.items.length;
+	phase.done = phase.items.filter((item) => item.state === "complete").length;
+	phase.running = phase.items.filter((item) => item.state === "running").length;
+	phase.queued = phase.items.filter((item) => item.state === "queued").length;
+	phase.blocked = phase.items.filter((item) => item.state === "blocked").length;
+	phase.failed = phase.items.filter((item) => item.state === "failed").length;
+	phase.paused = phase.items.filter((item) => item.state === "paused").length;
+	phase.stopped = phase.items.filter((item) => item.state === "stopped").length;
+	phase.parallel = phase.total > 1;
+	phase.state = phase.blocked ? "blocked" : phase.failed ? "failed" : phase.running ? "running" : phase.paused ? "paused" : phase.stopped ? "stopped" : phase.queued ? "queued" : "complete";
+}
+
+export function projectWorkflowChecklist(input: WorkflowChecklistInput): WorkflowChecklistProjection {
+	const phases = new Map<string, WorkflowChecklistPhase>();
+	const lanes = new Map((input.preflight?.lanes ?? []).map((lane) => [lane.key, lane]));
+	const steps = (input.steps ?? []) as readonly WorkflowChecklistStep[];
+	const nodes = graphNodes(input.graph);
+	const trace = traceSources(input.trace);
+	const traceByKey = new Map(trace.map((entry) => [entry.key, entry]));
+	const phaseByNode = new Map<string, string>();
+	const graphPhaseLabels = new Set<string>();
+	for (const phase of input.graph?.phases ?? []) {
+		const title = keyText(phase.title, "Workflow");
+		graphPhaseLabels.add(title);
+		phaseFor(phases, title);
+		for (const nodeId of phase.nodeIds) if (!phaseByNode.has(nodeId)) phaseByNode.set(nodeId, title);
+	}
+
+	const stepsByKey = new Map<string, Array<{ step: WorkflowChecklistStep; index: number }>>();
+	for (const [index, step] of steps.entries()) {
+		const key = stepKey(step);
+		if (!key) continue;
+		stepsByKey.set(key, [...(stepsByKey.get(key) ?? []), { step, index }]);
+	}
+
+	const usedSteps = new Set<number>();
+	const hostById = new Map((input.hostSteps ?? []).map((host) => [host.id, host]));
+	const graphKeys = new Set(nodes.map((node) => node.id));
+	const stepKeys = new Set([...stepsByKey.keys()]);
+	const hostKeys = new Set(hostById.keys());
+
+	for (const node of nodes) {
+		const host = node.hostStep ?? hostById.get(node.id);
+		const phase = keyText(phaseByNode.get(node.id) ?? node.phase ?? (host ? host.label : node.label), "Workflow");
+		if (host) {
+			add(phases, phase, hostItem(host, phase, node.id));
+			hostById.delete(node.id);
+			continue;
+		}
+		const matches = (stepsByKey.get(node.id) ?? []).filter(({ index }) => !usedSteps.has(index));
+		if (matches.length) {
+			for (const match of matches) {
+				usedSteps.add(match.index);
+				add(phases, phase, applyNow(mergeNodeStep(node, match.step, phase, traceByKey.get(stepKey(match.step) ?? node.id), laneFor(node.id, phase, lanes)), input.now));
+			}
+			continue;
+		}
+		add(phases, phase, applyNow(mergeNodeStep(node, { key: node.id, label: node.label, phase, agent: node.agent, status: node.status, outputName: node.outputName, error: node.error, acceptance: node.acceptanceStatus ? { status: node.acceptanceStatus } : undefined }, phase, traceByKey.get(node.id), laneFor(node.id, phase, lanes)), input.now));
+	}
+
+	for (const [index, step] of steps.entries()) {
+		if (usedSteps.has(index)) continue;
+		const key = keyText(stepKey(step), `step-${index + 1}`);
+		const traceEntry = traceByKey.get(key);
+		const phase = keyText(step.phase ?? laneFor(key, "", lanes)?.key ?? traceEntry?.generatedLaneKey ?? traceEntry?.phase, "Workflow");
+		add(phases, phase, applyNow(stepItem(step, index, phase, key, step.label ?? step.key ?? step.agent, laneFor(key, phase, lanes)), input.now));
+	}
+
+	for (const host of hostById.values()) add(phases, keyText(host.label, "Host"), hostItem(host, keyText(host.label, "Host")));
+	for (const entry of trace) {
+		if (graphKeys.has(entry.key) || stepKeys.has(entry.key) || hostKeys.has(entry.key)) continue;
+		const item = traceItem(entry, phases.size, laneFor(entry.key, entry.generatedLaneKey ?? entry.phase ?? "", lanes));
+		add(phases, item.phase, item);
+	}
+	for (const lane of input.preflight?.lanes ?? []) if (!graphKeys.has(lane.key) && !graphPhaseLabels.has(lane.key) && !phases.get(lane.key)?.items.length) add(phases, lane.key, { key: lane.key, label: lane.key, phase: lane.key, state: "queued", preflight: lane });
+
+	const finalized = [...phases.values()].filter((phase) => phase.items.length > 0);
+	for (const phase of finalized) {
+		phase.items = phase.items.map((item) => applyNow(item, input.now));
+		finalize(phase);
+	}
+	const all = finalized.flatMap((phase) => phase.items);
+	const counts = (state: WorkflowChecklistState): number => all.filter((item) => item.state === state).length;
+	const bottleneck = [...all].sort((left, right) => priority(left) - priority(right))[0];
+	return { phases: finalized, total: all.length, done: counts("complete"), running: counts("running"), queued: counts("queued"), blocked: counts("blocked"), failed: counts("failed"), paused: counts("paused"), stopped: counts("stopped"), ...(bottleneck && bottleneck.state !== "complete" ? { bottleneck } : {}) };
+}
+
+function stateLabel(state: WorkflowChecklistState): string {
+	return state === "running" ? "active" : state;
+}
+
+export function formatWorkflowChecklistSummary(projection: WorkflowChecklistProjection): string {
+	if (!projection.total) return "";
+	return [`${projection.done}/${projection.total} done`, projection.running ? `${projection.running} active` : undefined, projection.queued ? `${projection.queued} queued` : undefined, projection.blocked ? `${projection.blocked} blocked` : undefined, projection.failed ? `${projection.failed} failed` : undefined, projection.paused ? `${projection.paused} paused` : undefined, projection.stopped ? `${projection.stopped} stopped` : undefined].filter((value): value is string => Boolean(value)).join(" · ");
+}
+
+export function formatWorkflowChecklistPhase(phase: WorkflowChecklistPhase): string {
+	const counts = [phase.total > 1 && phase.done ? `${phase.done} done` : undefined, phase.running ? `${phase.running} active` : undefined, phase.queued ? `${phase.queued} queued` : undefined, phase.blocked ? `${phase.blocked} blocked` : undefined, phase.failed ? `${phase.failed} failed` : undefined, phase.paused ? `${phase.paused} paused` : undefined, phase.stopped ? `${phase.stopped} stopped` : undefined].filter((value): value is string => Boolean(value));
+	return counts.length ? `${phase.label} ${counts.join(" · ")}` : phase.label;
+}
+
+export function formatWorkflowChecklistBottleneck(item: WorkflowChecklistItem | undefined, options: { includeOutput?: boolean } = {}): string | undefined {
+	if (!item) return undefined;
+	const identity = [item.label, item.agent && item.agent !== item.label ? item.agent : undefined].filter((value): value is string => Boolean(value)).join(" · ") || item.key;
+	const includeOutput = options.includeOutput ?? true;
+	const details = [item.context ? `(${item.context})` : undefined, item.currentTool ? `${item.currentTool}${item.durationMs !== undefined ? ` ${formatDurationText(item.durationMs)}` : ""}` : undefined, !item.currentTool && item.currentPath ? item.currentPath : undefined, !item.currentTool && item.durationMs !== undefined ? formatDurationText(item.durationMs) : undefined, item.toolCount !== undefined ? `${item.toolCount} tools` : undefined, includeOutput && item.outputName ? `out:${item.outputName}` : undefined, item.error ? `error:${item.error.replace(/\bOutput:/g, "output:")}` : undefined].filter((value): value is string => Boolean(value));
+	return [identity, ...details].join(" · ");
+}
+
+function formatWorkflowChecklistItem(item: WorkflowChecklistItem): string {
+	const identity = [item.label, item.agent && item.agent !== item.label ? item.agent : undefined].filter((value): value is string => Boolean(value)).join(" · ") || item.key;
+	const details = [item.kind && item.monitorKind ? item.monitorKind : undefined, item.provider ? `provider:${item.provider}` : undefined, item.role ? `role:${item.role}` : undefined, item.target, item.currentTool, !item.currentTool && item.currentPath ? item.currentPath : undefined, item.durationMs !== undefined ? formatDurationText(item.durationMs) : undefined, item.toolCount !== undefined ? `${item.toolCount} tools` : undefined, item.outputName ? `out:${item.outputName}` : undefined, item.reportPath ? `out:${item.reportPath}` : undefined, item.stale ? "stale" : undefined, item.reasonCode ? `reason:${item.reasonCode}` : undefined, item.error ? `error:${item.error.replace(/\bOutput:/g, "output:")}` : undefined].filter((value): value is string => Boolean(value));
+	return `${identity}${item.context ? ` (${item.context})` : ""}${item.state === "complete" ? "" : ` · ${stateLabel(item.state)}`}${details.length ? ` · ${details.join(" · ")}` : ""}`;
+}
+
+function formatDurationText(ms: number): string {
+	const seconds = Math.max(0, Math.round(ms / 1000));
+	return seconds < 60 ? `${seconds}s` : `${Math.floor(seconds / 60)}m ${seconds % 60}s`;
+}
+
+export function formatWorkflowChecklistText(projection: WorkflowChecklistProjection, indent = "", options: { includeItems?: boolean } = {}): string[] {
+	if (!projection.total) return [];
+	const lines = [`${indent}Workflow checklist: ${formatWorkflowChecklistSummary(projection)}`];
+	for (const phase of projection.phases) {
+		const phaseMarker = phase.state === "complete" ? "✓" : phase.state === "running" ? "⠼" : phase.state === "blocked" ? "!" : phase.state === "failed" ? "✗" : phase.state === "paused" || phase.state === "stopped" ? "■" : "◦";
+		lines.push(`${indent}  ${phaseMarker} ${formatWorkflowChecklistPhase(phase)}`);
+		if (options.includeItems === false) continue;
+		for (const item of phase.items) {
+			const marker = item.state === "complete" ? "✓" : item.state === "running" ? "⠼" : item.state === "blocked" ? "!" : item.state === "failed" ? "✗" : item.state === "paused" || item.state === "stopped" ? "■" : "◦";
+			lines.push(`${indent}    ${marker} ${formatWorkflowChecklistItem(item)}`);
+		}
+	}
+	const bottleneck = formatWorkflowChecklistBottleneck(projection.bottleneck);
+	if (bottleneck) lines.push(`${indent}  bottleneck · ${bottleneck}`);
+	return lines;
+}