@deepseek-insight/dsi 0.6.16 → 0.6.18

package/README.md

@@ -1,6 +1,6 @@
 # DeepSeek Insight
 
-> [DeepSeek Insight](https://github.com/mitmplay/deepseek-insight) (**DSI**) **See your multiple agents run on the floor (agent, sub-agent, etc)**, each **conversation on the floor are updated instantly**. 
+> [DeepSeek Insight](https://github.com/mitmplay/dsh-insight) (**DSI**) **See your multiple agents run on the floor (agent, sub-agent, etc)**, each **conversation on the floor are updated instantly**. 
 
 > A `Control room` built on [Deepseek Harness's](https://github.com/deepseek-ai/deepseek-harness) (**DSH**) **records**: any (running) session, show side by side on the floor; **Lineage tree** of **parent to sub-agents**; Clean conversation with **tool-call(s) chips** with status **+** auto-expand **thingking chips**. 
 
@@ -43,7 +43,7 @@ The workspace explorer is DSI's window into the folder your agents are working i
 
 <details>
   <summary>Deepseek-insight-panels</summary>
-  <img src="https://raw.githubusercontent.com/mitmplay/deepseek-insight/refs/heads/main/docs/images/dsi-panels.png"/>
+  <img src="https://raw.githubusercontent.com/mitmplay/dsh-insight/refs/heads/main/docs/images/dsi-panels.png"/>
 </details>
 
 ---

package/bin/dsi.mjs

@@ -28,7 +28,7 @@ import { fileURLToPath } from 'node:url';
 import { parse, stringify } from 'yaml';
 
 import { mirrorSkills } from './lib/mirror-skills.mjs';
-import { dshLauncherCmd, parsePluginArgs, takeoverFloorPorts } from './lib/plugin-chain.mjs';
+import { dshLauncherCmd, parsePluginArgs, takeoverFloorPorts, hostBounceDecision, floorUiPort, parseDevFloorPids, launchUrl, tokenFromSettings } from './lib/plugin-chain.mjs';
 import { parseDevArg, devModeEnv, modeFromBoolean, resolveBounceMode, extractInspectArgs, parseInspectArgsFromEnv } from './lib/dev-mode.mjs';
 
 // Layman-facing help: wrapped near 76 columns, continuation lines indented,
@@ -260,18 +260,53 @@ if (command === 'dsh') {
 		// records the mode records the inspector flags — re-forward them so
 		// the bounce boot comes back debuggable when it left that way.
 		const bounceExecArgv = parseInspectArgsFromEnv(floorEnvDump);
-		killOrphans();
-		// The pkill sweep cannot see every floor shape (RCA 2026-09-27: the
-		// npx shims — 'npm exec @deepseek-ai/dsh…' and '.bin/dsh web' — are
-		// invisible to pkill -f on macOS, so the dsh host survived holding
-		// 3080 and preflightPort exited 64, killing the detached chain
-		// silently). The bounce chain owns the DSI ports by contract, so
-		// free them by listener, not by name.
-		await freeFloorPorts(floorPortSet());
-		// Restore the SAME UI mode the floor was serving. The bounce's
-		// boolean signal normalizes to 'pair'/'build' inside runSyncedPair;
-		// 3.5 teaches the bounce the full enum via DSI_DEV_MODE.
-		runSyncedPair([], mode, bounceExecArgv);
+		// ADR-0025 D1/D3 — the bounce fork: an in-process floor with a live
+		// bounce verb bounces AT THE HOST via the running floor's route; the
+		// vite process never dies and the sweep is SKIPPED. Pair/build floors,
+		// a missing verb, or an unreachable route take the sweep below.
+		const sweepAndReserve = async () => {
+			killOrphans();
+			// The pkill sweep cannot see every floor shape (RCA 2026-09-27: the
+			// npx shims — 'npm exec @deepseek-ai/dsh…' and '.bin/dsh web' — are
+			// invisible to pkill -f on macOS, so the dsh host survived holding
+			// 3080 and preflightPort exited 64, killing the detached chain
+			// silently). The bounce chain owns the DSI ports by contract, so
+			// free them by listener, not by name.
+			await freeFloorPorts(floorPortSet());
+			// Restore the SAME UI mode the floor was serving. The bounce's
+			// boolean signal normalizes to 'pair'/'build' inside runSyncedPair;
+			// 3.5 teaches the bounce the full enum via DSI_DEV_MODE.
+			runSyncedPair([], mode, bounceExecArgv);
+		};
+		const bounceVerdict = await hostBounceDecision({
+			mode,
+			post: async () => {
+				// ADR-0025 Wave 3 gate finding (2026-10-14): the route is a DSI
+				// (vite) route - POST the vite UI port, not the DSH host port.
+				const uiPort = floorUiPort({
+					floorEnv: floorEnvDump,
+					command: floorCommand(devFloorPid())
+				});
+				const res = await fetch('http://127.0.0.1:' + uiPort + '/api/plugins/host-bounce', { method: 'POST' });
+				return res.ok;
+			},
+			sweep: sweepAndReserve,
+		});
+		if (bounceVerdict === 'host') {
+			console.log('dsi dsh: host-level bounce done via the running floor — vite never died, sweep skipped (ADR-0025)');
+			// D4 amended (2026-10-14): the DSH launch token is minted inside the
+			// host process (dsh-client-connection processLaunchToken, a WeakMap on
+			// the cordis root — no preset seam), so the bounce CANNOT re-boot with
+			// the old token. The bounce's announce intercept lands the NEW token in
+			// settings.yaml; hand the operator a URL that works on first click.
+			await new Promise((r) => setTimeout(r, 1500));
+			const fresh = tokenFromSettings(readFileSync(dsiConfigPath(), 'utf-8'));
+			const url = launchUrl({ port: process.env.DSH_HOST_PORT ?? 3080, token: fresh });
+			if (url) console.log('dsi dsh: fresh launch URL after the bounce (loaded pages keep working — durable cookie):\n\t  ' + url);
+		} else {
+			console.log('dsi dsh: host bounce unavailable — whole-floor sweep fallback (ADR-0025 D3)');
+			await sweepAndReserve();
+		}
 	} else if (flag === '--sync-kills') {
 		killOrphans();
 		process.exit(0);
@@ -521,21 +556,42 @@ async function freeFloorPorts(ports) {
 
 /** True when a vite dev server of THIS checkout is alive. Only the
  *  checkout's own vite matches — a foreign project's dev server never
- *  carries the deepseek-insight path segment. pgrep sees this process
- *  (it does not rewrite argv the way the npm/npx shims do), so the probe
- *  is reliable where the orphan sweep's name matching is not. */
+ *  carries the deepseek-insight path segment. ADR-0025 Wave 3 (2026-10-14):
+ *  the probe rides devFloorPid's ps -eo discovery — pgrep -f went blind to
+ *  the vite process on the live floor, so this boolean read false-negative
+ *  and the bounce chain swept floors it could have host-bounced. */
 function isDevFloorAlive() {
-	const probe = spawnSync('pgrep', ['-f', 'deepseek-insight/node_modules/vite/bin/vite.js'], { stdio: 'pipe' });
-	return (probe.status ?? 1) === 0;
+	return devFloorPid() !== null;
 }
 
 /** The alive dev floor's vite pid (first match), or null. Same match rule
  *  as isDevFloorAlive — the pid feeds the D6 mode read (ps -E). */
 function devFloorPid() {
-	const probe = spawnSync('pgrep', ['-f', 'deepseek-insight/node_modules/vite/bin/vite.js'], { stdio: 'pipe' });
+
+	// ADR-0025 Wave 3 gate finding (2026-10-14): pgrep -f went BLIND to the
+	// vite process on the live floor (exit 1 while ps listed it), so the
+	// chain misread the floor as absent and swept a bounceable in-process
+	// floor. ps -eo pid,command sees what pgrep does not; the parse is the
+	// pure parseDevFloorPids twin in plugin-chain.mjs.
+	const probe = spawnSync('ps', ['-eo', 'pid=,command='], { stdio: 'pipe', timeout: 5000 });
 	if ((probe.status ?? 1) !== 0) return null;
-	const first = (probe.stdout?.toString() || '').split('\n').find(Boolean);
-	return first ? first.trim() : null;
+	const first = parseDevFloorPids(probe.stdout?.toString() || '')[0];
+	return first ?? null;
+}
+
+/** The floor process's command line (ps -o command), or '' on any failure -
+ *  feeds floorUiPort's --port arm (the launcher passes the vite port as an
+ *  argument, not as env). */
+function floorCommand(pid) {
+	if (!pid) return '';
+	try {
+		const ps = spawnSync('ps', ['-o', 'command', '-p', String(pid)], { stdio: 'pipe', timeout: 5000 });
+		if (ps.status !== 0) return '';
+		const lines = (ps.stdout?.toString() || '').split('\n').filter(Boolean);
+		return lines.length > 1 ? lines.slice(1).join('\n') : '';
+	} catch {
+		return '';
+	}
 }
 
 /** The floor's DSI_DEV_MODE via ps -E (macOS: own processes only). Returns

package/bin/lib/dev-mode.mjs

@@ -24,6 +24,7 @@ const DEV_VALUES = new Set(['in-process', 'pair']);
  */
 export function parseDevArg(rest) {
 	const out = [];
+	/** @type {'build' | 'pair' | 'in-process'} */
 	let mode = 'build';
 	for (let i = 0; i < rest.length; i++) {
 		const arg = rest[i];
@@ -48,10 +49,23 @@ export function parseDevArg(rest) {
  * DSI_DEV=1 is the pre-existing dev-floor marker (RCA 2026-09-27) — kept for
  * the bounce chain's boolean probe; DSI_DEV_MODE is the D6 mode enum.
  */
+/** @param {string} mode
+ * @returns {Record<string, string>}
+ */
 export function devModeEnv(mode) {
 	if (mode === 'build') return {};
+	/** @type {Record<string, string>} */
 	const env = { DSI_DEV: '1', DSI_DEV_MODE: mode };
-	if (mode === 'in-process') env.DSI_DEV_IN_PROCESS = '1';
+	if (mode === 'in-process') {
+		env.DSI_DEV_IN_PROCESS = '1';
+		// ADR-0025 Wave 3 (real-floor gate finding, 2026-10-14): the bounce
+		// verb only exists when the embed OWNS the host - a runCli boot has
+		// no stop handle and the host-bounce route answers 409 no-handle,
+		// sending every in-process bounce down the whole-floor sweep. The
+		// introspection boot (DSH_HOST_INTROSPECT=1, ADR-0024) is the boot
+		// that carries the handle, so in-process floors default to it.
+		env.DSH_HOST_INTROSPECT = '1';
+	}
 	return env;
 }
 
@@ -60,6 +74,9 @@ export function devModeEnv(mode) {
  * to a mode. Wave 3.5 will teach the bounce the enum; until then the bounce
  * can only ever restore 'pair' or 'build'.
  */
+/** @param {boolean} dev
+ * @returns {'pair' | 'build'}
+ */
 export function modeFromBoolean(dev) {
 	return dev ? 'pair' : 'build';
 }

package/bin/lib/plugin-chain.mjs

@@ -77,6 +77,103 @@ export function bounceDevMode(flagDev, devFloorAlive) {
 export const TAKEOVER_BUDGET_MS = 10_000;
 export const TAKEOVER_POLL_MS = 250;
 
+/** The host-level bounce's retry window (ADR-0025 D3): the chain POSTs the
+ *  running floor's /api/plugins/host-bounce at most this many times before
+ *  giving up and taking the whole-floor sweep fallback. */
+export const HOST_BOUNCE_TRIES = 2;
+export const HOST_BOUNCE_RETRY_MS = 1_000;
+
+/**
+ * The bounce fork (ADR-0025 D1/D3): an in-process floor with a live bounce
+ * verb bounces AT THE HOST — the chain POSTs the route and, on ok, sweeps
+ * NOTHING (vite never dies). Any other mode, refusal, or unreachable route
+ * falls back to today's whole-floor sweep. Pure orchestration: the POST and
+ * the sweep are injected, so unit tests pin BOTH branches.
+ *
+ * @param {{ mode: string, post: () => Promise<boolean>, sweep: () => void | Promise<void>,
+ *            sleep?: (ms: number) => Promise<void>, tries?: number }} params
+ * @returns {Promise<'host' | 'sweep'>} which body ran
+ */
+export async function hostBounceDecision({ mode, post, sweep, sleep = (ms) => new Promise((r) => setTimeout(r, ms)), tries = HOST_BOUNCE_TRIES }) {
+	if (mode !== 'in-process') {
+		await sweep();
+		return 'sweep';
+	}
+	for (let attempt = 1; attempt <= tries; attempt++) {
+		try {
+			if ((await post()) === true) return 'host';
+		} catch {
+			// unreachable or refused — retry, then sweep
+		}
+		if (attempt < tries) await sleep(HOST_BOUNCE_RETRY_MS);
+	}
+	await sweep();
+	return 'sweep';
+}
+
+/** The browser launch URL after a bounce (ADR-0025 D4, amended
+ *  2026-10-14): the DSH launch token is minted INSIDE the host process
+ *  (WeakMap keyed on the cordis root, dsh-client-connection processLaunchToken)
+ *  and has no preset seam, so an in-place bounce cannot re-boot with the OLD
+ *  token. The equivalent guarantee: after the bounce the chain reads the NEW
+ *  token from the sink and hands the operator a URL that works on first
+ *  click. Pure: port and token are injected.
+ *
+ * @param {{ port?: number|string, token?: string, host?: string }} p
+ * @returns {string} the launch URL ('' when the token is unknown)
+ */
+export function launchUrl({ port = 3080, token = '', host = '127.0.0.1' } = {}) {
+	if (!token) return '';
+	return 'http://' + host + ':' + port + '/?token=' + encodeURIComponent(token);
+}
+
+/** Reads dsh.authToken out of the DSI settings.yaml text. Pure: the file
+ *  text is injected; dsi.mjs reads the file.
+ *
+ * @param {string} yamlText - full settings.yaml text
+ * @returns {string} the token ('' when absent or not parseable)
+ */
+export function tokenFromSettings(yamlText) {
+	const m = /authToken:\s*['"]?([^"'/\s]+)/.exec(String(yamlText || ''));
+	return m ? m[1] : '';
+}
+
+/** The dev floor's vite pid(s) parsed from ONE ps -eo pid,command dump
+ *  (ADR-0025 Wave 3 gate finding, 2026-10-14): pgrep -f proved blind to the
+ *  vite process on the live floor (exit 1 while ps listed it), which made
+ *  the bounce chain misread the mode and sweep a bounceable floor. ps -eo
+ *  sees what pgrep does not, and parsing is pure + unit-pinned here; the
+ *  ps invocation stays in dsi.mjs.
+ *
+ * @param {string} psOutput - full `ps -eo pid=,command=` dump
+ * @returns {string[]} matching pids (as strings), oldest-first order kept
+ */
+export function parseDevFloorPids(psOutput) {
+	return String(psOutput || '').split('\n').flatMap((line) => {
+		const m = /^\s*(\d+)\s+(.*)$/.exec(line);
+		return m && m[2].includes('node_modules/vite/bin/vite.js') ? [m[1]] : [];
+	});
+}
+
+/** The port the floor's DSI UI answers on (ADR-0025 Wave 3 gate finding,
+ *  2026-10-14): the host-bounce route is a DSI (vite) route, so the bounce
+ *  chain must POST the VITE port - the DSH host port only knows the fence
+ *  (401) or 404. Resolution order: PORT= in the floor env dump, then
+ *  --port N on the vite command line, then the 5175 default the launcher
+ *  pins. Pure: both inputs are strings read by dsi.mjs (ps -E and ps -o
+ *  command), so unit tests pin all three arms.
+ *
+ * @param {{ floorEnv?: string, command?: string }} params
+ * @returns {number} the UI port
+ */
+export function floorUiPort({ floorEnv = '', command = '' } = {}) {
+	const envPort = /(?:^|\s)PORT=(\d+)/.exec(floorEnv || '');
+	if (envPort) return Number(envPort[1]);
+	const argPort = /--port\s+(\d+)/.exec(command || '');
+	if (argPort) return Number(argPort[1]);
+	return 5175;
+}
+
 /**
  * The takeover sweep (The Port Takeover ADR 2026-10-12, D2/D3/D5): SIGTERM
  * whatever LISTENS on the given ports, then WAIT until each port frees,