Vault: add History section — unified timeline with group-by-anything (date/last-24h first)

.github/workflows/ci.yml

@@ -1196,6 +1196,35 @@ jobs:
             -only-testing:cmuxTests/GhosttyTerminalViewVisibilityPolicyTests \
             test
 
+      - name: Ensure node for hook and wrapper regressions
+        id: detect-node
+        run: |
+          set -euo pipefail
+          # App-host hook tests and the CLI wrapper regressions both execute
+          # Node. Prepare it before unit tests on every shard; runner images
+          # are not required to ship a Node runtime.
+          for candidate in "$(command -v node || true)" /opt/homebrew/bin/node /usr/local/bin/node; do
+            if [ -n "$candidate" ] && [ -x "$candidate" ]; then
+              dirname "$candidate" >> "$GITHUB_PATH"
+              "$candidate" --version
+              echo "found=true" >> "$GITHUB_OUTPUT"
+              exit 0
+            fi
+          done
+          echo "no node runtime in the runner image; installing via setup-node"
+          echo "found=false" >> "$GITHUB_OUTPUT"
+
+      - name: Install node (runner image has none)
+        if: ${{ steps.detect-node.outputs.found == 'false' }}
+        uses: actions/setup-node@48b55a011bda9f5d6aeb4c2d9c7362e8dae4041e # v6.4.0
+        with:
+          node-version: "20"
+
+      - name: Set up Bun for app-host and Pi extension regressions
+        uses: oven-sh/setup-bun@0c5077e51419868618aeaa5fe8019c62421857d6 # v2
+        with:
+          bun-version: "1.3.6"
+
       - name: Run unit tests
         run: |
           set -euo pipefail
@@ -1361,38 +1390,6 @@ jobs:
           CMUX_SOURCE_PACKAGES_DIR="$PWD/.ci-source-packages" \
             ./tests/test_bundled_ghostty_theme_picker_helper.sh
 
-      - name: Ensure node for wrapper regressions
-        id: detect-node
-        if: ${{ matrix.shard == fromJSON(env.CMUX_APP_HOST_FOCUSED_REGRESSION_SHARD) }}
-        run: |
-          set -euo pipefail
-          # The claude wrapper regressions below exec `node` from fake claude
-          # binaries. The tart-macos-15 runner image shipped without node on
-          # the runner PATH (2026-07-10), which failed every branch. Reuse an
-          # image-provided node when present; otherwise install one below.
-          for candidate in "$(command -v node || true)" /opt/homebrew/bin/node /usr/local/bin/node; do
-            if [ -n "$candidate" ] && [ -x "$candidate" ]; then
-              dirname "$candidate" >> "$GITHUB_PATH"
-              "$candidate" --version
-              echo "found=true" >> "$GITHUB_OUTPUT"
-              exit 0
-            fi
-          done
-          echo "no node runtime in the runner image; installing via setup-node"
-          echo "found=false" >> "$GITHUB_OUTPUT"
-
-      - name: Install node (runner image has none)
-        if: ${{ matrix.shard == fromJSON(env.CMUX_APP_HOST_FOCUSED_REGRESSION_SHARD) && steps.detect-node.outputs.found == 'false' }}
-        uses: actions/setup-node@48b55a011bda9f5d6aeb4c2d9c7362e8dae4041e # v6.4.0
-        with:
-          node-version: "20"
-
-      - name: Set up Bun for Pi extension dispatch regression
-        if: ${{ matrix.shard == fromJSON(env.CMUX_APP_HOST_FOCUSED_REGRESSION_SHARD) }}
-        uses: oven-sh/setup-bun@0c5077e51419868618aeaa5fe8019c62421857d6 # v2
-        with:
-          bun-version: "1.3.6"
-
       - name: Install pinned nushell (shell-integration tests)
         if: ${{ matrix.shard == fromJSON(env.CMUX_APP_HOST_FOCUSED_REGRESSION_SHARD) }}
         run: |
@@ -1766,6 +1763,7 @@ jobs:
             CmuxTerminal
             CmuxTerminalCore
             CmuxUpdater
+            CmuxVaultHistory
             CMUXAgentLaunch
             CmuxAgentJournal
             CmuxFilePreviewCore

.github/workflows/test-depot.yml

@@ -81,6 +81,12 @@ jobs:
       - name: Setup Bun
         uses: oven-sh/setup-bun@0c5077e51419868618aeaa5fe8019c62421857d6 # v2
 
+      - name: Set up Node for hook integration tests
+        if: ${{ !inputs.skip_unit_tests }}
+        uses: actions/setup-node@48b55a011bda9f5d6aeb4c2d9c7362e8dae4041e # v6.4.0
+        with:
+          node-version: "20"
+
       - name: Download pre-built GhosttyKit.xcframework
         env:
           GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
@@ -144,6 +150,7 @@ jobs:
           set -euo pipefail
           SOURCE_PACKAGES_DIR="$PWD/.ci-source-packages"
           run_unit_suite() {
+            TEST_RUNNER_PATH="${TEST_RUNNER_PATH-$PATH:__CURRENT_VALUE__}" \
             scripts/ci/xcodebuild_noninteractive.py \
               xcodebuild -project cmux.xcodeproj -scheme cmux-unit -configuration Debug \
               -clonedSourcePackagesDirPath "$SOURCE_PACKAGES_DIR" \
@@ -165,14 +172,15 @@ jobs:
               suite_output=$(run_unit_suite "-only-testing:cmuxTests/$suite") || suite_status=$?
               printf '%s\n' "$suite_output"
               if [ "$suite_status" -ne 0 ]; then return "$suite_status"; fi
-              # A pipeline here makes `set -o pipefail` treat grep's normal
-              # early exit as a printf SIGPIPE when the xcodebuild log is
-              # large. Feed grep with a here-string so a passing suite cannot
-              # be reported as empty because of that logging artifact.
-              if ! grep -Eq 'Test run with [1-9][0-9]* tests|Executed [1-9][0-9]* tests' <<<"$suite_output"; then
-                echo "No tests executed for $suite" >&2
-                return 1
-              fi
+              # Share the E2E lane's execution guard, including singular
+              # Swift Testing summaries and the app-activation failure check.
+              local suite_log execution_status=0
+              suite_log=$(mktemp "${RUNNER_TEMP:-/tmp}/cmux-unit-suite.XXXXXX")
+              printf '%s\n' "$suite_output" > "$suite_log"
+              scripts/ci/require_selected_test_execution.sh "$suite_log" "cmuxTests/$suite" \
+                || execution_status=$?
+              rm -f -- "$suite_log"
+              if [ "$execution_status" -ne 0 ]; then return "$execution_status"; fi
             done
           }
 

.github/workflows/test-e2e.yml

@@ -24,6 +24,11 @@ on:
         required: false
         default: true
         type: boolean
+      symbolicate_crashes:
+        description: Resolve Swift crash symbols for a focused diagnostic run
+        required: false
+        default: false
+        type: boolean
       runner:
         description: "Runner OS (auto follows MACOS_RUNNER_15; tart-* choices use isolated VMs)"
         required: false
@@ -170,6 +175,12 @@ jobs:
           echo "Resolved target: $test_target"
           echo "Resolved selector: $test_selector"
 
+      - name: Set up Node for hook integration tests
+        if: ${{ steps.filter.outputs.target == 'cmuxTests' }}
+        uses: actions/setup-node@48b55a011bda9f5d6aeb4c2d9c7362e8dae4041e # v6.4.0
+        with:
+          node-version: "20"
+
       - name: Select Xcode
         run: |
           set -euo pipefail
@@ -341,7 +352,7 @@ jobs:
           RECORD_VIDEO: ${{ steps.filter.outputs.record_video }}
           # App-host crash recovery must not stall on interactive backtraces
           # (mirrors ci.yml's tests job hardening).
-          SWIFT_BACKTRACE: "interactive=no,timeout=0s,symbolicate=off,color=no"
+          SWIFT_BACKTRACE: ${{ inputs.symbolicate_crashes && 'interactive=no,timeout=0s,symbolicate=full,color=no' || 'interactive=no,timeout=0s,symbolicate=off,color=no' }}
           CMUX_XCODEBUILD_NONINTERACTIVE_POST_TEST_TIMEOUT_SECONDS: "45"
         run: |
           set -euo pipefail

Packages/Shared/CmuxIrohTransport/Tests/CmuxIrohTransportTests/CmxIrohRelayCredentialCoordinatorTests.swift

@@ -133,6 +133,7 @@ struct CmxIrohRelayCredentialCoordinatorTests {
         let endpoint = TestIrohEndpoint(identity: fixture.identity)
         let supervisor = try await fixture.activeSupervisor(endpoint: endpoint)
         let clock = TestRelayClock(now: fixture.now)
+        var clockEvents = clock.events().makeAsyncIterator()
         let persistence = TestRelayCredentialPersistenceGate()
         let coordinator = CmxIrohRelayCredentialCoordinator(
             supervisor: supervisor,
@@ -154,7 +155,7 @@ struct CmxIrohRelayCredentialCoordinatorTests {
             )
         }
         await persistence.waitUntilStarted()
-        for _ in 0 ..< 20 { await Task.yield() }
+        #expect(await clockEvents.next() != nil, "Expected refresh scheduling while persistence is blocked")
 
         #expect(clock.observedSleepDeadlines() == [fixture.refreshAfter])
         #expect(await endpoint.observedRelayUpdates().count == 1)

Packages/iOS/CmuxMobileShell/Sources/CmuxMobileShell/MobileTerminalLaneCoordinator.swift

@@ -110,6 +110,16 @@ actor MobileTerminalLaneCoordinator {
         self.inputOnlyProvider = inputOnlyProvider
     }
 
+    /// Output lanes must never fall back to the input-only transport.
+    func resolvedProvider(for mode: LaneMode) -> MobileTerminalLaneProvider? {
+        switch mode {
+        case .output:
+            return provider
+        case .inputOnly:
+            return inputOnlyProvider ?? provider
+        }
+    }
+
     func ensure(_ configuration: Configuration) async {
         guard let key = LaneKey(configuration: configuration) else { return }
         focusedKeyBySurfaceID[configuration.surfaceID] = key
@@ -232,14 +242,7 @@ actor MobileTerminalLaneCoordinator {
                 ? nil
                 : await configuration.cursor()
             do {
-                let laneProvider: MobileTerminalLaneProvider?
-                switch configuration.mode {
-                case .output:
-                    laneProvider = provider
-                case .inputOnly:
-                    laneProvider = inputOnlyProvider ?? provider
-                }
-                guard let laneProvider else {
+                guard let laneProvider = resolvedProvider(for: configuration.mode) else {
                     await markFailed(key: key, id: id)
                     return
                 }

Packages/iOS/CmuxMobileShell/Tests/CmuxMobileShellTests/MobileTerminalLaneCoordinatorTests.swift

@@ -159,6 +159,32 @@ struct MobileTerminalLaneCoordinatorTests {
         #expect(await coordinator.isOutputReady(surfaceID: Self.surfaceID) == false)
     }
 
+    @Test
+    func missingOutputProviderDoesNotSelectInputOnlyTransport() async throws {
+        let inputProvider = TerminalLaneTestProvider(lanes: [
+            TerminalLaneTestConnection(
+                frames: [Self.frame(kind: .replay, sequence: 0, bytes: "")],
+                waitsAfterFrames: true
+            ),
+        ])
+        let coordinator = MobileTerminalLaneCoordinator(
+            provider: nil,
+            inputOnlyProvider: { request, surfaceID, cursor in
+                try await inputProvider.callAsFunction(request, surfaceID, cursor: cursor)
+            }
+        )
+
+        // Keep the absent-provider boundary covered separately from the
+        // failing-provider integration test above, without waiting for a non-call.
+        #expect(await coordinator.resolvedProvider(for: .output) == nil)
+        #expect(await inputProvider.requestCount() == 0)
+
+        let selectedInputProvider = try #require(await coordinator.resolvedProvider(for: .inputOnly))
+        let lane = try await selectedInputProvider(try Self.request(), Self.surfaceID, nil)
+        #expect(await inputProvider.requestCount() == 1)
+        await lane.close()
+    }
+
     @Test
     func sequenceGapSuspendsUntilAuthoritativeCursorThenReopens() async throws {
         let firstLane = TerminalLaneTestConnection(

Packages/macOS/CmuxVaultHistory/Package.swift

@@ -0,0 +1,35 @@
+// swift-tools-version: 6.0
+
+import PackageDescription
+
+let package = Package(
+    name: "CmuxVaultHistory",
+    platforms: [
+        .macOS(.v14),
+    ],
+    products: [
+        .library(
+            name: "CmuxVaultHistory",
+            targets: ["CmuxVaultHistory"]
+        ),
+    ],
+    targets: [
+        .target(
+            name: "CmuxVaultHistory",
+            swiftSettings: [
+                .swiftLanguageMode(.v6),
+                .enableUpcomingFeature("ExistentialAny"),
+                .enableUpcomingFeature("InternalImportsByDefault"),
+            ]
+        ),
+        .testTarget(
+            name: "CmuxVaultHistoryTests",
+            dependencies: ["CmuxVaultHistory"],
+            swiftSettings: [
+                .swiftLanguageMode(.v6),
+                .enableUpcomingFeature("ExistentialAny"),
+                .enableUpcomingFeature("InternalImportsByDefault"),
+            ]
+        ),
+    ]
+)

Packages/macOS/CmuxVaultHistory/README.md

@@ -0,0 +1,25 @@
+# CmuxVaultHistory
+
+`CmuxVaultHistory` owns the locale-independent values, bounded JSONL
+persistence, and deterministic grouping used by the macOS History timeline.
+The app target owns lifecycle coordination and localized presentation.
+
+Construct a repository with an explicit file URL. Passing `nil` gives tests an
+in-memory repository with the same retention behavior:
+
+```swift
+let store = VaultHistoryEventStore(fileURL: nil)
+let accepted = await store.append(event)
+let events = await store.recentEvents()
+```
+
+Grouping is a pure operation. Inject `now` at the call site and inspect group
+identities without loading AppKit or SwiftUI:
+
+```swift
+let groups = VaultHistoryGrouper(calendar: calendar).groups(
+    events: events,
+    by: .date,
+    now: now
+)
+```

Packages/macOS/CmuxVaultHistory/Sources/CmuxVaultHistory/VaultHistoryDateBucket.swift

@@ -0,0 +1,53 @@
+public import Foundation
+
+/// Browser-history-style date buckets ordered from newest to oldest.
+public enum VaultHistoryDateBucket: Int, CaseIterable, Identifiable, Sendable {
+    /// Events in the rolling 24-hour window or on the current calendar day.
+    case last24Hours
+    /// Events on the previous calendar day that are outside the rolling window.
+    case yesterday
+    /// Older events in the current calendar week.
+    case thisWeek
+    /// Older events in the current calendar month.
+    case thisMonth
+    /// Events preceding the current calendar month.
+    case older
+
+    /// Stable ordinal identity used by grouped views.
+    public var id: Int { rawValue }
+
+    /// Classifies a timestamp relative to an injected clock and calendar.
+    ///
+    /// - Parameters:
+    ///   - date: Event timestamp to classify.
+    ///   - now: Reference time used for the rolling 24-hour window.
+    ///   - calendar: Calendar used for day, week, and month boundaries.
+    /// - Returns: The single date bucket containing `date`.
+    public static func bucket(
+        for date: Date,
+        now: Date,
+        calendar: Calendar
+    ) -> VaultHistoryDateBucket {
+        if date >= now.addingTimeInterval(-24 * 60 * 60)
+            || calendar.isDate(date, inSameDayAs: now) {
+            return .last24Hours
+        }
+        if isYesterday(date, now: now, calendar: calendar) {
+            return .yesterday
+        }
+        if calendar.isDate(date, equalTo: now, toGranularity: .weekOfYear) {
+            return .thisWeek
+        }
+        if calendar.isDate(date, equalTo: now, toGranularity: .month) {
+            return .thisMonth
+        }
+        return .older
+    }
+
+    private static func isYesterday(_ date: Date, now: Date, calendar: Calendar) -> Bool {
+        guard let yesterday = calendar.date(byAdding: .day, value: -1, to: now) else {
+            return false
+        }
+        return calendar.isDate(date, inSameDayAs: yesterday)
+    }
+}