anon-pi 0.6.0 → 0.8.0

package/src/anon-pi.ts

@@ -30,7 +30,7 @@
 // init's proxy detect/verify decisions). cli.ts owns only the impure edges (fs,
 // the interactive TUI, the netcage query, the spawn).
 
-import {existsSync} from 'node:fs';
+import {existsSync, readFileSync} from 'node:fs';
 import {homedir} from 'node:os';
 import {dirname, join, resolve} from 'node:path';
 import {fileURLToPath} from 'node:url';
@@ -237,6 +237,67 @@ export function machineJsonPath(env: AnonPiEnv, name: string): string {
 	return join(machineDir(env, name), 'machine.json');
 }
 
+/**
+ * The GLOBAL local-model models.json seed: `<home>/models.json`. The local model
+ * is a WORKSPACE-level thing (config.json holds ONE global `llm`, the single
+ * `--allow-direct` hole shared by every machine), so its generated models.json
+ * lives once at the workspace root and seeds EVERY machine's fresh home. A
+ * machine may override it with its own `machines/<M>/models.json` (see
+ * resolveModelsSeedPath) for the rare "this machine uses a different local
+ * model" case; by default all machines share this one.
+ */
+export function globalModelsSeedPath(env: AnonPiEnv): string {
+	return join(resolveAnonPiHome(env), MODELS_FILE);
+}
+
+/** The GLOBAL settings seed (the default-model selection): `<home>/settings-seed.json`. */
+export function globalSettingsSeedPath(env: AnonPiEnv): string {
+	return join(resolveAnonPiHome(env), SETTINGS_SEED_FILE);
+}
+
+/** A machine's OPTIONAL per-machine models.json override: `machines/<M>/models.json`. */
+export function machineModelsSeedPath(env: AnonPiEnv, name: string): string {
+	return join(machineDir(env, name), MODELS_FILE);
+}
+
+/** A machine's OPTIONAL per-machine settings seed override: `machines/<M>/settings-seed.json`. */
+export function machineSettingsSeedPath(env: AnonPiEnv, name: string): string {
+	return join(machineDir(env, name), SETTINGS_SEED_FILE);
+}
+
+/**
+ * PURE: resolve the models.json SEED path for a machine, per-machine override
+ * first, else the global one. `exists` is injected (the CLI passes existsSync)
+ * so this stays pure/testable. Returns the chosen path, or undefined when
+ * NEITHER exists (a machine with no local-model seed at all — pi starts with no
+ * models). The precedence is: `machines/<M>/models.json` (a deliberate
+ * per-machine override) > `<home>/models.json` (the global default).
+ */
+export function resolveModelsSeedPath(
+	env: AnonPiEnv,
+	machine: string,
+	exists: (p: string) => boolean,
+): string | undefined {
+	const perMachine = machineModelsSeedPath(env, machine);
+	if (exists(perMachine)) return perMachine;
+	const global = globalModelsSeedPath(env);
+	if (exists(global)) return global;
+	return undefined;
+}
+
+/** PURE: the settings-seed path for a machine (per-machine override > global), or undefined. */
+export function resolveSettingsSeedPath(
+	env: AnonPiEnv,
+	machine: string,
+	exists: (p: string) => boolean,
+): string | undefined {
+	const perMachine = machineSettingsSeedPath(env, machine);
+	if (exists(perMachine)) return perMachine;
+	const global = globalSettingsSeedPath(env);
+	if (exists(global)) return global;
+	return undefined;
+}
+
 /** The sessions dirname pi keeps its per-cwd conversation dirs under (in the agent dir). */
 export const SESSIONS_DIRNAME = 'sessions';
 
@@ -372,7 +433,9 @@ export const ROOT_TOKEN = '.';
  * reserved-name concept is explicit and extendable. `--mount`'s `/work` is a
  * CONTAINER path, not a name in this namespace, so it needs no reservation.
  */
-export const RESERVED_NAMES: readonly string[] = ['.', '..'];
+export const RESERVED_NAMES: readonly string[] = ['.', '..', 'pi'];
+// NOTE: `pi` is reserved so the `anon-pi pi <args…>` passthrough token
+// (PI_PASSTHROUGH_TOKEN) can never be shadowed by a project named `pi`.
 
 /** What a name names, for a clear validation error. */
 export type NameKind = 'machine' | 'project';
@@ -462,6 +525,24 @@ export function resolveCwd(kind: RootKind, token: string): string {
 	return `${rootCwd(kind)}/${validateName(token, 'project')}`;
 }
 
+/**
+ * PURE: the launch cwd for a resolved (mode, rootKind, project). With a project
+ * token it resolves under the active root (resolveCwd). With NO project: a
+ * `shell` sits at the machine home (`/root`) — the "sit on the machine" mode —
+ * while `pi` (a `--session`/`--resume` launch that pi cwd-switches itself) starts
+ * at the projects root (`rootCwd`), a real pi launch position. `menu` never
+ * reaches here (it is argv-less). Shared by resolveRunPlan + keptContainerKey so
+ * the run cwd and the container-identity key always agree.
+ */
+export function launchCwd(
+	mode: LaunchMode,
+	kind: RootKind,
+	project: string | undefined,
+): string {
+	if (project !== undefined) return resolveCwd(kind, project);
+	return mode === 'shell' ? CONTAINER_HOME_ROOT : rootCwd(kind);
+}
+
 /** Parsed shape of config.json. All fields optional (a hand-edited file may omit any). */
 export interface AnonPiConfig {
 	/** socks5h proxy URL. */
@@ -721,14 +802,105 @@ export interface ParsedLaunch {
 	piArgs?: string[];
 }
 
+/**
+ * pi flags that make sense with NO anon-pi project, so `anon-pi <flag> ...`
+ * launches pi (at the projects root) and forwards this flag + everything after
+ * it verbatim. Two families:
+ *  - SESSION selection (`--session <id>` etc.): pi finds the session file (in the
+ *    always-mounted machine home) and switches to its own project cwd, so no
+ *    project is needed. Mirrors pi's own resume hint (`pi --session <id>`), so
+ *    pasting `anon-pi --session <id>` just works.
+ *  - QUERY (`--list-models`/`--models`): pi prints + exits, no project relevant.
+ * For arbitrary pi flags with no project (e.g. `--model x`), use the explicit
+ * `anon-pi pi <args…>` passthrough instead.
+ */
+const PI_NO_PROJECT_FLAGS: ReadonlySet<string> = new Set([
+	// session selection
+	'--session',
+	'--session-id',
+	'--resume',
+	'-r',
+	'--continue',
+	'-c',
+	'--fork',
+	// query-and-exit
+	'--list-models',
+	'--models',
+]);
+
+/** True iff `a` is a pi flag anon-pi accepts with no project (see PI_NO_PROJECT_FLAGS). */
+function isPiNoProjectFlag(a: string): boolean {
+	return PI_NO_PROJECT_FLAGS.has(a);
+}
+
+/**
+ * The explicit pi-passthrough token: `anon-pi pi <args…>` runs pi with the given
+ * args and NO project (the general escape hatch for any pi flag). It is a
+ * RESERVED project name (see RESERVED_NAMES) so a project can never shadow it.
+ */
+export const PI_PASSTHROUGH_TOKEN = 'pi';
+
+/**
+ * PURE: whether forwarded pi args request pi's NON-INTERACTIVE (print) mode,
+ * i.e. contain `-p`/`--print`. This is the ONLY headless shape (it needs no
+ * TTY): other forwarded args (`--session <id>`, `--model x`, ...) are still
+ * INTERACTIVE and need a TTY + `-it`. Shared by the CLI's no-TTY discipline and
+ * the RunPlan's `-it` decision so they agree.
+ */
+export function isHeadlessPiArgs(
+	piArgs: readonly string[] | undefined,
+): boolean {
+	return !!piArgs && piArgs.some((a) => a === '-p' || a === '--print');
+}
+
+/**
+ * Finish parsing a NO-PROJECT pi launch (`anon-pi --session <id> ...`,
+ * `anon-pi --list-models`, or the explicit `anon-pi pi <args…>`): pi mode, NO
+ * project (pi picks its own cwd / prints + exits), the flag(s) + rest forwarded.
+ * `--shell` is incompatible (a shell forwards no pi args).
+ */
+function finishPiNoProjectLaunch(args: {
+	machine: string;
+	machineExplicit: boolean;
+	mountParent?: string;
+	keep: boolean;
+	rm: boolean;
+	shell: boolean;
+	piArgs: string[];
+	fail: (msg: string) => never;
+}): ParsedLaunch {
+	if (args.keep && args.rm) {
+		args.fail(
+			'--keep and --rm are contradictory (pick one; --rm is the default)',
+		);
+	}
+	if (args.shell) {
+		args.fail(
+			'--shell forwards no pi args (a shell has no session/query). Drop --shell.',
+		);
+	}
+	return {
+		mode: 'pi',
+		machine: args.machine,
+		machineExplicit: args.machineExplicit,
+		project: undefined,
+		mountParent: args.mountParent,
+		keep: args.keep,
+		piArgs: args.piArgs,
+	};
+}
+
 /**
  * PURE: parse grammar A into a ParsedLaunch. Consumes the anon-pi flags
  * (`-m <machine>`, `--shell`, `--mount <parent>`, `--keep`/`--rm`) LEFT of the
  * project positional; the FIRST bare positional is the project (`.` allowed as
  * the root token). In pi mode every token AFTER the project is forwarded to pi
  * verbatim (so `anon-pi recon -p '...'` works) — anon-pi flags must come before
- * the project. In shell/menu mode a stray extra positional is an error (bash has
- * no forwarded-args grammar; the menu takes no project).
+ * the project. A pi session-resume flag (`--session <id>`, `--continue`,
+ * `--resume`, `--fork <id>`) in the project position starts a NO-project pi
+ * launch that forwards to pi (pi resolves the session + cwd itself). In
+ * shell/menu mode a stray extra positional is an error (bash has no
+ * forwarded-args grammar; the menu takes no project).
  *
  * Validates the project name and the `-m` machine name via validateName (the
  * reserved-name guard); `--mount <parent>` is a HOST path in its own namespace,
@@ -784,6 +956,44 @@ export function parseLaunchArgs(args: readonly string[]): ParsedLaunch {
 			i++;
 			break;
 		}
+		if (a === PI_PASSTHROUGH_TOKEN) {
+			// `anon-pi pi <args…>`: the explicit passthrough. Run pi with the
+			// following args and NO project (pi picks its own cwd, or prints + exits
+			// for a query). The general escape hatch for ANY pi flag with no project
+			// (`anon-pi pi --model x`, `anon-pi pi --export out.html --session <id>`).
+			return finishPiNoProjectLaunch({
+				machine,
+				machineExplicit: machineSet,
+				mountParent,
+				keep: keepSeen,
+				rm: rmSeen,
+				shell,
+				piArgs: args.slice(i + 1),
+				fail,
+			});
+		}
+		if (isPiNoProjectFlag(a)) {
+			// A pi flag that needs NO anon-pi project (`--session <id>`/`--continue`/
+			// `--fork` resume by id; `--list-models`/`--models` print + exit). pi
+			// resolves its own cwd (or just prints), so anon-pi launches pi at the
+			// projects root and forwards this flag + everything after it verbatim.
+			// This makes pi's own "To resume: pi --session <id>" hint usable as
+			// `anon-pi --session <id>`. (For ARBITRARY pi flags with no project, use
+			// the explicit `anon-pi pi <args…>` passthrough.)
+			piArgs = args.slice(i);
+			project = undefined;
+			i = args.length;
+			return finishPiNoProjectLaunch({
+				machine,
+				machineExplicit: machineSet,
+				mountParent,
+				keep: keepSeen,
+				rm: rmSeen,
+				shell,
+				piArgs,
+				fail,
+			});
+		}
 		if (a.startsWith('-')) {
 			fail(`unknown option: ${a}`);
 		}
@@ -898,10 +1108,7 @@ export function resolveRunPlan(
 	// Which root the cwd resolves under: /work when --mount, else /projects.
 	const rootKind: RootKind = mounted ? 'mount' : 'projects';
 
-	// cwd: shell with no project sits at the machine home (/root); otherwise the
-	// project token (a name or `.`) resolves under the active root uniformly.
-	const cwd =
-		project === undefined ? CONTAINER_HOME_ROOT : resolveCwd(rootKind, project);
+	const cwd = launchCwd(mode, rootKind, project);
 
 	const fresh = homeFresh(machine.home);
 	const seedVersion = intent.seedVersion ?? SEED_VERSION;
@@ -913,7 +1120,7 @@ export function resolveRunPlan(
 	// (podman fails to allocate a TTY on a non-tty stdin). The CLI's broader
 	// no-TTY discipline (erroring when an interactive mode has no TTY) is a later
 	// task; here the argv simply omits -it for the one headless shape.
-	const headless = mode === 'pi' && !!intent.piArgs && intent.piArgs.length > 0;
+	const headless = mode === 'pi' && isHeadlessPiArgs(intent.piArgs);
 
 	const netcageArgs: string[] = ['run'];
 	// --rm by DEFAULT (throwaway); --keep leaves the container kept.
@@ -1073,13 +1280,12 @@ export type RunVsStart = {action: 'run'} | {action: 'start'; ref: string};
  * its internal shape is not a contract (compare only keys this function makes).
  */
 export function keptContainerKey(intent: LaunchIntent): string {
-	const {machine, projectsRoot, project, mountParent} = intent;
+	const {machine, mode, projectsRoot, project, mountParent} = intent;
 	const mounted = nonEmpty(mountParent) !== undefined;
 	const rootKind: RootKind = mounted ? 'mount' : 'projects';
 	// The same cwd resolution resolveRunPlan uses, so the key names the exact
 	// container a matching launch would run in (its conversation key).
-	const cwd =
-		project === undefined ? CONTAINER_HOME_ROOT : resolveCwd(rootKind, project);
+	const cwd = launchCwd(mode, rootKind, project);
 	return [
 		`machine=${machine.name}`,
 		`projectsRoot=${projectsRoot}`,
@@ -2035,6 +2241,22 @@ function shippedFile(rel: string): string | undefined {
 	return undefined;
 }
 
+/**
+ * anon-pi's own version, read from the package.json shipped in the package root
+ * (resolved via shippedFile). Returns undefined if it cannot be found/parsed, so
+ * `--version` can fall back to a placeholder. Read-only.
+ */
+export function anonPiVersion(): string | undefined {
+	const pkg = shippedFile('package.json');
+	if (!pkg) return undefined;
+	try {
+		const parsed = JSON.parse(readFileSync(pkg, 'utf8')) as {version?: unknown};
+		return typeof parsed.version === 'string' ? parsed.version : undefined;
+	} catch {
+		return undefined;
+	}
+}
+
 // --- The `machine {create,list,set-image,rm}` verbs (pure parts) -------------
 //
 // Machines are first-class: an image + a persistent host home
@@ -2220,7 +2442,12 @@ export const HELP = `anon-pi - run pi on anonymized, jailed machines (netcage: f
 USAGE
   anon-pi                        MENU: pick a project (pi), a shell, or a new project
   anon-pi <project>              pi in the project (${CONTAINER_PROJECTS_ROOT}/<project>); exit pi -> host
-  anon-pi <project> <pi-args…>   forward args to pi (headless/one-shot; no TTY needed)
+  anon-pi <project> <pi-args…>   forward args to pi (e.g. -p for a headless one-shot)
+  anon-pi --session <id>         resume a pi session by id (forwarded to pi; no project needed)
+  anon-pi --continue             continue your most recent pi session (also -r/--resume, --fork)
+  anon-pi --list-models          list the models pi sees (also --models; no project needed)
+  anon-pi pi <pi-args…>          run pi with ANY args and no project (the passthrough)
+  anon-pi --version              print anon-pi's version (also -V)
   anon-pi --shell [<project>]    a jailed bash (at ~, or cd'd into <project>) - the project-hopper
   anon-pi -m <machine> [<p>]     the same, on <machine> (its own image + home + conversations)
   anon-pi --mount <parent> [<p>] root at a HOST parent folder instead of the projects root

package/src/cli.ts

@@ -26,6 +26,7 @@ import {
 	AnonPiError,
 	HELP,
 	MODELS_FILE,
+	SETTINGS_FILE,
 	SETTINGS_SEED_FILE,
 	SEED_MARKER,
 	DEFAULT_MACHINE,
@@ -34,15 +35,24 @@ import {
 	buildMenuEntries,
 	builtinProjectsRoot,
 	deriveProjectUsage,
+	globalModelsSeedPath,
+	globalSettingsSeedPath,
+	machineAgentDir,
 	machineDir,
 	machineHomeDir,
 	machineJsonPath,
+	machineModelsSeedPath,
 	machineSessionsDir,
+	mergeModelSelection,
+	resolveModelsSeedPath,
+	resolveSettingsSeedPath,
 	validateName,
 	resolveDeleteHome,
 	resolveDeleteProject,
 	parseConfigJson,
 	parseLaunchArgs,
+	isHeadlessPiArgs,
+	anonPiVersion,
 	parseMachineArgs,
 	parseMachineJson,
 	projectHostDir,
@@ -83,6 +93,7 @@ import {
 	type AnonPiEnv,
 	type GeneratedModel,
 	type ModelCandidate,
+	type ModelSelection,
 	type KeptContainer,
 	type LaunchIntent,
 	type Machine,
@@ -101,6 +112,14 @@ const ANON_PI_KEY_LABEL = 'anon-pi.key';
 function main(argv: string[]): number {
 	const args = argv.slice(2);
 
+	// `--version`/`-V` prints anon-pi's own version and exits (before the launch
+	// grammar, so it is never parsed as a project/flag). For pi's version inside
+	// the jail, forward it: `anon-pi pi --version`.
+	if (args[0] === '--version' || args[0] === '-V') {
+		process.stdout.write(`anon-pi ${anonPiVersion() ?? '(unknown)'}\n`);
+		return 0;
+	}
+
 	// The global `--help`/`-h` prints the top-level HELP, EXCEPT when the first
 	// token is a subcommand that owns its own `--help` (so `anon-pi init --help`
 	// and `anon-pi machine --help` show THEIR help, not the global one). Those
@@ -244,10 +263,12 @@ function runLaunch(parsed: ParsedLaunch): number {
 		const home = machineHomeDir(env, machineName);
 		const machine: Machine = {name: machineName, home, image};
 
-		// The generated models.json + settings seed for this machine (mounted
-		// read-only for the first-launch seed) when present. Keyed per machine.
-		const modelsSeed = join(machineDir(env, machineName), MODELS_FILE);
-		const settingsSeed = join(machineDir(env, machineName), SETTINGS_SEED_FILE);
+		// The local-model models.json + settings seed for this machine's FRESH-home
+		// promotion. GLOBAL by default (<home>/models.json, shared across every
+		// machine because the `llm` endpoint is global), with an optional
+		// per-machine override (machines/<M>/models.json). Mounted read-only.
+		const modelsSeed = resolveModelsSeedPath(env, machineName, existsSync);
+		const settingsSeed = resolveSettingsSeedPath(env, machineName, existsSync);
 
 		intent = {
 			machine,
@@ -259,18 +280,18 @@ function runLaunch(parsed: ParsedLaunch): number {
 			keep: parsed.keep,
 			proxy,
 			llmDirect: llm,
-			modelsSeed: existsSync(modelsSeed) ? modelsSeed : undefined,
-			settingsSeed: existsSync(settingsSeed) ? settingsSeed : undefined,
+			modelsSeed,
+			settingsSeed,
 		};
 	} catch (e) {
 		return reportAnonPiError(e);
 	}
 
 	// No-TTY discipline: the bare MENU and every INTERACTIVE launch (interactive
-	// pi, or a shell) need a TTY; a HEADLESS pi run (`<project> <pi-args…>`) does
-	// NOT. Check BEFORE we mutate anything or spawn.
-	const headless =
-		parsed.mode === 'pi' && !!parsed.piArgs && parsed.piArgs.length > 0;
+	// pi, or a shell) need a TTY; only a HEADLESS pi run (forwarded `-p`/`--print`)
+	// does NOT. Forwarded args that stay interactive (e.g. `--session <id>`,
+	// `--model x`) still require a TTY. Check BEFORE we mutate anything or spawn.
+	const headless = parsed.mode === 'pi' && isHeadlessPiArgs(parsed.piArgs);
 	if (!headless && !process.stdin.isTTY) {
 		if (parsed.mode === 'menu') {
 			process.stderr.write(
@@ -1052,45 +1073,75 @@ function runInit(args: string[]): number {
 	// pin/re-pin its image when one was chosen. Its home seeds on first launch.
 	initWriteDefaultMachine(env, image);
 
-	// The per-machine models.json + settings.json seed for the default machine,
-	// generated from the captured endpoint + the CHOSEN models (this is the
-	// `import` replacement). Written next to the machine so the first-launch seed
-	// promotes them into the fresh home.
+	// The GLOBAL local-model models.json + settings seed, generated from the
+	// captured endpoint + the CHOSEN models (this is the `import` replacement).
 	const endpoint = llm ?? current.llm;
 	if (endpoint !== undefined) {
-		const mdir = machineDir(env, DEFAULT_MACHINE);
-		mkdirSync(mdir, {recursive: true});
 		const models = generateModelsJson(
 			endpoint,
 			llmResult.models,
 			llmResult.apiKey,
 		);
-		writeFileSync(
-			join(mdir, MODELS_FILE),
-			JSON.stringify(models, null, '\t') + '\n',
-		);
+		const modelsBody = JSON.stringify(models, null, '\t') + '\n';
+		// GLOBAL seed: the local model is a workspace-level thing (config.llm is
+		// global), so its models.json lives once at the workspace root and seeds
+		// EVERY machine's fresh home. A machine may still override with its own
+		// machines/<M>/models.json.
+		mkdirSync(resolveAnonPiHome(env), {recursive: true});
+		writeFileSync(globalModelsSeedPath(env), modelsBody);
+
+		// Migration: earlier versions wrote this seed under machines/default/. Now
+		// that it is global, remove the old default-machine copy so `default`
+		// picks up the global seed like every other machine (leaving it would look
+		// like a deliberate per-machine override and shadow the global one). Only
+		// the `default` machine's init-generated copy is migrated; a per-machine
+		// override you created for ANY OTHER machine is left untouched.
+		for (const stale of [
+			machineModelsSeedPath(env, DEFAULT_MACHINE),
+			join(machineDir(env, DEFAULT_MACHINE), SETTINGS_SEED_FILE),
+		]) {
+			if (existsSync(stale)) rmSync(stale, {force: true});
+		}
 		process.stdout.write(
-			`anon-pi: wrote the local-model models.json for machine "${DEFAULT_MACHINE}" ` +
-				`(${llmResult.models.length} model${llmResult.models.length === 1 ? '' : 's'}).\n`,
+			`anon-pi: wrote the global local-model models.json ` +
+				`(${llmResult.models.length} model${llmResult.models.length === 1 ? '' : 's'}; shared by all machines).\n`,
 		);
 
-		// settings.json: set the default model + enabledModels for the imported
-		// set. Written as a SEED that the first-launch promotion merges into the
-		// home's settings (so image-staged packages/extensions survive). Only when
-		// the user picked at least one model + a default.
-		if (llmResult.defaultId !== undefined && llmResult.models.length > 0) {
-			const selection = generateModelSelection(
-				llmResult.models.map((m) => m.id),
-				llmResult.defaultId,
-			);
+		// settings.json seed: the default model + enabledModels for the imported
+		// set. The first-launch promotion merges it into each home's settings (so
+		// image-staged packages/extensions survive). Only when the user picked at
+		// least one model + a default.
+		const selection =
+			llmResult.defaultId !== undefined && llmResult.models.length > 0
+				? generateModelSelection(
+						llmResult.models.map((m) => m.id),
+						llmResult.defaultId,
+					)
+				: undefined;
+		if (selection) {
 			writeFileSync(
-				join(mdir, SETTINGS_SEED_FILE),
+				globalSettingsSeedPath(env),
 				JSON.stringify(selection, null, '\t') + '\n',
 			);
 			process.stdout.write(
 				`anon-pi: default model set to "${llmResult.defaultId}".\n`,
 			);
 		}
+
+		// Re-run reconfigure: the seed above only takes effect on a FRESH home
+		// (the first-launch promotion is marker-guarded). Apply the new
+		// models.json + settings selection DIRECTLY to EVERY already-seeded machine
+		// home now, so re-running `init` updates existing environments without
+		// wiping conversations (init runs on the host; homes are host dirs). Fresh
+		// (unseeded) homes are left to the launch-time seed. A machine with its OWN
+		// per-machine models.json override is skipped (its local model differs).
+		const updated = applyModelsToSeededHomes(env, modelsBody, selection);
+		if (updated.length > 0) {
+			process.stdout.write(
+				`anon-pi: updated ${updated.length} existing machine home${updated.length === 1 ? '' : 's'} ` +
+					`(${updated.join(', ')}); conversations untouched.\n`,
+			);
+		}
 	}
 
 	process.stdout.write(
@@ -1100,6 +1151,42 @@ function runInit(args: string[]): number {
 	return 0;
 }
 
+/**
+ * Apply the freshly-generated GLOBAL local-model config to EVERY already-seeded
+ * machine home directly (init runs on the host; homes are host dirs). The
+ * launch-time seed only promotes on a FRESH home (marker-guarded), so without
+ * this a re-run of `init` would update the global seed but never reach existing
+ * homes. For each machine: skip a FRESH home (no marker — the launch seed will
+ * pick up the new global seed), skip a machine with its OWN per-machine
+ * models.json override (its local model differs on purpose), else overwrite the
+ * home's models.json and merge the settings selection. Conversations/sessions
+ * are untouched. Returns the machine names updated.
+ */
+function applyModelsToSeededHomes(
+	env: AnonPiEnv,
+	modelsBody: string,
+	selection: ModelSelection | undefined,
+): string[] {
+	const updated: string[] = [];
+	for (const machine of listMachineNames(env).sort()) {
+		const agentDir = machineAgentDir(env, machine);
+		// Only an already-seeded home (marker present).
+		if (!existsSync(join(agentDir, SEED_MARKER))) continue;
+		// A machine that deliberately overrides the global models.json keeps its
+		// own local model; do not clobber its home with the global one.
+		if (existsSync(machineModelsSeedPath(env, machine))) continue;
+
+		writeFileSync(join(agentDir, MODELS_FILE), modelsBody);
+		if (selection) {
+			const settingsPath = join(agentDir, SETTINGS_FILE);
+			const merged = mergeModelSelection(readJsonFile(settingsPath), selection);
+			writeFileSync(settingsPath, JSON.stringify(merged, null, '\t') + '\n');
+		}
+		updated.push(machine);
+	}
+	return updated;
+}
+
 /** A sentinel a step returns when the user aborted (distinct from "skipped"). */
 const ABORT = Symbol('abort');