fix: retain incomplete JSONL tails

Sources/CodexBarCore/Generated/CodexParserHash.generated.swift

@@ -1,5 +1,5 @@
 // Generated by Scripts/regenerate-codex-parser-hash.sh. Do not edit by hand.
 
 enum CodexParserHash {
-    static let value = "9b26fd821cf090dc"
+    static let value = "577571954a2d36bc"
 }

Sources/CodexBarCore/PiSessionCostCache.swift

@@ -2,7 +2,7 @@ import Foundation
 
 enum PiSessionCostCacheIO {
     /// Artifact schema version. Pricing changes are tracked separately by `pricingKey`.
-    private static let artifactVersion = 5
+    private static let artifactVersion = 6
 
     private static func defaultCacheRoot() -> URL {
         let root = FileManager.default.urls(for: .cachesDirectory, in: .userDomainMask).first!
@@ -56,7 +56,7 @@ struct PiSessionCostCache: Codable {
     var daysByProvider: [String: [String: [String: PiPackedUsage]]] = [:]
     var files: [String: PiSessionFileUsage] = [:]
 
-    init(version: Int = 5) {
+    init(version: Int = 6) {
         self.version = version
     }
 }

Sources/CodexBarCore/Vendored/CostUsage/CostUsageCache.swift

@@ -11,9 +11,9 @@ enum CostUsageCacheIO {
     private static func artifactVersion(for provider: UsageProvider) -> Int {
         switch provider {
         case .codex:
-            9
+            10
         case .claude, .vertexai:
-            4
+            5
         default:
             1
         }

Sources/CodexBarCore/Vendored/CostUsage/CostUsageJsonl.swift

@@ -6,6 +6,220 @@ enum CostUsageJsonl {
         let wasTruncated: Bool
     }
 
+    private struct JSONTailState {
+        private enum ScalarState {
+            case notScalar
+            case trueLiteral(Int)
+            case falseLiteral(Int)
+            case nullLiteral(Int)
+            case number(NumberState)
+            case invalid
+        }
+
+        private enum NumberState {
+            private enum ByteKind {
+                case zero
+                case digit
+                case decimalPoint
+                case exponentMarker
+                case sign
+                case whitespace
+                case other
+
+                init(_ byte: UInt8) {
+                    switch byte {
+                    case 0x30: self = .zero
+                    case 0x31...0x39: self = .digit
+                    case 0x2E: self = .decimalPoint
+                    case 0x65, 0x45: self = .exponentMarker
+                    case 0x2B, 0x2D: self = .sign
+                    case 0x20, 0x09, 0x0A, 0x0D: self = .whitespace
+                    default: self = .other
+                    }
+                }
+            }
+
+            case sign
+            case zero
+            case integer
+            case decimalPoint
+            case fraction
+            case exponentMarker
+            case exponentSign
+            case exponentDigits
+            case finished
+            case invalid
+
+            var canCommitAtEOF: Bool {
+                switch self {
+                case .finished, .invalid:
+                    true
+                case .sign, .zero, .integer, .decimalPoint, .fraction,
+                     .exponentMarker, .exponentSign, .exponentDigits:
+                    false
+                }
+            }
+
+            func appending(_ byte: UInt8) -> Self {
+                switch (self, ByteKind(byte)) {
+                case (.invalid, _): .invalid
+                case (.finished, .whitespace): .finished
+                case (.sign, .zero): .zero
+                case (.sign, .digit): .integer
+                case (.zero, .decimalPoint): .decimalPoint
+                case (.zero, .exponentMarker): .exponentMarker
+                case (.integer, .zero), (.integer, .digit): .integer
+                case (.integer, .decimalPoint): .decimalPoint
+                case (.integer, .exponentMarker): .exponentMarker
+                case (.decimalPoint, .zero), (.decimalPoint, .digit): .fraction
+                case (.fraction, .zero), (.fraction, .digit): .fraction
+                case (.fraction, .exponentMarker): .exponentMarker
+                case (.exponentMarker, .sign): .exponentSign
+                case (.exponentMarker, .zero), (.exponentMarker, .digit): .exponentDigits
+                case (.exponentSign, .zero), (.exponentSign, .digit): .exponentDigits
+                case (.exponentDigits, .zero), (.exponentDigits, .digit): .exponentDigits
+                case (.zero, .whitespace),
+                     (.integer, .whitespace),
+                     (.fraction, .whitespace),
+                     (.exponentDigits, .whitespace): .finished
+                default: .invalid
+                }
+            }
+        }
+
+        private static let trueLiteral = Array("true".utf8)
+        private static let falseLiteral = Array("false".utf8)
+        private static let nullLiteral = Array("null".utf8)
+
+        private var containerDepth = 0
+        private var insideString = false
+        private var escaping = false
+        private var sawNonWhitespace = false
+        private var scalarState = ScalarState.notScalar
+
+        mutating func reset() {
+            self = Self()
+        }
+
+        var isStructurallyComplete: Bool {
+            guard self.sawNonWhitespace else { return false }
+            switch self.scalarState {
+            case .notScalar:
+                return !self.insideString && self.containerDepth == 0
+            case let .trueLiteral(matched):
+                return matched == Self.trueLiteral.count
+            case let .falseLiteral(matched):
+                return matched == Self.falseLiteral.count
+            case let .nullLiteral(matched):
+                return matched == Self.nullLiteral.count
+            case let .number(state):
+                return state.canCommitAtEOF
+            case .invalid:
+                return true
+            }
+        }
+
+        mutating func append(_ byte: UInt8) {
+            if !self.sawNonWhitespace {
+                self.start(byte)
+                return
+            }
+
+            guard !self.appendScalar(byte) else { return }
+            self.appendContainer(byte)
+        }
+
+        private mutating func start(_ byte: UInt8) {
+            guard !Self.isWhitespace(byte) else { return }
+            self.sawNonWhitespace = true
+            switch byte {
+            case 0x22:
+                self.insideString = true
+            case 0x7B, 0x5B:
+                self.containerDepth = 1
+            case 0x74:
+                self.scalarState = .trueLiteral(1)
+            case 0x66:
+                self.scalarState = .falseLiteral(1)
+            case 0x6E:
+                self.scalarState = .nullLiteral(1)
+            case 0x2D:
+                self.scalarState = .number(.sign)
+            case 0x30:
+                self.scalarState = .number(.zero)
+            case 0x31...0x39:
+                self.scalarState = .number(.integer)
+            default:
+                self.scalarState = .invalid
+            }
+        }
+
+        private mutating func appendScalar(_ byte: UInt8) -> Bool {
+            switch self.scalarState {
+            case let .trueLiteral(matched):
+                self.scalarState = self.advanceLiteral(byte, expected: Self.trueLiteral, matched: matched)
+                    .map(ScalarState.trueLiteral) ?? .invalid
+                return true
+            case let .falseLiteral(matched):
+                self.scalarState = self.advanceLiteral(byte, expected: Self.falseLiteral, matched: matched)
+                    .map(ScalarState.falseLiteral) ?? .invalid
+                return true
+            case let .nullLiteral(matched):
+                self.scalarState = self.advanceLiteral(byte, expected: Self.nullLiteral, matched: matched)
+                    .map(ScalarState.nullLiteral) ?? .invalid
+                return true
+            case let .number(state):
+                self.scalarState = .number(state.appending(byte))
+                return true
+            case .invalid:
+                return true
+            case .notScalar:
+                return false
+            }
+        }
+
+        private mutating func appendContainer(_ byte: UInt8) {
+            if self.insideString {
+                if self.escaping {
+                    self.escaping = false
+                } else if byte == 0x5C {
+                    self.escaping = true
+                } else if byte == 0x22 {
+                    self.insideString = false
+                }
+                return
+            }
+
+            switch byte {
+            case 0x20, 0x09, 0x0D:
+                return
+            case 0x22:
+                self.insideString = true
+            case 0x7B, 0x5B:
+                self.containerDepth += 1
+            case 0x7D, 0x5D:
+                self.containerDepth = max(0, self.containerDepth - 1)
+            default:
+                break
+            }
+        }
+
+        private func advanceLiteral(
+            _ byte: UInt8,
+            expected: [UInt8],
+            matched: Int) -> Int?
+        {
+            if matched < expected.count {
+                return byte == expected[matched] ? matched + 1 : nil
+            }
+            return Self.isWhitespace(byte) ? matched : nil
+        }
+
+        private static func isWhitespace(_ byte: UInt8) -> Bool {
+            byte == 0x20 || byte == 0x09 || byte == 0x0A || byte == 0x0D
+        }
+    }
+
     @discardableResult
     static func scan(
         fileURL: URL,
@@ -47,6 +261,8 @@ enum CostUsageJsonl {
         var lineBytes = 0
         var truncated = false
         var bytesRead: Int64 = 0
+        var committedOffset = startOffset
+        var jsonTailState = JSONTailState()
 
         func appendSegment(_ bytes: UnsafePointer<UInt8>, count: Int) {
             guard count > 0 else { return }
@@ -69,19 +285,35 @@ enum CostUsageJsonl {
             current.removeAll(keepingCapacity: true)
             lineBytes = 0
             truncated = false
+            jsonTailState.reset()
+        }
+
+        func hasCompleteJSONTail() -> Bool {
+            guard jsonTailState.isStructurallyComplete else { return false }
+            if truncated {
+                // The full record is intentionally not retained. Its incremental state is enough
+                // to keep incomplete containers, strings, literals, and numbers retriable.
+                return true
+            }
+            guard lineBytes == current.count else { return false }
+            return (try? JSONSerialization.jsonObject(with: current, options: [.fragmentsAllowed])) != nil
         }
 
         while true {
             try checkCancellation?()
             let reachedEOF = try autoreleasepool {
                 let chunk = try handle.read(upToCount: 256 * 1024) ?? Data()
                 if chunk.isEmpty {
-                    flushLine()
+                    if hasCompleteJSONTail() {
+                        flushLine()
+                        committedOffset = startOffset + bytesRead
+                    }
                     return true
                 }
 
                 try checkCancellation?()
                 bytesRead += Int64(chunk.count)
+                let chunkStartOffset = startOffset + bytesRead - Int64(chunk.count)
                 chunk.withUnsafeBytes { rawBuffer in
                     guard let base = rawBuffer.bindMemory(to: UInt8.self).baseAddress else { return }
                     var segmentStart = 0
@@ -90,7 +322,10 @@ enum CostUsageJsonl {
                         if base[index] == 0x0A {
                             appendSegment(base.advanced(by: segmentStart), count: index - segmentStart)
                             flushLine()
+                            committedOffset = chunkStartOffset + Int64(index + 1)
                             segmentStart = index + 1
+                        } else {
+                            jsonTailState.append(base[index])
                         }
                         index += 1
                     }
@@ -100,10 +335,12 @@ enum CostUsageJsonl {
                 }
                 return false
             }
-            if reachedEOF { break }
+            if reachedEOF {
+                break
+            }
             try checkCancellation?()
         }
 
-        return startOffset + bytesRead
+        return committedOffset
     }
 }