[BUG] /ultrareview fails with "firestore: not found" seed-bundle error across all client-side variables

Preflight Checklist

• [x] I have searched existing issues and this hasn't been reported yet
• [x] This is a single bug report (please file separate reports for different bugs)
• [x] I am using the latest version of Claude Code

What's Wrong?

## Summary

/ultrareview consistently fails to start the remote review session
with the error below. Failure is reproducible across every client-side
variable I could vary; the error is identical each time and appears
pre-billing (no charges accrued).

## Error returned (CLI output)

Ultrareview could not start the remote session: seed bundle: seed bundle
import: failed to import files: error executing request: file not found:
{"code":"not_found","message":"file to import not found: error
retrieving file to import: firestore: not found"}

## Reproductions

8 failures across two days (2026-05-18 and 2026-05-19), all with the
same error string. Variables eliminated as causes:

| Variable | # variants tested | Result |
|-------------------------|------------------------------|---------------|
| Commit SHA | 7 distinct SHAs | All fail |
| Parent commit SHA | 2 distinct empty-tree commits| Both fail |
| Branch name | 8 variants | All fail |
| Chunk file content | Pre-fix + post-fix versions | Both fail |
| Chunk file size | 366 lines + 564 lines | Both fail |
| Filename | kalshi_market_maker.py, wrapper_chunk.py | Both fail |
| Chunk class subject | KalshiWrapper, KalshiWebSocket | Both fail |
| Header docstring style | Full, minimal, rephrased, renamed | All fail |

Repo: a self-contained Python project (no submodules, no LFS).
Branch under review: a single-file chunk with a fresh empty-tree
parent commit, structured per the documented audit workflow
(empty-tree baseline + single-file diff).

## Expected behavior

/ultrareview should start the remote review and either return
findings or a content-specific error.

## Actual behavior

The error returned references Firestore (Google Cloud) and a
"file not found" / "file to import not found" condition. This
appears to be a service-side seed-bundle dependency failing to
load, independent of the client's submission content.

## Cost impact

None observed — failure occurs before any tokens are billed.
Confirmed via account dashboard across all 8 runs.

## Environment

• Claude Code CLI (latest)
• Linux (Ubuntu, AWS EC2 ARM64)
• git 2.x, local-only repo, no remote
• Branch structure: chunk-branch parented on a manufactured

empty-tree commit so merge-base main chunk-branch resolves
to the empty-tree commit (/ultrareview requires this).

## Workaround

Pivoted to running parallel general-purpose agents in the main
Claude Code session as a free audit fallback (validated on
2026-05-19: 25 findings across two ~250-400 line class extracts
in ~10 min, 22 shipped).

Please investigate the seed-bundle Firestore dependency; the bug
appears persistent across days for this account/repo combination.

What Should Happen?

/ultrareview session should begin on the web.

Error Messages/Logs

Ultrareview could not start the remote session: seed bundle: seed bundle
  import: failed to import files: error executing request: file not found:
  {"code":"not_found","message":"file to import not found: error
  retrieving file to import: firestore: not found"}

Steps to Reproduce

## Summary

/ultrareview consistently fails to start the remote review session
with a Firestore "file to import not found" error during seed-bundle
import. Failure is reproducible from a minimal, 23-line repo on this
account; eight prior attempts on my real working repo (a Python
project) failed identically with every client-side variable
independently varied. The error fires pre-billing — no tokens are
consumed.

## Error returned (verbatim CLI output)

Ultrareview could not start the remote session: seed bundle: seed
bundle import: failed to import files: error executing request: file
not found: {"code":"not_found","message":"file to import not found:
error retrieving file to import: firestore: not found"}

## Minimal reproduction (confirmed on my account)

These steps create a fresh git repository with the smallest shape
that triggers the bug: a chunk branch parented on a manufactured
empty-tree commit, with main pointing at that empty-tree commit
so merge-base main review/chunk resolves to it. (This is the
empty-tree-baseline pattern used by Claude Code's documented
audit-without-disturbing-the-working-tree workflow.)

### 1. Create a fresh empty git repository

```bash
mkdir /tmp/ultrareview-repro
cd /tmp/ultrareview-repro
git init -q
git config user.email "repro@example.com"
git config user.name "Repro User"

1. Create the minimal chunk file

cat > chunk_under_review.py << 'PYEOF'
#!/usr/bin/env python3
"""Minimal chunk file for /ultrareview reproduction."""

from typing import Optional

class Calculator:
"""Tiny class under audit."""

def __init__(self, name: str = "default") -> None:
self.name = name
self._total = 0

def add(self, n: int) -> int:
self._total += n
return self._total

def divide(self, n: int) -> Optional[float]:
return self._total / n

@property
def total(self) -> int:
return self._total
PYEOF

1. Build empty-tree baseline + chunk commits via git plumbing

# Git's well-known empty-tree SHA (constant; same in every repo)
EMPTY_TREE=4b825dc642cb6eb9a060e54bf8d69288fbee4904

# Empty-tree baseline commit
EMPTY_COMMIT=$(git commit-tree $EMPTY_TREE -m "Empty baseline for /ultrareview")

# Hash the chunk file into a blob
BLOB=$(git hash-object -w chunk_under_review.py)

# Build a tree containing just that one file (via temp index)
TMPIDX=/tmp/repro-idx-$$
rm -f $TMPIDX
GIT_INDEX_FILE=$TMPIDX git update-index --add --cacheinfo 100644 \
$BLOB chunk_under_review.py
TREE=$(GIT_INDEX_FILE=$TMPIDX git write-tree)
rm -f $TMPIDX

# Build the chunk commit on top of the empty baseline
CHUNK_COMMIT=$(git commit-tree $TREE -p $EMPTY_COMMIT \
-m "chunk: Calculator class for /ultrareview repro")

# Point main at the empty baseline (so merge-base resolves)
git update-ref refs/heads/main $EMPTY_COMMIT

# Create + checkout the review branch (force, because the untracked
# chunk_under_review.py on disk is byte-identical to the blob in
# the chunk tree and would otherwise block the checkout)
git branch review/chunk $CHUNK_COMMIT
git checkout -f -q review/chunk

1. Verify the repo is in the expected shape

git branch -v
# Expected:
# main <empty-commit-sha> Empty baseline for /ultrareview
# * review/chunk <chunk-commit-sha> chunk: Calculator class for /ultrareview repro

git merge-base main review/chunk
# Expected: prints the empty-commit-sha (same as main)

git ls-tree -r review/chunk
# Expected: a single line for chunk_under_review.py

1. Launch Claude Code and run /ultrareview

claude

At the Claude Code prompt:

/ultrareview

Expected behaviour

/ultrareview should start the remote review session, diff
review/chunk against main (the empty-tree baseline), and return
findings on the single file (or a content-specific message like
"file too small to review meaningfully").

Actual behaviour

/ultrareview immediately returns the Firestore seed-bundle error
quoted above. No tokens are billed (verified via account dashboard
across every run). The error fires before any review starts — it's
the remote session bootstrap itself that fails.

Reproductions on my account

┌───────────────────────────────────────────┬──────────────────────┐
│ Run │ Result │
├───────────────────────────────────────────┼──────────────────────┤
│ Minimal repo per the steps above │ Same Firestore error │
├───────────────────────────────────────────┼──────────────────────┤
│ Real-repo chunk M-3 (KalshiWrapper, 514L) │ Same Firestore error │
├───────────────────────────────────────────┼──────────────────────┤
│ Real-repo chunk M-4 (KalshiWebSocket) │ Same Firestore error │
├───────────────────────────────────────────┼──────────────────────┤
│ Real-repo chunk M-3 v1-v5 variants │ Same Firestore error │
├───────────────────────────────────────────┼──────────────────────┤
│ Total: 9 attempts across 2 days │ Identical error each │
└───────────────────────────────────────────┴──────────────────────┘

Variables I independently varied across the 9 attempts — all of
which still produce the identical error:

• Commit SHA (7+ distinct SHAs)
• Parent commit SHA (2 distinct empty-tree commits with different timestamps)
• Branch name (8+ variants)
• Chunk file content (pre-fix + post-fix versions; minimal 23-line repro; 564-line real chunk)
• File name (kalshi_market_maker.py, wrapper_chunk.py, chunk_under_review.py)
• Worktree path (4 distinct paths)
• Chunk subject class (KalshiWrapper + KalshiWebSocket + minimal Calculator)
• Header docstring style (full, minimal, rephrased, renamed)

Triage notes

• The error message references Firestore (Google Cloud) and a

"file to import not found" / seed-bundle import failure. This reads
like a service-side dependency missing from the remote review
worker's startup path — not a client submission validation error.

• /ultrareview ran successfully on this same machine and account

for several chunks on 2026-05-18 morning. Degradation appeared
later that day and has persisted across two days of attempts.

• Whether the bug is universal across accounts (vs scoped to mine)

is something I can't test from a single account. Running the
minimal steps above from a different account would resolve that
question quickly.

Environment

• Claude Code CLI (latest as of 2026-05-19)
• Linux (Ubuntu, AWS EC2 ARM64 Graviton2)
• git 2.x
• Local-only repository (no remote configured)
• No Claude Code plugins or unusual configuration

Workaround

I have pivoted to running parallel general-purpose agents inside the
main Claude Code session as a free audit fallback. On 2026-05-19
this produced 25 findings across two 250-400 line class extracts in
roughly 10 minutes, of which 22 were ranked actionable and shipped
the same day. The /ultrareview cloud review is preferable when
working — please investigate the seed-bundle Firestore dependency.

Claude Model

Opus

Is this a regression?

Yes, this worked in a previous version

Last Working Version

_No response_

Claude Code Version

2.1.138 (Claude Code)

Platform

Anthropic API

Operating System

Ubuntu/Debian Linux

Terminal/Shell

Other

Additional Information

_No response_