feat(perf): establish baseline and identify async patterns

- Scanned codebase for `setInterval`, `Promise.all`, and other async patterns.
- Generated `reports/performance/hits-2026-02-20.json`.
- Identified potential unbounded concurrency in `src/services/memory`.
- Created daily performance report.
- Updated run artifacts and memory.

Co-authored-by: PR0M3TH3AN <[email protected]>

memory-updates/2026-02-20T19-31-14Z__perf-agent.md

@@ -0,0 +1,12 @@
+# Memory Update — perf-agent — 2026-02-20
+
+## Key findings
+- Initial scan found 22 performance-relevant patterns (async/timers).
+- Identified potential unbounded concurrency in `src/services/memory` (formatter, retriever, pruner).
+
+## Patterns / reusable knowledge
+- `Promise.all(array.map(...))` is the most common pattern needing scrutiny.
+- `scripts/perf-search.mjs` is effective for baseline scanning.
+
+## Warnings / gotchas
+- Memory service arrays might grow large, posing a risk without concurrency limits.

reports/performance/INITIAL_BASELINE.md

@@ -1,4 +1,5 @@
-# Initial Baseline
+# Initial Performance Baseline
 
-- Date: 2026-02-15
-- Initial metrics established from static analysis.
+## Date: 2026-02-20
+
+Establishing baseline via search patterns.

reports/performance/daily-perf-report-2026-02-20.md

@@ -0,0 +1,35 @@
+# Daily Performance Report - 2026-02-20
+
+## Summary
+Initial baseline scan completed. Identified 22 instances of async/background patterns. No critical (P0) login-blocking issues found, but several potential unbounded concurrency issues identified in the memory service.
+
+## Findings
+
+### P1: Potential Unbounded Concurrency in Memory Service
+Several locations use `Promise.all(array.map(...))` without concurrency limits. If the arrays (memories, actions) grow large, this could spike CPU/Network usage.
+
+- **File**: `src/services/memory/formatter.js:181`
+  - `await Promise.all((memories ?? []).map((memory) => memoryService.updateMemoryUsage...))`
+- **File**: `src/services/memory/retriever.js:256`
+  - `await Promise.all(ids.map((id) => repository.updateMemoryUsage...))`
+- **File**: `src/services/memory/pruner.js:276`
+  - `await Promise.all(plan.actions.map(async (decision) => ...))`
+
+**Recommendation**: Replace with a concurrency-limited runner (e.g., `p-limit` or a utility function) if these arrays are expected to exceed ~50 items.
+
+### Other Hits
+- Standard `setTimeout`/`Promise.race` usage in lock/relay logic (expected).
+- `setInterval` in `src/services/memory/scheduler.js` (expected).
+
+## Metrics
+- **Total Hits**: 22
+- **P0 Issues**: 0
+- **P1 Issues**: 3 (Potential)
+
+## Actions Taken
+- Established baseline `hits-2026-02-20.json`.
+- Documented findings.
+
+## Next Steps
+- Investigate array sizes in memory service to determine if concurrency limits are strictly necessary.
+- Continue monitoring for new patterns.

scripts/perf-search.mjs

@@ -0,0 +1,51 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+
+const patterns = [
+  /setInterval|setTimeout|requestAnimationFrame|requestIdleCallback/i,
+  /Promise\.allSettled|Promise\.all|Promise\.any|Promise\.race/i,
+  /new Worker|Worker\(|postMessage\(|getDmDecryptWorkerQueueSize|decryptDmInWorker/i,
+  /new WebTorrent|WebTorrent|torrent|magnet|torrentHash|magnetValidators/i,
+  /integrationClient\.pool|publishEventToRelays|pool\.list|queueSignEvent|relayManager|authService|hydrateFromStorage/i,
+  /document\.hidden|visibilitychange/i
+];
+
+async function scanDir(dir) {
+  const hits = [];
+  try {
+    const entries = await fs.readdir(dir, { withFileTypes: true });
+
+    for (const entry of entries) {
+      const fullPath = path.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        if (entry.name === 'node_modules' || entry.name.startsWith('.')) continue;
+        hits.push(...await scanDir(fullPath));
+      } else if (entry.isFile() && /\.(mjs|js|jsx|ts|tsx)$/.test(entry.name)) {
+        const content = await fs.readFile(fullPath, 'utf8');
+        const lines = content.split('\n');
+
+        lines.forEach((line, index) => {
+          for (const pattern of patterns) {
+            if (pattern.test(line)) {
+              hits.push({
+                file: fullPath,
+                line: index + 1,
+                content: line.trim(),
+                pattern: pattern.toString()
+              });
+              break; // One hit per line is enough
+            }
+          }
+        });
+      }
+    }
+  } catch (err) {
+    if (err.code !== 'ENOENT') console.error(`Error scanning ${dir}:`, err);
+  }
+  return hits;
+}
+
+const hits = await scanDir('src');
+const outputFile = process.argv[2] || 'reports/performance/hits.json';
+await fs.writeFile(outputFile, JSON.stringify(hits, null, 2));
+console.log(`Wrote ${hits.length} hits to ${outputFile}`);

src/context/CONTEXT_2026-02-20T19-31-14Z.md

@@ -0,0 +1,21 @@
+# Context - perf-agent - 2026-02-20
+
+Agent: perf-agent
+Cadence: daily
+Run-Start: 2026-02-20T19:31:14Z
+Prompt: src/prompts/daily/perf-agent.md
+
+## Goal
+Establish a performance baseline and identify P0/P1 issues using search patterns.
+
+## Scope
+- Scan codebase for performance-critical patterns (intervals, workers, etc.).
+- Generate hits report.
+- Audit /content documentation if needed (deferred to analysis).
+
+## Constraints
+- Minimal changes for baseline establishment.
+- Must run search script.
+
+## Assumptions
+- This is the first run (or treated as such for baseline).

src/decisions/DECISIONS_2026-02-20T19-31-14Z.md

@@ -0,0 +1,10 @@
+# Decisions - perf-agent - 2026-02-20
+
+Agent: perf-agent
+Cadence: daily
+Run-Start: 2026-02-20T19:31:14Z
+Prompt: src/prompts/daily/perf-agent.md
+
+## Key Decision
+- **Baseline Scan**: Decided to run a full scan to establish a baseline `hits.json` file.
+- **Rationale**: Need to know the current state before prioritizing fixes.

src/test_logs/TEST_LOG_2026-02-20T19-31-14Z.md

@@ -0,0 +1,13 @@
+# Test Log - perf-agent - 2026-02-20
+
+Agent: perf-agent
+Cadence: daily
+Run-Start: 2026-02-20T19:31:14Z
+Prompt: src/prompts/daily/perf-agent.md
+
+## Environment
+- Agent: perf-agent
+- Cadence: daily
+
+- Command: node scripts/perf-search.mjs
+- Result: Success (22 hits found).

src/todo/TODO_2026-02-20T19-31-14Z.md

@@ -0,0 +1,16 @@
+# TODO - perf-agent - 2026-02-20
+
+Agent: perf-agent
+Cadence: daily
+Run-Start: 2026-02-20T19:31:14Z
+Prompt: src/prompts/daily/perf-agent.md
+
+## Done
+- [x] Create run artifacts.
+- [x] Run memory retrieval.
+- [x] Run search patterns.
+- [x] Generate daily report.
+- [x] Store memory.
+
+## Pending
+- [ ] Analyze hits in depth (next run).

task-logs/daily/2026-02-20T19-31-14Z__perf-agent__completed.md

@@ -0,0 +1,21 @@
+---
+agent: perf-agent
+cadence: daily
+date: 2026-02-20
+platform: jules
+status: completed
+run-start: 2026-02-20T19:31:14Z
+---
+
+# Task Log - perf-agent - 2026-02-20
+
+## Summary
+- Established performance baseline.
+- Scanned codebase for async patterns.
+- Generated `reports/performance/hits-2026-02-20.json` (22 hits).
+- Identified potential unbounded concurrency in `src/services/memory`.
+
+## Artifacts
+- `reports/performance/hits-2026-02-20.json`
+- `reports/performance/daily-perf-report-2026-02-20.md`
+- `src/context/CONTEXT_2026-02-20T19-31-14Z.md`