fix: preserve conservative subagent parsing

Author: steipete

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 = "e4483fa9d0706ab2"
+    static let value = "aff14fe562b54e8b"
 }

Sources/CodexBarCore/Vendored/CostUsage/CostUsageScanner+CodexTruncatedPrefix.swift

@@ -1,6 +1,23 @@
 import Foundation
 
 extension CostUsageScanner {
+    static func extractCodexTruncatedSessionMetadata(from bytes: Data) ->
+        (isSessionMetadata: Bool, sessionID: String?)
+    {
+        guard let text = truncatedUTF8String(from: bytes) else { return (false, nil) }
+        let object = text[...]
+        guard Self.extractJSONStringField("type", from: object, atDepth: 1) == "session_meta" else {
+            return (false, nil)
+        }
+        guard let payloadText = Self.extractJSONObjectField("payload", from: object, atDepth: 1) else {
+            return (true, nil)
+        }
+        let sessionID = Self.extractJSONStringField("id", from: payloadText, atDepth: 1)
+            ?? Self.extractJSONStringField("session_id", from: payloadText, atDepth: 1)
+            ?? Self.extractJSONStringField("sessionId", from: payloadText, atDepth: 1)
+        return (true, sessionID)
+    }
+
     static func extractCodexTurnContextModel(from bytes: Data) -> String? {
         guard let text = truncatedUTF8String(from: bytes) else { return nil }
         let object = text[...]
@@ -44,8 +61,12 @@ extension CostUsageScanner {
             case "}":
                 depth -= 1
                 text.formIndex(after: &index)
-                if depth == 0 { return true }
-                if depth < 0 { return false }
+                if depth == 0 {
+                    return true
+                }
+                if depth < 0 {
+                    return false
+                }
             case "\"":
                 guard Self.parseJSONString(in: text, index: &index) != nil else { return false }
             default:

Sources/CodexBarCore/Vendored/CostUsage/CostUsageScanner.swift

@@ -1313,6 +1313,15 @@ enum CostUsageScanner {
         case interAgentCommunication(triggerTurn: Bool)
         case taskStarted(turnID: String?)
         case tokenCount(CodexTokenCountRecord)
+
+        var requiresValidTimestamp: Bool {
+            switch self {
+            case .sessionMeta:
+                false
+            case .turnContext, .interAgentCommunication, .taskStarted, .tokenCount:
+                true
+            }
+        }
     }
 
     private struct CodexBufferedFastLine {
@@ -1704,6 +1713,20 @@ enum CostUsageScanner {
         }
     }
 
+    private static func codexFastLineTimestampValidity(_ bytes: Data) -> Bool? {
+        let timestamp = bytes.withUnsafeBytes { rawBytes in
+            let rawBuffer = rawBytes.bindMemory(to: UInt8.self)
+            guard !rawBuffer.isEmpty else { return nil as String? }
+            return Self.extractJSONByteStringField(
+                Self.codexJSONFieldTimestamp,
+                from: rawBuffer,
+                in: 0..<rawBuffer.count,
+                atDepth: 1)
+        }
+        guard let timestamp else { return nil }
+        return (Self.dayKeyFromTimestamp(timestamp) ?? Self.dayKeyFromParsedISO(timestamp)) != nil
+    }
+
     static func parseCodexSessionIdentifier(
         fileURL: URL,
         checkCancellation: CancellationCheck? = nil) throws -> String?
@@ -2387,6 +2410,23 @@ enum CostUsageScanner {
                                 deferredError = error
                             }
                         }
+                        if pendingSubagentLines != nil {
+                            let truncatedMetadata = Self.extractCodexTruncatedSessionMetadata(from: line.bytes)
+                            if truncatedMetadata.isSessionMetadata {
+                                do {
+                                    try routeFastLine(
+                                        .sessionMeta(CodexSessionMetadata(
+                                            sessionId: truncatedMetadata.sessionID,
+                                            forkedFromId: nil,
+                                            forkTimestamp: nil,
+                                            projectPath: nil,
+                                            isSubagentThread: false)),
+                                        lineIndex: lineIndex)
+                                } catch {
+                                    deferredError = error
+                                }
+                            }
+                        }
                         return
                     }
 
@@ -2408,12 +2448,20 @@ enum CostUsageScanner {
                     }
 
                     if let fastLine = Self.parseCodexFastLine(line.bytes) {
-                        do {
-                            try routeFastLine(fastLine, lineIndex: lineIndex)
-                        } catch {
-                            deferredError = error
+                        let timestampValidity = fastLine.requiresValidTimestamp
+                            ? Self.codexFastLineTimestampValidity(line.bytes)
+                            : true
+                        if timestampValidity == true {
+                            do {
+                                try routeFastLine(fastLine, lineIndex: lineIndex)
+                            } catch {
+                                deferredError = error
+                            }
+                            return
+                        }
+                        if timestampValidity == false {
+                            return
                         }
-                        return
                     }
 
                     autoreleasepool {

Tests/CodexBarTests/CodexSubagentAccountingIntegrationTests.swift

@@ -158,10 +158,16 @@ struct CodexSubagentAccountingIntegrationTests {
                 .replacingOccurrences(
                     of: "\"type\":\"inter_agent_communication_metadata\"",
                     with: "\"ty\\u0070e\":\"inter_agent_communication_metadata\""))
+        let escapedTimestampFileURL = try env.writeCodexSessionFile(
+            day: day,
+            filename: "rollout-\(forkTimestamp)-marker-child-escaped-timestamp.jsonl",
+            contents: fastContents
+                .replacingOccurrences(of: "marker-child", with: "marker-child-escaped-timestamp")
+                .replacingOccurrences(of: "\"timestamp\":", with: "\"time\\u0073tamp\":"))
 
         let dayKey = CostUsageScanner.CostUsageDayRange.dayKey(from: day)
         let normalizedLeafModel = CostUsagePricing.normalizeCodexModel(leafModel)
-        for fileURL in [fastFileURL, fallbackFileURL] {
+        for fileURL in [fastFileURL, fallbackFileURL, escapedTimestampFileURL] {
             var resolvedParentBaseline = false
             let parsed = CostUsageScanner.parseCodexFile(
                 fileURL: fileURL,
@@ -187,11 +193,11 @@ struct CodexSubagentAccountingIntegrationTests {
             until: day,
             now: day,
             options: options)
-        #expect(report.data.first?.totalTokens == 110)
+        #expect(report.data.first?.totalTokens == 165)
 
         let cache = CostUsageCacheIO.load(provider: .codex, cacheRoot: env.cacheRoot)
         let childUsages = cache.files.values.filter { $0.sessionId?.hasPrefix("marker-child") == true }
-        #expect(childUsages.count == 2)
+        #expect(childUsages.count == 3)
         #expect(childUsages.allSatisfy {
             $0.forkBaselineDependencyKey == CostUsageScanner.codexForkDependencyNotRequiredKey
         })
@@ -261,6 +267,133 @@ struct CodexSubagentAccountingIntegrationTests {
         #expect(resolvedParentBaseline)
     }
 
+    @Test
+    func `oversized ancestor metadata remains conservative copied-prefix evidence`() throws {
+        let env = try CostUsageTestEnvironment()
+        defer { env.cleanup() }
+
+        let day = try env.makeLocalNoon(year: 2026, month: 7, day: 16)
+        let timestamp = env.isoString(for: day)
+        let opening = try env.jsonl([
+            [
+                "type": "session_meta",
+                "timestamp": timestamp,
+                "payload": [
+                    "id": "oversized-child",
+                    "source": ["subagent": ["thread_spawn": [:]]],
+                ],
+            ],
+            self.tokenCount(
+                timestamp: env.isoString(for: day.addingTimeInterval(1)),
+                model: "openai/gpt-5.3",
+                total: (input: 1000, cached: 900, output: 100),
+                last: (input: 50, cached: 10, output: 5)),
+        ])
+        let oversizedAncestor = "{\"type\":\"session_meta\",\"timestamp\":\"\(timestamp)\"," +
+            "\"payload\":{\"id\":\"oversized-parent\",\"padding\":\"" +
+            String(repeating: "x", count: 300_000) + "\"}}\n"
+        let tail = try env.jsonl([
+            self.tokenCount(
+                timestamp: env.isoString(for: day.addingTimeInterval(2)),
+                model: "openai/gpt-5.4",
+                total: (input: 1050, cached: 910, output: 105),
+                last: (input: 50, cached: 10, output: 5)),
+        ])
+        let fileURL = try env.writeCodexSessionFile(
+            day: day,
+            filename: "rollout-\(timestamp)-oversized-ancestor.jsonl",
+            contents: opening + oversizedAncestor + tail)
+
+        var resolvedParentBaseline = false
+        let parsed = CostUsageScanner.parseCodexFile(
+            fileURL: fileURL,
+            range: CostUsageScanner.CostUsageDayRange(since: day, until: day),
+            inheritedTotalsResolver: { parentSessionID, _ in
+                resolvedParentBaseline = true
+                #expect(parentSessionID == "oversized-parent")
+                return .resolved(.init(input: 1000, cached: 900, output: 100))
+            })
+
+        let dayKey = CostUsageScanner.CostUsageDayRange.dayKey(from: day)
+        let model = CostUsagePricing.normalizeCodexModel("openai/gpt-5.4")
+        #expect(parsed.days[dayKey]?[model] == [50, 10, 5])
+        #expect(parsed.forkedFromId == "oversized-parent")
+        #expect(parsed.dependsOnParentTotals)
+        #expect(resolvedParentBaseline)
+    }
+
+    @Test
+    func `invalid timestamp suffix markers preserve parent dependency on both parser paths`() throws {
+        let env = try CostUsageTestEnvironment()
+        defer { env.cleanup() }
+
+        let day = try env.makeLocalNoon(year: 2026, month: 7, day: 16)
+        let timestamp = env.isoString(for: day)
+        let contents = try env.jsonl([
+            [
+                "type": "session_meta",
+                "timestamp": timestamp,
+                "payload": [
+                    "id": "invalid-marker-child",
+                    "source": ["subagent": ["thread_spawn": [:]]],
+                ],
+            ],
+            self.tokenCount(
+                timestamp: env.isoString(for: day.addingTimeInterval(1)),
+                model: "openai/gpt-5.3",
+                total: (input: 1000, cached: 900, output: 100),
+                last: (input: 50, cached: 10, output: 5)),
+            [
+                "type": "session_meta",
+                "timestamp": timestamp,
+                "payload": ["id": "invalid-marker-parent"],
+            ],
+            [
+                "type": "turn_context",
+                "payload": ["model": "openai/gpt-5.4"],
+            ],
+            [
+                "type": "inter_agent_communication_metadata",
+                "payload": ["trigger_turn": true],
+            ],
+            self.tokenCount(
+                timestamp: env.isoString(for: day.addingTimeInterval(2)),
+                model: "openai/gpt-5.4",
+                total: (input: 1050, cached: 910, output: 105),
+                last: (input: 50, cached: 10, output: 5)),
+        ])
+        let fastFileURL = try env.writeCodexSessionFile(
+            day: day,
+            filename: "rollout-\(timestamp)-invalid-marker.jsonl",
+            contents: contents)
+        let fallbackFileURL = try env.writeCodexSessionFile(
+            day: day,
+            filename: "rollout-\(timestamp)-invalid-marker-fallback.jsonl",
+            contents: contents
+                .replacingOccurrences(of: "invalid-marker-child", with: "invalid-marker-child-fallback")
+                .replacingOccurrences(of: "\"type\":\"turn_context\"", with: "\"ty\\u0070e\":\"turn_context\"")
+                .replacingOccurrences(
+                    of: "\"type\":\"inter_agent_communication_metadata\"",
+                    with: "\"ty\\u0070e\":\"inter_agent_communication_metadata\""))
+
+        let dayKey = CostUsageScanner.CostUsageDayRange.dayKey(from: day)
+        let model = CostUsagePricing.normalizeCodexModel("openai/gpt-5.4")
+        for fileURL in [fastFileURL, fallbackFileURL] {
+            var resolvedParentBaseline = false
+            let parsed = CostUsageScanner.parseCodexFile(
+                fileURL: fileURL,
+                range: CostUsageScanner.CostUsageDayRange(since: day, until: day),
+                inheritedTotalsResolver: { parentSessionID, _ in
+                    resolvedParentBaseline = true
+                    #expect(parentSessionID == "invalid-marker-parent")
+                    return .resolved(.init(input: 1000, cached: 900, output: 100))
+                })
+            #expect(parsed.days[dayKey]?[model] == [50, 10, 5])
+            #expect(parsed.dependsOnParentTotals)
+            #expect(resolvedParentBaseline)
+        }
+    }
+
     @Test
     func `idless copied prefix without a parent or local marker is suppressed`() throws {
         let env = try CostUsageTestEnvironment()