fuli-context 0.7.4-beta.3 → 0.7.5

package/src/server.js

@@ -63,7 +63,8 @@ export async function createServer(options = {}) {
         }),
         packageRoot: PACKAGE_ROOT,
         activePort: port,
-        activeLan: lanEnabled
+        activeLan: lanEnabled,
+        executorAdapters: options.executorAdapters
       })
     : null);
   for (let attempt = 0; attempt < 20; attempt += 1) {
@@ -109,7 +110,10 @@ export async function createServer(options = {}) {
       throw new Error('Server did not bind to a valid local authority');
     }
 
-    server.once('close', runtime.close);
+    server.once('close', () => {
+      system?.close?.();
+      runtime.close();
+    });
     return {
       server,
       url: `http://${authority}`,

package/src/setup/agent-installation-status.js

@@ -63,7 +63,13 @@ export function inspectAgentInstallations(agents, context, {
 function inspectRegistration(agent, context, readers) {
   const expected = {
     command: context.nodePath,
-    args: [context.mcpServerPath, '--runtime-config', context.runtimeConfigPath]
+    args: [
+      context.mcpServerPath,
+      '--runtime-config',
+      context.runtimeConfigPath,
+      '--source-application',
+      agent.id === 'claude-code' ? 'claude_code' : agent.id
+    ]
   };
   try {
     if (agent.id === 'codex') {

package/src/setup/agents.js

@@ -60,7 +60,9 @@ export function buildAgentCommands(agent, context) {
   const serverArgs = [
     context.mcpServerPath,
     '--runtime-config',
-    context.runtimeConfigPath
+    context.runtimeConfigPath,
+    '--source-application',
+    agent.id === 'claude-code' ? 'claude_code' : agent.id
   ];
   const mcpArgs = [context.nodePath, ...serverArgs];
   if (agent.id === 'codex') {

package/src/setup/claude-code-config.js

@@ -32,7 +32,9 @@ export function connectClaudeCode(agent, context, {
         args: [
           context.mcpServerPath,
           '--runtime-config',
-          context.runtimeConfigPath
+          context.runtimeConfigPath,
+          '--source-application',
+          'claude_code'
         ],
         alwaysLoad: true
       }

package/src/setup/codex-bootstrap.js

@@ -15,16 +15,17 @@ const BLOCK_START = '<!-- BEGIN FULI MANAGED INSTRUCTIONS -->';
 const BLOCK_END = '<!-- END FULI MANAGED INSTRUCTIONS -->';
 
 const GLOBAL_INSTRUCTIONS = `${BLOCK_START}
-At the start of every user task, before any other tool or answer, call exactly
-\`get_collaboration_preferences\` with \`projectPath\`=current working directory and
-\`taskPrompt\`=current user request; never substitute a project action/Fuli tool. Fuli uses both
-transiently and never stores or returns them. Apply all returned \`effective_preferences\`.
-Before asking the user to repeat a stable project fact or method, inspect
-\`task_knowledge_recall\`. On miss call \`search_current_project_knowledge\` with 1-4 focused
-action/artifact/target/identifier queries; never use the full request as the only query.
-For write tools enforce them in the actual payload; mentioning them later is not compliance.
-Relevant \`deferred_conflict\`: call \`resolve_deferred_preference_conflict\` first; ignore others.
-Current request wins.
+At start of every user task, before any other tool or answer, call exactly
+\`get_collaboration_preferences\` with \`projectPath\`=current working directory,
+\`taskPrompt\`=current user request. Never substitute a project action/Fuli tool.
+Fuli never stores or returns them; inputs are transient. Apply all returned \`effective_preferences\`.
+Before asking user to repeat a stable project fact or method, inspect \`task_knowledge_recall\`.
+On miss call \`search_current_project_knowledge\` with focused action/artifact/target/identifier
+queries; never use the full request as the only query.
+Write tools enforce preferences in actual payload; mentioning later is not compliance.
+Resolve relevant \`deferred_conflict\` first; ignore others.
+Team: \`coordinate_project_agent_task\`; host \`acquire_runtime_lease\`, start workers, report
+execution, \`release_runtime_lease\` in finally.
 ${codexReviewCommandBridge()}
 ${BLOCK_END}`;
 

package/src/setup/codex-config.js

@@ -22,7 +22,13 @@ export function connectCodex(agent, context, {
   const current = readConfig(agent.configPath);
   const next = replaceFuliTable(current, {
     command: context.nodePath,
-    args: [context.mcpServerPath, '--runtime-config', context.runtimeConfigPath]
+    args: [
+      context.mcpServerPath,
+      '--runtime-config',
+      context.runtimeConfigPath,
+      '--source-application',
+      'codex'
+    ]
   });
   const bootstrap = installBootstrap(agent, context);
   const registrationChanged = next !== current;

package/src/setup/cursor-config.js

@@ -21,7 +21,9 @@ export function connectCursor(agent, context, {
         args: [
           context.mcpServerPath,
           '--runtime-config',
-          context.runtimeConfigPath
+          context.runtimeConfigPath,
+          '--source-application',
+          'cursor'
         ]
       }
     }

package/src/setup/graph-runtime.js

@@ -15,6 +15,10 @@ import {
   ensureContainerRuntime,
   runDockerCompose
 } from './container-runtime.js';
+import {
+  createNativeGraphServices,
+  ensureNativeRuntime
+} from '../native-runtime/runtime.js';
 import {
   discoverLanAddresses,
   LAN_ACCESS_USERNAME,
@@ -28,6 +32,20 @@ import {
   runtimeSettingsWithOverrides,
   writeRuntimeSettings
 } from '../system/runtime-settings.js';
+import {
+  neo4jMemoryEnvironment,
+  resolveNeo4jMemoryProfile
+} from './neo4j-memory-profile.js';
+import {
+  DEFAULT_ADAPTIVE_RUNTIME_SETTINGS,
+  normalizeAdaptiveRuntimeSettings,
+  readAdaptiveRuntimeSettings,
+  writeAdaptiveRuntimeSettings
+} from '../adaptive-runtime/settings.js';
+import {
+  initialAdaptiveRuntimeState,
+  writeAdaptiveRuntimeState
+} from '../adaptive-runtime/state.js';
 
 export {
   dockerInfoIndicatesDaemon,
@@ -42,31 +60,79 @@ export async function ensureGraphRuntime(input, dependencies = {}) {
       lanAccess: input.lan === true
     }));
   const urls = managedProviderUrls(runtimeSettings);
+  const adaptiveRuntimeSettings = normalizeAdaptiveRuntimeSettings(
+    input.adaptiveRuntimeSettings ?? (input.paths.adaptiveRuntimeSettingsPath
+      ? deps.readAdaptiveSettings(input.paths.adaptiveRuntimeSettingsPath)
+      : DEFAULT_ADAPTIVE_RUNTIME_SETTINGS)
+  );
   const lan = runtimeSettings.lanAccess;
+  const runtimeMode = input.runtimeMode ?? runtimeSettings.graphRuntimeMode;
+  const activeRuntimeState = deps.readState(input.paths.graphRuntimeStatePath);
+  const previousRuntimeMode = input.previousRuntimeMode ??
+    activeRuntimeState?.runtimeSettings?.graphRuntimeMode ?? runtimeMode;
   const lanAddresses = lan ? deps.discoverLanAddresses() : [];
   if (lan && lanAddresses.length === 0) {
     throw new Error('No private IPv4 LAN address is available, so LAN mode cannot start.');
   }
-  const containerRuntime = await deps.ensureContainerRuntime({
-    env: input.env ?? process.env,
-    onProgress: input.onProgress
-  });
+  const selectedGraphRuntime = runtimeMode === 'native'
+    ? await deps.ensureNativeRuntime({
+        paths: input.paths,
+        env: input.env ?? process.env,
+        runtimeSettings,
+        memoryProfile: input.memoryProfile,
+        personalOnly: input.personalOnly === true,
+        onProgress: input.onProgress
+      })
+    : await deps.ensureContainerRuntime({
+        env: input.env ?? process.env,
+        onProgress: input.onProgress
+      });
   deps.ensureDirectory(input.paths.dataDir);
+  const configSelection = selectRuntimeConfig({
+    paths: input.paths,
+    previousRuntimeMode,
+    runtimeMode,
+    deps
+  });
+  if (input.paths.adaptiveRuntimeSettingsPath) {
+    deps.writeAdaptiveSettings(
+      input.paths.adaptiveRuntimeSettingsPath,
+      adaptiveRuntimeSettings
+    );
+  }
   const secrets = ensureProviderEnvironment(
     input.paths.graphEnvPath,
     runtimeSettings,
+    input.memoryProfile,
     deps
   );
   deps.writeRuntimeSettings(input.paths.runtimeSettingsPath, runtimeSettings);
-  deps.startProviders(input.paths, input.paths.graphEnvPath, {
-    personalOnly: input.personalOnly === true,
-    containerRuntime,
-    ...(input.buildProviders === false ? { build: false } : {})
-  });
+  if (runtimeMode === 'native') {
+    await deps.startNativeProviders(input.paths, input.paths.graphEnvPath, {
+      personalOnly: input.personalOnly === true,
+      nativeRuntime: selectedGraphRuntime
+    });
+  } else {
+    deps.startProviders(input.paths, input.paths.graphEnvPath, {
+      personalOnly: input.personalOnly === true,
+      containerRuntime: selectedGraphRuntime,
+      ...(input.buildProviders === false ? { build: false } : {})
+    });
+  }
   await waitForProvider(urls.personal, deps.fetch);
   if (!input.personalOnly) await waitForProvider(urls.workspace, deps.fetch);
+  if (input.paths.adaptiveRuntimeStatePath) {
+    deps.writeAdaptiveState(
+      input.paths.adaptiveRuntimeStatePath,
+      initialAdaptiveRuntimeState({ enabled: adaptiveRuntimeSettings.enabled })
+    );
+  }
 
-  let config = deps.readConfig(input.paths.graphRuntimeConfigPath);
+  let config = configSelection.config;
+  if (configSelection.switched && config) {
+    deps.writeConfig(input.paths.graphRuntimeConfigPath, config);
+    deps.secureFile(input.paths.graphRuntimeConfigPath);
+  }
   if (!config) {
     config = await bootstrapGraph({
       urls,
@@ -95,9 +161,16 @@ export async function ensureGraphRuntime(input, dependencies = {}) {
       deps.secureFile(input.paths.graphRuntimeConfigPath);
     }
   }
+  const activeProfilePath = configSelection.switched
+    ? graphConfigProfilePath(input.paths, runtimeMode)
+    : null;
+  if (activeProfilePath) {
+    deps.writeConfig(activeProfilePath, config);
+    deps.secureFile(activeProfilePath);
+  }
 
   if (input.noStart) return { status: 'initialized', url: null, pid: null };
-  const existing = deps.readState(input.paths.graphRuntimeStatePath);
+  const existing = activeRuntimeState;
   if (isGraphRuntimeState(existing) && deps.isProcessAlive(existing.pid)) {
     const healthy = await deps.webHealth(existing.url, existing.pid, existing.version);
     if (
@@ -105,6 +178,9 @@ export async function ensureGraphRuntime(input, dependencies = {}) {
       existing.port === runtimeSettings.ports.console &&
       exposureMatches(existing, { lan, lanAddresses })
     ) {
+      if (adaptiveRuntimeSettings.enabled) {
+        await notifyAdaptiveRuntime(existing.url, deps.fetch);
+      }
       return runtimeResult('running', existing);
     }
     if (!healthy) throw new Error('Recorded Fuli Graphiti runtime is not healthy');
@@ -149,10 +225,38 @@ export async function ensureGraphRuntime(input, dependencies = {}) {
   return runtimeResult('started', state, lanAccessToken);
 }
 
-function ensureProviderEnvironment(path, settings, deps) {
+function selectRuntimeConfig({ paths, previousRuntimeMode, runtimeMode, deps }) {
+  const current = deps.readConfig(paths.graphRuntimeConfigPath);
+  const switched = previousRuntimeMode !== runtimeMode;
+  if (!switched) return { switched: false, config: current };
+
+  const previousProfilePath = graphConfigProfilePath(paths, previousRuntimeMode);
+  if (current && previousProfilePath) {
+    deps.writeConfig(previousProfilePath, current);
+    deps.secureFile(previousProfilePath);
+  }
+  const targetProfilePath = graphConfigProfilePath(paths, runtimeMode);
+  return {
+    switched: true,
+    config: targetProfilePath ? deps.readConfig(targetProfilePath) : null
+  };
+}
+
+function graphConfigProfilePath(paths, mode) {
+  if (mode === 'native') return paths.nativeGraphConfigProfilePath ?? null;
+  if (mode === 'container') return paths.containerGraphConfigProfilePath ?? null;
+  return null;
+}
+
+function ensureProviderEnvironment(path, settings, requestedMemoryProfile, deps) {
   const previous = deps.fileExists(path) ? parseEnv(deps.readText(path)) : {};
+  const memoryProfile = resolveNeo4jMemoryProfile(
+    requestedMemoryProfile,
+    previous.FULI_NEO4J_MEMORY_PROFILE
+  );
   const values = {
     ...previous,
+    ...neo4jMemoryEnvironment(memoryProfile),
     FULI_PERSONAL_NEO4J_PASSWORD: previous.FULI_PERSONAL_NEO4J_PASSWORD ?? secret(),
     FULI_WORKSPACE_NEO4J_PASSWORD: previous.FULI_WORKSPACE_NEO4J_PASSWORD ?? secret(),
     FULI_PERSONAL_BOOTSTRAP_TOKEN: previous.FULI_PERSONAL_BOOTSTRAP_TOKEN ?? secret(),
@@ -390,7 +494,14 @@ export function startGraphProviders(paths, envPath, options = {}) {
   runDockerCompose(args, options.containerRuntime);
 }
 
-export function stopGraphProviders(paths, envPath, options = {}) {
+export async function stopGraphProviders(paths, envPath, options = {}) {
+  if (options.runtimeMode === 'native') {
+    await createNativeGraphServices({
+      paths,
+      personalOnly: options.personalOnly === true
+    }).stopDatabases();
+    return;
+  }
   const args = [
     'compose',
     '--env-file', envPath,
@@ -437,10 +548,19 @@ function graphDependencies(overrides) {
     readConfig: (path) => readJsonFile(path, null),
     writeConfig: writeJsonFileAtomic,
     writeRuntimeSettings,
+    readAdaptiveSettings: readAdaptiveRuntimeSettings,
+    writeAdaptiveSettings: writeAdaptiveRuntimeSettings,
+    writeAdaptiveState: writeAdaptiveRuntimeState,
     readState: (path) => readJsonFile(path, null),
     writeState: writeJsonFileAtomic,
     ensureContainerRuntime,
+    ensureNativeRuntime,
     startProviders: startGraphProviders,
+    startNativeProviders: (paths, _envPath, options) => createNativeGraphServices({
+      paths,
+      runtimeDescriptor: options.nativeRuntime,
+      personalOnly: options.personalOnly
+    }).start(),
     spawnWebRuntime,
     isProcessAlive,
     stopProcess,
@@ -452,6 +572,31 @@ function graphDependencies(overrides) {
   };
 }
 
+async function notifyAdaptiveRuntime(url, fetchImpl) {
+  let leaseId = null;
+  try {
+    const acquired = await fetchImpl(`${url}/api/system/runtime/leases`, {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({ kind: 'graph', owner: 'setup' }),
+      signal: AbortSignal.timeout(180_000)
+    });
+    if (!acquired.ok) return;
+    leaseId = (await acquired.json())?.leaseId ?? null;
+  } catch {
+    return;
+  }
+  if (!leaseId) return;
+  try {
+    await fetchImpl(`${url}/api/system/runtime/leases/${encodeURIComponent(leaseId)}`, {
+      method: 'DELETE',
+      signal: AbortSignal.timeout(10_000)
+    });
+  } catch {
+    // Lease expiry remains the safety net if setup cannot release explicitly.
+  }
+}
+
 export async function checkLocalConsoleHealth(url, expectedPid, stateVersion = 3) {
   try {
     const response = await fetch(`${url}/api/health`, {

package/src/setup/neo4j-memory-profile.js

@@ -0,0 +1,43 @@
+export const DEFAULT_NEO4J_MEMORY_PROFILE = 'balanced';
+
+export const NEO4J_MEMORY_PROFILES = Object.freeze({
+  balanced: Object.freeze({
+    heapInitial: '256m',
+    heapMax: '512m',
+    pageCache: '256m'
+  }),
+  low: Object.freeze({
+    heapInitial: '128m',
+    heapMax: '256m',
+    pageCache: '64m'
+  })
+});
+
+export function normalizeNeo4jMemoryProfile(value) {
+  const profile = typeof value === 'string' ? value.trim() : '';
+  if (!Object.hasOwn(NEO4J_MEMORY_PROFILES, profile)) {
+    throw new TypeError('Neo4j memory profile must be "low" or "balanced"');
+  }
+  return profile;
+}
+
+export function resolveNeo4jMemoryProfile(requested, saved) {
+  if (requested !== null && requested !== undefined) {
+    return normalizeNeo4jMemoryProfile(requested);
+  }
+  if (typeof saved === 'string' && saved.trim()) {
+    return normalizeNeo4jMemoryProfile(saved);
+  }
+  return DEFAULT_NEO4J_MEMORY_PROFILE;
+}
+
+export function neo4jMemoryEnvironment(profile = DEFAULT_NEO4J_MEMORY_PROFILE) {
+  const resolved = normalizeNeo4jMemoryProfile(profile);
+  const values = NEO4J_MEMORY_PROFILES[resolved];
+  return {
+    FULI_NEO4J_MEMORY_PROFILE: resolved,
+    FULI_NEO4J_HEAP_INITIAL_SIZE: values.heapInitial,
+    FULI_NEO4J_HEAP_MAX_SIZE: values.heapMax,
+    FULI_NEO4J_PAGECACHE_SIZE: values.pageCache
+  };
+}

package/src/setup/options.js

@@ -1,7 +1,11 @@
+import { normalizeNeo4jMemoryProfile } from './neo4j-memory-profile.js';
+
 const VALUE_OPTIONS = Object.freeze({
   '--data-dir': 'dataDir',
   '--personal-space': 'personalSpaceName',
-  '--port': 'port'
+  '--port': 'port',
+  '--memory-profile': 'memoryProfile',
+  '--runtime-mode': 'runtimeMode'
 });
 
 const BOOLEAN_OPTIONS = Object.freeze({
@@ -11,6 +15,11 @@ const BOOLEAN_OPTIONS = Object.freeze({
   '--no-start': 'noStart'
 });
 
+const ADAPTIVE_MEMORY_OPTIONS = Object.freeze({
+  '--adaptive-memory': true,
+  '--no-adaptive-memory': false
+});
+
 const PROVIDER_MODE_OPTIONS = new Set(['--personal-only', '--with-dev-public']);
 
 export function parseSetupOptions(args = []) {
@@ -26,6 +35,9 @@ function parseSetupLikeOptions(args, command) {
     dataDir: null,
     personalSpaceName: 'Personal',
     port: null,
+    memoryProfile: null,
+    runtimeMode: null,
+    adaptiveMemory: null,
     yes: false,
     codexOnly: false,
     skipAgents: false,
@@ -37,6 +49,17 @@ function parseSetupLikeOptions(args, command) {
   for (let index = 0; index < args.length; index += 1) {
     const flag = args[index];
     if (seen.has(flag)) throw new TypeError(`Duplicate ${flag}`);
+    if (Object.hasOwn(ADAPTIVE_MEMORY_OPTIONS, flag)) {
+      const conflicting = flag === '--adaptive-memory'
+        ? '--no-adaptive-memory'
+        : '--adaptive-memory';
+      if (seen.has(conflicting)) {
+        throw new TypeError('--adaptive-memory and --no-adaptive-memory cannot be combined');
+      }
+      result.adaptiveMemory = ADAPTIVE_MEMORY_OPTIONS[flag];
+      seen.add(flag);
+      continue;
+    }
     if (PROVIDER_MODE_OPTIONS.has(flag)) {
       const conflicting = flag === '--personal-only' ? '--with-dev-public' : '--personal-only';
       if (seen.has(conflicting)) {
@@ -58,7 +81,7 @@ function parseSetupLikeOptions(args, command) {
     if (typeof value !== 'string' || !value.trim() || value.startsWith('--')) {
       throw new TypeError(`Missing value for ${flag}`);
     }
-    result[valueKey] = valueKey === 'port' ? parsePort(value) : value.trim();
+    result[valueKey] = parseValue(valueKey, value);
     seen.add(flag);
     index += 1;
   }
@@ -95,3 +118,16 @@ function parsePort(value) {
   }
   return port;
 }
+
+function parseValue(key, value) {
+  if (key === 'port') return parsePort(value);
+  if (key === 'memoryProfile') return normalizeNeo4jMemoryProfile(value);
+  if (key === 'runtimeMode') {
+    const mode = value.trim();
+    if (!['container', 'native'].includes(mode)) {
+      throw new TypeError('Runtime mode must be "container" or "native"');
+    }
+    return mode;
+  }
+  return value.trim();
+}

package/src/setup/paths.js

@@ -14,12 +14,25 @@ export function resolveSetupPaths({
 } = {}) {
   const resolvedDataDir = resolve(cwd, dataDir ?? defaultDataDir({ platform, env, homeDir }));
   const root = resolve(packageRoot);
+  const nativeRuntimeDir = join(resolvedDataDir, 'native-runtime');
+  const runtimeConfigDir = join(resolvedDataDir, 'runtime-configs');
   return {
     dataDir: resolvedDataDir,
     graphEnvPath: join(resolvedDataDir, 'graph-provider.env'),
     graphRuntimeConfigPath: join(resolvedDataDir, 'graph-runtime.json'),
     graphRuntimeStatePath: join(resolvedDataDir, 'graph-runtime-state.json'),
+    adaptiveRuntimeSettingsPath: join(resolvedDataDir, 'adaptive-runtime-settings.json'),
+    adaptiveRuntimeStatePath: join(resolvedDataDir, 'adaptive-runtime-state.json'),
     runtimeSettingsPath: join(resolvedDataDir, 'runtime-settings.json'),
+    nativeRuntimeDir,
+    nativeRuntimeManifestPath: join(nativeRuntimeDir, 'manifest.json'),
+    nativeProcessStatePath: join(nativeRuntimeDir, 'processes.json'),
+    nativeNeo4jHome: join(nativeRuntimeDir, 'neo4j-community-5.26.28'),
+    nativeProviderVenvPath: join(nativeRuntimeDir, 'provider-venv'),
+    nativePersonalDir: join(nativeRuntimeDir, 'personal'),
+    nativeWorkspaceDir: join(nativeRuntimeDir, 'workspace'),
+    containerGraphConfigProfilePath: join(runtimeConfigDir, 'container.json'),
+    nativeGraphConfigProfilePath: join(runtimeConfigDir, 'native.json'),
     externalKnowledgeRegistryPath: join(
       resolvedDataDir,
       'external-knowledge',
@@ -36,6 +49,7 @@ export function resolveSetupPaths({
       'connectors'
     ),
     backupDir: join(resolvedDataDir, 'backups', 'agents'),
+    graphBackupDir: join(resolvedDataDir, 'backups', 'graph'),
     logPath: join(resolvedDataDir, 'logs', 'runtime.log'),
     serverPath: join(root, 'src', 'server.js'),
     mcpServerPath: join(root, 'src', 'mcp-server.js'),

package/src/setup/setup.js

@@ -1,4 +1,5 @@
 import { backupAgentConfig } from './config-backup.js';
+import { totalmem } from 'node:os';
 import { inspectAgentInstallations } from './agent-installation-status.js';
 import { connectAgent, discoverAgents } from './agents.js';
 import { resolveSetupPaths } from './paths.js';
@@ -9,6 +10,11 @@ import {
   readRuntimeSettings,
   runtimeSettingsWithOverrides
 } from '../system/runtime-settings.js';
+import {
+  DEFAULT_ADAPTIVE_RUNTIME_SETTINGS,
+  adaptiveRuntimeSettingsWithOverrides,
+  readAdaptiveRuntimeSettings
+} from '../adaptive-runtime/settings.js';
 
 export function planLocalSetup(options, {
   env = process.env,
@@ -16,6 +22,9 @@ export function planLocalSetup(options, {
   discover = discoverAgents,
   inspectInstallations = inspectAgentInstallations,
   readSettings = readRuntimeSettings,
+  readAdaptiveSettings = readAdaptiveRuntimeSettings,
+  platform = process.platform,
+  hostTotalMemory = totalmem,
   nodePath = process.execPath
 } = {}) {
   const paths = resolvePaths({ dataDir: options.dataDir, env });
@@ -23,8 +32,16 @@ export function planLocalSetup(options, {
     ? readSettings(paths.runtimeSettingsPath)
     : DEFAULT_RUNTIME_SETTINGS;
   const runtimeSettings = runtimeSettingsWithOverrides(savedRuntimeSettings, {
-    consolePort: options.port
+    consolePort: options.port,
+    graphRuntimeMode: options.runtimeMode
   });
+  const savedAdaptiveRuntimeSettings = paths.adaptiveRuntimeSettingsPath
+    ? readAdaptiveSettings(paths.adaptiveRuntimeSettingsPath)
+    : DEFAULT_ADAPTIVE_RUNTIME_SETTINGS;
+  const adaptiveRuntimeSettings = adaptiveRuntimeSettingsWithOverrides(
+    savedAdaptiveRuntimeSettings,
+    { enabled: options.adaptiveMemory ?? null }
+  );
   const discovered = options.skipAgents ? [] : discover({ env });
   const agents = options.codexOnly
     ? discovered.filter(({ id }) => id === 'codex')
@@ -32,6 +49,11 @@ export function planLocalSetup(options, {
   return {
     paths,
     runtimeSettings,
+    runtimeModeRecommendation: graphRuntimeModeRecommendation({
+      platform,
+      hostTotalBytes: hostTotalMemory()
+    }),
+    adaptiveRuntimeSettings,
     agents: inspectInstallations(agents, {
       nodePath,
       mcpServerPath: paths.mcpServerPath,
@@ -43,6 +65,17 @@ export function planLocalSetup(options, {
   };
 }
 
+function graphRuntimeModeRecommendation({ platform, hostTotalBytes }) {
+  const lowMemoryMac = platform === 'darwin' &&
+    Number.isFinite(hostTotalBytes) &&
+    hostTotalBytes <= 16 * 1024 ** 3;
+  return {
+    recommendedMode: lowMemoryMac ? 'native' : 'container',
+    reason: lowMemoryMac ? 'low-memory-mac' : 'default',
+    hostTotalBytes
+  };
+}
+
 export async function applyLocalSetup(plan, options, dependencies = {}) {
   const ensureRuntime = dependencies.ensureRuntime ?? ensureGraphRuntime;
   const backupConfig = dependencies.backupConfig ?? backupAgentConfig;
@@ -58,7 +91,10 @@ export async function applyLocalSetup(plan, options, dependencies = {}) {
     port: runtimeSettings.ports.console,
     lan: runtimeSettings.lanAccess,
     runtimeSettings,
+    runtimeMode: runtimeSettings.graphRuntimeMode,
     personalOnly: options.personalOnly,
+    memoryProfile: options.memoryProfile,
+    adaptiveRuntimeSettings: plan.adaptiveRuntimeSettings,
     noStart: options.noStart,
     env: dependencies.env ?? process.env,
     onProgress: dependencies.onProgress