gentle-pi 4.1.0 → 4.3.0

package/runtime/gentle-ai-binary.mjs

@@ -15,7 +15,7 @@ import {
 	resolveGentleAiReleaseAsset,
 } from "../scripts/gentle-ai-installer.mjs";
 import { engramPinVersion } from "../scripts/installer-downloads.mjs";
-import { bundledGentlePiConfigHome, bundledPiConfigDir, bundledPiConfigParent, runningBundledPrefix } from "./gentle-shell-bundled.mjs";
+import { bundledPiConfigDir, bundledPiConfigParent, GENTLE_SHELL_CONFIG_HOME_ENV, resolveGentlePiConfigHome, runningBundledPrefix } from "./gentle-shell-bundled.mjs";
 import { fileURLToPath } from "node:url";
 
 export const GENTLE_AI_BINARY_MISSING_CODE = "package-local-binary-missing";
@@ -87,9 +87,11 @@ export function bundledGentleAiPaths(prefix        , platform         = process.
  * (only when the pinned Engram is published), GENTLE_AI_NO_SELF_UPDATE=1 and
  * GENTLE_PI_CONFIG_HOME (the parent of GENTLE_AI_PI_CONFIG_DIR)
  * when this gentle-pi runs from the valid bundled install GENTLE_SHELL_PREFIX
- * names (runningBundledPrefix). Otherwise `env` itself, unchanged: a gentle-pi
- * installed elsewhere (the user's own, started from the agent's shell, which
- * inherits the variable) keeps its own Gentle AI.
+ * names (runningBundledPrefix). In the standalone launcher's isolated home
+ * (#2201) only the config pair, for the folder its marker names. Otherwise
+ * `env` itself, unchanged: a gentle-pi installed elsewhere (the user's own,
+ * started from the agent's shell, which inherits the variable) keeps its own
+ * Gentle AI.
  */
 export function gentleAiIsolationEnv(
 	env                   ,
@@ -97,7 +99,7 @@ export function gentleAiIsolationEnv(
 )                    {
 	const platform = options.platform ?? process.platform;
 	const prefix = runningBundledPrefix(env, { packageRoot: options.packageRoot, platform });
-	if (prefix === undefined) return env;
+	if (prefix === undefined) return standaloneGentleAiEnv(env, platform);
 	const paths = bundledGentleAiPaths(prefix, platform);
 	let engram = false;
 	try {
@@ -126,6 +128,23 @@ export function gentleAiIsolationEnv(
 	};
 }
 
+// #2201: the same config pair as a bundled install, for the folder the
+// standalone launcher's marker names, when it decides the config home
+// (resolveGentlePiConfigHome; an explicit GENTLE_PI_CONFIG_HOME keeps its
+// existing meaning for Gentle AI). Gentle AI's own state stays where it was.
+// The parent is given only for a folder named gentle-ai, the one Gentle AI
+// 4.0.0 appends to it.
+function standaloneGentleAiEnv(env                   , platform        )                    {
+	const marker = env[GENTLE_SHELL_CONFIG_HOME_ENV];
+	if (marker === undefined || resolveGentlePiConfigHome(env, homedir(), { platform }) !== marker) return env;
+	const path = platform === "win32" ? win32 : posix;
+	return {
+		...env,
+		GENTLE_AI_PI_CONFIG_DIR: marker,
+		...(path.basename(marker) === "gentle-ai" ? { GENTLE_PI_CONFIG_HOME: path.dirname(marker) } : {}),
+	};
+}
+
 function sha256(value        )         {
 	return createHash("sha256").update(value).digest("hex");
 }
@@ -137,7 +156,9 @@ function sha256(value        )         {
 //   1. GENTLE_PI_GENTLE_AI_DEV_BINARY (session override, absolute path), then
 //   2. the persistent registration file at
 //      <config home>/dev-binary.json (a bundled prefix's gentle-pi, else
-//      GENTLE_PI_CONFIG_HOME, else ~/.pi/gentle-ai) with the strict
+//      GENTLE_PI_CONFIG_HOME, else ~/.pi/gentle-ai, never the standalone
+//      launcher's marker: the main channel writes it outside any session,
+//      #2201) with the strict
 //      shape {"schema":"gentle-pi.dev-binary/v1","path":"<absolute path>"}.
 //
 // The registration deliberately pins no digest: it is the unpinned field-test
@@ -195,7 +216,7 @@ function ambientDevBinaryEnvironment()                               {
 }
 
 export function gentleAiDevBinaryRegistrationPath(environment                               = ambientDevBinaryEnvironment())         {
-	const configHome = bundledGentlePiConfigHome(environment.env) ?? environment.env.GENTLE_PI_CONFIG_HOME ?? join(environment.home, ".pi", "gentle-ai");
+	const configHome = resolveGentlePiConfigHome(environment.env, environment.home, { launcherMarker: false });
 	return join(configHome, "dev-binary.json");
 }
 

package/runtime/gentle-shell-bundled.mjs

@@ -176,6 +176,29 @@ export function bundledGentlePiConfigHome(env     )                     {
 	return prefix === undefined ? undefined : bundledPiConfigDir(prefix);
 }
 
+// #2201: the standalone launcher gives Pi this variable in its isolated home
+// only, naming the config folder next to the agent dir (standaloneConfigHome:
+// ~/.gentle-shell/gentle-ai by default). It is launcher-owned, never
+// GENTLE_PI_CONFIG_HOME: Gentle AI 4.0.0 reads that one as the parent of its
+// own gentle-ai folder, and the agent's shell would pass it to any gentle-ai.
+export const GENTLE_SHELL_CONFIG_HOME_ENV = "GENTLE_SHELL_CONFIG_HOME";
+
+// gentle-pi's config home, the one rule every reader shares: a bundled
+// prefix's folder, then an explicit GENTLE_PI_CONFIG_HOME, then the launcher's
+// marker (absolute only), then ~/.pi/gentle-ai. Empty values count as unset.
+// `launcherMarker: false` is for install-level state written outside a session
+// (the main channel's channel.json, builds and dev-binary.json): the installer
+// and `gentle-shell upgrade` never see the marker, so their readers ignore it.
+export function resolveGentlePiConfigHome(env     , home        , options                                                  = {})         {
+	const path = pathFor(options.platform ?? process.platform);
+	const bundled = bundledGentlePiConfigHome(env);
+	if (bundled !== undefined) return bundled;
+	if (env.GENTLE_PI_CONFIG_HOME) return env.GENTLE_PI_CONFIG_HOME;
+	const marker = env[GENTLE_SHELL_CONFIG_HOME_ENV];
+	if (options.launcherMarker !== false && marker && path.isAbsolute(marker)) return marker;
+	return path.join(home, ".pi", "gentle-ai");
+}
+
 // The exact Pi of the version (S8): the Pi the version's package.json pins,
 // installed inside the version folder with Pi's own bin entry. Never another Pi.
 export function bundledPi(install                , input                                     )            {
@@ -214,14 +237,32 @@ export function bundledPi(install                , input
 // memory is allowed locally; otherwise the Shell-owned guard, so no provider,
 // whatever loaded it, runs an Engram binary against an unverified store.
 export const ENGRAM_COMPANION_SOURCE = "npm:gentle-engram@0.4.2";
-export const ENGRAM_RECOVERY_NOTICE = "Engram memory disabled: the existing Engram data's compatibility is unknown. Back up your existing Engram data, update Engram and restart its server, then restart Shell to recheck memory safety (it rechecks on every launch). Shell remains usable without memory.";
+export const ENGRAM_PRIVATE_REQUIRED_NOTICE = "Engram memory disabled: session-owned servers require a supporting published bundled core and companion. This bundle does not establish both capabilities; it will not fall back to a detached shared server. Install a supporting published bundle and restart Shell. Existing shared services are not stopped or adopted as session-owned.";
+export const ENGRAM_CORE_CHANGED_NOTICE = "Engram memory disabled: the bundled core changed since Shell recorded this store. Install a published bundle supporting migrate-copy, stop every Engram client, retain a complete backup, then run gentle-shell memory migrate --confirm-quiescent. The command verifies and migrates a copy before updating provenance; older bundles refuse safely. Do not edit coreSha256 or delete the original store. Shell remains usable without memory.";
+export const ENGRAM_RECOVERY_NOTICE = "Engram memory disabled: Shell could not verify safe store or server reuse. Matching versions or updating alone do not prove compatibility. Reuse requires a server with verified /compatibility evidence or matching Shell-provisioned store identity. Back up existing Engram data before manual changes; do not delete it or bypass the safety check. Shell rechecks on every launch and remains usable without memory.";
 // `gentle-shell setup` publishes the verified core (ensureEngram) on every run.
 export const ENGRAM_PROVISION_FAILED_NOTICE = "Engram memory disabled for this launch: Shell could not provision a new Engram store identity, so it cannot vouch for that store. Restart Shell to retry. If Shell keeps reporting unknown compatibility and ~/.engram holds only .instance-id files, back it up and remove it, then restart Shell. Shell remains usable without memory.";
 export const ENGRAM_CORE_MISSING_NOTICE = "Engram memory disabled: the bundled Engram core is not installed yet. Run 'gentle-shell setup' to install the verified core, then restart Shell. Shell remains usable without memory.";
+// The first Engram release whose server answers GET /compatibility (PR #1792).
+export const ENGRAM_COMPATIBILITY_MIN_VERSION = "3.4.0";
+export function engramOutdatedServerNotice(version        )         {
+	return `Engram memory disabled: the running Engram server reports version ${version}, which cannot prove store compatibility. Back up your Engram data, update that server to ${ENGRAM_COMPATIBILITY_MIN_VERSION} or later with the method you installed it with, and restart it; updating Shell alone does not replace a running server. Shell rechecks on every launch and remains usable without memory.`;
+}
+// A canonical numeric x.y.z (optionally v-prefixed, no leading zeros) older than
+// the minimum. The version comes from the server, so anything else is never
+// echoed to the user.
+function outdatedServerVersion(version                    )                     {
+	const match = /^v?(0|[1-9]\d{0,3})\.(0|[1-9]\d{0,3})\.(0|[1-9]\d{0,3})$/.exec(version ?? "");
+	if (match === null) return undefined;
+	const parts = match.slice(1).map(Number);
+	const minimum = ENGRAM_COMPATIBILITY_MIN_VERSION.split(".").map(Number);
+	const index = parts.findIndex((part, i) => part !== minimum[i]);
+	return index >= 0 && parts[index] < minimum[index] ? parts.join(".") : undefined;
+}
 // The default endpoint gentle-engram uses without ENGRAM_URL or ENGRAM_PORT.
 export const ENGRAM_DEFAULT_PORT = 7437;
 export const ENGRAM_DEFAULT_URL = `http://127.0.0.1:${ENGRAM_DEFAULT_PORT}`;
-const ENGRAM_SELECTIONS = ["ENGRAM_BIN", "ENGRAM_URL", "ENGRAM_DATA_DIR", "ENGRAM_PORT", "ENGRAM_DATABASE_URL"];
+const ENGRAM_SELECTIONS = ["ENGRAM_BIN", "ENGRAM_URL", "ENGRAM_DATA_DIR", "ENGRAM_PORT", "ENGRAM_SOCKET", "ENGRAM_DATABASE_URL"];
 const HEX32 = /^[a-f0-9]{32}$/;
 
 
@@ -239,11 +280,13 @@ export function engramProbeAllowed(env     )          {
 // Evidence only: never run an executable, open SQLite or infer compatibility
 // from versions. `provenance` means Shell's own record matched the store
 // (directory, .instance-id, core digest) and its header showed no newer schema.
+// A server version only selects the wording of a disabled decision.
 export function classifyEngramStartup(input
 	                                                          )                {
-	const unknown                = { policy: "disabled", notice: ENGRAM_RECOVERY_NOTICE };
-	if (!engramProbeAllowed(input.env)) return unknown;
+	if (!engramProbeAllowed(input.env)) return { policy: "disabled", notice: ENGRAM_RECOVERY_NOTICE };
 	const endpoint = input.endpoint;
+	const outdated = endpoint.kind === "listening" && !endpoint.compatible ? outdatedServerVersion(endpoint.healthVersion) : undefined;
+	const unknown                = { policy: "disabled", notice: outdated === undefined ? ENGRAM_RECOVERY_NOTICE : engramOutdatedServerNotice(outdated) };
 	if (endpoint.kind === "listening" && endpoint.compatible) return { policy: "allow", url: ENGRAM_DEFAULT_URL };
 	if (endpoint.kind === "refused" && input.store === "absent") {
 		return input.core ? { policy: "allow", fresh: true } : { policy: "disabled", notice: ENGRAM_CORE_MISSING_NOTICE };
@@ -253,7 +296,7 @@ export function classifyEngramStartup(input
 	// Shell's own store, created by this exact core: offline, the provider starts
 	// that core; a running server must be that store and that exact core.
 	if (endpoint.kind === "refused") return { policy: "allow" };
-	if (endpoint.kind === "listening" && endpoint.healthInstanceId === own.instanceId && endpoint.healthVersion === input.coreVersion) return { policy: "allow" };
+	if (endpoint.kind === "listening" && endpoint.healthInstanceId === own.instanceId && endpoint.healthVersion === input.coreVersion) return { policy: "allow", url: ENGRAM_DEFAULT_URL };
 	return unknown;
 }
 
@@ -334,9 +377,9 @@ export function engramProvenanceMatches(record                              , ob
 }
 
 // The bundled core's own schema (SQLite user_version), verified from the
-// tagged source: v3.3.2:internal/store/store.go `const schemaVersion = 1`.
+// tagged sources v3.3.2 and v3.4.0: internal/store/store.go `const schemaVersion = 1`.
 // A pin without a verified entry leaves the header check unavailable.
-const BUNDLED_ENGRAM_SCHEMA                         = { "3.3.2": 1 };
+const BUNDLED_ENGRAM_SCHEMA                         = { "3.3.2": 1, "3.4.0": 1 };
 
 export function bundledEngramSchema(coreVersion        )                     {
 	return Object.hasOwn(BUNDLED_ENGRAM_SCHEMA, coreVersion) ? BUNDLED_ENGRAM_SCHEMA[coreVersion] : undefined;
@@ -384,6 +427,11 @@ export function supportsEngramStartupPolicy(metadata                    )
 	return pkg?.name === "gentle-engram" && pkg.engram?.startupPolicy === 1;
 }
 
+export function supportsEngramSessionOwned(metadata                    )          {
+	const pkg = parseJson(metadata);
+	return supportsEngramStartupPolicy(metadata) && pkg?.engram?.sessionOwned === 1;
+}
+
 export function bundledChildEnv(base     , input                                                                                                        )      {
 	const env      = { ...base, PI_SKIP_VERSION_CHECK: "1", [GENTLE_SHELL_PREFIX_ENV]: input.prefix };
 	delete env.GENTLE_SHELL_PI;
@@ -408,6 +456,12 @@ export function bundledChildEnv(base     , input
 	if (memory.url !== undefined) env.ENGRAM_URL = memory.url;
 	const local = memory.policy === "allow" && memory.url === undefined ? input.engram : undefined;
 	env.ENGRAM_BIN = local ?? input.guard;
+	if (local && memory.owned) {
+		env.ENGRAM_SERVER_MODE = "session-owned";
+		delete env.ENGRAM_URL;
+		delete env.ENGRAM_PORT;
+		delete env.ENGRAM_SOCKET;
+	}
 	return env;
 }
 

package/runtime/gentle-shell-import-pi.mjs

@@ -0,0 +1,234 @@
+// Generated by scripts/build-runtime-modules.mjs. Do not edit.
+import { chmodSync, closeSync, linkSync, lstatSync, openSync, readFileSync, renameSync, unlinkSync, writeFileSync } from "node:fs";
+import { basename, dirname, join } from "node:path";
+import { detectJsonFormatting } from "./gentle-shell-launcher.mjs";
+
+// `gentle-shell home import-pi`: a one-time, opt-in copy of the user's pi
+// sign-ins and MCP servers into a separate Gentle Shell home, as an
+// alternative to --link. Only the files and settings keys below are read;
+// packages, extensions, caches, AGENTS.md and sessions are never copied, so
+// the target home keeps its own provisioning. Nothing is ever overwritten and
+// the source is only read.
+
+// auth.json holds OAuth tokens and API keys: always private in the copy.
+const IMPORTED_FILES                                             = [
+	{ name: "auth.json", mode: 0o600 },
+	{ name: "mcp.json" },
+];
+
+// Pi 1.2.0's own settings for the default model (SettingsManager
+// get/setDefaultProvider, DefaultModel, DefaultThinkingLevel).
+export const IMPORTED_SETTINGS_KEYS                    = ["defaultProvider", "defaultModel", "defaultThinkingLevel"];
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+function tempPathFor(path        )         {
+	return join(dirname(path), `.${basename(path)}.gentle-shell-${process.pid}.tmp`);
+}
+
+function removeQuietly(path        )       {
+	try {
+		unlinkSync(path);
+	} catch {
+		// Nothing left to clean up.
+	}
+}
+
+function writeTemp(path        , data                 , mode        )         {
+	const temp = tempPathFor(path);
+	const fd = openSync(temp, "wx", mode);
+	try {
+		try {
+			writeFileSync(fd, data);
+		} finally {
+			closeSync(fd);
+		}
+		chmodSync(temp, mode); // the umask must not change the mode
+	} catch (error) {
+		// A partial copy may hold credentials: never leave it behind.
+		removeQuietly(temp);
+		throw error;
+	}
+	return temp;
+}
+
+export const nodeImportPiFs             = {
+	kind: (path) => {
+		try {
+			const stat = lstatSync(path);
+			if (stat.isSymbolicLink()) return "other";
+			return stat.isFile() ? "file" : stat.isDirectory() ? "dir" : "other";
+		} catch (error) {
+			if ((error                         ).code === "ENOENT") return "missing";
+			throw error;
+		}
+	},
+	mode: (path) => lstatSync(path).mode & 0o777,
+	readText: (path) => readFileSync(path, "utf8"),
+	copyNew: (from, to, mode) => {
+		const temp = writeTemp(to, readFileSync(from), mode);
+		try {
+			linkSync(temp, to); // EEXIST instead of replacing a file that appeared meanwhile
+		} finally {
+			removeQuietly(temp);
+		}
+	},
+	writeAtomic: (path, text) => {
+		const mode = lstatSync(path, { throwIfNoEntry: false })?.mode;
+		const temp = writeTemp(path, text, mode === undefined ? 0o600 : mode & 0o777);
+		try {
+			renameSync(temp, path);
+		} catch (error) {
+			removeQuietly(temp);
+			throw error;
+		}
+	},
+};
+
+function reason(error         )         {
+	const code = (error                                     )?.code;
+	return typeof code === "string" ? code : error instanceof Error ? error.message : String(error);
+}
+
+function parseObject(text        )                                      {
+	try {
+		const value          = JSON.parse(text.replace(/^\uFEFF/, ""));
+		return value !== null && typeof value === "object" && !Array.isArray(value) ? (value                           ) : undefined;
+	} catch {
+		return undefined;
+	}
+}
+
+function importFile(name        , mode                    , input                                                                     )               {
+	const { fs } = input;
+	const from = join(input.source, name);
+	const to = join(input.target, name);
+	// Classification can throw too (ENOTDIR under a file): one failed item, never an aborted report.
+	try {
+		const kind = fs.kind(from);
+		if (kind === "missing") return { item: name, status: "not found" };
+		if (kind !== "file") return { item: name, status: "skipped", detail: "not a regular file" };
+		if (fs.kind(to) !== "missing") return { item: name, status: "present" };
+		const copyMode = mode ?? fs.mode(from);
+		const detail = `${copyMode.toString(8).padStart(4, "0")}`;
+		if (input.dryRun) return { item: name, status: "would copy", detail };
+		fs.copyNew(from, to, copyMode);
+		return { item: name, status: "copied", detail };
+	} catch (error) {
+		return { item: name, status: "failed", detail: reason(error) };
+	}
+}
+
+function importSettings(input                                                                     )                 {
+	try {
+		return planAndWriteSettings(input);
+	} catch (error) {
+		// An unreadable settings.json stays one failed item, never an aborted report.
+		return [{ item: "settings.json", status: "failed", detail: reason(error) }];
+	}
+}
+
+function planAndWriteSettings(input                                                                     )                 {
+	const { fs } = input;
+	const from = join(input.source, "settings.json");
+	const to = join(input.target, "settings.json");
+	const sourceKind = fs.kind(from);
+	if (sourceKind === "missing") return [{ item: "settings.json", status: "not found" }];
+	if (sourceKind !== "file") return [{ item: "settings.json", status: "skipped", detail: "not a regular file" }];
+	const source = parseObject(fs.readText(from));
+	if (source === undefined) return [{ item: "settings.json", status: "skipped", detail: `${from} is not a JSON object` }];
+	const targetKind = fs.kind(to);
+	if (targetKind !== "missing" && targetKind !== "file") return [{ item: "settings.json", status: "skipped", detail: `${to} is not a regular file` }];
+	const targetText = targetKind === "missing" ? undefined : fs.readText(to);
+	const target = targetText === undefined ? {} : parseObject(targetText);
+	if (target === undefined) return [{ item: "settings.json", status: "skipped", detail: `${to} is not a JSON object` }];
+
+	const items                 = [];
+	const added                          = {};
+	for (const key of IMPORTED_SETTINGS_KEYS) {
+		const item = `settings.json ${key}`;
+		if (!Object.hasOwn(source, key)) items.push({ item, status: "not found" });
+		else if (Object.hasOwn(target, key)) items.push({ item, status: "present" });
+		else if (typeof source[key] !== "string") items.push({ item, status: "skipped", detail: "not a string" });
+		else {
+			added[key] = source[key];
+			items.push({ item, status: input.dryRun ? "would copy" : "copied" });
+		}
+	}
+	if (input.dryRun || Object.keys(added).length === 0) return items;
+	try {
+		// Keep the target's own indentation and trailing-newline style.
+		const style = targetText === undefined ? { indent: undefined, trailingNewline: true } : detectJsonFormatting(targetText);
+		const body = JSON.stringify({ ...target, ...added }, null, style.indent ?? 2);
+		fs.writeAtomic(to, style.trailingNewline ? `${body}\n` : body);
+		return items;
+	} catch (error) {
+		const detail = reason(error);
+		return items.map((entry) => (entry.status === "copied" ? { ...entry, status: "failed", detail } : entry));
+	}
+}
+
+// Copies what the target lacks. A dry run reads the same files and writes
+// nothing. The caller has already made sure `target` is a home this launcher
+// owns (and exists, unless this is a dry run).
+export function importPi(input                                                                      )                 {
+	const options = { ...input, fs: input.fs ?? nodeImportPiFs };
+	const items = IMPORTED_FILES.map((file) => importFile(file.name, file.mode, options));
+	items.push(...importSettings(options));
+	return { items, failed: items.some((item) => item.status === "failed") };
+}
+
+function describe(item              )         {
+	switch (item.status) {
+		case "copied":
+		case "would copy":
+			return item.detail !== undefined && item.item === "auth.json" ? `${item.status} (${item.detail})` : item.status;
+		case "present":
+			return "already present, kept";
+		case "not found":
+			return "not found";
+		case "skipped":
+			return `skipped: ${item.detail}`;
+		case "failed":
+			return `failed: ${item.detail}`;
+	}
+}
+
+export function formatImportPiReport(result                , context                                                     )           {
+	const lines = [
+		context.dryRun
+			? `Dry run: would import from ${context.source} into ${context.target} (nothing is written)`
+			: `Importing from ${context.source} into ${context.target}`,
+	];
+	for (const item of result.items) lines.push(`  ${item.item}: ${describe(item)}`);
+	const count = (...statuses                  ) => result.items.filter((item) => statuses.includes(item.status)).length;
+	const imported = count("copied", "would copy");
+	const rest = `${count("present")} already present, ${count("not found")} not found, ${count("skipped")} skipped`;
+	if (result.failed) lines.push(`Import failed for ${count("failed")} item(s); ${count("copied")} copied and kept. ${rest}.`);
+	else if (imported === 0) lines.push(`Nothing to import: ${rest}.`);
+	else lines.push(`${context.dryRun ? "Would import" : "Imported"} ${imported} item(s); ${rest}.`);
+	return lines;
+}