fuli-context 0.7.4-beta.2 → 0.7.5

package/src/backup/identity-reconciliation.js

@@ -0,0 +1,208 @@
+import { chmodSync } from 'node:fs';
+
+import { readJsonFile, writeJsonFileAtomic } from '../storage/json-file.js';
+import {
+  managedProviderUrls,
+  readRuntimeSettings
+} from '../system/runtime-settings.js';
+
+const PROVIDER_READY_ATTEMPTS = 120;
+
+export function graphBackupSelection(paths, {
+  readConfig = (path) => readJsonFile(path, null)
+} = {}) {
+  const config = readConfig(paths.graphRuntimeConfigPath);
+  const personalSpaceId = nonEmpty(config?.personal?.spaceId);
+  return personalSpaceId ? { personalSpaceId } : null;
+}
+
+export async function reconcileImportedGraphIdentity({
+  paths,
+  instances,
+  selection = {},
+  sourceMode,
+  targetMode,
+  fetchImpl = globalThis.fetch,
+  wait = delay,
+  readConfig = (path) => readJsonFile(path, null),
+  writeConfig = writeJsonFileAtomic,
+  secureConfig = (path) => chmodSync(path, 0o600),
+  readSettings = readRuntimeSettings,
+  readEnvironment = readEnvironmentFile
+}) {
+  const current = readConfig(paths.graphRuntimeConfigPath);
+  if (!current?.personal) {
+    throw new Error('The target graph mode is not configured. Run setup before importing.');
+  }
+  const settings = readSettings(paths.runtimeSettingsPath);
+  const urls = managedProviderUrls(settings);
+  const values = await readEnvironment(paths.graphEnvPath);
+  const sourceConfigPath = profilePath(paths, sourceMode);
+  const source = sourceMode === targetMode || !sourceConfigPath
+    ? null
+    : readConfig(sourceConfigPath);
+  const next = structuredClone(current);
+  next.workspaces = mergedExternalWorkspaces(current, source);
+
+  await waitForProvider(urls.personal, fetchImpl, wait);
+  const personal = await bootstrapProvider({
+    url: urls.personal,
+    bootstrapToken: requiredValue(values, 'FULI_PERSONAL_BOOTSTRAP_TOKEN'),
+    fetchImpl
+  });
+  const spaces = await listSpaces(urls.personal, personal.accessToken, fetchImpl);
+  const personalSpaceId = selectPersonalSpace({
+    spaces,
+    requestedId: selection.personalSpaceId,
+    currentId: source?.personal?.spaceId ?? current.personal.spaceId
+  });
+  next.personal = {
+    ...next.personal,
+    providerUrl: urls.personal,
+    accessToken: personal.accessToken,
+    principalId: personal.principalId,
+    spaceId: personalSpaceId,
+    ...(nonEmpty(values.FULI_PERSONAL_WORKFLOW_OBSERVATION_TOKEN)
+      ? { workflowObservationToken: values.FULI_PERSONAL_WORKFLOW_OBSERVATION_TOKEN }
+      : {})
+  };
+
+  if (instances.includes('workspace')) {
+    await waitForProvider(urls.workspace, fetchImpl, wait);
+    const workspace = await bootstrapProvider({
+      url: urls.workspace,
+      bootstrapToken: requiredValue(values, 'FULI_WORKSPACE_BOOTSTRAP_TOKEN'),
+      fetchImpl
+    });
+    next.workspaces.push({
+      providerUrl: urls.workspace,
+      accessToken: workspace.accessToken,
+      principalId: workspace.principalId,
+      managedDevelopment: true
+    });
+  }
+
+  try {
+    writeConfig(paths.graphRuntimeConfigPath, next);
+    secureConfig(paths.graphRuntimeConfigPath);
+  } catch (error) {
+    try {
+      writeConfig(paths.graphRuntimeConfigPath, current);
+      secureConfig(paths.graphRuntimeConfigPath);
+    } catch (restoreError) {
+      throw new AggregateError(
+        [error, restoreError],
+        'Imported graph credentials could not be saved or restored.'
+      );
+    }
+    throw error;
+  }
+  return { personalSpaceId, instances: [...instances] };
+}
+
+async function waitForProvider(url, fetchImpl, wait) {
+  for (let attempt = 0; attempt < PROVIDER_READY_ATTEMPTS; attempt += 1) {
+    try {
+      const response = await fetchImpl(`${url}/health`, {
+        signal: AbortSignal.timeout(2500)
+      });
+      if (response.ok) return;
+    } catch {
+      // The target is still starting.
+    }
+    if (attempt < PROVIDER_READY_ATTEMPTS - 1) await wait(1000);
+  }
+  throw new Error('The imported graph Provider did not become ready for credential rotation.');
+}
+
+async function bootstrapProvider({ url, bootstrapToken, fetchImpl }) {
+  const response = await fetchImpl(`${url}/v1/bootstrap`, {
+    method: 'POST',
+    headers: {
+      'content-type': 'application/json',
+      'x-fuli-bootstrap-token': bootstrapToken
+    },
+    body: JSON.stringify({ principal_name: 'Fuli migration' }),
+    signal: AbortSignal.timeout(10_000)
+  });
+  if (!response.ok) throw new Error('The imported graph Provider rejected credential rotation.');
+  const body = await response.json();
+  const principalId = nonEmpty(body?.principal_id);
+  const accessToken = nonEmpty(body?.access_token);
+  if (!principalId || !accessToken) {
+    throw new Error('The imported graph Provider returned an invalid bootstrap identity.');
+  }
+  return { principalId, accessToken };
+}
+
+async function listSpaces(url, accessToken, fetchImpl) {
+  const response = await fetchImpl(`${url}/v1/spaces`, {
+    headers: { authorization: `Bearer ${accessToken}` },
+    signal: AbortSignal.timeout(10_000)
+  });
+  if (!response.ok) throw new Error('The imported graph Provider could not list personal spaces.');
+  const body = await response.json();
+  if (!Array.isArray(body)) throw new Error('The imported graph Provider returned invalid spaces.');
+  return body.filter((space) => space?.kind === 'personal' && nonEmpty(space.id));
+}
+
+function selectPersonalSpace({ spaces, requestedId, currentId }) {
+  for (const candidate of [requestedId, currentId]) {
+    const id = nonEmpty(candidate);
+    if (id && spaces.some((space) => space.id === id)) return id;
+  }
+  if (spaces.length === 1) return spaces[0].id;
+  throw new Error(
+    'The imported graph contains multiple personal spaces and the backup does not select one.'
+  );
+}
+
+function mergedExternalWorkspaces(current, source) {
+  const result = new Map();
+  for (const workspace of [
+    ...(source?.workspaces ?? []),
+    ...(current?.workspaces ?? [])
+  ]) {
+    if (isManagedWorkspace(workspace)) continue;
+    const providerUrl = nonEmpty(workspace?.providerUrl);
+    if (providerUrl) result.set(providerUrl, structuredClone(workspace));
+  }
+  return [...result.values()];
+}
+
+function isManagedWorkspace(workspace) {
+  return workspace?.managedDevelopment === true;
+}
+
+function profilePath(paths, mode) {
+  if (mode === 'container') return paths.containerGraphConfigProfilePath;
+  if (mode === 'native') return paths.nativeGraphConfigProfilePath;
+  return null;
+}
+
+async function readEnvironmentFile(path) {
+  const { readFile } = await import('node:fs/promises');
+  const body = await readFile(path, 'utf8');
+  const values = {};
+  for (const line of body.split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith('#')) continue;
+    const separator = trimmed.indexOf('=');
+    if (separator > 0) values[trimmed.slice(0, separator)] = trimmed.slice(separator + 1);
+  }
+  return values;
+}
+
+function requiredValue(values, name) {
+  const value = nonEmpty(values[name]);
+  if (!value) throw new Error(`The target graph environment is missing ${name}.`);
+  return value;
+}
+
+function nonEmpty(value) {
+  return typeof value === 'string' && value.trim() ? value.trim() : null;
+}
+
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}

package/src/backup/runtime-adapters.js

@@ -0,0 +1,269 @@
+import { execFile } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { copyFile, mkdir, rename, rm } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import { randomUUID } from 'node:crypto';
+
+import { createNativeGraphServices } from '../native-runtime/runtime.js';
+import { ensureContainerRuntime } from '../setup/container-runtime.js';
+import { readJsonFile } from '../storage/json-file.js';
+import {
+  graphBackupSelection,
+  reconcileImportedGraphIdentity
+} from './identity-reconciliation.js';
+
+const COMMAND_TIMEOUT_MS = 10 * 60_000;
+
+export async function createGraphBackupAdapter({
+  mode,
+  paths,
+  onProgress = () => {},
+  ensureContainer = ensureContainerRuntime,
+  run = runCommand
+}) {
+  const instances = managedGraphInstances(paths);
+  if (mode === 'native') return createNativeBackupAdapter({ paths, instances, run });
+  if (mode === 'container') {
+    const runtime = await ensureContainer({ onProgress });
+    return createContainerBackupAdapter({ paths, instances, runtime, run });
+  }
+  throw new TypeError('Graph backup runtime mode must be container or native.');
+}
+
+export function managedGraphInstances(paths) {
+  const state = readJsonFile(paths.graphRuntimeStatePath, null);
+  const config = readJsonFile(paths.graphRuntimeConfigPath, null);
+  const workspace = state?.managedProviders?.includes('development-workspace') ||
+    (config?.workspaces ?? []).some(({ managedDevelopment }) => managedDevelopment === true);
+  return workspace ? ['personal', 'workspace'] : ['personal'];
+}
+
+function createNativeBackupAdapter({ paths, instances, run }) {
+  const descriptor = readJsonFile(paths.nativeRuntimeManifestPath, null);
+  if (descriptor?.status !== 'ready' || descriptor.mode !== 'native') {
+    throw new Error(
+      'Native graph mode is not initialized. Run `fuli setup --runtime-mode native` first.'
+    );
+  }
+  const services = createNativeGraphServices({
+    paths,
+    runtimeDescriptor: descriptor,
+    personalOnly: !instances.includes('workspace')
+  });
+
+  async function stop() {
+    const lifecycle = nativeRuntimeLifecycle(paths, instances);
+    await services.stopDatabases();
+    return lifecycle;
+  }
+
+  async function start(lifecycle = {}) {
+    if (lifecycle.resumeProviders === true) {
+      await services.start();
+    } else if (lifecycle.resumeDatabases === true) {
+      await services.start({ providers: false });
+    }
+  }
+
+  async function dump(instance, destination) {
+    const spec = nativeSpec(paths, descriptor, instance);
+    await withStagingDirectory(destination, async (stage) => {
+      await run(join(descriptor.neo4jHome, 'bin', 'neo4j-admin'), [
+        'database', 'dump', 'neo4j', `--to-path=${stage}`
+      ], { env: spec.environment });
+      await rename(join(stage, 'neo4j.dump'), destination);
+    });
+  }
+
+  async function load(instance, source) {
+    const spec = nativeSpec(paths, descriptor, instance);
+    await withStagingDirectory(source, async (stage) => {
+      await copyFile(source, join(stage, 'neo4j.dump'));
+      await run(join(descriptor.neo4jHome, 'bin', 'neo4j-admin'), [
+        'database', 'load', 'neo4j', `--from-path=${stage}`, '--overwrite-destination=true'
+      ], { env: spec.environment });
+    });
+  }
+
+  function hasData(instance) {
+    return existsSync(join(nativeInstanceDir(paths, instance), 'data', 'databases', 'neo4j'));
+  }
+
+  async function reconcile(input) {
+    await services.start();
+    try {
+      return await reconcileImportedGraphIdentity({ paths, instances, ...input });
+    } finally {
+      await services.stopDatabases();
+    }
+  }
+
+  return {
+    mode: 'native',
+    instances,
+    stop,
+    start,
+    dump,
+    load,
+    hasData,
+    selection: () => graphBackupSelection(paths),
+    reconcile
+  };
+}
+
+function createContainerBackupAdapter({ paths, instances, runtime, run }) {
+  const composePrefix = [
+    'compose', '--env-file', paths.graphEnvPath, '-f', paths.graphComposePath
+  ];
+  const services = instances.flatMap((instance) => [
+    `${instance}-provider`, `${instance}-neo4j`
+  ]);
+
+  async function docker(args) {
+    return run(runtime.dockerCommand, args, { env: runtime.dockerEnvironment });
+  }
+
+  async function stop() {
+    const running = await docker([
+      ...composePrefix, 'ps', '--status', 'running', '--services', ...services
+    ]);
+    const resumeServices = String(running).split(/\r?\n/)
+      .map((service) => service.trim())
+      .filter((service) => services.includes(service));
+    await docker([...composePrefix, 'stop', '-t', '30', ...services]);
+    return { resume: resumeServices.length > 0, resumeServices };
+  }
+
+  async function start(lifecycle = {}) {
+    const resumeServices = Array.isArray(lifecycle.resumeServices)
+      ? lifecycle.resumeServices.filter((service) => services.includes(service))
+      : (lifecycle.resume === true ? services : []);
+    if (resumeServices.length === 0) return;
+    await docker([...composePrefix, 'up', '-d', '--no-build', ...resumeServices]);
+  }
+
+  async function dump(instance, destination) {
+    await withBackupHelper(instance, async (helper) => {
+      await docker([
+        'exec', helper,
+        'neo4j-admin', 'database', 'dump', 'neo4j', '--to-path=/backup'
+      ]);
+      await docker(['cp', `${helper}:/backup/neo4j.dump`, destination]);
+    });
+  }
+
+  async function load(instance, source) {
+    await withBackupHelper(instance, async (helper) => {
+      await docker(['cp', source, `${helper}:/backup/neo4j.dump`]);
+      await docker([
+        'exec', helper,
+        'neo4j-admin', 'database', 'load', 'neo4j',
+        '--from-path=/backup', '--overwrite-destination=true'
+      ]);
+    });
+  }
+
+  async function hasData(instance) {
+    return withBackupHelper(instance, async (helper) => {
+      try {
+        await docker(['exec', helper, 'test', '-d', '/data/databases/neo4j']);
+        return true;
+      } catch {
+        return false;
+      }
+    });
+  }
+
+  async function reconcile(input) {
+    await docker([...composePrefix, 'up', '-d', '--no-build', ...services]);
+    try {
+      return await reconcileImportedGraphIdentity({ paths, instances, ...input });
+    } finally {
+      await docker([...composePrefix, 'stop', '-t', '30', ...services]);
+    }
+  }
+
+  async function withBackupHelper(instance, operation) {
+    const helper = `fuli-neo4j-backup-${randomUUID()}`;
+    try {
+      await docker([
+        ...composePrefix,
+        'run', '--detach', '--name', helper, '--no-deps', '-T',
+        `${instance}-neo4j`, 'tail', '-f', '/dev/null'
+      ]);
+      await docker(['exec', helper, 'mkdir', '-p', '/backup']);
+      return await operation(helper);
+    } finally {
+      await docker(['rm', '--force', helper]).catch(() => {});
+    }
+  }
+
+  return {
+    mode: 'container',
+    instances,
+    stop,
+    start,
+    dump,
+    load,
+    hasData,
+    selection: () => graphBackupSelection(paths),
+    reconcile
+  };
+}
+
+function nativeSpec(paths, descriptor, instance) {
+  const instanceDir = nativeInstanceDir(paths, instance);
+  return {
+    instanceDir,
+    environment: {
+      ...process.env,
+      JAVA_HOME: descriptor.javaHome,
+      NEO4J_HOME: descriptor.neo4jHome,
+      NEO4J_CONF: join(instanceDir, 'conf')
+    }
+  };
+}
+
+function nativeInstanceDir(paths, instance) {
+  if (instance === 'personal') return paths.nativePersonalDir;
+  if (instance === 'workspace') return paths.nativeWorkspaceDir;
+  throw new TypeError(`Unsupported graph instance: ${instance}`);
+}
+
+function nativeRuntimeLifecycle(paths, instances) {
+  const processes = readJsonFile(paths.nativeProcessStatePath, null);
+  const resumeProviders = Object.keys(processes?.providers ?? {}).length > 0;
+  const resumeDatabases = Object.keys(processes?.databases ?? {}).length > 0 || instances.some((instance) =>
+    existsSync(join(nativeInstanceDir(paths, instance), 'run', 'neo4j.pid')));
+  return {
+    resume: resumeProviders || resumeDatabases,
+    resumeProviders,
+    resumeDatabases: resumeProviders || resumeDatabases
+  };
+}
+
+async function withStagingDirectory(referencePath, operation) {
+  const parent = dirname(referencePath);
+  const stage = join(parent, `.fuli-neo4j-${randomUUID()}`);
+  await mkdir(stage, { recursive: false, mode: 0o700 });
+  try {
+    return await operation(stage);
+  } finally {
+    await rm(stage, { recursive: true, force: true });
+  }
+}
+
+function runCommand(command, args, { env } = {}) {
+  return new Promise((resolve, reject) => {
+    execFile(command, args, {
+      env: env ?? process.env,
+      encoding: 'utf8',
+      timeout: COMMAND_TIMEOUT_MS,
+      maxBuffer: 4 * 1024 * 1024,
+      windowsHide: true
+    }, (error, stdout, stderr) => {
+      if (error) reject(new Error(String(stderr || stdout || error.message).trim()));
+      else resolve(stdout);
+    });
+  });
+}

package/src/cli/command-registry.js

@@ -19,7 +19,12 @@ Local service:
   open [--data-dir DIR]
 
 Install and Agent connection:
-  setup [--yes] [--codex-only] [--data-dir DIR] [--personal-space NAME] [--port PORT] [--skip-agents] [--no-start] [--personal-only|--with-dev-public]
+  setup [--yes] [--codex-only] [--data-dir DIR] [--personal-space NAME] [--port PORT] [--runtime-mode container|native] [--memory-profile low|balanced] [--adaptive-memory|--no-adaptive-memory] [--skip-agents] [--no-start] [--personal-only|--with-dev-public]
+  connect-workspace --url URL --token-file FILE [--data-dir DIR]
   update [setup options]
-  uninstall [--yes] [--data-dir DIR]`);
+  uninstall [--yes] [--data-dir DIR]
+
+Graph data portability:
+  graph export --output DIR [--mode container|native] [--data-dir DIR]
+  graph import --input DIR [--target-mode container|native] [--yes] [--data-dir DIR]`);
 }

package/src/cli/graph-data-command.js

@@ -0,0 +1,112 @@
+import { createInterface } from 'node:readline/promises';
+
+import { exportGraphData, importGraphData } from '../backup/graph-backup.js';
+import { createGraphBackupAdapter } from '../backup/runtime-adapters.js';
+import { resolveSetupPaths } from '../setup/paths.js';
+import { readRuntimeSettings } from '../system/runtime-settings.js';
+
+export async function runGraphDataCommand(action, args, dependencies = {}) {
+  const options = parseGraphDataOptions(action, args);
+  const resolvePaths = dependencies.resolvePaths ?? resolveSetupPaths;
+  const paths = resolvePaths({ dataDir: options.dataDir, env: dependencies.env ?? process.env });
+  const readSettings = dependencies.readSettings ?? readRuntimeSettings;
+  const saved = readSettings(paths.runtimeSettingsPath);
+  const mode = options.mode ?? saved.graphRuntimeMode;
+  const write = dependencies.write ?? writeLine;
+
+  if (action === 'import' && !options.yes) {
+    const confirm = dependencies.confirm ?? confirmImport;
+    if (!await confirm(mode)) {
+      write('Cancelled. Graph data was not changed.');
+      return { status: 'cancelled' };
+    }
+  }
+
+  const createAdapter = dependencies.createAdapter ?? createGraphBackupAdapter;
+  const adapter = await createAdapter({
+    mode,
+    paths,
+    onProgress: write
+  });
+  if (action === 'export') {
+    const exportData = dependencies.exportData ?? exportGraphData;
+    const result = await exportData({
+      outputDir: options.outputDir,
+      sourceMode: mode,
+      instances: adapter.instances,
+      adapter
+    });
+    write(`Graph data exported from ${mode} mode to ${options.outputDir}.`);
+    return result;
+  }
+
+  const importData = dependencies.importData ?? importGraphData;
+  const result = await importData({
+    inputDir: options.inputDir,
+    targetMode: mode,
+    rollbackDir: paths.graphBackupDir,
+    adapter
+  });
+  write(result.rollbackDir
+    ? `Graph data imported into ${mode} mode. A pre-import rollback backup was preserved.`
+    : `Graph data imported into ${mode} mode. The target had no prior data to preserve.`);
+  return result;
+}
+
+export function parseGraphDataOptions(action, args = []) {
+  if (!['export', 'import'].includes(action)) {
+    throw new TypeError('Graph command must be export or import.');
+  }
+  const result = {
+    action,
+    outputDir: null,
+    inputDir: null,
+    mode: null,
+    dataDir: null,
+    yes: false
+  };
+  const values = action === 'export'
+    ? { '--output': 'outputDir', '--mode': 'mode', '--data-dir': 'dataDir' }
+    : { '--input': 'inputDir', '--target-mode': 'mode', '--data-dir': 'dataDir' };
+  const seen = new Set();
+  for (let index = 0; index < args.length; index += 1) {
+    const flag = args[index];
+    if (seen.has(flag)) throw new TypeError(`Duplicate ${flag}`);
+    if (flag === '--yes' && action === 'import') {
+      result.yes = true;
+      seen.add(flag);
+      continue;
+    }
+    const key = values[flag];
+    if (!key) throw new TypeError(`Unknown graph ${action} option: ${flag}`);
+    const value = args[index + 1];
+    if (typeof value !== 'string' || !value.trim() || value.startsWith('--')) {
+      throw new TypeError(`Missing value for ${flag}`);
+    }
+    result[key] = value.trim();
+    seen.add(flag);
+    index += 1;
+  }
+  if (action === 'export' && !result.outputDir) throw new TypeError('--output is required');
+  if (action === 'import' && !result.inputDir) throw new TypeError('--input is required');
+  if (result.mode && !['container', 'native'].includes(result.mode)) {
+    throw new TypeError('Graph runtime mode must be container or native.');
+  }
+  return result;
+}
+
+async function confirmImport(mode) {
+  const input = createInterface({ input: process.stdin, output: process.stdout });
+  try {
+    const answer = (await input.question(
+      `Import will replace the current ${mode} graph after making a rollback backup. Continue? [y/N] `
+    )).trim().toLowerCase();
+    return answer === 'y' || answer === 'yes';
+  } finally {
+    input.close();
+  }
+}
+
+function writeLine(value) {
+  process.stdout.write(`${value}\n`);
+}

package/src/cli/local-runtime-command.js

@@ -180,16 +180,30 @@ function formatStatus(result) {
   const publicSummary = result.public.configured
     ? `${labels[result.public.status] ?? result.public.status} (${result.public.providers.length} Providers)`
     : labels.not_connected;
-  return [
+  const lines = [
     `Fuli local status: ${labels[result.status] ?? result.status}`,
     `Management UI: ${labels[result.console.status] ?? result.console.status} · ${result.console.url}`,
     `Personal graph: ${providerLabel(result.personal.status, labels)}`,
     `Shared services: ${publicSummary}`
-  ].join('\n');
+  ];
+  if (result.adaptiveRuntime?.enabled) {
+    const stages = {
+      awake: 'awake',
+      'provider-sleeping': 'Provider sleeping',
+      sleeping: 'Provider and database sleeping',
+      waking: 'waking',
+      degraded: 'degraded',
+      unknown: 'unknown'
+    };
+    lines.push(`Adaptive memory: ${stages[result.adaptiveRuntime.stage] ??
+      result.adaptiveRuntime.stage}`);
+  }
+  return lines.join('\n');
 }
 
 function providerLabel(status, labels) {
   if (status === 'not_configured') return labels.not_configured_provider;
+  if (status === 'sleeping') return 'sleeping on purpose';
   return labels[status] ?? status;
 }
 

package/src/cli/setup-command.js

@@ -49,19 +49,35 @@ export function formatSetupPreview(plan, options) {
     DEFAULT_RUNTIME_SETTINGS,
     { consolePort: options.port }
   );
-  return [
+  const runtimeMode = runtimeSettings.graphRuntimeMode;
+  const lines = [
     'Ready to set up Fuli',
     options.personalOnly
       ? 'Storage: personal only, using local Graphiti / Neo4j'
       : 'Storage: local Graphiti / Neo4j plus a development shared-project Provider',
-    'Container runtime: detected automatically; an installed desktop runtime starts if needed',
+    runtimeMode === 'native'
+      ? 'Graph runtime: native processes; no Docker VM required'
+      : 'Graph runtime: container; Docker or Rancher Desktop starts if needed',
     `Shared services: ${options.personalOnly ? 'not connected' : 'local development Provider'}`,
     `Personal space: ${options.personalSpaceName}`,
+    `Neo4j memory: ${options.memoryProfile ?? 'saved profile or balanced default'}`,
+    `Adaptive memory: ${plan.adaptiveRuntimeSettings?.enabled ?
+      'enabled; Provider and database sleep after idle time' :
+      'disabled; graph services stay running'}`,
     `Management UI: ${options.noStart
       ? 'will not start'
       : `http://127.0.0.1:${runtimeSettings.ports.console}`}`,
     `Agents: ${agentSummary}`
-  ].join('\n');
+  ];
+  if (
+    runtimeMode !== 'native' &&
+    plan.runtimeModeRecommendation?.recommendedMode === 'native'
+  ) {
+    lines.splice(3, 0,
+      'Recommendation: native mode avoids shared VM memory on this low-memory Mac; ' +
+      'select it with --runtime-mode native');
+  }
+  return lines.join('\n');
 }
 
 export function formatSetupResult(result, plan) {

package/src/cli/update-command.js

@@ -137,6 +137,10 @@ export function formatUpdatePreview(options) {
     options.dataDir
       ? `Data: preserve ${options.dataDir}`
       : 'Data: preserve the current default data directory',
+    `Neo4j memory: ${options.memoryProfile ?? 'keep saved profile or use balanced by default'}`,
+    `Adaptive memory: ${options.adaptiveMemory === null
+      ? 'keep saved setting'
+      : options.adaptiveMemory ? 'enable' : 'disable'}`,
     `Agent integrations and Skills: ${options.skipAgents
       ? 'skip refresh as requested'
       : 'refresh through setup in the new version'}`