enigma-memory 0.1.18 → 0.1.22

package/apps/ios/EnigmaIOS/EnigmaIOS.xcodeproj/project.pbxproj

@@ -0,0 +1,211 @@
+// !$*UTF8*$!
+{
+	archiveVersion = 1;
+	classes = {};
+	objectVersion = 60;
+	objects = {
+
+/* Begin PBXBuildFile section */
+		A10000000000000000000001 /* EnigmaApp.swift in Sources */ = {isa = PBXBuildFile; fileRef = A20000000000000000000001 /* EnigmaApp.swift */; };
+		A10000000000000000000002 /* AppModel.swift in Sources */ = {isa = PBXBuildFile; fileRef = A20000000000000000000002 /* AppModel.swift */; };
+		A10000000000000000000003 /* Theme.swift in Sources */ = {isa = PBXBuildFile; fileRef = A20000000000000000000003 /* Theme.swift */; };
+		A10000000000000000000004 /* SecureStore.swift in Sources */ = {isa = PBXBuildFile; fileRef = A20000000000000000000004 /* SecureStore.swift */; };
+		A10000000000000000000005 /* OAuthClient.swift in Sources */ = {isa = PBXBuildFile; fileRef = A20000000000000000000005 /* OAuthClient.swift */; };
+		A10000000000000000000006 /* OnboardingView.swift in Sources */ = {isa = PBXBuildFile; fileRef = A20000000000000000000006 /* OnboardingView.swift */; };
+		A10000000000000000000007 /* ChatView.swift in Sources */ = {isa = PBXBuildFile; fileRef = A20000000000000000000007 /* ChatView.swift */; };
+		A10000000000000000000008 /* CouncilView.swift in Sources */ = {isa = PBXBuildFile; fileRef = A20000000000000000000008 /* CouncilView.swift */; };
+		A10000000000000000000009 /* CreateView.swift in Sources */ = {isa = PBXBuildFile; fileRef = A20000000000000000000009 /* CreateView.swift */; };
+		A1000000000000000000000A /* PrivateVaultView.swift in Sources */ = {isa = PBXBuildFile; fileRef = A2000000000000000000000A /* PrivateVaultView.swift */; };
+		A1000000000000000000000B /* SettingsView.swift in Sources */ = {isa = PBXBuildFile; fileRef = A2000000000000000000000B /* SettingsView.swift */; };
+		A1000000000000000000000E /* NaturalLanguagePrivacyTagger.swift in Sources */ = {isa = PBXBuildFile; fileRef = A2000000000000000000000F /* NaturalLanguagePrivacyTagger.swift */; };
+		A1000000000000000000000C /* Assets.xcassets in Resources */ = {isa = PBXBuildFile; fileRef = A2000000000000000000000C /* Assets.xcassets */; };
+		A1000000000000000000000D /* EnigmaCore in Frameworks */ = {isa = PBXBuildFile; productRef = A90000000000000000000001 /* EnigmaCore */; };
+/* End PBXBuildFile section */
+
+/* Begin PBXFileReference section */
+		A20000000000000000000001 /* EnigmaApp.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = EnigmaApp.swift; sourceTree = "<group>"; };
+		A20000000000000000000002 /* AppModel.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = AppModel.swift; sourceTree = "<group>"; };
+		A20000000000000000000003 /* Theme.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = Theme.swift; sourceTree = "<group>"; };
+		A20000000000000000000004 /* SecureStore.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = SecureStore.swift; sourceTree = "<group>"; };
+		A20000000000000000000005 /* OAuthClient.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = OAuthClient.swift; sourceTree = "<group>"; };
+		A20000000000000000000006 /* OnboardingView.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = OnboardingView.swift; sourceTree = "<group>"; };
+		A20000000000000000000007 /* ChatView.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = ChatView.swift; sourceTree = "<group>"; };
+		A20000000000000000000008 /* CouncilView.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = CouncilView.swift; sourceTree = "<group>"; };
+		A20000000000000000000009 /* CreateView.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = CreateView.swift; sourceTree = "<group>"; };
+		A2000000000000000000000A /* PrivateVaultView.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = PrivateVaultView.swift; sourceTree = "<group>"; };
+		A2000000000000000000000B /* SettingsView.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = SettingsView.swift; sourceTree = "<group>"; };
+		A2000000000000000000000F /* NaturalLanguagePrivacyTagger.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = NaturalLanguagePrivacyTagger.swift; sourceTree = "<group>"; };
+		A2000000000000000000000C /* Assets.xcassets */ = {isa = PBXFileReference; lastKnownFileType = folder.assetcatalog; path = Assets.xcassets; sourceTree = "<group>"; };
+		A2000000000000000000000D /* Info.plist */ = {isa = PBXFileReference; lastKnownFileType = text.plist.xml; path = Info.plist; sourceTree = "<group>"; };
+		A2000000000000000000000E /* Enigma.app */ = {isa = PBXFileReference; explicitFileType = wrapper.application; includeInIndex = 0; path = Enigma.app; sourceTree = BUILT_PRODUCTS_DIR; };
+/* End PBXFileReference section */
+
+/* Begin PBXFrameworksBuildPhase section */
+		A30000000000000000000001 /* Frameworks */ = {
+			isa = PBXFrameworksBuildPhase;
+			buildActionMask = 2147483647;
+			files = (A1000000000000000000000D /* EnigmaCore in Frameworks */,);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+/* End PBXFrameworksBuildPhase section */
+
+/* Begin PBXGroup section */
+		A40000000000000000000001 = {
+			isa = PBXGroup;
+			children = (A40000000000000000000002 /* Enigma */, A40000000000000000000003 /* Products */);
+			sourceTree = "<group>";
+		};
+		A40000000000000000000002 /* Enigma */ = {
+			isa = PBXGroup;
+			path = Enigma;
+			sourceTree = "<group>";
+			children = (
+				A20000000000000000000001 /* EnigmaApp.swift */,
+				A20000000000000000000002 /* AppModel.swift */,
+				A20000000000000000000003 /* Theme.swift */,
+				A20000000000000000000004 /* SecureStore.swift */,
+				A20000000000000000000005 /* OAuthClient.swift */,
+				A20000000000000000000006 /* OnboardingView.swift */,
+				A20000000000000000000007 /* ChatView.swift */,
+				A20000000000000000000008 /* CouncilView.swift */,
+				A20000000000000000000009 /* CreateView.swift */,
+				A2000000000000000000000A /* PrivateVaultView.swift */,
+				A2000000000000000000000B /* SettingsView.swift */,
+				A2000000000000000000000F /* NaturalLanguagePrivacyTagger.swift */,
+				A2000000000000000000000C /* Assets.xcassets */,
+				A2000000000000000000000D /* Info.plist */,
+			);
+		};
+		A40000000000000000000003 /* Products */ = {
+			isa = PBXGroup;
+			children = (A2000000000000000000000E /* Enigma.app */,);
+			name = Products;
+			sourceTree = "<group>";
+		};
+/* End PBXGroup section */
+
+/* Begin PBXNativeTarget section */
+		A50000000000000000000001 /* Enigma */ = {
+			isa = PBXNativeTarget;
+			buildConfigurationList = A80000000000000000000002 /* Build configuration list for PBXNativeTarget Enigma */;
+			buildPhases = (A30000000000000000000003 /* Sources */, A30000000000000000000001 /* Frameworks */, A30000000000000000000002 /* Resources */);
+			buildRules = ();
+			dependencies = ();
+			name = Enigma;
+			packageProductDependencies = (A90000000000000000000001 /* EnigmaCore */,);
+			productName = Enigma;
+			productReference = A2000000000000000000000E /* Enigma.app */;
+			productType = "com.apple.product-type.application";
+		};
+/* End PBXNativeTarget section */
+
+/* Begin PBXProject section */
+		A60000000000000000000001 /* Project object */ = {
+			isa = PBXProject;
+			attributes = { BuildIndependentTargetsInParallel = 1; LastSwiftUpdateCheck = 1600; LastUpgradeCheck = 1600; TargetAttributes = { A50000000000000000000001 = { CreatedOnToolsVersion = 16.0; }; }; };
+			buildConfigurationList = A80000000000000000000001 /* Build configuration list for PBXProject EnigmaIOS */;
+			compatibilityVersion = "Xcode 15.0";
+			developmentRegion = en;
+			hasScannedForEncodings = 0;
+			knownRegions = (en, Base);
+			mainGroup = A40000000000000000000001;
+			packageReferences = (A90000000000000000000002 /* XCLocalSwiftPackageReference ../EnigmaCore */,);
+			productRefGroup = A40000000000000000000003 /* Products */;
+			projectDirPath = "";
+			projectRoot = "";
+			targets = (A50000000000000000000001 /* Enigma */,);
+		};
+/* End PBXProject section */
+
+/* Begin PBXResourcesBuildPhase section */
+		A30000000000000000000002 /* Resources */ = {
+			isa = PBXResourcesBuildPhase;
+			buildActionMask = 2147483647;
+			files = (A1000000000000000000000C /* Assets.xcassets in Resources */,);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+/* End PBXResourcesBuildPhase section */
+
+/* Begin PBXSourcesBuildPhase section */
+		A30000000000000000000003 /* Sources */ = {
+			isa = PBXSourcesBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				A10000000000000000000001 /* EnigmaApp.swift in Sources */,
+				A10000000000000000000002 /* AppModel.swift in Sources */,
+				A10000000000000000000003 /* Theme.swift in Sources */,
+				A10000000000000000000004 /* SecureStore.swift in Sources */,
+				A10000000000000000000005 /* OAuthClient.swift in Sources */,
+				A10000000000000000000006 /* OnboardingView.swift in Sources */,
+				A10000000000000000000007 /* ChatView.swift in Sources */,
+				A10000000000000000000008 /* CouncilView.swift in Sources */,
+				A10000000000000000000009 /* CreateView.swift in Sources */,
+				A1000000000000000000000A /* PrivateVaultView.swift in Sources */,
+				A1000000000000000000000B /* SettingsView.swift in Sources */,
+				A1000000000000000000000E /* NaturalLanguagePrivacyTagger.swift in Sources */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+/* End PBXSourcesBuildPhase section */
+
+/* Begin XCBuildConfiguration section */
+		A70000000000000000000001 /* Debug */ = {isa = XCBuildConfiguration; buildSettings = {CLANG_ENABLE_MODULES = YES; ENABLE_STRICT_OBJC_MSGSEND = YES; GCC_C_LANGUAGE_STANDARD = gnu17; IPHONEOS_DEPLOYMENT_TARGET = 17.0; SDKROOT = iphoneos; SWIFT_VERSION = 5.0; }; name = Debug; };
+		A70000000000000000000002 /* Release */ = {isa = XCBuildConfiguration; buildSettings = {CLANG_ENABLE_MODULES = YES; ENABLE_STRICT_OBJC_MSGSEND = YES; GCC_C_LANGUAGE_STANDARD = gnu17; IPHONEOS_DEPLOYMENT_TARGET = 17.0; SDKROOT = iphoneos; SWIFT_COMPILATION_MODE = wholemodule; SWIFT_VERSION = 5.0; VALIDATE_PRODUCT = YES; }; name = Release; };
+		A70000000000000000000003 /* Debug */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				ASSETCATALOG_COMPILER_GLOBAL_ACCENT_COLOR_NAME = AccentColor;
+				ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon;
+				CODE_SIGN_STYLE = Automatic;
+				CURRENT_PROJECT_VERSION = 1;
+				ENABLE_PREVIEWS = YES;
+				ENABLE_USER_SCRIPT_SANDBOXING = YES;
+				INFOPLIST_FILE = Enigma/Info.plist;
+				IPHONEOS_DEPLOYMENT_TARGET = 17.0;
+				MARKETING_VERSION = 1.0;
+				PRODUCT_BUNDLE_IDENTIFIER = com.enigmamemory.ios;
+				PRODUCT_NAME = "$(TARGET_NAME)";
+				SUPPORTED_PLATFORMS = "iphoneos iphonesimulator";
+				SWIFT_EMIT_LOC_STRINGS = YES;
+				SWIFT_VERSION = 5.0;
+				TARGETED_DEVICE_FAMILY = "1,2";
+			};
+			name = Debug;
+		};
+		A70000000000000000000004 /* Release */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				ASSETCATALOG_COMPILER_GLOBAL_ACCENT_COLOR_NAME = AccentColor;
+				ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon;
+				CODE_SIGN_STYLE = Automatic;
+				CURRENT_PROJECT_VERSION = 1;
+				ENABLE_USER_SCRIPT_SANDBOXING = YES;
+				INFOPLIST_FILE = Enigma/Info.plist;
+				IPHONEOS_DEPLOYMENT_TARGET = 17.0;
+				MARKETING_VERSION = 1.0;
+				PRODUCT_BUNDLE_IDENTIFIER = com.enigmamemory.ios;
+				PRODUCT_NAME = "$(TARGET_NAME)";
+				SUPPORTED_PLATFORMS = "iphoneos iphonesimulator";
+				SWIFT_EMIT_LOC_STRINGS = YES;
+				SWIFT_VERSION = 5.0;
+				TARGETED_DEVICE_FAMILY = "1,2";
+			};
+			name = Release;
+		};
+/* End XCBuildConfiguration section */
+
+/* Begin XCConfigurationList section */
+		A80000000000000000000001 /* Build configuration list for PBXProject EnigmaIOS */ = {isa = XCConfigurationList; buildConfigurations = (A70000000000000000000001 /* Debug */, A70000000000000000000002 /* Release */); defaultConfigurationIsVisible = 0; defaultConfigurationName = Release; };
+		A80000000000000000000002 /* Build configuration list for PBXNativeTarget Enigma */ = {isa = XCConfigurationList; buildConfigurations = (A70000000000000000000003 /* Debug */, A70000000000000000000004 /* Release */); defaultConfigurationIsVisible = 0; defaultConfigurationName = Release; };
+/* End XCConfigurationList section */
+
+/* Begin XCLocalSwiftPackageReference section */
+		A90000000000000000000002 /* XCLocalSwiftPackageReference ../EnigmaCore */ = {isa = XCLocalSwiftPackageReference; relativePath = ../EnigmaCore; };
+/* End XCLocalSwiftPackageReference section */
+
+/* Begin XCSwiftPackageProductDependency section */
+		A90000000000000000000001 /* EnigmaCore */ = {isa = XCSwiftPackageProductDependency; package = A90000000000000000000002 /* XCLocalSwiftPackageReference ../EnigmaCore */; productName = EnigmaCore; };
+/* End XCSwiftPackageProductDependency section */
+	};
+	rootObject = A60000000000000000000001 /* Project object */;
+}

package/apps/ios/EnigmaIOS/EnigmaIOS.xcodeproj/xcshareddata/xcschemes/Enigma.xcscheme

@@ -0,0 +1,23 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<Scheme LastUpgradeVersion="1600" version="1.7">
+  <BuildAction parallelizeBuildables="YES" buildImplicitDependencies="YES">
+    <BuildActionEntries>
+      <BuildActionEntry buildForTesting="YES" buildForRunning="YES" buildForProfiling="YES" buildForArchiving="YES" buildForAnalyzing="YES">
+        <BuildableReference BuildableIdentifier="primary" BlueprintIdentifier="A50000000000000000000001" BuildableName="Enigma.app" BlueprintName="Enigma" ReferencedContainer="container:EnigmaIOS.xcodeproj"/>
+      </BuildActionEntry>
+    </BuildActionEntries>
+  </BuildAction>
+  <TestAction buildConfiguration="Debug" selectedDebuggerIdentifier="Xcode.DebuggerFoundation.Debugger.LLDB" selectedLauncherIdentifier="Xcode.DebuggerFoundation.Launcher.LLDB" shouldUseLaunchSchemeArgsEnv="YES"/>
+  <LaunchAction buildConfiguration="Debug" selectedDebuggerIdentifier="Xcode.DebuggerFoundation.Debugger.LLDB" selectedLauncherIdentifier="Xcode.DebuggerFoundation.Launcher.LLDB" launchStyle="0" useCustomWorkingDirectory="NO" ignoresPersistentStateOnLaunch="NO" debugDocumentVersioning="YES" debugServiceExtension="internal" allowLocationSimulation="YES">
+    <BuildableProductRunnable runnableDebuggingMode="0">
+      <BuildableReference BuildableIdentifier="primary" BlueprintIdentifier="A50000000000000000000001" BuildableName="Enigma.app" BlueprintName="Enigma" ReferencedContainer="container:EnigmaIOS.xcodeproj"/>
+    </BuildableProductRunnable>
+  </LaunchAction>
+  <ProfileAction buildConfiguration="Release" shouldUseLaunchSchemeArgsEnv="YES" savedToolIdentifier="" useCustomWorkingDirectory="NO" debugDocumentVersioning="YES">
+    <BuildableProductRunnable runnableDebuggingMode="0">
+      <BuildableReference BuildableIdentifier="primary" BlueprintIdentifier="A50000000000000000000001" BuildableName="Enigma.app" BlueprintName="Enigma" ReferencedContainer="container:EnigmaIOS.xcodeproj"/>
+    </BuildableProductRunnable>
+  </ProfileAction>
+  <AnalyzeAction buildConfiguration="Debug"/>
+  <ArchiveAction buildConfiguration="Release" revealArchiveInOrganizer="YES"/>
+</Scheme>

package/apps/native-host/README.md

@@ -33,19 +33,28 @@ The CLI manifest generator and install-plan preview are the recommended path bec
 
    ```sh
    mkdir -p "$HOME/.enigma"
-   enigma init --bundle "$HOME/.enigma/bundle.json" --subject local-user --display-name "Local user"
+   ENIGMA_PASSPHRASE_FILE="$HOME/.enigma/passphrase"
+   test -s "$ENIGMA_PASSPHRASE_FILE" || { printf '%s\n' 'Create the passphrase file with an approved secret manager or secure editor and restrict it to your user.' >&2; exit 1; }
+   enigma init --bundle "$HOME/.enigma/bundle.json" --passphrase-file "$ENIGMA_PASSPHRASE_FILE" --subject local-user --display-name "Local user"
    export ENIGMA_BUNDLE="$HOME/.enigma/bundle.json"
+   export ENIGMA_PASSPHRASE_FILE
    ```
 
    Windows PowerShell:
 
    ```powershell
    New-Item -ItemType Directory -Force "$HOME\.enigma"
-   enigma init --bundle "$HOME\.enigma\bundle.json" --subject local-user --display-name "Local user"
+   $PassphraseFile = "$HOME\.enigma\passphrase"
+   if (-not (Test-Path -LiteralPath $PassphraseFile -PathType Leaf)) { throw 'Create the passphrase file with an approved secret manager or secure editor and restrict it to your user.' }
+   enigma init --bundle "$HOME\.enigma\bundle.json" --passphrase-file $PassphraseFile --subject local-user --display-name "Local user"
    [Environment]::SetEnvironmentVariable('ENIGMA_BUNDLE', "$HOME\.enigma\bundle.json", 'User')
+   [Environment]::SetEnvironmentVariable('ENIGMA_PASSPHRASE_FILE', $PassphraseFile, 'User')
    $env:ENIGMA_BUNDLE="$HOME\.enigma\bundle.json"
+   $env:ENIGMA_PASSPHRASE_FILE=$PassphraseFile
    ```
 
+   The native host fails closed for persistent access unless the bundle keyring is protected and the passphrase is supplied out of band. Set `ENIGMA_PASSPHRASE`, set `ENIGMA_PASSPHRASE_FILE`, or start the host with `--passphrase-file <owner-readable-path>`. Passphrases are never accepted as command-line values, and every host write re-exports an encrypted keyring atomically.
+
 3. Resolve the absolute path to the host executable. Native messaging manifests do not expand `~`, `$HOME`, `%USERPROFILE%`, shell aliases, or `PATH` lookups. Use the full executable path, for example:
 
    - macOS/Linux: `/Users/REPLACE_WITH_USER/.npm-global/bin/enigma-native-host` or `/usr/local/bin/enigma-native-host`
@@ -53,7 +62,7 @@ The CLI manifest generator and install-plan preview are the recommended path bec
 
    Useful checks: `command -v enigma-native-host` on macOS/Linux, or `(Get-Command enigma-native-host.cmd).Source` in Windows PowerShell. If you use a wrapper to set `ENIGMA_BUNDLE`, resolve the wrapper's absolute path instead.
 
-4. If your browser does not inherit the `ENIGMA_BUNDLE` user environment, create a small local wrapper that sets `ENIGMA_BUNDLE` and then execs the absolute `enigma-native-host` path. Point the manifest `path` to that wrapper. Keep the wrapper owner-writable only.
+4. If your browser does not inherit `ENIGMA_BUNDLE` and one passphrase source, create a small local wrapper that sets `ENIGMA_BUNDLE` plus `ENIGMA_PASSPHRASE_FILE` and then execs the absolute `enigma-native-host` path. Point the manifest `path` to that wrapper. Keep both the wrapper and passphrase file owner-readable only.
 
 
 ## Fast MCP client setup
@@ -61,16 +70,18 @@ The CLI manifest generator and install-plan preview are the recommended path bec
 For Claude Desktop, Cursor, Kimi Code, and VS Code Cline, avoid hand-editing MCP JSON. After installing the package, use the CLI to create the local bundle and merge only the Enigma MCP server entry into the selected client config:
 
 ```sh
-npm install -g enigma-memory && enigma setup --client claude-desktop --write-connectors --overwrite
-npm install -g enigma-memory && enigma setup --client cursor --write-connectors --overwrite
-npm install -g enigma-memory && enigma setup --client kimi-code --write-connectors --overwrite
-npm install -g enigma-memory && enigma setup --client vscode-cline --write-connectors --overwrite
+PASSPHRASE_FILE="$HOME/.enigma/passphrase"
+test -s "$PASSPHRASE_FILE" || { printf '%s\n' 'Create the protected passphrase file before setup.' >&2; exit 1; }
+npm install -g enigma-memory && enigma setup --passphrase-file "$PASSPHRASE_FILE" --client claude-desktop --write-connectors --overwrite
+npm install -g enigma-memory && enigma setup --passphrase-file "$PASSPHRASE_FILE" --client cursor --write-connectors --overwrite
+npm install -g enigma-memory && enigma setup --passphrase-file "$PASSPHRASE_FILE" --client kimi-code --write-connectors --overwrite
+npm install -g enigma-memory && enigma setup --passphrase-file "$PASSPHRASE_FILE" --client vscode-cline --write-connectors --overwrite
 ```
 
 To connect only clients whose config files already exist, use:
 
 ```sh
-npm install -g enigma-memory && enigma setup --client auto --connect-installed --overwrite
+npm install -g enigma-memory && enigma setup --passphrase-file "$HOME/.enigma/passphrase" --client auto --connect-installed --overwrite
 ```
 
 The generated MCP entry uses `enigma-mcp` with `ENIGMA_BUNDLE` pointing at the local bundle. Existing sibling MCP servers are preserved; changed configs are backed up by `enigma connect`.

package/apps/native-host/bin/enigma-native-host.mjs

@@ -1,11 +1,12 @@
 #!/usr/bin/env node
 import { realpathSync } from 'node:fs';
-import { readFile, writeFile } from 'node:fs/promises';
+import { readFile } from 'node:fs/promises';
 import { isAbsolute, posix, win32 } from 'node:path';
 import { pathToFileURL } from 'node:url';
 import { canonicalize, receiptHash, sha256Hex } from '../../../packages/core/src/index.js';
 import { compileContextPack } from '../../../packages/passport/src/index.js';
-import { exportBundle, importBundle } from '../../../packages/vault/src/index.js';
+import { exportBundle, importBundle, remember } from '../../../packages/vault/src/index.js';
+import { readFileRevision, writeJsonFileAtomic } from '../../../packages/vault/src/persistence.js';
 
 export const NATIVE_HOST_NAME = 'com.enigma.native_host';
 export const NATIVE_BROWSER_PROTOCOL = 'enigma.native.browser.v1';
@@ -16,6 +17,7 @@ const CONTEXT_RESPONSE = 'enigma.browser.context.response';
 const INSERTION_RECORD = 'enigma.browser.insertion.record';
 const INSERTION_RECORDED = 'enigma.browser.insertion.recorded';
 const GENERIC_ERROR = 'enigma.native.error';
+const NATIVE_VAULT_CACHE = Symbol('enigma.native.vaultCache');
 const SHA256_ROOT_RE = /^sha256:[a-f0-9]{64}$/;
 const SUPPORTED_PROVIDER_IDS = new Set(['chatgpt', 'claude', 'kimi', 'perplexity']);
 const SAFE_MESSAGE_ID_RE = /^[A-Za-z0-9._:-]{1,80}$/;
@@ -188,6 +190,8 @@ export async function handleNativeBrowserMessage(message, options = {}) {
     if (message.type === INSERTION_RECORD) return await handleInsertionRecord(message, options);
     return safeError({ id, type: responseType, code: 'ENIGMA_UNSUPPORTED_REQUEST', message: 'Native host received an unsupported request type.' });
   } catch {
+    const cache = options[NATIVE_VAULT_CACHE];
+    if (cache) cache.loaded = undefined;
     return safeError({ id, type: responseType, code: 'ENIGMA_NATIVE_HOST_ERROR', message: 'Enigma native host failed without exposing local memory.' });
   }
 }
@@ -204,9 +208,10 @@ export function createNativeHostRuntime(options = {}) {
     ...options,
     argv: options.argv ?? process.argv.slice(2),
     env: options.env ?? process.env,
+    [NATIVE_VAULT_CACHE]: { loaded: undefined, source: undefined },
   };
 
-  async function handleChunk(chunk) {
+  async function processChunk(chunk) {
     pending = pending.length === 0 ? Buffer.from(chunk) : Buffer.concat([pending, Buffer.from(chunk)]);
     let decoded;
     try {
@@ -223,10 +228,15 @@ export function createNativeHostRuntime(options = {}) {
     }
   }
 
-  function onData(chunk) {
-    queue = queue.then(() => handleChunk(chunk)).catch(() => {
+  function handleChunk(chunk) {
+    queue = queue.then(() => processChunk(chunk)).catch(() => {
       stdout.write(encodeNativeMessage(safeError({ type: GENERIC_ERROR, code: 'ENIGMA_NATIVE_HOST_ERROR', message: 'Enigma native host failed without exposing local memory.' })));
     });
+    return queue;
+  }
+
+  function onData(chunk) {
+    void handleChunk(chunk);
   }
 
   function onError() {
@@ -256,12 +266,13 @@ function nativeHostUsage() {
   return {
     manifest_generator: 'enigma native-host manifest --browser <chrome|edge|firefox> --host-path <absolute path> --extension-id <id> [--out <file>]',
     install_planner: 'enigma native-host install-plan --browser <chrome|edge|firefox> --manifest <absolute path> [--os <windows|macos|linux>] [--home <absolute path>]',
-    usage: 'enigma-native-host [--bundle <path>]',
+    usage: 'enigma-native-host [--bundle <path>] [--passphrase-file <path>]',
     native_host: NATIVE_HOST_NAME,
     protocol: NATIVE_BROWSER_PROTOCOL,
     transport: 'Chrome/Edge/Firefox native messaging: 4-byte little-endian length-prefixed JSON over stdio.',
     options: {
       '--bundle <path>': 'Local Enigma bundle path. Defaults to ENIGMA_BUNDLE.',
+      '--passphrase-file <path>': 'Owner-readable passphrase file. Defaults to ENIGMA_PASSPHRASE_FILE; ENIGMA_PASSPHRASE is also accepted.',
       '--help': 'Print this JSON help and exit without starting the native messaging loop.',
     },
     claim_boundaries: 'The native host reads local Enigma bundles and returns user-approved context plus receipt summaries. It does not prove provider deletion, model forgetting, or provider-side memory behavior.',
@@ -290,6 +301,42 @@ async function handleContextRequest(message, options) {
   const loaded = await loadVault(options);
   if (!loaded.ok) return safeError({ id, type: CONTEXT_RESPONSE, ...loaded.error });
 
+  const selection = selectedBrowserContext(message);
+  let selectionMemoryAddr;
+  if (selection) {
+    const memoryOperation = typeof options.memoryOperation === 'function' ? options.memoryOperation : remember;
+    const memoryResult = await memoryOperation({
+      vault: loaded.vault,
+      content: selection.text,
+      kind: 'browser_selection',
+      confidence: 'user_confirmed',
+      sensitivity: 'sensitive',
+      purpose_tags: ['browser_context'],
+      source_refs: [{
+        type: 'browser_selection',
+        provider: selection.provider,
+        origin_commitment: selection.page.origin_commitment,
+        metadata_commitment: selection.page.metadata_commitment,
+      }],
+      metadata: {
+        browser_provider: selection.provider,
+        browser_selection_source: selection.source,
+        page_origin_commitment: selection.page.origin_commitment,
+        page_hostname_commitment: selection.page.hostname_commitment,
+        page_metadata_commitment: selection.page.metadata_commitment,
+        page_title_present: selection.page.raw.display.titlePresent,
+        page_title_char_count: selection.page.raw.display.titleCharCount,
+        page_top_level: selection.page.topLevel,
+      },
+      browser_context: {
+        page: selection.page.raw,
+        selection: { source: selection.source },
+      },
+      now: options.now,
+    });
+    selectionMemoryAddr = typeof memoryResult?.memory_addr === 'string' ? memoryResult.memory_addr : undefined;
+  }
+
   const activeAddresses = [...(loaded.vault.activeAddresses ?? [])];
   if (activeAddresses.length === 0) {
     return safeError({
@@ -300,11 +347,16 @@ async function handleContextRequest(message, options) {
       action: 'Run enigma remember, then retry from the browser extension.',
     });
   }
+  const orderedAddresses = selectionMemoryAddr && activeAddresses.includes(selectionMemoryAddr)
+    ? [selectionMemoryAddr, ...activeAddresses.filter((address) => address !== selectionMemoryAddr)]
+    : undefined;
 
   const contextPack = compileContextPack({
     vault: loaded.vault,
+    memory_addresses: orderedAddresses,
     provider: safeProvider(message.provider),
     purpose: 'browser_context_injection',
+    query: selection?.text ?? '',
     limit: options.limit ?? options.maxMemories ?? 12,
     now: options.now,
   });
@@ -366,10 +418,46 @@ async function handleInsertionRecord(message, options) {
 }
 
 async function loadVault(options) {
-  if (options.vault) return { ok: true, vault: options.vault, bundlePath: options.bundlePath, source: 'options.vault' };
+  const cache = options[NATIVE_VAULT_CACHE];
+  const importOperation = typeof options.importOperation === 'function' ? options.importOperation : importBundle;
+
+  if (options.vault) {
+    if (cache?.source === options.vault && cache.loaded) return cache.loaded;
+    const passphraseResult = await resolveNativePassphrase(options);
+    if (!passphraseResult.ok) return passphraseResult;
+    if (options.persist !== false && options.bundlePath && !passphraseResult.passphrase) return missingPassphraseResult();
+    const loaded = {
+      ok: true,
+      vault: options.vault,
+      bundlePath: options.bundlePath,
+      passphrase: passphraseResult.passphrase,
+      source: 'options.vault',
+    };
+    if (cache) {
+      cache.source = options.vault;
+      cache.loaded = loaded;
+    }
+    return loaded;
+  }
+
   if (options.bundle) {
+    if (cache?.source === options.bundle && cache.loaded) return cache.loaded;
+    const passphraseResult = await resolveNativePassphrase(options);
+    if (!passphraseResult.ok) return passphraseResult;
+    if (bundleNeedsPassphrase(options.bundle, options) && !passphraseResult.passphrase) return missingPassphraseResult();
     try {
-      return { ok: true, ...importBundle({ bundle: options.bundle }), bundlePath: options.bundlePath, source: 'options.bundle' };
+      const loaded = {
+        ok: true,
+        ...importOperation({ bundle: options.bundle, passphrase: passphraseResult.passphrase, strict: bundleNeedsPassphrase(options.bundle, options) }),
+        bundlePath: options.bundlePath,
+        passphrase: passphraseResult.passphrase,
+        source: 'options.bundle',
+      };
+      if (cache) {
+        cache.source = options.bundle;
+        cache.loaded = loaded;
+      }
+      return loaded;
     } catch {
       return { ok: false, error: invalidBundleError() };
     }
@@ -388,8 +476,26 @@ async function loadVault(options) {
   }
 
   try {
-    const bundle = JSON.parse(await readFile(bundlePath, 'utf8'));
-    return { ok: true, ...importBundle({ bundle }), bundlePath, source: 'bundlePath' };
+    const snapshot = await readFileRevision(bundlePath);
+    if (cache?.source === bundlePath && cache.loaded?.revision === snapshot.revision) return cache.loaded;
+    if (cache?.source === bundlePath) cache.loaded = undefined;
+    const bundle = JSON.parse(snapshot.raw.toString('utf8'));
+    const passphraseResult = await resolveNativePassphrase(options);
+    if (!passphraseResult.ok) return passphraseResult;
+    if (bundleNeedsPassphrase(bundle, options) && !passphraseResult.passphrase) return missingPassphraseResult();
+    const loaded = {
+      ok: true,
+      ...importOperation({ bundle, passphrase: passphraseResult.passphrase, strict: bundleNeedsPassphrase(bundle, options) }),
+      bundlePath,
+      passphrase: passphraseResult.passphrase,
+      revision: snapshot.revision,
+      source: 'bundlePath',
+    };
+    if (cache) {
+      cache.source = bundlePath;
+      cache.loaded = loaded;
+    }
+    return loaded;
   } catch {
     return { ok: false, error: invalidBundleError() };
   }
@@ -397,15 +503,86 @@ async function loadVault(options) {
 
 async function persistVault(loaded, options) {
   if (options.persist === false || !loaded.bundlePath || !loaded.vault) return;
-  const bundle = exportBundle({ vault: loaded.vault, now: options.now });
-  await writeFile(loaded.bundlePath, `${JSON.stringify(bundle, null, 2)}\n`);
+  if (!loaded.passphrase) throw new Error('Native host persistence requires a passphrase.');
+  try {
+    const bundle = exportBundle({ vault: loaded.vault, passphrase: loaded.passphrase, now: options.now });
+    const persisted = await writeJsonFileAtomic(loaded.bundlePath, bundle, {
+      ...(loaded.revision ? { expectedRevision: loaded.revision } : {}),
+    });
+    loaded.revision = persisted.revision;
+  } catch (error) {
+    const cache = options[NATIVE_VAULT_CACHE];
+    if (cache?.loaded === loaded) cache.loaded = undefined;
+    throw error;
+  }
+}
+
+function missingPassphraseResult() {
+  return {
+    ok: false,
+    error: {
+      code: 'ENIGMA_PASSPHRASE_REQUIRED',
+      message: 'Enigma native host requires ENIGMA_PASSPHRASE or --passphrase-file for persistent bundle access.',
+      action: 'Set ENIGMA_PASSPHRASE in the native host environment or pass --passphrase-file with an owner-readable secret file.',
+    },
+  };
+}
+
+function bundleNeedsPassphrase(bundle, options) {
+  return options.persist !== false || bundle?.keyring?.type === 'local_secret_encrypted';
+}
+
+async function resolveNativePassphrase(options) {
+  const env = options.env && typeof options.env === 'object' ? options.env : {};
+  const envPassphrase = typeof env.ENIGMA_PASSPHRASE === 'string' && env.ENIGMA_PASSPHRASE.trim().length > 0
+    ? env.ENIGMA_PASSPHRASE
+    : undefined;
+  const passphraseFile = passphraseFileFromOptions(options);
+  if (!passphraseFile) return { ok: true, passphrase: envPassphrase };
+
+  let filePassphrase;
+  try {
+    filePassphrase = (await readFile(passphraseFile, 'utf8')).replace(/[\r\n]+$/u, '');
+  } catch {
+    return {
+      ok: false,
+      error: {
+        code: 'ENIGMA_PASSPHRASE_FILE_INVALID',
+        message: 'Enigma native host could not read the configured passphrase file.',
+        action: 'Check --passphrase-file permissions and provide a non-empty passphrase file.',
+      },
+    };
+  }
+  if (filePassphrase.trim().length === 0 || (envPassphrase !== undefined && envPassphrase !== filePassphrase)) {
+    return {
+      ok: false,
+      error: {
+        code: 'ENIGMA_PASSPHRASE_CONFLICT',
+        message: 'Enigma native host passphrase sources are empty or conflicting.',
+        action: 'Use one non-empty passphrase source, or make ENIGMA_PASSPHRASE match --passphrase-file.',
+      },
+    };
+  }
+  return { ok: true, passphrase: filePassphrase };
+}
+
+function passphraseFileFromOptions(options) {
+  const argv = Array.isArray(options.argv) ? options.argv : [];
+  for (let index = 0; index < argv.length; index += 1) {
+    if (argv[index] === '--passphrase-file' && typeof argv[index + 1] === 'string' && argv[index + 1].length > 0) return argv[index + 1];
+    if (argv[index]?.startsWith('--passphrase-file=')) return argv[index].slice('--passphrase-file='.length);
+  }
+  const env = options.env && typeof options.env === 'object' ? options.env : {};
+  return typeof env.ENIGMA_PASSPHRASE_FILE === 'string' && env.ENIGMA_PASSPHRASE_FILE.length > 0
+    ? env.ENIGMA_PASSPHRASE_FILE
+    : undefined;
 }
 
 function invalidBundleError() {
   return {
     code: 'ENIGMA_BUNDLE_INVALID',
     message: 'Enigma native host could not load the local bundle.',
-    action: 'Check that ENIGMA_BUNDLE points to an enigma.vault_bundle.v1 JSON file.',
+    action: 'Check that ENIGMA_BUNDLE points to an enigma.vault_bundle.v1 JSON file and that its passphrase is correct.',
   };
 }
 
@@ -420,6 +597,45 @@ function bundlePathFromOptions(options) {
   return typeof env.ENIGMA_BUNDLE === 'string' && env.ENIGMA_BUNDLE.length > 0 ? env.ENIGMA_BUNDLE : undefined;
 }
 
+function selectedBrowserContext(message) {
+  const text = typeof message.selection?.text === 'string' ? message.selection.text : '';
+  if (text.length === 0) return undefined;
+  if (text.length > 4000) throw new Error('Browser selection exceeds the native host limit.');
+  const source = typeof message.selection.source === 'string' && message.selection.source.length > 0
+    ? message.selection.source.slice(0, 80)
+    : 'user-selection';
+  const rawPage = message.page && typeof message.page === 'object' && !Array.isArray(message.page) ? message.page : {};
+  const rawDisplay = rawPage.display && typeof rawPage.display === 'object' && !Array.isArray(rawPage.display) ? rawPage.display : {};
+  const raw = {
+    providerId: safeProvider(rawPage.providerId ?? message.provider),
+    origin: boundedString(rawPage.origin, 512),
+    hostname: boundedString(rawPage.hostname, 255).toLowerCase(),
+    display: {
+      providerLabel: boundedString(rawDisplay.providerLabel, 80),
+      hostLabel: boundedString(rawDisplay.hostLabel, 255).toLowerCase(),
+      titlePresent: rawDisplay.titlePresent === true,
+      titleCharCount: safeCount(rawDisplay.titleCharCount),
+    },
+    topLevel: rawPage.topLevel === true,
+  };
+  return {
+    text,
+    source,
+    provider: safeProvider(message.provider),
+    page: {
+      raw,
+      topLevel: raw.topLevel,
+      origin_commitment: `sha256:${sha256Hex(raw.origin)}`,
+      hostname_commitment: `sha256:${sha256Hex(raw.hostname)}`,
+      metadata_commitment: `sha256:${sha256Hex(canonicalize(raw))}`,
+    },
+  };
+}
+
+function boundedString(value, maxLength) {
+  return typeof value === 'string' ? value.slice(0, maxLength) : '';
+}
+
 function renderContextText(contextPack) {
   return contextPack.memories
     .map((memory, index) => {