mainflow 0.7.0 → 0.9.0

package/dist/cli.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
-import { A as createFinding, C as startSession, E as sessionBriefing, F as setFindingStatus, H as TASK_FILE, I as setIssueArchived, L as HubError, M as planIssue, N as reopenIssue, O as appendOps, P as setFindingArchived, R as loadHub, S as setSessionStatus, T as updateAction, V as MAINLINE_FILE, W as WriteError, a as createDecision, b as setSessionArchived, c as dropChecklistItem, d as setChecklistItem, f as setCriterion, g as addAction, h as updateTask, i as addRepo, j as createIssue, k as closeIssue, l as initHub, m as supersedeDecision, n as acceptDecision, o as createMainline, p as setMainlineStatus, q as findHubRoot, r as addHub, s as createTask, t as migrateHub, u as setArchived, y as readSession } from "./dist-BktkzRuK.js";
-import { r as launchUi, s as listProgress } from "./launch-BR70uSMc.js";
+import { A as appendOps, B as loadHub, C as setSessionStatus, D as updateAction, F as reopenIssue, I as setFindingArchived, K as WriteError, L as setFindingStatus, M as createFinding, N as createIssue, O as sessionBriefing, P as planIssue, R as setIssueArchived, T as startSession, U as MAINLINE_FILE, W as TASK_FILE, Y as findHubRoot, _ as addAction, a as createDecision, b as readSession, c as dropChecklistItem, d as setChecklistItem, f as setCriterion, g as updateTask, h as supersedeDecision, i as addRepo, j as closeIssue, l as initHub, n as acceptDecision, o as createMainline, p as setMainlineStatus, r as addHub, s as createTask, t as migrateHub, u as setArchived, x as setSessionArchived, z as HubError } from "./dist-_ArTiNbL.js";
+import { c as listProgress, r as launchUi, s as CLI_VERSION } from "./launch-D2WJRvPD.js";
 import { COMMAND_SPECS, OPTIONS } from "./facts.js";
 import { runHook } from "./hooks.js";
 import { readFileSync, realpathSync } from "node:fs";
@@ -249,7 +249,7 @@ function run(argv, cwd) {
 		return fail(`${error.message}\n\n${USAGE}`);
 	}
 	const { values: opts, positionals } = parsed;
-	if (opts.version) return done(JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8")).version);
+	if (opts.version) return done(CLI_VERSION);
 	if (opts.help || positionals.length === 0) {
 		console.log(USAGE);
 		return opts.help ? 0 : 1;

package/dist/{dist-BktkzRuK.js → dist-_ArTiNbL.js}

@@ -1042,11 +1042,17 @@ function splitActionRef(ref) {
 		action
 	};
 }
-/** Every served checklist item must exist, so a session never points at work that is not in a mainline. */
+/**
+* Every served checklist item must exist, so a session never points at work that is not in a mainline. Its
+* mainline must still be open: follow-up work on an ended one either reopens it with a criterion or task for the
+* follow-up, or starts a new mainline, so the follow-up is tracked instead of hanging off finished work.
+*/
 function requireServes(root, serves) {
 	for (const ref of serves) {
 		const parsed = parseRef(ref);
 		if (!CHECKLIST_REF.test(ref) || parsed?.kind !== "checklistItem") throw new WriteError(`--serves takes checklist references like m001/t002#c003, got "${ref}"`);
+		const mainline = readFrontMatter(mainlineFile(root, parsed.mainline), mainlineSchema).data;
+		if (CLOSED_STATUS.mainline.includes(mainline.status)) throw new WriteError(`${parsed.mainline} is ${mainline.status}; to continue it, run "mainline set ${parsed.mainline} --status active" and add a criterion or task for the follow-up, or start a new mainline with "new mainline"`);
 		if (!readFrontMatter(taskFile(root, parsed.mainline, parsed.task), taskSchema).data.checklist.some((c) => c.id === parsed.item)) throw new WriteError(`checklist item ${ref} not found`);
 	}
 }
@@ -1126,6 +1132,31 @@ function setSessionStatus(root, id, status) {
 		s.status = value;
 	});
 }
+/**
+* Settle a session when its turn ends. A session that tracked no action, and whose subagents tracked none, leaves
+* no record, since nothing in it points at the hub's work. An active session whose actions are all done or dropped
+* and whose subagents have all stopped ends. The next prompt or action brings it back.
+*/
+function settleSession(root, id) {
+	return withLock(root, () => {
+		const session = readSession(root, id);
+		if (!session) return "kept";
+		const { sessions } = loadSessions(root);
+		const subagents = (parent) => sessions.filter((s) => s.delegatedFrom === parent).flatMap((s) => [s, ...subagents(s.id)]);
+		const family = [session, ...subagents(id)];
+		if (family.every((s) => s.actions.length === 0)) {
+			for (const s of family) rmSync(sessionFile(root, s.id), { force: true });
+			return "removed";
+		}
+		const finished = session.actions.length > 0 && session.actions.every((a) => a.status === "done" || a.status === "dropped");
+		if (session.status !== "active" || !finished || family.slice(1).some((s) => s.status === "active")) return "kept";
+		writeAtomic(sessionFile(root, id), toYaml(validate(sessionSchema, {
+			...session,
+			status: "ended"
+		}, sessionFile(root, id))));
+		return "ended";
+	});
+}
 /** Archive or unarchive a session; the status stays as it is, so an ended session is visible until archived. */
 function setSessionArchived(root, id, archived) {
 	return mutateYaml(root, requireSession(root, id), sessionSchema, (s) => {
@@ -1153,6 +1184,7 @@ function addAction(root, sessionId, input) {
 			status: "todo",
 			serves: input.serves
 		}, input.before);
+		if (s.status === "ended") s.status = "active";
 	});
 	return `${sessionId}#${created}`;
 }
@@ -1292,6 +1324,15 @@ function setMainlineStatus(root, id, status, expectedVersion) {
 		stampClosed(m, closes("mainline", next), today());
 	}, expectedVersion);
 }
+/** Rename a mainline. References use its ID, so they keep resolving and show the new title. */
+function setMainlineTitle(root, id, title, expectedVersion) {
+	requireRef(id, "mainline");
+	const next = title.replace(/\s+/g, " ").trim();
+	if (!next) throw new WriteError(`${id} needs a title, e.g. "mainflow 改發布到 npm 公開套件"`);
+	return mutateFrontMatter(root, mainlineFile(root, id), mainlineSchema, (m) => {
+		m.title = next;
+	}, expectedVersion);
+}
 function setArchived(root, id, archived, expectedVersion) {
 	requireRef(id, "mainline");
 	return mutateFrontMatter(root, mainlineFile(root, id), mainlineSchema, (m) => {
@@ -1612,4 +1653,4 @@ function migrateHub(root, options = {}) {
 	});
 }
 //#endregion
-export { createFinding as A, refIndex as B, startSession as C, turnReminder as D, sessionBriefing as E, setFindingStatus as F, DATA_DIR as G, TASK_FILE as H, setIssueArchived as I, worktreesOf as J, currentBranch as K, HubError as L, planIssue as M, reopenIssue as N, appendOps as O, setFindingArchived as P, loadHub as R, setSessionStatus as S, updateAction as T, ConflictError as U, MAINLINE_FILE as V, WriteError as W, ensureSession as _, createDecision as a, setSessionArchived as b, dropChecklistItem as c, setChecklistItem as d, setCriterion as f, addAction as g, updateTask as h, addRepo as i, createIssue as j, closeIssue as k, initHub as l, supersedeDecision as m, acceptDecision as n, createMainline as o, setMainlineStatus as p, findHubRoot as q, addHub as r, createTask as s, migrateHub as t, setArchived as u, loadSessions as v, transcriptPath as w, setSessionInfo as x, readSession as y, linksInto as z };
+export { appendOps as A, loadHub as B, setSessionStatus as C, updateAction as D, transcriptPath as E, reopenIssue as F, ConflictError as G, refIndex as H, setFindingArchived as I, currentBranch as J, WriteError as K, setFindingStatus as L, createFinding as M, createIssue as N, sessionBriefing as O, planIssue as P, setIssueArchived as R, setSessionInfo as S, startSession as T, MAINLINE_FILE as U, linksInto as V, TASK_FILE as W, worktreesOf as X, findHubRoot as Y, addAction as _, createDecision as a, readSession as b, dropChecklistItem as c, setChecklistItem as d, setCriterion as f, updateTask as g, supersedeDecision as h, addRepo as i, closeIssue as j, turnReminder as k, initHub as l, setMainlineTitle as m, acceptDecision as n, createMainline as o, setMainlineStatus as p, DATA_DIR as q, addHub as r, createTask as s, migrateHub as t, setArchived as u, ensureSession as v, settleSession as w, setSessionArchived as x, loadSessions as y, HubError as z };

package/dist/hooks.js

@@ -1,4 +1,4 @@
-import { D as turnReminder, E as sessionBriefing, G as DATA_DIR, J as worktreesOf, K as currentBranch, L as HubError, R as loadHub, S as setSessionStatus, _ as ensureSession, q as findHubRoot, x as setSessionInfo, y as readSession } from "./dist-BktkzRuK.js";
+import { B as loadHub, C as setSessionStatus, J as currentBranch, O as sessionBriefing, S as setSessionInfo, X as worktreesOf, Y as findHubRoot, b as readSession, k as turnReminder, q as DATA_DIR, v as ensureSession, w as settleSession, z as HubError } from "./dist-_ArTiNbL.js";
 import { appendFileSync, existsSync, readFileSync } from "node:fs";
 import { basename, dirname, isAbsolute, join, relative, resolve } from "node:path";
 //#region src/hooks.ts
@@ -26,22 +26,36 @@ const claudeCodeSessionId = (raw) => `claude-code-${shortId(raw)}`;
 * One handler per Claude Code event; each returns what to print for the model, or null. SessionStart and
 * UserPromptSubmit take plain text; PostToolUse takes the hook JSON, since its plain stdout never reaches the model.
 */
+/**
+* Record the main session: create it when it is missing, since a turn that tracked nothing left no record, and
+* bring an ended or archived one back, since the viewer is working in it again. Its environment facts are
+* written when it is created and whenever `refresh` asks, such as on SessionStart after a resume.
+*/
+function recordSession(root, payload, id, refresh) {
+	const cwd = payload.cwd ?? root;
+	const { session, created } = ensureSession(root, {
+		id,
+		agent: "claude-code",
+		cwd
+	});
+	if (!created && !refresh) return session;
+	return setSessionInfo(root, id, {
+		transcript: payload.transcript_path,
+		worktree: worktreesOf(cwd)?.current,
+		branch: currentBranch(cwd) ?? void 0,
+		effort: payload.effort?.level
+	});
+}
+/** Settle the main session by the rules settleSession states; prints nothing. */
+const settleOnEnd = (root, { payload }) => {
+	if (payload.session_id) settleSession(root, claudeCodeSessionId(payload.session_id));
+	return null;
+};
 const CLAUDE_CODE_EVENTS = {
 	"session-start": (root, { payload, envFile, cli }) => {
 		if (!payload.session_id) return null;
 		const id = claudeCodeSessionId(payload.session_id);
-		const cwd = payload.cwd ?? root;
-		ensureSession(root, {
-			id,
-			agent: "claude-code",
-			cwd
-		});
-		const session = setSessionInfo(root, id, {
-			transcript: payload.transcript_path,
-			worktree: worktreesOf(cwd)?.current,
-			branch: currentBranch(cwd) ?? void 0,
-			effort: payload.effort?.level
-		});
+		const session = recordSession(root, payload, id, true);
 		if (envFile) appendFileSync(envFile, `export MAINFLOW_SESSION=${id}\n`);
 		return sessionBriefing(root, session, {
 			cli,
@@ -49,9 +63,11 @@ const CLAUDE_CODE_EVENTS = {
 		});
 	},
 	"user-prompt-submit": (root, { payload, cli }) => {
-		const session = payload.session_id ? readSession(root, claudeCodeSessionId(payload.session_id)) : null;
-		return session ? turnReminder(root, session, { cli }) : null;
+		if (!payload.session_id) return null;
+		return turnReminder(root, recordSession(root, payload, claudeCodeSessionId(payload.session_id), false), { cli });
 	},
+	stop: settleOnEnd,
+	"session-end": settleOnEnd,
 	"subagent-start": (root, { payload }) => {
 		if (!payload.agent_id) return null;
 		const parent = payload.session_id ? claudeCodeSessionId(payload.session_id) : null;

package/dist/host.js

@@ -1,4 +1,4 @@
-import { G as DATA_DIR, W as WriteError } from "./dist-BktkzRuK.js";
+import { K as WriteError, q as DATA_DIR } from "./dist-_ArTiNbL.js";
 import { existsSync, lstatSync, mkdirSync, readFileSync, readlinkSync, realpathSync, rmSync, symlinkSync, writeFileSync } from "node:fs";
 import { dirname, join, resolve } from "node:path";
 import { spawnSync } from "node:child_process";

package/dist/{launch-BR70uSMc.js → launch-D2WJRvPD.js}

@@ -1,4 +1,4 @@
-import { B as refIndex, G as DATA_DIR, I as setIssueArchived, P as setFindingArchived, R as loadHub, U as ConflictError, W as WriteError, b as setSessionArchived, d as setChecklistItem, f as setCriterion, h as updateTask, p as setMainlineStatus, u as setArchived, v as loadSessions, w as transcriptPath, y as readSession, z as linksInto } from "./dist-BktkzRuK.js";
+import { B as loadHub, E as transcriptPath, G as ConflictError, H as refIndex, I as setFindingArchived, K as WriteError, R as setIssueArchived, V as linksInto, b as readSession, d as setChecklistItem, f as setCriterion, g as updateTask, m as setMainlineTitle, p as setMainlineStatus, q as DATA_DIR, u as setArchived, x as setSessionArchived, y as loadSessions } from "./dist-_ArTiNbL.js";
 import { DEFAULT_UI_PORT, syncHost } from "./host.js";
 import { createRequire } from "node:module";
 import { closeSync, existsSync, mkdirSync, openSync, readFileSync, readSync, statSync, watch, writeFileSync } from "node:fs";
@@ -214,6 +214,10 @@ function listProgress(items) {
 	};
 }
 //#endregion
+//#region src/version.ts
+/** This CLI's own version, from the package manifest one level above both src/ and dist/. */
+const CLI_VERSION = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8")).version;
+//#endregion
 //#region src/server.ts
 /** Every reference with a hub prefix in the documents of `hub`: links, origins and replaced items. */
 function prefixedRefs(hub) {
@@ -323,6 +327,7 @@ function createApp(root) {
 		const hub = loadHub(root);
 		const body = {
 			hub: hub.config.hub,
+			version: CLI_VERSION,
 			repos: hub.config.repos,
 			mainlines: hub.mainlines.map(summarize),
 			openIssues: hub.issues.filter((i) => i.status !== "closed").length,
@@ -415,6 +420,10 @@ function createApp(root) {
 		const { archived, version } = await c.req.json();
 		return c.json(setArchived(root, c.req.param("m"), archived, version));
 	});
+	app.post("/api/mainlines/:m/title", async (c) => {
+		const { title, version } = await c.req.json();
+		return c.json(setMainlineTitle(root, c.req.param("m"), title, version));
+	});
 	app.post("/api/mainlines/:m/status", async (c) => {
 		const { status, version } = await c.req.json();
 		return c.json(setMainlineStatus(root, c.req.param("m"), status, version));
@@ -476,19 +485,24 @@ function serveUi(root, port) {
 //#region src/launch.ts
 /** How many ports above DEFAULT_UI_PORT are tried before giving up. */
 const PORT_SPAN = 100;
-/** Where the last port used is remembered: machine-specific, so under the unversioned local/ folder. */
-const lastPortFile = (root) => join(root, DATA_DIR, "local", "ui.json");
-function readLastPort(root) {
+/** Where the last server started is remembered: machine-specific, so under the unversioned local/ folder. */
+const uiRecordFile = (root) => join(root, DATA_DIR, "local", "ui.json");
+function readUiRecord(root) {
 	try {
-		const port = JSON.parse(readFileSync(lastPortFile(root), "utf8")).port;
-		return Number.isInteger(port) ? port : void 0;
+		const record = JSON.parse(readFileSync(uiRecordFile(root), "utf8"));
+		if (!Number.isInteger(record.port)) return void 0;
+		return {
+			port: record.port,
+			...Number.isInteger(record.pid) && { pid: record.pid },
+			...typeof record.version === "string" && { version: record.version }
+		};
 	} catch {
 		return;
 	}
 }
-function writeLastPort(root, port) {
+function writeUiRecord(root, record) {
 	mkdirSync(join(root, DATA_DIR, "local"), { recursive: true });
-	writeFileSync(lastPortFile(root), `${JSON.stringify({ port })}\n`);
+	writeFileSync(uiRecordFile(root), `${JSON.stringify(record)}\n`);
 }
 /**
 * Ports to try, in order. An explicit --port is the only candidate: the user asked for that port. Otherwise
@@ -503,13 +517,18 @@ function portCandidates(options) {
 		...range
 	].filter((p) => p !== void 0))];
 }
+const sleep = (ms) => new Promise((done) => setTimeout(done, ms));
 const networkProbe = {
-	async hubAt(port) {
+	async serverAt(port) {
 		try {
 			const res = await fetch(`http://localhost:${port}/api/hub`, { signal: AbortSignal.timeout(500) });
 			if (!res.ok) return null;
 			const body = await res.json();
-			return typeof body.hub === "string" ? body.hub : null;
+			if (typeof body.hub !== "string") return null;
+			return {
+				hub: body.hub,
+				...typeof body.version === "string" && { version: body.version }
+			};
 		} catch {
 			return null;
 		}
@@ -517,7 +536,29 @@ const networkProbe = {
 	isFree: (port) => new Promise((done) => {
 		const probe = createServer().once("error", () => done(false));
 		probe.listen(port, () => probe.close(() => done(true)));
-	})
+	}),
+	listenerOf(port) {
+		const out = spawnSync("lsof", [
+			"-nP",
+			`-iTCP:${port}`,
+			"-sTCP:LISTEN",
+			"-t"
+		], { encoding: "utf8" });
+		const pid = Number(out.stdout?.split("\n")[0]);
+		return out.status === 0 && Number.isInteger(pid) && pid > 0 ? pid : null;
+	},
+	async stop(pid, port) {
+		try {
+			process.kill(pid, "SIGTERM");
+		} catch {
+			return false;
+		}
+		for (let i = 0; i < 25; i++) {
+			await sleep(200);
+			if (await networkProbe.isFree(port)) return true;
+		}
+		return false;
+	}
 };
 /**
 * A candidate already serving this hub wins wherever it sits in the order, so a lost last-port record or a
@@ -525,15 +566,15 @@ const networkProbe = {
 * probe timeout. Otherwise the first free candidate; ports held by another hub or program are skipped.
 */
 async function choosePort(hub, candidates, probe = networkProbe) {
-	const owners = await Promise.all(candidates.map((port) => probe.hubAt(port)));
-	const running = candidates.find((_, i) => owners[i] === hub);
-	if (running !== void 0) return {
-		port: running,
-		running: true
+	const servers = await Promise.all(candidates.map((port) => probe.serverAt(port)));
+	const at = candidates.findIndex((_, i) => servers[i]?.hub === hub);
+	if (at >= 0) return {
+		port: candidates[at],
+		running: servers[at].version ?? ""
 	};
-	for (const [i, port] of candidates.entries()) if (owners[i] === null && await probe.isFree(port)) return {
+	for (const [i, port] of candidates.entries()) if (servers[i] === null && await probe.isFree(port)) return {
 		port,
-		running: false
+		running: void 0
 	};
 	const tried = candidates.length === 1 ? `port ${candidates[0]} is` : `ports ${candidates[0]} to ${candidates.at(-1)} are`;
 	throw new WriteError(`${tried} taken by other programs; free one, or pass --port <port>`);
@@ -560,20 +601,35 @@ async function launchUi(root, hub, configured, options) {
 		explicit = Number(options.port);
 		if (!Number.isInteger(explicit) || explicit < 1024 || explicit > 65535) throw new WriteError("--port must be an integer from 1024 to 65535, e.g. --port 4320");
 	}
+	const probe = options.probe ?? networkProbe;
+	const record = readUiRecord(root);
 	const choice = await choosePort(hub, portCandidates({
 		explicit,
 		configured,
-		last: readLastPort(root)
-	}), options.probe);
+		last: record?.port
+	}), probe);
+	let reuse = choice.running !== void 0;
+	if (reuse && choice.running !== CLI_VERSION) {
+		const from = choice.running || "unknown";
+		const pid = record?.port === choice.port && record.pid !== void 0 ? record.pid : probe.listenerOf(choice.port);
+		if (pid !== null && await probe.stop(pid, choice.port)) {
+			log(`! restarted: mainflow ${from} → ${CLI_VERSION}`);
+			reuse = false;
+		} else log(`! localhost:${choice.port} still runs mainflow ${from}, not ${CLI_VERSION}; stop it with \`kill $(lsof -ti tcp:${choice.port})\` and run mainflow ui again`);
+	}
 	let server;
-	if (!choice.running) {
+	if (!reuse) {
 		server = await serveUi(root, choice.port);
-		writeLastPort(root, choice.port);
+		writeUiRecord(root, {
+			port: choice.port,
+			pid: process.pid,
+			version: CLI_VERSION
+		});
 	}
 	const host = await syncHost(root, hub, choice.port, options.host);
 	if (host.url === null) log(`! host name not available: ${host.reason}`);
 	const url = host.url ?? `http://localhost:${choice.port}`;
-	log(`${choice.running ? "already running" : "mainflow ui"}: ${url} (localhost:${choice.port})`);
+	log(`${reuse ? "already running" : "mainflow ui"}: ${url} (localhost:${choice.port})`);
 	if (options.open) openUrl(url);
 	return {
 		url,
@@ -581,4 +637,4 @@ async function launchUi(root, hub, configured, options) {
 	};
 }
 //#endregion
-export { portCandidates as a, networkProbe as i, choosePort as n, readLastPort as o, launchUi as r, listProgress as s, PORT_SPAN as t };
+export { portCandidates as a, listProgress as c, networkProbe as i, choosePort as n, readUiRecord as o, launchUi as r, CLI_VERSION as s, PORT_SPAN as t };

package/dist/launch.d.ts

@@ -3,7 +3,13 @@ import { ServerType } from "@hono/node-server";
 //#region src/launch.d.ts
 /** How many ports above DEFAULT_UI_PORT are tried before giving up. */
 export declare const PORT_SPAN = 100;
-export declare function readLastPort(root: string): number | undefined;
+/** The server this hub last started: its port, and the process and version when it recorded them. */
+export interface UiRecord {
+  port: number;
+  pid?: number;
+  version?: string;
+}
+export declare function readUiRecord(root: string): UiRecord | undefined;
 /**
  * Ports to try, in order. An explicit --port is the only candidate: the user asked for that port. Otherwise
  * the hub's configured port, then the last one used, then the default range.
@@ -13,15 +19,25 @@ export declare function portCandidates(options: {
   configured?: number;
   last?: number;
 }): number[];
+/** What a mainflow interface on a port reports; servers older than 0.8.1 report no version. */
+export interface ServerInfo {
+  hub: string;
+  version?: string;
+}
 export interface PortProbe {
-  /** The hub name a mainflow interface on this port reports, or null when nothing mainflow answers. */
-  hubAt: (port: number) => Promise<string | null>;
+  /** The mainflow interface on this port, or null when nothing mainflow answers. */
+  serverAt: (port: number) => Promise<ServerInfo | null>;
   isFree: (port: number) => Promise<boolean>;
+  /** The process listening on this port, or null when it cannot be found. */
+  listenerOf: (port: number) => number | null;
+  /** Stop a process and wait until the port is free; false when it did not free up. */
+  stop: (pid: number, port: number) => Promise<boolean>;
 }
 export declare const networkProbe: PortProbe;
+/** A port to serve on; `running` is the version already serving this hub there, '' when it reports none. */
 export type PortChoice = {
   port: number;
-  running: boolean;
+  running?: string;
 };
 /**
  * A candidate already serving this hub wins wherever it sits in the order, so a lost last-port record or a

package/dist/launch.js

@@ -1,2 +1,2 @@
-import { a as portCandidates, i as networkProbe, n as choosePort, o as readLastPort, r as launchUi, t as PORT_SPAN } from "./launch-BR70uSMc.js";
-export { PORT_SPAN, choosePort, launchUi, networkProbe, portCandidates, readLastPort };
+import { a as portCandidates, i as networkProbe, n as choosePort, o as readUiRecord, r as launchUi, t as PORT_SPAN } from "./launch-D2WJRvPD.js";
+export { PORT_SPAN, choosePort, launchUi, networkProbe, portCandidates, readUiRecord };