@bli-cockpit/cli 0.2.236 → 0.2.238

package/dist/adapters/claude-attribution-score.js

@@ -19,95 +19,18 @@ import { CLAUDE_SESSION_MAX_FILE_BYTES, } from "./claude-attribution-types.js";
  * work and must not inflate this session's numbers.
  */
 export async function attributeOneSession(session, worktrees, collectionRoots) {
-    const fileName = path.basename(session.mainFile);
     const factsAcc = newSessionFactsAccumulator("claude_code");
-    const base = {
-        file_path: session.mainFile,
-        file_name: fileName,
-        claude_session_id: sessionIdFromFileName(fileName) ?? shortHash(session.mainFile),
-        cwd_basename: null,
-        cwd_hash: null,
-        session_file_mtime: new Date(session.mainMtimeMs).toISOString(),
-        session_file_mtime_ms: session.mainMtimeMs,
-        session_recency_ms: session.recencyMs,
-        byte_size: session.mainByteSize,
-        content_hash_sha256: null,
-        main_file_oversized: false,
-        oversized_lines_skipped: 0,
-        sidecars_capped: session.sidecarsCapped,
-        sidecar_files: [],
-        session_facts: null,
-    };
+    const base = createSessionBase(session);
     if (session.mainByteSize === 0) {
         return skippedResult(base, "empty_file");
     }
-    let signals;
-    const oversized = session.mainByteSize > CLAUDE_SESSION_MAX_FILE_BYTES;
-    if (oversized) {
-        // D7: stream the oversized main so metadata signals remain available. The
-        // bytes themselves are not uploaded until the collection ceiling changes.
-        let streamed;
-        try {
-            streamed = await streamMainSignals(session.mainFile, factsAcc);
-        }
-        catch (error) {
-            // A read race on one oversized main must not abort the whole scan; honor
-            // the per-file skip contract. Per session, so worth a line each time:
-            // this is a whole session nobody will ever coach on (BLI-3238).
-            console.error("[claude-attribution] oversized session could not be streamed, skipping it", JSON.stringify({
-                reason: "file_read_failed",
-                stage: "stream_oversized_main",
-                byte_size: session.mainByteSize,
-                ...describeError(error),
-            }));
-            return skippedResult(base, "file_read_failed");
-        }
-        signals = streamed.signals;
-        observeSessionFactsFile(factsAcc, {
-            bytes: streamed.byteSize,
-            lines: streamed.signals.line_count,
-        });
-        base.content_hash_sha256 = streamed.contentHash;
-        base.byte_size = streamed.byteSize;
-        base.main_file_oversized = true;
-        base.oversized_lines_skipped = streamed.oversizedLinesSkipped;
-    }
-    else {
-        let raw;
-        try {
-            raw = await fs.readFile(session.mainFile);
-        }
-        catch (error) {
-            console.error("[claude-attribution] session file unreadable, skipping it", JSON.stringify({
-                reason: "file_read_failed",
-                stage: "read_main",
-                byte_size: session.mainByteSize,
-                ...describeError(error),
-            }));
-            return skippedResult(base, "file_read_failed");
-        }
-        const content = raw.toString("utf8");
-        base.content_hash_sha256 = sha256(raw);
-        base.byte_size = raw.byteLength;
-        if (content.trim() === "") {
-            return skippedResult(base, "empty_file");
-        }
-        signals = extractClaudeSessionSignals(content, factsAcc);
-        observeSessionFactsFile(factsAcc, {
-            bytes: raw.byteLength,
-            lines: signals.line_count,
-        });
-    }
-    const metaSessionId = sanitizeSessionId(signals.session_ids[0]);
-    if (metaSessionId) {
-        base.claude_session_id = metaSessionId;
-    }
-    const primaryCwd = signals.cwds[0] ?? null;
-    if (primaryCwd) {
-        base.local_cwd = primaryCwd;
-        base.cwd_basename = (path.win32.isAbsolute(primaryCwd) ? path.win32 : path.posix).basename(primaryCwd) || null;
-        base.cwd_hash = shortHash(primaryCwd);
-    }
+    const read = session.mainByteSize > CLAUDE_SESSION_MAX_FILE_BYTES
+        ? await streamOversizedMain(session, base, factsAcc)
+        : await readMainSignals(session, base, factsAcc);
+    if (typeof read === "string")
+        return skippedResult(base, read);
+    const signals = read;
+    applySessionMetadata(base, signals);
     if (signals.line_count === 0 || signals.parse_error_count === signals.line_count) {
         return {
             ...base,
@@ -131,15 +54,7 @@ export async function attributeOneSession(session, worktrees, collectionRoots) {
         extraSignals.push("main_file_oversized");
     if (isSchemaDriftSuspected(signals))
         extraSignals.push("schema_drift_suspected");
-    const sidecarFiles = isRawEvidenceUploadableAttributionState(outcome.state, outcome.worktree !== null) && outcome.worktree
-        ? await collectSidecarDiagnostics(session.sidecars, outcome.worktree, factsAcc)
-        : session.sidecars.map((sidecar) => ({
-            local_path: sidecar.local_path,
-            file_name: sidecar.file_name,
-            byte_size: sidecar.byteSize,
-            content_hash_sha256: null,
-            skipped_reason: null,
-        }));
+    const sidecarFiles = await collectSessionSidecars(session, outcome, factsAcc);
     return {
         ...base,
         session_facts: finalizeSessionFacts(factsAcc),
@@ -152,6 +67,105 @@ export async function attributeOneSession(session, worktrees, collectionRoots) {
         sidecar_files: sidecarFiles,
     };
 }
+function createSessionBase(session) {
+    const fileName = path.basename(session.mainFile);
+    return {
+        file_path: session.mainFile,
+        file_name: fileName,
+        claude_session_id: sessionIdFromFileName(fileName) ?? shortHash(session.mainFile),
+        cwd_basename: null,
+        cwd_hash: null,
+        session_file_mtime: new Date(session.mainMtimeMs).toISOString(),
+        session_file_mtime_ms: session.mainMtimeMs,
+        session_recency_ms: session.recencyMs,
+        byte_size: session.mainByteSize,
+        content_hash_sha256: null,
+        main_file_oversized: false,
+        oversized_lines_skipped: 0,
+        sidecars_capped: session.sidecarsCapped,
+        sidecar_files: [],
+        session_facts: null,
+    };
+}
+async function streamOversizedMain(session, base, factsAcc) {
+    // D7: stream the oversized main so metadata signals remain available. The
+    // bytes themselves are not uploaded until the collection ceiling changes.
+    let streamed;
+    try {
+        streamed = await streamMainSignals(session.mainFile, factsAcc);
+    }
+    catch (error) {
+        // A read race on one oversized main must not abort the whole scan; honor
+        // the per-file skip contract. Per session, so worth a line each time:
+        // this is a whole session nobody will ever coach on (BLI-3238).
+        console.error("[claude-attribution] oversized session could not be streamed, skipping it", JSON.stringify({
+            reason: "file_read_failed",
+            stage: "stream_oversized_main",
+            byte_size: session.mainByteSize,
+            ...describeError(error),
+        }));
+        return "file_read_failed";
+    }
+    observeSessionFactsFile(factsAcc, {
+        bytes: streamed.byteSize,
+        lines: streamed.signals.line_count,
+    });
+    base.content_hash_sha256 = streamed.contentHash;
+    base.byte_size = streamed.byteSize;
+    base.main_file_oversized = true;
+    base.oversized_lines_skipped = streamed.oversizedLinesSkipped;
+    return streamed.signals;
+}
+async function readMainSignals(session, base, factsAcc) {
+    let raw;
+    try {
+        raw = await fs.readFile(session.mainFile);
+    }
+    catch (error) {
+        console.error("[claude-attribution] session file unreadable, skipping it", JSON.stringify({
+            reason: "file_read_failed",
+            stage: "read_main",
+            byte_size: session.mainByteSize,
+            ...describeError(error),
+        }));
+        return "file_read_failed";
+    }
+    const content = raw.toString("utf8");
+    base.content_hash_sha256 = sha256(raw);
+    base.byte_size = raw.byteLength;
+    if (content.trim() === "") {
+        return "empty_file";
+    }
+    const signals = extractClaudeSessionSignals(content, factsAcc);
+    observeSessionFactsFile(factsAcc, {
+        bytes: raw.byteLength,
+        lines: signals.line_count,
+    });
+    return signals;
+}
+function applySessionMetadata(base, signals) {
+    const metaSessionId = sanitizeSessionId(signals.session_ids[0]);
+    if (metaSessionId) {
+        base.claude_session_id = metaSessionId;
+    }
+    const primaryCwd = signals.cwds[0] ?? null;
+    if (primaryCwd) {
+        base.local_cwd = primaryCwd;
+        base.cwd_basename = (path.win32.isAbsolute(primaryCwd) ? path.win32 : path.posix).basename(primaryCwd) || null;
+        base.cwd_hash = shortHash(primaryCwd);
+    }
+}
+async function collectSessionSidecars(session, outcome, factsAcc) {
+    return isRawEvidenceUploadableAttributionState(outcome.state, outcome.worktree !== null) && outcome.worktree
+        ? await collectSidecarDiagnostics(session.sidecars, outcome.worktree, factsAcc)
+        : session.sidecars.map((sidecar) => ({
+            local_path: sidecar.local_path,
+            file_name: sidecar.file_name,
+            byte_size: sidecar.byteSize,
+            content_hash_sha256: null,
+            skipped_reason: null,
+        }));
+}
 /**
  * Validates and content-addresses an attributed session's sidecars. Each
  * sidecar's envelope cwd must resolve within the attributed worktree root, or

package/dist/adapters/claude-attribution-signals.js

@@ -75,20 +75,21 @@ function createSignalAccumulator(facts) {
                     contentRecordsWithEnvelope += 1;
             }
         },
-        finalize() {
-            return {
-                session_ids: [...sessionIds],
-                cwds: [...cwds],
-                branches: [...branches],
-                repository_urls: [...repositoryUrls],
-                line_count: lineCount,
-                parse_error_count: parseErrorCount,
-                content_record_count: contentRecordCount,
-                envelope_field_hit_rate: contentRecordCount === 0
-                    ? 1
-                    : contentRecordsWithEnvelope / contentRecordCount,
-            };
-        },
+        finalize: () => finalizeSignals(sessionIds, cwds, branches, repositoryUrls, lineCount, parseErrorCount, contentRecordCount, contentRecordsWithEnvelope),
+    };
+}
+function finalizeSignals(sessionIds, cwds, branches, repositoryUrls, lineCount, parseErrorCount, contentRecordCount, contentRecordsWithEnvelope) {
+    return {
+        session_ids: [...sessionIds],
+        cwds: [...cwds],
+        branches: [...branches],
+        repository_urls: [...repositoryUrls],
+        line_count: lineCount,
+        parse_error_count: parseErrorCount,
+        content_record_count: contentRecordCount,
+        envelope_field_hit_rate: contentRecordCount === 0
+            ? 1
+            : contentRecordsWithEnvelope / contentRecordCount,
     };
 }
 export function isSchemaDriftSuspected(signals) {
@@ -106,8 +107,40 @@ export function isSchemaDriftSuspected(signals) {
 export async function streamMainSignals(filePath, facts) {
     const accumulator = createSignalAccumulator(facts);
     const hash = crypto.createHash("sha256");
-    let oversizedLinesSkipped = 0;
     let byteSize = 0;
+    const lines = bufferSignalLines(accumulator);
+    const { consumeText } = lines;
+    // StringDecoder buffers an incomplete multibyte char across chunk boundaries
+    // so a UTF-8 character split by the read boundary never decodes to a fragment
+    // that could weaken the secret guard or corrupt a cwd signal. The content
+    // hash is over raw bytes (below) and is unaffected either way.
+    const decoder = new StringDecoder("utf8");
+    await new Promise((resolve, reject) => {
+        const stream = createReadStream(filePath);
+        stream.on("data", (chunk) => {
+            const buffer = typeof chunk === "string" ? Buffer.from(chunk) : chunk;
+            hash.update(buffer);
+            byteSize += buffer.byteLength;
+            consumeText(decoder.write(buffer));
+        });
+        stream.on("end", () => {
+            const tail = decoder.end();
+            if (tail)
+                consumeText(tail);
+            lines.finish();
+            resolve();
+        });
+        stream.on("error", reject);
+    });
+    return {
+        signals: accumulator.finalize(),
+        oversizedLinesSkipped: lines.skippedCount(),
+        contentHash: hash.digest("hex"),
+        byteSize,
+    };
+}
+function bufferSignalLines(accumulator) {
+    let oversizedLinesSkipped = 0;
     let pending = "";
     let pendingTruncated = false;
     const flushCompletedLine = (lineText) => {
@@ -123,11 +156,6 @@ export async function streamMainSignals(filePath, facts) {
         pending = "";
         accumulator.processLine(full);
     };
-    // StringDecoder buffers an incomplete multibyte char across chunk boundaries
-    // so a UTF-8 character split by the read boundary never decodes to a fragment
-    // that could weaken the secret guard or corrupt a cwd signal. The content
-    // hash is over raw bytes (below) and is unaffected either way.
-    const decoder = new StringDecoder("utf8");
     const consumeText = (text) => {
         let remaining = text;
         let newlineIndex = remaining.indexOf("\n");
@@ -146,29 +174,11 @@ export async function streamMainSignals(filePath, facts) {
             pending += remaining;
         }
     };
-    await new Promise((resolve, reject) => {
-        const stream = createReadStream(filePath);
-        stream.on("data", (chunk) => {
-            const buffer = typeof chunk === "string" ? Buffer.from(chunk) : chunk;
-            hash.update(buffer);
-            byteSize += buffer.byteLength;
-            consumeText(decoder.write(buffer));
-        });
-        stream.on("end", () => {
-            const tail = decoder.end();
-            if (tail)
-                consumeText(tail);
-            if (pending.length > 0 || pendingTruncated)
-                flushCompletedLine("");
-            resolve();
-        });
-        stream.on("error", reject);
-    });
     return {
-        signals: accumulator.finalize(),
-        oversizedLinesSkipped,
-        contentHash: hash.digest("hex"),
-        byteSize,
+        consumeText, flushCompletedLine,
+        finish: () => { if (pending.length > 0 || pendingTruncated)
+            flushCompletedLine(""); },
+        skippedCount: () => oversizedLinesSkipped
     };
 }
 function normalizePrRepository(repository) {

package/dist/adapters/codex-attribution.js

@@ -120,25 +120,28 @@ async function discoverCodexJsonlFiles(dir, cutoffMs) {
             }
         }
     }
+    logDiscoveryFailures(directoryReadFailedCount, statFailedCount, out.length, firstDirectoryFailure, firstStatFailure);
+    out.sort((a, b) => b.mtimeMs - a.mtimeMs);
+    return {
+        files: out,
+        directoryReadFailedCount,
+        statFailedCount,
+        secretPathSkippedCount,
+    };
+}
+function logDiscoveryFailures(directoryReadFailedCount, statFailedCount, foundFileCount, firstDirectoryFailure, firstStatFailure) {
     if (directoryReadFailedCount > 0 || statFailedCount > 0) {
         console.error("[codex-attribution] Codex sessions were invisible to the walk", JSON.stringify({
             reason: "session_discovery_incomplete",
             directory_read_failed_count: directoryReadFailedCount,
             stat_failed_count: statFailedCount,
-            found_file_count: out.length,
+            found_file_count: foundFileCount,
             ...(firstDirectoryFailure
                 ? { first_directory_failure: firstDirectoryFailure }
                 : {}),
             ...(firstStatFailure ? { first_stat_failure: firstStatFailure } : {}),
         }));
     }
-    out.sort((a, b) => b.mtimeMs - a.mtimeMs);
-    return {
-        files: out,
-        directoryReadFailedCount,
-        statFailedCount,
-        secretPathSkippedCount,
-    };
 }
 function isMissingPathError(error) {
     return (error instanceof Error &&
@@ -162,20 +165,7 @@ function dedupePaths(values) {
     return out;
 }
 async function attributeOneSession(file, worktrees, collectionRoots) {
-    const fileName = path.basename(file.file);
-    const base = {
-        file_path: file.file,
-        file_name: fileName,
-        codex_session_id: sessionIdFromFileName(fileName) ?? shortHash(file.file),
-        session_id_source: sessionIdFromFileName(fileName) ? "file_name" : "path_hash",
-        cwd_basename: null,
-        cwd_hash: null,
-        session_file_mtime: new Date(file.mtimeMs).toISOString(),
-        session_file_mtime_ms: file.mtimeMs,
-        byte_size: file.byteSize,
-        content_hash_sha256: null,
-        session_facts: null,
-    };
+    const base = createSessionBase(file);
     let read;
     try {
         read = await readCodexMetadataSignals(file.file);
@@ -195,17 +185,7 @@ async function attributeOneSession(file, worktrees, collectionRoots) {
     base.byte_size = read.byteSize;
     base.session_facts = read.facts;
     const signals = read.signals;
-    const metaSessionId = sanitizeSessionId(signals.session_ids[0]);
-    if (metaSessionId) {
-        base.codex_session_id = metaSessionId;
-        base.session_id_source = "session_meta";
-    }
-    const primaryCwd = signals.cwds[0] ?? null;
-    if (primaryCwd) {
-        base.local_cwd = primaryCwd;
-        base.cwd_basename = (path.win32.isAbsolute(primaryCwd) ? path.win32 : path.posix).basename(primaryCwd) || null;
-        base.cwd_hash = shortHash(primaryCwd);
-    }
+    applySessionMetadata(base, signals);
     if (signals.line_count === 0 || signals.parse_error_count === signals.line_count) {
         return {
             ...base,
@@ -226,6 +206,35 @@ async function attributeOneSession(file, worktrees, collectionRoots) {
     }, worktrees, { collectionRoots, pathExists: existsSync });
     return { ...base, ...outcome };
 }
+function createSessionBase(file) {
+    const fileName = path.basename(file.file);
+    return {
+        file_path: file.file,
+        file_name: fileName,
+        codex_session_id: sessionIdFromFileName(fileName) ?? shortHash(file.file),
+        session_id_source: sessionIdFromFileName(fileName) ? "file_name" : "path_hash",
+        cwd_basename: null,
+        cwd_hash: null,
+        session_file_mtime: new Date(file.mtimeMs).toISOString(),
+        session_file_mtime_ms: file.mtimeMs,
+        byte_size: file.byteSize,
+        content_hash_sha256: null,
+        session_facts: null,
+    };
+}
+function applySessionMetadata(base, signals) {
+    const metaSessionId = sanitizeSessionId(signals.session_ids[0]);
+    if (metaSessionId) {
+        base.codex_session_id = metaSessionId;
+        base.session_id_source = "session_meta";
+    }
+    const primaryCwd = signals.cwds[0] ?? null;
+    if (primaryCwd) {
+        base.local_cwd = primaryCwd;
+        base.cwd_basename = (path.win32.isAbsolute(primaryCwd) ? path.win32 : path.posix).basename(primaryCwd) || null;
+        base.cwd_hash = shortHash(primaryCwd);
+    }
+}
 function skippedResult(base, reason) {
     return {
         ...base,

package/dist/adapters/codex-session-signals.js

@@ -142,15 +142,17 @@ function absorbCodexSessionLine(state, line) {
     }
     else if (type === "turn_context") {
         addString(state.cwds, payloadRecord["cwd"]);
-        const roots = payloadRecord["workspace_roots"];
-        if (Array.isArray(roots)) {
-            for (const root of roots) {
-                if (typeof root === "string") {
-                    addString(state.workspaceRoots, root);
-                }
-                else if (root && typeof root === "object") {
-                    addString(state.workspaceRoots, root["path"]);
-                }
+        absorbWorkspaceRoots(state, payloadRecord["workspace_roots"]);
+    }
+}
+function absorbWorkspaceRoots(state, roots) {
+    if (Array.isArray(roots)) {
+        for (const root of roots) {
+            if (typeof root === "string") {
+                addString(state.workspaceRoots, root);
+            }
+            else if (root && typeof root === "object") {
+                addString(state.workspaceRoots, root["path"]);
             }
         }
     }

package/dist/adapters/git-state.js

@@ -6,56 +6,7 @@ const execFileAsync = promisify(execFile);
 export async function collectGitState(context, runner = defaultGitCommandRunner()) {
     const startedAt = context.now.toISOString();
     try {
-        const repoRoot = (await runner.runGit(["rev-parse", "--show-toplevel"], context.repoRoot, 2_000)).trim() ||
-            context.repoRoot;
-        const branch = (await runner.runGit(["rev-parse", "--abbrev-ref", "HEAD"], repoRoot, 2_000)).trim() ||
-            context.branch;
-        const porcelain = await runner.runGit(["status", "--porcelain=v1"], repoRoot, 2_000);
-        const unstagedNumstat = await runner.runGit(["diff", "--numstat"], repoRoot, 2_000);
-        const stagedNumstat = await runner.runGit(["diff", "--cached", "--numstat"], repoRoot, 2_000);
-        const fileStats = [...parseNumstat(unstagedNumstat), ...parseNumstat(stagedNumstat)];
-        const addedLines = fileStats.reduce((sum, file) => sum + file.added_lines, 0);
-        const deletedLines = fileStats.reduce((sum, file) => sum + file.deleted_lines, 0);
-        const changedPaths = [
-            ...new Set([
-                ...parsePorcelainPaths(porcelain),
-                ...fileStats.map((file) => file.path),
-            ]),
-        ].sort();
-        const ticketIdFromBranch = parseTicketIdFromBranch(branch);
-        const ticketBindingCandidates = ticketIdFromBranch
-            ? [
-                {
-                    ticket_id: ticketIdFromBranch,
-                    binding_source: "branch_name",
-                    confidence: 0.85,
-                    evidence_labels: [`branch:${branch}`],
-                },
-            ]
-            : [];
-        const facts = {
-            repo_root: repoRoot,
-            branch,
-            changed_file_count: changedPaths.length,
-            added_lines: addedLines,
-            deleted_lines: deletedLines,
-            changed_paths: changedPaths,
-            ticket_id_from_branch: ticketIdFromBranch,
-        };
-        const scan = makeGitScan({
-            context,
-            startedAt,
-            status: "ok",
-            branch,
-            facts,
-            ticketBindingCandidates,
-            diagnosticLabels: [
-                `changed_files:${facts.changed_file_count}`,
-                `added_lines:${facts.added_lines}`,
-                `deleted_lines:${facts.deleted_lines}`,
-            ],
-        });
-        return { scan, facts };
+        return await collectAvailableGitState(context, runner, startedAt);
     }
     catch (error) {
         const scan = makeGitScan({
@@ -72,6 +23,61 @@ export async function collectGitState(context, runner = defaultGitCommandRunner(
         return { scan, facts: { git_unavailable: true } };
     }
 }
+async function collectAvailableGitState(context, runner, startedAt) {
+    const repoRoot = (await runner.runGit(["rev-parse", "--show-toplevel"], context.repoRoot, 2_000)).trim() ||
+        context.repoRoot;
+    const branch = (await runner.runGit(["rev-parse", "--abbrev-ref", "HEAD"], repoRoot, 2_000)).trim() ||
+        context.branch;
+    const porcelain = await runner.runGit(["status", "--porcelain=v1"], repoRoot, 2_000);
+    const unstagedNumstat = await runner.runGit(["diff", "--numstat"], repoRoot, 2_000);
+    const stagedNumstat = await runner.runGit(["diff", "--cached", "--numstat"], repoRoot, 2_000);
+    const fileStats = [...parseNumstat(unstagedNumstat), ...parseNumstat(stagedNumstat)];
+    const addedLines = fileStats.reduce((sum, file) => sum + file.added_lines, 0);
+    const deletedLines = fileStats.reduce((sum, file) => sum + file.deleted_lines, 0);
+    const changedPaths = [
+        ...new Set([
+            ...parsePorcelainPaths(porcelain),
+            ...fileStats.map((file) => file.path),
+        ]),
+    ].sort();
+    const ticketIdFromBranch = parseTicketIdFromBranch(branch);
+    const ticketBindingCandidates = bindBranchTicket(ticketIdFromBranch, branch);
+    const facts = {
+        repo_root: repoRoot,
+        branch,
+        changed_file_count: changedPaths.length,
+        added_lines: addedLines,
+        deleted_lines: deletedLines,
+        changed_paths: changedPaths,
+        ticket_id_from_branch: ticketIdFromBranch,
+    };
+    const scan = makeGitScan({
+        context,
+        startedAt,
+        status: "ok",
+        branch,
+        facts,
+        ticketBindingCandidates,
+        diagnosticLabels: [
+            `changed_files:${facts.changed_file_count}`,
+            `added_lines:${facts.added_lines}`,
+            `deleted_lines:${facts.deleted_lines}`,
+        ],
+    });
+    return { scan, facts };
+}
+function bindBranchTicket(ticketIdFromBranch, branch) {
+    return ticketIdFromBranch
+        ? [
+            {
+                ticket_id: ticketIdFromBranch,
+                binding_source: "branch_name",
+                confidence: 0.85,
+                evidence_labels: [`branch:${branch}`],
+            },
+        ]
+        : [];
+}
 export function parseNumstat(raw) {
     return raw
         .split("\n")