brainlayer 1.1.0__tar.gz → 1.2.0__tar.gz

{brainlayer-1.1.0 → brainlayer-1.2.0}/.mcp.json.example

@@ -6,10 +6,6 @@
       "command": "socat",
       "args": ["STDIO", "UNIX-CONNECT:/tmp/brainbar.sock"]
     },
-    "brainlayer-legacy": {
-      "_comment": "Fallback: original Python MCP server (remove after BrainBar is stable)",
-      "command": "brainlayer-mcp"
-    },
     "voicelayer": {
       "command": "voicelayer-mcp"
     },

{brainlayer-1.1.0 → brainlayer-1.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: brainlayer
-Version: 1.1.0
+Version: 1.2.0
 Summary: Persistent memory MCP server for AI agents — 13 tools, semantic search, knowledge graph, on-device SQLite
 Project-URL: Homepage, https://brainlayer.etanheyman.com
 Project-URL: Repository, https://github.com/EtanHey/brainlayer

{brainlayer-1.1.0 → brainlayer-1.2.0}/brain-bar/Sources/BrainBar/BrainBarWindowRootView.swift

@@ -533,6 +533,7 @@ private struct BrainBarDashboardView: View {
         BrainBarQueueRail(
             summary: flowSummary.queue,
             coverageText: "\(Int(collector.stats.enrichmentPercent.rounded()))% enriched",
+            watcherText: collector.stats.watcherHealth?.summaryText ?? "unknown",
             compact: layout.compactCards
         )
     }
@@ -722,6 +723,7 @@ private struct BrainBarFlowLaneCard: View {
 private struct BrainBarQueueRail: View {
     let summary: DashboardQueueSummary
     let coverageText: String
+    let watcherText: String
     let compact: Bool
 
     var body: some View {
@@ -768,11 +770,13 @@ private struct BrainBarQueueRail: View {
             HStack(spacing: 14) {
                 BrainBarLaneMetric(label: "Backlog", value: "\(summary.backlogCount)")
                 BrainBarLaneMetric(label: "Coverage", value: coverageText)
+                BrainBarLaneMetric(label: "Watcher", value: watcherText)
             }
 
             VStack(alignment: .leading, spacing: 8) {
                 BrainBarLaneMetric(label: "Backlog", value: "\(summary.backlogCount)")
                 BrainBarLaneMetric(label: "Coverage", value: coverageText)
+                BrainBarLaneMetric(label: "Watcher", value: watcherText)
             }
         }
     }

{brainlayer-1.1.0 → brainlayer-1.2.0}/brain-bar/Sources/BrainBar/BrainDatabase.swift

@@ -67,6 +67,27 @@ final class BrainDatabase: @unchecked Sendable {
     }
 
     struct DashboardStats: Sendable, Equatable {
+        struct WatcherHealth: Sendable, Equatable {
+            let alerting: Bool
+            let filesTracked: Int
+            let maxOffsetLagBytes: Int
+            let activeEntriesPerMinute: Double
+            let realtimeInsertsPerMinute: Double
+
+            var summaryText: String {
+                if alerting {
+                    if maxOffsetLagBytes >= 1_048_576 {
+                        return "lag \(Int((Double(maxOffsetLagBytes) / 1_048_576.0).rounded())) MB"
+                    }
+                    return "coverage alert"
+                }
+                if filesTracked > 0 {
+                    return "\(filesTracked) files"
+                }
+                return "idle"
+            }
+        }
+
         let chunkCount: Int
         let enrichedChunkCount: Int
         let pendingEnrichmentCount: Int
@@ -86,6 +107,7 @@ final class BrainDatabase: @unchecked Sendable {
         let pendingStoreQueueDepth: Int
         let pendingStoreOldestQueuedAt: Date?
         let pendingStoreFlushRatePerMinute: Double
+        let watcherHealth: WatcherHealth?
 
         init(
             chunkCount: Int,
@@ -106,7 +128,8 @@ final class BrainDatabase: @unchecked Sendable {
             trigramIndexedChunkCount: Int = 0,
             pendingStoreQueueDepth: Int = 0,
             pendingStoreOldestQueuedAt: Date? = nil,
-            pendingStoreFlushRatePerMinute: Double = 0
+            pendingStoreFlushRatePerMinute: Double = 0,
+            watcherHealth: WatcherHealth? = nil
         ) {
             self.chunkCount = chunkCount
             self.enrichedChunkCount = enrichedChunkCount
@@ -127,6 +150,7 @@ final class BrainDatabase: @unchecked Sendable {
             self.pendingStoreQueueDepth = pendingStoreQueueDepth
             self.pendingStoreOldestQueuedAt = pendingStoreOldestQueuedAt
             self.pendingStoreFlushRatePerMinute = pendingStoreFlushRatePerMinute
+            self.watcherHealth = watcherHealth
         }
 
         var recentWriteCount: Int {
@@ -181,7 +205,8 @@ final class BrainDatabase: @unchecked Sendable {
                 trigramIndexedChunkCount: trigramIndexedChunkCount,
                 pendingStoreQueueDepth: pendingStoreQueueDepth,
                 pendingStoreOldestQueuedAt: pendingStoreOldestQueuedAt,
-                pendingStoreFlushRatePerMinute: rate
+                pendingStoreFlushRatePerMinute: rate,
+                watcherHealth: watcherHealth
             )
         }
     }
@@ -545,7 +570,8 @@ final class BrainDatabase: @unchecked Sendable {
                 timestamp TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ','now')),
                 query TEXT NOT NULL,
                 chunk_ids TEXT NOT NULL DEFAULT '[]',
-                token_count INTEGER NOT NULL DEFAULT 0
+                token_count INTEGER NOT NULL DEFAULT 0,
+                mode TEXT NOT NULL DEFAULT 'normal'
             )
         """)
 
@@ -553,6 +579,7 @@ final class BrainDatabase: @unchecked Sendable {
             CREATE INDEX IF NOT EXISTS idx_injection_events_session_timestamp
             ON injection_events(session_id, timestamp DESC)
         """)
+        try ensureInjectionEventColumns()
 
         // Filtered VIEW excludes co_occurs_with noise from KG queries
         try execute("""
@@ -583,6 +610,7 @@ final class BrainDatabase: @unchecked Sendable {
         try ensureKGEntityColumns()
         try ensureKGRelationColumns()
         try ensureKGEntityAliasTable()
+        try ensureInjectionEventColumns()
         try rebuildFTSTableIfNeeded()
         try rebuildTrigramFTSTableIfNeeded()
     }
@@ -1545,6 +1573,7 @@ final class BrainDatabase: @unchecked Sendable {
 
     func dashboardStats(activityWindowMinutes: Int = 30, bucketCount: Int = 12) throws -> DashboardStats {
         let pendingStoreQueue = pendingStoreQueueSnapshot()
+        let watcherHealth = watcherHealthSnapshot()
         return try withReadTransaction {
             let liveWindowMinutes = 1
             let now = Date()
@@ -1562,7 +1591,8 @@ final class BrainDatabase: @unchecked Sendable {
                     recentEnrichmentFiveMinuteCount: 0,
                     activityWindowMinutes: activityWindowMinutes,
                     bucketCount: bucketCount,
-                    liveWindowMinutes: liveWindowMinutes
+                    liveWindowMinutes: liveWindowMinutes,
+                    watcherHealth: watcherHealth
                 )
             }
 
@@ -1604,11 +1634,31 @@ final class BrainDatabase: @unchecked Sendable {
                 lastEnrichedAt: lastEvents.lastEnrichedAt,
                 trigramIndexedChunkCount: (try? countRows(in: "chunks_fts_trigram")) ?? 0,
                 pendingStoreQueueDepth: pendingStoreQueue.depth,
-                pendingStoreOldestQueuedAt: pendingStoreQueue.oldestQueuedAt
+                pendingStoreOldestQueuedAt: pendingStoreQueue.oldestQueuedAt,
+                watcherHealth: watcherHealth
             )
         }
     }
 
+    private func watcherHealthSnapshot() -> DashboardStats.WatcherHealth? {
+        let envPath = ProcessInfo.processInfo.environment["BRAINLAYER_WATCHER_HEALTH_PATH"]
+        let healthPath = envPath ?? URL(fileURLWithPath: path)
+            .deletingLastPathComponent()
+            .appendingPathComponent("watcher-health.json")
+            .path
+        guard let data = FileManager.default.contents(atPath: healthPath),
+              let payload = try? JSONSerialization.jsonObject(with: data) as? [String: Any] else {
+            return nil
+        }
+        return DashboardStats.WatcherHealth(
+            alerting: payload["alerting"] as? Bool ?? false,
+            filesTracked: payload["files_tracked"] as? Int ?? 0,
+            maxOffsetLagBytes: payload["max_offset_lag_bytes"] as? Int ?? 0,
+            activeEntriesPerMinute: payload["active_jsonl_entries_per_minute"] as? Double ?? 0,
+            realtimeInsertsPerMinute: payload["db_realtime_inserts_per_minute"] as? Double ?? 0
+        )
+    }
+
     func dataVersion() throws -> Int {
         guard let db else { throw DBError.notOpen }
         var stmt: OpaquePointer?
@@ -2386,6 +2436,15 @@ final class BrainDatabase: @unchecked Sendable {
         ]
     }
 
+    private func ensureInjectionEventColumns() throws {
+        guard let db else { throw DBError.notOpen }
+        guard (try? tableExists("injection_events")) == true else { return }
+        let existingColumns = try tableColumns(name: "injection_events", on: db)
+        if !existingColumns.contains("mode") {
+            try execute("ALTER TABLE injection_events ADD COLUMN mode TEXT NOT NULL DEFAULT 'normal'")
+        }
+    }
+
     private func ensureChunkColumns() throws {
         guard let db else { throw DBError.notOpen }
         try execute("""
@@ -4859,7 +4918,9 @@ final class BrainDatabase: @unchecked Sendable {
 
     func listInjectionEvents(sessionID: String? = nil, limit: Int = 20) throws -> [InjectionEvent] {
         guard let db else { throw DBError.notOpen }
-        var sql = "SELECT id, session_id, timestamp, query, chunk_ids, token_count FROM injection_events"
+        let hasModeColumn = try tableColumns(name: "injection_events", on: db).contains("mode")
+        let modeSelect = hasModeColumn ? "mode" : "'normal'"
+        var sql = "SELECT id, session_id, timestamp, query, chunk_ids, token_count, \(modeSelect) AS mode FROM injection_events"
         var conditions: [String] = []
         if sessionID != nil { conditions.append("session_id = ?") }
         conditions.append(Self.liveInjectionEventSQLPredicate(eventTable: "injection_events"))
@@ -4885,7 +4946,8 @@ final class BrainDatabase: @unchecked Sendable {
                 "timestamp": columnText(stmt, 2) as Any,
                 "query": columnText(stmt, 3) as Any,
                 "chunk_ids": columnText(stmt, 4) as Any,
-                "token_count": Int(sqlite3_column_int(stmt, 5))
+                "token_count": Int(sqlite3_column_int(stmt, 5)),
+                "mode": columnText(stmt, 6) as Any
             ]
             if let event = try? InjectionEvent(row: row) {
                 let details = (try? injectionChunkDetails(ids: event.chunkIDs)) ?? []
@@ -4901,6 +4963,7 @@ final class BrainDatabase: @unchecked Sendable {
                         query: scopedEvent.query,
                         chunkIDs: scopedEvent.chunkIDs,
                         tokenCount: scopedEvent.tokenCount,
+                        mode: scopedEvent.mode,
                         chunks: scopedEvent.chunks,
                         claudeConversationID: resumableID
                     )
@@ -5013,6 +5076,7 @@ final class BrainDatabase: @unchecked Sendable {
             query: event.query,
             chunkIDs: scopedChunkIDs,
             tokenCount: event.tokenCount,
+            mode: event.mode,
             chunks: liveChunks,
             claudeConversationID: event.claudeConversationID
         )

{brainlayer-1.1.0 → brainlayer-1.2.0}/brain-bar/Sources/BrainBar/InjectionEvent.swift

@@ -225,6 +225,7 @@ struct InjectionEvent: Equatable, Identifiable, Sendable {
     let query: String
     let chunkIDs: [String]
     let tokenCount: Int
+    let mode: String
     let chunks: [InjectionChunk]
     let claudeConversationID: String
 
@@ -292,6 +293,19 @@ struct InjectionEvent: Equatable, Identifiable, Sendable {
         "\(query) • \(chunkCount) chunks • \(tokenCount) tok"
     }
 
+    var chunkRibbonStatusText: String? {
+        if !chunks.isEmpty {
+            return nil
+        }
+        if mode == "degraded" {
+            return "BrainLayer degraded; source metadata unavailable."
+        }
+        if chunkIDs.isEmpty {
+            return "No memories surfaced."
+        }
+        return "Hit bars show retrieved chunk IDs; source metadata was unavailable."
+    }
+
     private static func normalizedForDedupe(_ text: String) -> String {
         text.trimmingCharacters(in: .whitespacesAndNewlines)
             .components(separatedBy: .whitespacesAndNewlines)
@@ -307,6 +321,7 @@ struct InjectionEvent: Equatable, Identifiable, Sendable {
         query: String,
         chunkIDs: [String],
         tokenCount: Int,
+        mode: String = "normal",
         chunks: [InjectionChunk] = [],
         claudeConversationID: String = ""
     ) {
@@ -316,6 +331,7 @@ struct InjectionEvent: Equatable, Identifiable, Sendable {
         self.query = query
         self.chunkIDs = chunkIDs
         self.tokenCount = tokenCount
+        self.mode = mode
         self.chunks = chunks
         self.claudeConversationID = claudeConversationID
     }
@@ -332,6 +348,7 @@ struct InjectionEvent: Equatable, Identifiable, Sendable {
         timestamp = row["timestamp"] as? String ?? ""
         query = row["query"] as? String ?? ""
         tokenCount = row["token_count"] as? Int ?? 0
+        mode = row["mode"] as? String ?? "normal"
         claudeConversationID = row["claude_conversation_id"] as? String ?? ""
 
         if let rawChunkIDs = row["chunk_ids"] as? [String] {

{brainlayer-1.1.0 → brainlayer-1.2.0}/brain-bar/Sources/BrainBar/InjectionFeedView.swift

@@ -505,8 +505,8 @@ struct InjectionFeedView: View {
                             .font(.system(size: 10, weight: .medium))
                     }
                 }
-                if event.chunks.isEmpty {
-                    Text("Hit bars show retrieved chunk IDs; source metadata was unavailable.")
+                if let statusText = event.chunkRibbonStatusText {
+                    Text(statusText)
                         .font(.system(size: 10, weight: .medium))
                         .foregroundStyle(.secondary)
                         .lineLimit(2)

{brainlayer-1.1.0 → brainlayer-1.2.0}/brain-bar/Tests/BrainBarTests/DashboardTests.swift

@@ -85,6 +85,31 @@ final class DashboardTests: XCTestCase {
         XCTAssertGreaterThan(stats.databaseSizeBytes, 0)
     }
 
+    func testDashboardStatsReadsWatcherHealthSnapshot() throws {
+        let healthURL = URL(fileURLWithPath: NSTemporaryDirectory())
+            .appendingPathComponent("watcher-health-\(UUID().uuidString).json")
+        try """
+        {
+          "alerting": true,
+          "files_tracked": 7,
+          "max_offset_lag_bytes": 2097152,
+          "active_jsonl_entries_per_minute": 44.0,
+          "db_realtime_inserts_per_minute": 3.0
+        }
+        """.write(to: healthURL, atomically: true, encoding: .utf8)
+        let restoreHealthPath = setDashboardWatcherHealthPath(healthURL)
+        defer {
+            restoreHealthPath()
+            try? FileManager.default.removeItem(at: healthURL)
+        }
+
+        let stats = try db.dashboardStats(activityWindowMinutes: 30, bucketCount: 6)
+
+        XCTAssertEqual(stats.watcherHealth?.filesTracked, 7)
+        XCTAssertEqual(stats.watcherHealth?.alerting, true)
+        XCTAssertEqual(stats.watcherHealth?.summaryText, "lag 2 MB")
+    }
+
     func testDashboardStatsRecentEnrichmentCountSharesBucketSource() {
         let stats = DashboardStats(
             chunkCount: 12,
@@ -1540,6 +1565,18 @@ private func setDashboardPendingStoreQueuePath(_ path: URL) -> () -> Void {
     }
 }
 
+private func setDashboardWatcherHealthPath(_ path: URL) -> () -> Void {
+    let previous = ProcessInfo.processInfo.environment["BRAINLAYER_WATCHER_HEALTH_PATH"]
+    setenv("BRAINLAYER_WATCHER_HEALTH_PATH", path.path, 1)
+    return {
+        if let previous {
+            setenv("BRAINLAYER_WATCHER_HEALTH_PATH", previous, 1)
+        } else {
+            unsetenv("BRAINLAYER_WATCHER_HEALTH_PATH")
+        }
+    }
+}
+
 private func brainBarSourceFile(_ relativePath: String, testFilePath: StaticString = #filePath) throws -> String {
     let packageRoot = URL(fileURLWithPath: "\(testFilePath)")
         .deletingLastPathComponent()

{brainlayer-1.1.0 → brainlayer-1.2.0}/brain-bar/Tests/BrainBarTests/DatabaseTests.swift

@@ -1274,6 +1274,77 @@ final class DatabaseTests: XCTestCase {
         XCTAssertEqual(event.chunks.map(\.id), ["live-hook"])
     }
 
+    func testListInjectionEventsPreservesModeAfterFeedScoping() throws {
+        try db.insertChunk(
+            id: "live-hook-mode",
+            content: "Injected project context for degraded hook session.",
+            sessionId: "session-live",
+            project: "brainlayer",
+            contentType: "assistant_text",
+            importance: 7
+        )
+        db.exec("""
+            UPDATE chunks
+            SET source = 'mcp',
+                source_file = 'precompact:live-hook-mode',
+                tags = '["hook-injection"]'
+            WHERE id = 'live-hook-mode'
+        """)
+
+        db.recordInjectionEvent(
+            sessionID: "claude-session-1",
+            query: "degraded mode survives scoping",
+            chunkIDs: ["live-hook-mode"],
+            tokenCount: 24,
+            timestamp: "2026-05-29T00:01:00.000Z"
+        )
+        db.exec("UPDATE injection_events SET mode = 'degraded' WHERE query = 'degraded mode survives scoping'")
+
+        let event = try XCTUnwrap(db.listInjectionEvents(sessionID: "claude-session-1", limit: 1).first)
+
+        XCTAssertEqual(event.mode, "degraded")
+        XCTAssertEqual(event.chunkRibbonStatusText, nil)
+    }
+
+    func testListInjectionEventsReadOnlyLegacyDBWithoutModeFallsBackToNormal() throws {
+        let legacyPath = NSTemporaryDirectory() + "brainbar-legacy-injection-events-\(UUID().uuidString).db"
+        try sqliteExecWrite(
+            path: legacyPath,
+            sql: """
+                CREATE TABLE chunks (
+                    id TEXT PRIMARY KEY,
+                    source TEXT NOT NULL DEFAULT '',
+                    source_file TEXT NOT NULL DEFAULT '',
+                    content_type TEXT NOT NULL DEFAULT '',
+                    tags TEXT NOT NULL DEFAULT '[]'
+                );
+                CREATE TABLE injection_events (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    session_id TEXT NOT NULL,
+                    timestamp TEXT NOT NULL DEFAULT (datetime('now')),
+                    query TEXT NOT NULL,
+                    chunk_ids TEXT NOT NULL,
+                    token_count INTEGER NOT NULL DEFAULT 0
+                );
+                INSERT INTO injection_events (session_id, timestamp, query, chunk_ids, token_count)
+                VALUES ('legacy-session', '2026-05-29T00:01:00.000Z', 'legacy no mode', '[]', 0);
+            """
+        )
+        defer {
+            try? FileManager.default.removeItem(atPath: legacyPath)
+            try? FileManager.default.removeItem(atPath: legacyPath + "-wal")
+            try? FileManager.default.removeItem(atPath: legacyPath + "-shm")
+        }
+
+        let legacyDB = BrainDatabase(path: legacyPath, openConfiguration: .init(readOnly: true))
+        defer { legacyDB.close() }
+
+        let event = try XCTUnwrap(legacyDB.listInjectionEvents(sessionID: "legacy-session", limit: 1).first)
+
+        XCTAssertEqual(event.query, "legacy no mode")
+        XCTAssertEqual(event.mode, "normal")
+    }
+
     func testListInjectionEventsFiltersBySessionAndNewestFirst() throws {
         try db.recordInjectionEvent(
             sessionID: "session-a",

{brainlayer-1.1.0 → brainlayer-1.2.0}/brain-bar/Tests/BrainBarTests/InjectionEventTests.swift

@@ -259,4 +259,64 @@ final class InjectionEventTests: XCTestCase {
         XCTAssertEqual(event.primaryKind, .other)
         XCTAssertEqual(event.displayTitle, "lead chunk metadata missing")
     }
+
+    func testEmptyChunkIDsReportNoMemoriesSurfaced() {
+        let event = InjectionEvent(
+            id: 7,
+            sessionID: "s7",
+            timestamp: "2026-03-31T04:50:00.000Z",
+            query: "zero result prompt",
+            chunkIDs: [],
+            tokenCount: 0,
+            chunks: []
+        )
+
+        XCTAssertEqual(event.chunkRibbonStatusText, "No memories surfaced.")
+    }
+
+    func testDegradedEventReportsInfrastructureStatus() {
+        let event = InjectionEvent(
+            id: 9,
+            sessionID: "s9",
+            timestamp: "2026-03-31T04:50:00.000Z",
+            query: "database unavailable",
+            chunkIDs: [],
+            tokenCount: 0,
+            mode: "degraded",
+            chunks: []
+        )
+
+        XCTAssertEqual(event.chunkRibbonStatusText, "BrainLayer degraded; source metadata unavailable.")
+    }
+
+    func testRowDecodesInjectionMode() throws {
+        let event = try InjectionEvent(
+            row: [
+                "id": 10,
+                "session_id": "sess-10",
+                "timestamp": "2026-03-31T04:50:00.000Z",
+                "query": "degraded event",
+                "chunk_ids": "[]",
+                "token_count": 0,
+                "mode": "degraded"
+            ]
+        )
+
+        XCTAssertEqual(event.mode, "degraded")
+        XCTAssertEqual(event.chunkRibbonStatusText, "BrainLayer degraded; source metadata unavailable.")
+    }
+
+    func testMissingChunkRowsReportMetadataUnavailable() {
+        let event = InjectionEvent(
+            id: 8,
+            sessionID: "s8",
+            timestamp: "2026-03-31T04:50:00.000Z",
+            query: "missing chunk metadata",
+            chunkIDs: ["missing"],
+            tokenCount: 12,
+            chunks: []
+        )
+
+        XCTAssertEqual(event.chunkRibbonStatusText, "Hit bars show retrieved chunk IDs; source metadata was unavailable.")
+    }
 }

{brainlayer-1.1.0 → brainlayer-1.2.0}/brain-bar/build-app.sh

@@ -50,7 +50,14 @@ done
 SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
 PACKAGE_DIR="$SCRIPT_DIR"
 BUNDLE_DIR="$SCRIPT_DIR/bundle"
-SIGN_IDENTITY="${BRAINBAR_CODESIGN_IDENTITY:-Apple Development: Etan Heyman (DXHB5E7P2D)}"
+SIGN_IDENTITY="${BRAINBAR_CODESIGN_IDENTITY:-Developer ID Application: Etan Heyman (PPN23G925Y)}"
+BRAINBAR_NOTARY_PROFILE="${BRAINBAR_NOTARY_PROFILE:-${BRAINBAR_NOTARY_KEYCHAIN_PROFILE:-}}"
+BRAINBAR_NOTARY_APPLE_ID="${BRAINBAR_NOTARY_APPLE_ID:-}"
+BRAINBAR_NOTARY_PASSWORD="${BRAINBAR_NOTARY_PASSWORD:-}"
+BRAINBAR_NOTARY_TEAM_ID="${BRAINBAR_NOTARY_TEAM_ID:-PPN23G925Y}"
+BRAINBAR_NOTARY_KEY="${BRAINBAR_NOTARY_KEY:-}"
+BRAINBAR_NOTARY_KEY_ID="${BRAINBAR_NOTARY_KEY_ID:-}"
+BRAINBAR_NOTARY_ISSUER="${BRAINBAR_NOTARY_ISSUER:-}"
 UI_PLIST_LABEL="com.brainlayer.brainbar"
 DAEMON_PLIST_LABEL="com.brainlayer.brainbar-daemon"
 UI_PLIST_FILENAME="$UI_PLIST_LABEL.plist"
@@ -435,6 +442,92 @@ wait_for_socket() {
     return 1
 }
 
+notary_credentials_available() {
+    if [ -n "$BRAINBAR_NOTARY_PROFILE" ]; then
+        return 0
+    fi
+    if [ -n "$BRAINBAR_NOTARY_APPLE_ID" ] && [ -n "$BRAINBAR_NOTARY_PASSWORD" ] && [ -n "$BRAINBAR_NOTARY_TEAM_ID" ]; then
+        return 0
+    fi
+    if [ -n "$BRAINBAR_NOTARY_KEY" ] && [ -n "$BRAINBAR_NOTARY_KEY_ID" ] && [ -n "$BRAINBAR_NOTARY_ISSUER" ]; then
+        return 0
+    fi
+    return 1
+}
+
+notarytool_auth_args() {
+    if [ -n "$BRAINBAR_NOTARY_PROFILE" ]; then
+        printf '%s\0%s\0' "--keychain-profile" "$BRAINBAR_NOTARY_PROFILE"
+        return 0
+    fi
+    if [ -n "$BRAINBAR_NOTARY_APPLE_ID" ] && [ -n "$BRAINBAR_NOTARY_PASSWORD" ] && [ -n "$BRAINBAR_NOTARY_TEAM_ID" ]; then
+        printf '%s\0%s\0%s\0%s\0%s\0%s\0' \
+            "--apple-id" "$BRAINBAR_NOTARY_APPLE_ID" \
+            "--password" "$BRAINBAR_NOTARY_PASSWORD" \
+            "--team-id" "$BRAINBAR_NOTARY_TEAM_ID"
+        return 0
+    fi
+    if [ -n "$BRAINBAR_NOTARY_KEY" ] && [ -n "$BRAINBAR_NOTARY_KEY_ID" ] && [ -n "$BRAINBAR_NOTARY_ISSUER" ]; then
+        printf '%s\0%s\0%s\0%s\0%s\0%s\0' \
+            "--key" "$BRAINBAR_NOTARY_KEY" \
+            "--key-id" "$BRAINBAR_NOTARY_KEY_ID" \
+            "--issuer" "$BRAINBAR_NOTARY_ISSUER"
+        return 0
+    fi
+    return 1
+}
+
+verify_spctl_assessment() {
+    local phase="$1"
+    local required="${2:-0}"
+    if spctl -a -vvv "$APP_DIR"; then
+        return 0
+    fi
+    if [ "$required" -eq 1 ]; then
+        echo "[build-app] ERROR: spctl assessment failed after $phase" >&2
+        return 1
+    fi
+    echo "[build-app] WARNING: spctl assessment failed before notarization; continuing to notary readiness/submit" >&2
+    return 0
+}
+
+notarize_and_staple() {
+    if ! notary_credentials_available; then
+        echo "[build-app] Notary credentials not configured; skipping notarytool submit."
+        echo "[build-app] Ready to submit with one of:"
+        echo "  BRAINBAR_NOTARY_PROFILE=<keychain-profile>"
+        echo "  BRAINBAR_NOTARY_APPLE_ID=<apple-id> BRAINBAR_NOTARY_PASSWORD=<app-specific-password> BRAINBAR_NOTARY_TEAM_ID=<team-id>"
+        echo "  BRAINBAR_NOTARY_KEY=<api-key.p8> BRAINBAR_NOTARY_KEY_ID=<key-id> BRAINBAR_NOTARY_ISSUER=<issuer-id>"
+        return 0
+    fi
+
+    local auth_args=()
+    while IFS= read -r -d '' arg; do
+        auth_args+=("$arg")
+    done < <(notarytool_auth_args)
+
+    local notary_zip_base
+    local notary_zip
+    local tmp_parent
+    tmp_parent="${TMPDIR:-/tmp}"
+    notary_zip_base="$(mktemp "${tmp_parent%/}/brainbar-notary.XXXXXX")"
+    notary_zip="$notary_zip_base.zip"
+    rm -f "$notary_zip_base"
+    ditto -c -k --keepParent "$APP_DIR" "$notary_zip"
+
+    echo "[build-app] Submitting for notarization..."
+    if xcrun notarytool submit "$notary_zip" "${auth_args[@]}" --wait; then
+        rm -f "$notary_zip"
+    else
+        local submit_status=$?
+        rm -f "$notary_zip"
+        return "$submit_status"
+    fi
+    echo "[build-app] Stapling notarization ticket..."
+    xcrun stapler staple "$APP_DIR"
+    verify_spctl_assessment "notarization" 1
+}
+
 if [ "$DEV_BUNDLE_BUILD" -eq 0 ]; then
     # Stop LaunchAgents first so KeepAlive cannot race the rebuild and unlink the
     # freshly rebound socket from an older instance that is still terminating.
@@ -509,7 +602,7 @@ echo "  BuildTimeUTC=$BUILD_UTC"
 
 # Developer signing keeps TCC permissions stable across rebuilds.
 echo "[build-app] Signing..."
-codesign --force --deep --sign "$SIGN_IDENTITY" --timestamp=none "$APP_DIR"
+codesign --force --deep --options runtime --timestamp --sign "$SIGN_IDENTITY" "$APP_DIR"
 
 echo "[build-app] Verifying signature..."
 if ! codesign -dv --verbose=4 "$APP_DIR" 2>&1 | grep -F "Authority=$SIGN_IDENTITY" >/dev/null; then
@@ -517,6 +610,8 @@ if ! codesign -dv --verbose=4 "$APP_DIR" 2>&1 | grep -F "Authority=$SIGN_IDENTIT
     codesign -dv --verbose=4 "$APP_DIR" 2>&1
     exit 1
 fi
+verify_spctl_assessment "Developer ID signing"
+notarize_and_staple
 
 # Register URL scheme with Launch Services (ensures brainbar:// works after rebuild)
 "$LSREGISTER" -R "$APP_DIR"

{brainlayer-1.1.0 → brainlayer-1.2.0}/docs/index.md

@@ -30,7 +30,8 @@ Add to Claude Code (`~/.claude.json`):
 {
   "mcpServers": {
     "brainlayer": {
-      "command": "brainlayer-mcp"
+      "command": "socat",
+      "args": ["STDIO", "UNIX-CONNECT:/tmp/brainbar.sock"]
     }
   }
 }

brainlayer-1.2.0/docs/mcp-config.md

@@ -0,0 +1,40 @@
+# MCP Configuration for BrainLayer
+
+Use the BrainBar socket bridge for agent MCP wiring. This avoids GUI `PATH`
+drift in Finder-launched apps because agents connect to the already-running
+BrainBar daemon instead of spawning a Python MCP process.
+
+Add this to Claude, Codex, Cursor, or Gemini MCP settings under `mcpServers`:
+
+```json
+{
+  "mcpServers": {
+    "brainlayer": {
+      "command": "socat",
+      "args": ["STDIO", "UNIX-CONNECT:/tmp/brainbar.sock"]
+    }
+  }
+}
+```
+
+If a GUI app cannot find `socat`, use the absolute Homebrew path in `command`
+(`/opt/homebrew/bin/socat` on Apple Silicon, `/usr/local/bin/socat` on Intel).
+
+The Python `brainlayer-mcp` entrypoint is still packaged for development and
+formula installs, but it is not the recommended agent wiring path.
+
+## Testing the MCP Server
+
+1. Confirm BrainBar owns the MCP socket:
+   ```bash
+   test -S /tmp/brainbar.sock
+   printf '{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2024-11-05","capabilities":{},"clientInfo":{"name":"smoke","version":"0"}}}\n' \
+     | socat - UNIX-CONNECT:/tmp/brainbar.sock
+   ```
+
+2. In Claude Code, the tools should appear:
+   - `brain_search` - Unified semantic search (query, file_path, chunk_id, filters)
+   - `brain_store` - Persist memories (ideas, decisions, learnings)
+   - `brain_recall` - Proactive retrieval (context, sessions, summaries)
+
+   *Old `brainlayer_*` names still work as backward-compat aliases.*