neoagent 2.4.4-beta.0 → 2.4.4-beta.11

package/flutter_app/lib/main_settings.dart

@@ -148,12 +148,24 @@ const _diagnosticsSettingsSection = _SettingsSection('diagnostics', <String>[
   'health',
 ]);
 
+const _securitySettingsSection = _SettingsSection('security', <String>[
+  'security',
+  'tool',
+  'permission',
+  'allowlist',
+  'shell',
+  'android',
+  'approval',
+  'policy',
+]);
+
 const List<_SettingsSection> _settingsSearchSections = <_SettingsSection>[
   _overviewSettingsSection,
   _workspaceSettingsSection,
   _modelsSettingsSection,
   _voiceRecordingSettingsSection,
   _desktopSettingsSection,
+  _securitySettingsSection,
   _diagnosticsSettingsSection,
 ];
 
@@ -399,6 +411,13 @@ class _SettingsPanelState extends State<SettingsPanel> {
           _buildDesktopSection(controller),
           const SizedBox(height: 16),
         ],
+        if (_matchesSettingsSection(
+          searchQuery,
+          _securitySettingsSection,
+        )) ...<Widget>[
+          _buildSecuritySection(context, controller),
+          const SizedBox(height: 16),
+        ],
         if (_matchesSettingsSection(
           searchQuery,
           _diagnosticsSettingsSection,
@@ -1492,6 +1511,43 @@ class _SettingsPanelState extends State<SettingsPanel> {
     );
   }
 
+  Widget _buildSecuritySection(BuildContext context, NeoAgentController controller) {
+    return Card(
+      child: Padding(
+        padding: const EdgeInsets.all(20),
+        child: Column(
+          crossAxisAlignment: CrossAxisAlignment.start,
+          children: <Widget>[
+            const _SectionTitle('Security'),
+            const SizedBox(height: 10),
+            Text(
+              'Per-tool permission policies, approval gates, and process isolation for shell execution.',
+              style: TextStyle(color: _textSecondary, height: 1.45),
+            ),
+            const SizedBox(height: 8),
+            ListTile(
+              contentPadding: EdgeInsets.zero,
+              leading: Icon(Icons.checklist_outlined, color: _accentAlt),
+              title: const Text('Tool Permissions'),
+              subtitle: Text(
+                'Set block / ask / allow per tool category, or pick a global mode.',
+                style: TextStyle(color: _textSecondary),
+              ),
+              trailing: const Icon(Icons.chevron_right),
+              onTap: () {
+                Navigator.of(context).push(
+                  MaterialPageRoute<void>(
+                    builder: (_) => MainSecurity(controller: controller),
+                  ),
+                );
+              },
+            ),
+          ],
+        ),
+      ),
+    );
+  }
+
   Widget _buildDiagnosticsSection(NeoAgentController controller) {
     return Card(
       child: Padding(

package/flutter_app/lib/src/backend_client.dart

@@ -1421,15 +1421,29 @@ class BackendClient {
     return getList(baseUrl, '/api/memory/memories$query');
   }
 
-  Future<List<Map<String, dynamic>>> recallMemories(
+  Future<List<Map<String, dynamic>>> recallMemory(
     String baseUrl,
     String query, {
+    int limit = 8,
     String? agentId,
   }) async {
     return postList(
       baseUrl,
-      '/api/memory/memories/recall',
-      _withAgentId(<String, dynamic>{'query': query, 'limit': 8}, agentId),
+      _withAgentQuery('/api/memory/memories/recall', agentId),
+      {'query': query, 'limit': limit},
+    );
+  }
+
+  Future<Map<String, dynamic>> inspectMemory(
+    String baseUrl,
+    String query, {
+    int limit = 20,
+    String? agentId,
+  }) async {
+    return postMap(
+      baseUrl,
+      _withAgentQuery('/api/memory/memories/inspect', agentId),
+      {'query': query, 'limit': limit},
     );
   }
 
@@ -2004,6 +2018,49 @@ class BackendClient {
 
     throw BackendException(message, statusCode: response.statusCode);
   }
+
+  // ── Tool security ──────────────────────────────────────────────────────────
+
+  Future<Map<String, dynamic>> fetchSecurityPolicies(String baseUrl) async {
+    return getMap(baseUrl, '/api/security/policies');
+  }
+
+  Future<Map<String, dynamic>> fetchSecurityMode(String baseUrl) async {
+    return getMap(baseUrl, '/api/security/mode');
+  }
+
+  Future<Map<String, dynamic>> saveSecurityMode(String baseUrl, String mode) async {
+    return putMap(baseUrl, '/api/security/mode', <String, dynamic>{'mode': mode});
+  }
+
+  Future<Map<String, dynamic>> saveSecurityPolicy(
+    String baseUrl, {
+    required String category,
+    required String policy,
+  }) async {
+    return putMap(baseUrl, '/api/security/policies', <String, dynamic>{
+      'category': category,
+      'policy': policy,
+    });
+  }
+
+  Future<Map<String, dynamic>> resolveToolApproval(
+    String baseUrl, {
+    required String approvalId,
+    required String decision,
+    required String scope,
+    String? runId,
+    String? toolName,
+    Map<String, dynamic>? toolArgs,
+  }) async {
+    return postMap(baseUrl, '/api/security/approvals/$approvalId', <String, dynamic>{
+      'decision': decision,
+      'scope': scope,
+      if (runId != null) 'runId': runId,
+      if (toolName != null) 'toolName': toolName,
+      if (toolArgs != null) 'toolArgs': toolArgs,
+    });
+  }
 }
 
 class BackendException implements Exception {

package/flutter_app/macos/Flutter/GeneratedPluginRegistrant.swift

@@ -9,6 +9,7 @@ import audioplayers_darwin
 import connectivity_plus
 import desktop_audio_capture
 import file_picker
+import flutter_local_notifications
 import flutter_secure_storage_macos
 import geolocator_apple
 import hotkey_manager_macos
@@ -29,6 +30,7 @@ func RegisterGeneratedPlugins(registry: FlutterPluginRegistry) {
   ConnectivityPlusPlugin.register(with: registry.registrar(forPlugin: "ConnectivityPlusPlugin"))
   AudioCapturePlugin.register(with: registry.registrar(forPlugin: "AudioCapturePlugin"))
   FilePickerPlugin.register(with: registry.registrar(forPlugin: "FilePickerPlugin"))
+  FlutterLocalNotificationsPlugin.register(with: registry.registrar(forPlugin: "FlutterLocalNotificationsPlugin"))
   FlutterSecureStoragePlugin.register(with: registry.registrar(forPlugin: "FlutterSecureStoragePlugin"))
   GeolocatorPlugin.register(with: registry.registrar(forPlugin: "GeolocatorPlugin"))
   HotkeyManagerMacosPlugin.register(with: registry.registrar(forPlugin: "HotkeyManagerMacosPlugin"))

package/flutter_app/pubspec.lock

@@ -277,6 +277,30 @@ packages:
       url: "https://pub.dev"
     source: hosted
     version: "5.0.0"
+  flutter_local_notifications:
+    dependency: "direct main"
+    description:
+      name: flutter_local_notifications
+      sha256: ef41ae901e7529e52934feba19ed82827b11baa67336829564aeab3129460610
+      url: "https://pub.dev"
+    source: hosted
+    version: "18.0.1"
+  flutter_local_notifications_linux:
+    dependency: transitive
+    description:
+      name: flutter_local_notifications_linux
+      sha256: "8f685642876742c941b29c32030f6f4f6dacd0e4eaecb3efbb187d6a3812ca01"
+      url: "https://pub.dev"
+    source: hosted
+    version: "5.0.0"
+  flutter_local_notifications_platform_interface:
+    dependency: transitive
+    description:
+      name: flutter_local_notifications_platform_interface
+      sha256: "6c5b83c86bf819cdb177a9247a3722067dd8cc6313827ce7c77a4b238a26fd52"
+      url: "https://pub.dev"
+    source: hosted
+    version: "8.0.0"
   flutter_markdown:
     dependency: "direct main"
     description:
@@ -1035,6 +1059,14 @@ packages:
       url: "https://pub.dev"
     source: hosted
     version: "0.7.11"
+  timezone:
+    dependency: transitive
+    description:
+      name: timezone
+      sha256: dd14a3b83cfd7cb19e7888f1cbc20f258b8d71b54c06f79ac585f14093a287d1
+      url: "https://pub.dev"
+    source: hosted
+    version: "0.10.1"
   tray_manager:
     dependency: "direct main"
     description:

package/flutter_app/pubspec.yaml

@@ -39,6 +39,7 @@ dependencies:
   url_launcher: ^6.3.2
   video_player: ^2.9.2
   flutter_animate: ^4.5.2
+  flutter_local_notifications: ^18.0.0
 
 dependency_overrides:
   flutter_secure_storage_linux:

package/lib/install_helpers.js

@@ -5,6 +5,7 @@ function withInstallEnv(extraEnv = {}) {
   return {
     ...process.env,
     PUPPETEER_SKIP_DOWNLOAD: process.env.PUPPETEER_SKIP_DOWNLOAD || 'true',
+    PLAYWRIGHT_SKIP_BROWSER_DOWNLOAD: process.env.PLAYWRIGHT_SKIP_BROWSER_DOWNLOAD || '1',
     ...extraEnv,
   };
 }

package/lib/manager.js

@@ -1593,7 +1593,12 @@ async function cmdInstall() {
   if (platform === 'macos' && commandExists('launchctl')) {
     installMacService();
   } else if (platform === 'linux' && commandExists('systemctl')) {
-    installLinuxService();
+    try {
+      installLinuxService();
+    } catch (err) {
+      logWarn(`systemd setup failed (${err.message}); falling back to detached process`);
+      startFallback();
+    }
   } else {
     startFallback();
   }
@@ -1693,6 +1698,59 @@ async function cmdRebuildWeb() {
   buildBundledWebClientIfPossible();
 }
 
+async function cmdFix() {
+  cliBanner(`Fix ${APP_NAME}`, 'reset and recover');
+  heading('Backup');
+  backupRuntimeData();
+  logOk(`Runtime data backed up to ${path.join(RUNTIME_HOME, 'backups')}`);
+
+  heading('Stop');
+  cmdStop();
+
+  if (fs.existsSync(path.join(APP_DIR, '.git')) && commandExists('git')) {
+    heading('Reset source files');
+    const dirty = runQuiet('git', ['status', '--porcelain']);
+    if (dirty.status === 0 && dirty.stdout.trim()) {
+      runOrThrow('git', ['checkout', '--', '.']);
+      logOk('Tracked source files reset to HEAD');
+    } else {
+      logOk('Working tree clean — nothing to reset');
+    }
+  }
+
+  heading('Dependencies');
+  const nodeModulesDir = path.join(APP_DIR, 'node_modules');
+  if (fs.existsSync(nodeModulesDir)) {
+    logInfo('Removing node_modules…');
+    fs.rmSync(nodeModulesDir, { recursive: true, force: true });
+    logOk('node_modules removed');
+  }
+  installDependencies();
+
+  heading('Web Client');
+  buildBundledWebClientIfPossible({ required: true });
+
+  heading('Start');
+  const platform = detectPlatform();
+  if (platform === 'macos' && commandExists('launchctl')) {
+    installMacService();
+  } else if (platform === 'linux' && commandExists('systemctl')) {
+    try {
+      installLinuxService();
+    } catch (err) {
+      logWarn(`systemd setup failed (${err.message}); falling back to detached process`);
+      startFallback();
+    }
+  } else {
+    startFallback();
+  }
+
+  const port = loadEnvPort();
+  logOk(`Running on http://localhost:${port}`);
+  heading('Ready');
+  logInfo('Fix complete. Run `neoagent status` to verify.');
+}
+
 function cmdUninstall() {
   heading(`Uninstall ${APP_NAME}`);
   const platform = detectPlatform();
@@ -1962,6 +2020,7 @@ function printHelp() {
   row('restart',             'Stop, then start');
   row('status',              'Health overview (server, service, config)');
   row('logs',                'Tail server logs');
+  row('fix',                 'Backup, reset source, reinstall deps, restart');
   row('uninstall',           'Remove the system service');
   console.log('');
 
@@ -2035,6 +2094,9 @@ async function runCLI(argv) {
     case 'logs':
       cmdLogs();
       break;
+    case 'fix':
+      await cmdFix();
+      break;
     case 'uninstall':
       cmdUninstall();
       break;

package/lib/schema_migrations.js

@@ -0,0 +1,262 @@
+'use strict';
+
+function migrateMemoryEmbeddingIndex(db) {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS memory_embedding_bands (
+      memory_id TEXT NOT NULL,
+      user_id INTEGER NOT NULL,
+      agent_id TEXT NOT NULL,
+      dimension INTEGER NOT NULL,
+      index_version INTEGER NOT NULL DEFAULT 3,
+      band_index INTEGER NOT NULL,
+      band_value INTEGER NOT NULL,
+      updated_at TEXT DEFAULT (datetime('now')),
+      PRIMARY KEY (memory_id, band_index),
+      FOREIGN KEY (memory_id) REFERENCES memories(id) ON DELETE CASCADE,
+      FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_memory_embedding_bands_lookup
+      ON memory_embedding_bands(
+        user_id,
+        agent_id,
+        dimension,
+        band_index,
+        band_value
+      );
+  `);
+  const columns = new Set(
+    db.prepare('PRAGMA table_info(memory_embedding_bands)').all()
+      .map((column) => column.name),
+  );
+  if (!columns.has('index_version')) {
+    db.exec('ALTER TABLE memory_embedding_bands ADD COLUMN index_version INTEGER');
+  }
+  db.exec(`
+    DROP INDEX IF EXISTS idx_memory_embedding_bands_lookup;
+    CREATE INDEX idx_memory_embedding_bands_lookup
+      ON memory_embedding_bands(
+        user_id,
+        agent_id,
+        dimension,
+        index_version,
+        band_index,
+        band_value
+      );
+  `);
+}
+
+function migrateMemoryProvenance(db) {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS memory_source_chunks (
+      id TEXT PRIMARY KEY,
+      document_id TEXT NOT NULL,
+      user_id INTEGER NOT NULL,
+      agent_id TEXT NOT NULL,
+      chunk_index INTEGER NOT NULL,
+      char_start INTEGER NOT NULL,
+      char_end INTEGER NOT NULL,
+      content TEXT NOT NULL,
+      content_hash TEXT NOT NULL,
+      metadata_json TEXT DEFAULT '{}',
+      created_at TEXT DEFAULT (datetime('now')),
+      updated_at TEXT DEFAULT (datetime('now')),
+      FOREIGN KEY (document_id) REFERENCES memory_ingestion_documents(id) ON DELETE CASCADE,
+      FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE,
+      UNIQUE(document_id, content_hash)
+    );
+
+    CREATE TABLE IF NOT EXISTS memory_source_links (
+      memory_id TEXT NOT NULL,
+      chunk_id TEXT NOT NULL,
+      source_document_id TEXT NOT NULL,
+      source_timestamp TEXT,
+      relevance_score REAL DEFAULT 1,
+      extraction_method TEXT DEFAULT 'source_chunk',
+      metadata_json TEXT DEFAULT '{}',
+      created_at TEXT DEFAULT (datetime('now')),
+      PRIMARY KEY (memory_id, chunk_id),
+      FOREIGN KEY (memory_id) REFERENCES memories(id) ON DELETE CASCADE,
+      FOREIGN KEY (chunk_id) REFERENCES memory_source_chunks(id) ON DELETE CASCADE,
+      FOREIGN KEY (source_document_id) REFERENCES memory_ingestion_documents(id) ON DELETE CASCADE
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_memory_source_chunks_document
+      ON memory_source_chunks(document_id, chunk_index);
+    CREATE INDEX IF NOT EXISTS idx_memory_source_links_memory
+      ON memory_source_links(memory_id);
+    CREATE INDEX IF NOT EXISTS idx_memory_source_links_document
+      ON memory_source_links(source_document_id);
+  `);
+}
+
+function migrateMemoryRelations(db) {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS memory_relations (
+      id TEXT PRIMARY KEY,
+      user_id INTEGER NOT NULL,
+      agent_id TEXT,
+      from_memory_id TEXT NOT NULL,
+      to_memory_id TEXT NOT NULL,
+      relation_type TEXT NOT NULL CHECK(relation_type IN ('updates', 'extends', 'derives')),
+      confidence REAL DEFAULT 0.7,
+      metadata_json TEXT DEFAULT '{}',
+      created_at TEXT DEFAULT (datetime('now')),
+      UNIQUE(from_memory_id, to_memory_id, relation_type),
+      FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE,
+      FOREIGN KEY (agent_id) REFERENCES agents(id) ON DELETE SET NULL,
+      FOREIGN KEY (from_memory_id) REFERENCES memories(id) ON DELETE CASCADE,
+      FOREIGN KEY (to_memory_id) REFERENCES memories(id) ON DELETE CASCADE
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_memory_relations_from
+      ON memory_relations(user_id, agent_id, from_memory_id);
+    CREATE INDEX IF NOT EXISTS idx_memory_relations_to
+      ON memory_relations(user_id, agent_id, to_memory_id);
+  `);
+}
+
+function migrateMemoryRetrievalEvents(db) {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS memory_retrieval_events (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      user_id INTEGER NOT NULL,
+      agent_id TEXT NOT NULL,
+      query_hash TEXT NOT NULL,
+      scope_type TEXT NOT NULL,
+      scope_id TEXT,
+      requested_k INTEGER NOT NULL,
+      candidate_count INTEGER DEFAULT 0,
+      semantic_candidate_count INTEGER DEFAULT 0,
+      lexical_candidate_count INTEGER DEFAULT 0,
+      entity_candidate_count INTEGER DEFAULT 0,
+      relation_candidate_count INTEGER DEFAULT 0,
+      result_count INTEGER DEFAULT 0,
+      result_ids_json TEXT DEFAULT '[]',
+      context_tokens_estimate INTEGER DEFAULT 0,
+      latency_ms REAL DEFAULT 0,
+      created_at TEXT DEFAULT (datetime('now')),
+      FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_memory_retrieval_events_user
+      ON memory_retrieval_events(user_id, agent_id, created_at DESC);
+
+    CREATE TABLE IF NOT EXISTS memory_retrieval_enhancements (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      user_id INTEGER NOT NULL,
+      agent_id TEXT NOT NULL,
+      run_id TEXT,
+      query_hash TEXT NOT NULL,
+      trigger_reason TEXT NOT NULL,
+      plan_json TEXT,
+      initial_count INTEGER DEFAULT 0,
+      merged_count INTEGER DEFAULT 0,
+      result_ids_json TEXT DEFAULT '[]',
+      latency_ms REAL DEFAULT 0,
+      created_at TEXT DEFAULT (datetime('now')),
+      FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE,
+      FOREIGN KEY (run_id) REFERENCES agent_runs(id) ON DELETE SET NULL
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_memory_retrieval_enhancements_user
+      ON memory_retrieval_enhancements(user_id, agent_id, created_at DESC);
+  `);
+}
+
+function migrateMemoryEmbeddingMetadata(db) {
+  const columns = new Set(
+    db.prepare('PRAGMA table_info(memories)').all().map((column) => column.name),
+  );
+  const additions = [
+    ['embedding_provider', 'TEXT'],
+    ['embedding_model', 'TEXT'],
+    ['embedding_dimensions', 'INTEGER'],
+    ['embedded_at', 'TEXT'],
+  ];
+  for (const [name, type] of additions) {
+    if (!columns.has(name)) {
+      db.exec(`ALTER TABLE memories ADD COLUMN ${name} ${type}`);
+    }
+  }
+  try {
+    db.exec(`
+      UPDATE memories
+      SET embedding_dimensions = json_array_length(embedding),
+          embedding_provider = COALESCE(embedding_provider, 'legacy_unknown')
+      WHERE embedding IS NOT NULL AND embedding_dimensions IS NULL
+    `);
+  } catch {
+    // JSON1 may be unavailable. New writes still carry complete metadata.
+  }
+}
+
+function migrateToolPermissions(db) {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS tool_policies (
+      user_id    INTEGER NOT NULL REFERENCES users(id) ON DELETE CASCADE,
+      category   TEXT    NOT NULL,
+      policy     TEXT    NOT NULL CHECK(policy IN ('allow','deny','require_approval','allow_always')),
+      updated_at TEXT    DEFAULT (datetime('now')),
+      PRIMARY KEY (user_id, category)
+    );
+
+    CREATE TABLE IF NOT EXISTS tool_approval_log (
+      id             TEXT    PRIMARY KEY,
+      user_id        INTEGER NOT NULL REFERENCES users(id) ON DELETE CASCADE,
+      run_id         TEXT    NOT NULL,
+      tool_name      TEXT    NOT NULL,
+      tool_args_json TEXT,
+      decision       TEXT    NOT NULL CHECK(decision IN ('approved','denied','timeout')),
+      scope          TEXT    NOT NULL CHECK(scope IN ('once','session','always')),
+      decided_at     TEXT    DEFAULT (datetime('now'))
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_approval_log_user
+      ON tool_approval_log(user_id, decided_at DESC);
+  `);
+}
+
+function migrateToolPoliciesAllowAlways(db) {
+  // SQLite doesn't support ALTER COLUMN — recreate the table to add 'allow_always'
+  // to the CHECK constraint on existing installations.
+  const tableInfo = db.prepare("PRAGMA table_info(tool_policies)").all();
+  if (!tableInfo.length) return; // table doesn't exist yet; migrateToolPermissions will create it correctly
+  const checkRow = db.prepare(
+    "SELECT sql FROM sqlite_master WHERE type='table' AND name='tool_policies'",
+  ).get();
+  if (checkRow && checkRow.sql.includes("'allow_always'")) return; // already migrated
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS tool_policies_v2 (
+      user_id    INTEGER NOT NULL REFERENCES users(id) ON DELETE CASCADE,
+      category   TEXT    NOT NULL,
+      policy     TEXT    NOT NULL CHECK(policy IN ('allow','deny','require_approval','allow_always')),
+      updated_at TEXT    DEFAULT (datetime('now')),
+      PRIMARY KEY (user_id, category)
+    );
+    INSERT OR IGNORE INTO tool_policies_v2 SELECT * FROM tool_policies;
+    DROP TABLE tool_policies;
+    ALTER TABLE tool_policies_v2 RENAME TO tool_policies;
+  `);
+}
+
+function runSchemaMigrations(db) {
+  migrateMemoryEmbeddingIndex(db);
+  migrateMemoryProvenance(db);
+  migrateMemoryRelations(db);
+  migrateMemoryRetrievalEvents(db);
+  migrateMemoryEmbeddingMetadata(db);
+  migrateToolPermissions(db);
+  migrateToolPoliciesAllowAlways(db);
+}
+
+module.exports = {
+  migrateMemoryEmbeddingIndex,
+  migrateMemoryProvenance,
+  migrateMemoryRelations,
+  migrateMemoryRetrievalEvents,
+  migrateMemoryEmbeddingMetadata,
+  migrateToolPermissions,
+  migrateToolPoliciesAllowAlways,
+  runSchemaMigrations,
+};

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "neoagent",
-  "version": "2.4.4-beta.0",
+  "version": "2.4.4-beta.11",
   "description": "Proactive personal AI agent with no limits",
   "license": "AGPL-3.0-only",
   "main": "server/index.js",
   "engines": {
-    "node": ">=20"
+    "node": ">=18.0.0"
   },
   "bin": {
     "neoagent": "bin/neoagent.js"
@@ -52,6 +52,8 @@
     "flutter:test:unit": "cd flutter_app && flutter test ../test/flutter/unit",
     "flutter:test:widget": "cd flutter_app && flutter test ../test/flutter/widget",
     "benchmark:tokens": "node scripts/benchmark-token-cost.js",
+    "benchmark:memory": "node scripts/benchmark-memory.js",
+    "benchmark:memorybench:install": "node scripts/install-memorybench-provider.js",
     "release": "npx semantic-release"
   },
   "repository": {