[juliusmarminge]

Problem

An agent cloning through the t3_project_clone MCP tool is killed after 120 s, because the tool calls cloneRepository with no options and inherits the deadline meant for the synchronous clone RPC. The failure message doesn't mention the timeout: runClone builds the detail from git's last stderr lines (the reporter got remote: Total 7514 (delta 2859), … pack-reused …) or falls back to "The repository could not be cloned.", so the user and agent suspect credentials or the remote. The UI's "Add project → Git URL" clone of the same repository has no deadline and finishes.

How it was reproduced:

• Dev server on main 32ecd71, fresh database.
• A local smart-HTTP remote throttled so a clone takes about 145 s.
• A Codex thread asked to call t3_project_clone against that remote.
• The remote saw the client hang up at 119.9 s and the tool returned "The repository could not be cloned.". This happened on both runs.
• The UI "Git URL" clone of the same remote finished in 145.1 s.

Change

• t3_project_clone has no deadline: it now passes timeoutMs: null, as the UI's tracked clone already does. T3's providers give its MCP tools a 65-minute call budget, and interrupting the call interrupts git.
• The deadline moves into runClone: git runs with no driver deadline, and runClone applies the budget with Effect.timeoutOrElse.
• A clone that hits its deadline says so: the failure detail is "The clone timed out after 2m." instead of the stderr tail. Only the synchronous sourceControlCloneRepository RPC still has a deadline (120 s, unchanged).
• Unchanged: interrupting git.execute closes the scope that owns the git process, the same way the driver's own timeout did. Real git failures keep the stderr-tail detail. A timeout is not treated as an SSH rejection, so it never starts the HTTPS retry.

Scope and approval

Fixes #27567

Triaged via the automated issue flow.

Verification

Focused tests. Both fail on the test-only commit 787ed2b and pass at the fix commit:

• handlers.test.ts, "an agent's clone is not cut off while git is still transferring". On main it fails with OrchestratorMcpFailure: The repository could not be cloned. after the test clock advances 10 minutes.
• SourceControlRepositoryService.test.ts, "says a clone that ran out of time timed out, not git's last remote line". On main the detail is remote: Total 4 (delta 0), reused 0 (delta 0), pack-reused 0.

handlers.test.ts, SourceControlRepositoryService.test.ts and ProjectCloneTracker.test.ts pass 45/45, and vp run check:changed passes (format, lint, knip, typecheck, tests).

Runtime transcript. This is a server-only fix with no rendered surface, so the evidence is a real run, not screenshots. Each side ran on a fresh dev server with the same agent prompt and the same throttled remote. Server trace spans:

	Before (main 32ecd71)	After (fix a9319b8)
Agent t3_project_clone	runGitCommand 120001 ms Interrupted → GitCommandError … Git command timed out. → tool result "The repository could not be cloned."; destination empty	runGitCommand 145464 ms Success → tool result {"cwd":"…/clones/mcp-fix","remoteUrl":"http://127.0.0.1:18432/slow.git","repository":null}; checkout present
UI "Git URL" clone, same remote	runGitCommand 145494 ms Success	the fix does not change this path; not rerun

Not checked:

• The timeout wording of the synchronous RPC (mobile and older clients) is covered by the unit test only, not a live run.
• Not tested: whether every provider's MCP client cancels a call on abort.
• Not tested: forwarded clones over T3 Connect. They still meet the edge's own idle limit, and that predates this change.

Synthetic slow remote used for the run (not committed)

#!/usr/bin/env python3
"""Smart-HTTP git remote that trickles upload-pack responses, so a clone takes minutes.

Usage: slow_git_http.py <project_root> <port> <bytes_per_second>
Synthetic fixture for pingdotgg/t3code#27567; not part of the PR.
"""
import os
import subprocess
import sys
import time
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
from urllib.parse import urlsplit

ROOT, PORT, RATE = sys.argv[1], int(sys.argv[2]), int(sys.argv[3])


class Handler(BaseHTTPRequestHandler):
    protocol_version = "HTTP/1.0"

    def _run(self, method):
        parts = urlsplit(self.path)
        length = int(self.headers.get("Content-Length") or 0)
        body = self.rfile.read(length) if length else b""
        env = {
            "PATH": os.environ["PATH"],
            "GIT_PROJECT_ROOT": ROOT,
            "GIT_HTTP_EXPORT_ALL": "1",
            "REQUEST_METHOD": method,
            "PATH_INFO": parts.path,
            "QUERY_STRING": parts.query,
            "CONTENT_TYPE": self.headers.get("Content-Type") or "",
            "CONTENT_LENGTH": str(len(body)),
            "HTTP_GIT_PROTOCOL": self.headers.get("Git-Protocol") or "",
            "REMOTE_ADDR": self.client_address[0],
        }
        if self.headers.get("Content-Encoding"):
            env["HTTP_CONTENT_ENCODING"] = self.headers["Content-Encoding"]
        out = subprocess.run(["git", "http-backend"], input=body, env=env, capture_output=True).stdout
        head, _, payload = out.partition(b"\r\n\r\n")
        status = 200
        headers = []
        for line in head.decode().split("\r\n"):
            if not line:
                continue
            key, _, value = line.partition(":")
            if key.lower() == "status":
                status = int(value.strip().split()[0])
            else:
                headers.append((key, value.strip()))
        self.send_response(status)
        for key, value in headers:
            self.send_header(key, value)
        self.end_headers()
        slow = method == "POST" and parts.path.endswith("git-upload-pack")
        start = time.time()
        sys.stderr.write(f"{time.strftime('%H:%M:%S')} {method} {parts.path} {len(payload)}B slow={slow}\n")
        if not slow:
            self.wfile.write(payload)
            return
        chunk = max(1, RATE // 4)
        try:
            for offset in range(0, len(payload), chunk):
                self.wfile.write(payload[offset : offset + chunk])
                self.wfile.flush()
                time.sleep(0.25)
        except (BrokenPipeError, ConnectionResetError):
            sys.stderr.write(f"{time.strftime('%H:%M:%S')} client hung up after {time.time() - start:.1f}s\n")
            return
        sys.stderr.write(f"{time.strftime('%H:%M:%S')} sent pack in {time.time() - start:.1f}s\n")

    def do_GET(self):
        self._run("GET")

    def do_POST(self):
        self._run("POST")

    def log_message(self, *args):
        pass


ThreadingHTTPServer(("127.0.0.1", PORT), Handler).serve_forever()

Serve a bare repository with about 2.6 MB of random data at 18000 B/s: slow_git_http.py <root> 18432 18000.

Claude Opus 5.5 (claude-opus-5-5) via Claude Code in T3 Code; reviewed by GPT-6.1-sol (Codex) and Claude Opus 5.5.

🤖 Generated with Claude Code

[macroscopeapp]

Approvability

Verdict: Needs Human Approval

Macroscope's review found this PR requires human approval — Agent clones now run beyond the previous two-minute deadline, while other callers retain it and receive clearer timeout errors. Human review is required for this default-behavior change to rely on MCP call limits and cancellation.

No code changes detected at fda8222. Prior analysis still applies.

^{You can add or adjust custom eligibility rules. Learn more.}

[github-actions]

Thread transfer impact

✅ Thread transfer remains within every enforced ceiling.

Provider	Metric	Main baseline	This PR	Impact	PR ceiling
Codex	Total thread wire	5.0 KiB	5.0 KiB	0 B (0.0%)	6.8 KiB	✅
Codex	Thread snapshot wire	3.8 KiB	3.8 KiB	0 B (0.0%)	4.9 KiB	✅
Codex	Live turn WebSocket wire	1.2 KiB	1.2 KiB	0 B (0.0%)	2.0 KiB	✅
Codex	Live turn WebSocket decoded	21.5 KiB	21.5 KiB	0 B (0.0%)	24.4 KiB	✅
Codex	Live turn messages	1	1	0 (0.0%)	8	✅
Claude	Total thread wire	5.0 KiB	5.0 KiB	0 B (0.0%)	6.8 KiB	✅
Claude	Thread snapshot wire	3.8 KiB	3.8 KiB	0 B (0.0%)	4.9 KiB	✅
Claude	Live turn WebSocket wire	1.2 KiB	1.2 KiB	0 B (0.0%)	2.0 KiB	✅
Claude	Live turn WebSocket decoded	21.9 KiB	21.9 KiB	0 B (0.0%)	24.4 KiB	✅
Claude	Live turn messages	1	1	0 (0.0%)	8	✅

Baseline: b3fdf2b · PR result: fda8222 · Source CI: success

Scenario and decoded snapshot size

10 historical turns, 5 command tools per turn, 878.9 KiB retained MCP result per historical turn, and a 1.05 MiB retained result in the measured turn.

• Codex decoded thread snapshot: 108.5 KiB
• Claude decoded thread snapshot: 108.8 KiB

Updated in place by a trusted workflow. PR artifacts are strictly validated and never executed.

[coderabbitai]

Important

Review skipped

Review was skipped as selected files did not have any reviewable changes.

Run configuration

• Source mode: Auto
• Repository: pingdotgg/t3code
• Branch: fix/issue-27567
• File: .coderabbit.config.ts
• Commit: fda8222
• Layers: Repository TS config
• Review profile: CHILL
• Plan: Team
• Run ID: 3f21b6fe-75d9-41bf-ace3-e254a06bddb3

Commits

Reviewing files that changed from the base of the PR and between a1cb3b9 and fda8222.

You can disable this status message by setting the reviews.review_status to false in the CodeRabbit configuration file.

Use the checkbox below for a quick retry:

• Trigger review

No actionable comments were generated in the recent review.

Walkthrough

The repository service now applies clone timeouts outside the Git command. The MCP project clone call disables that deadline. Tests cover timeout errors and clones that remain active beyond ten minutes.

Changes: Clone timeout behavior

Layer / File(s)	Summary
Repository clone deadline apps/server/src/sourceControl/SourceControlRepositoryService.ts, apps/server/src/sourceControl/SourceControlRepositoryService.test.ts	runClone disables the Git command timeout and applies the configured deadline around clone execution. A null timeout disables the deadline. The test checks that expiration reports a timeout.
MCP clone timeout override apps/server/src/mcp/toolkits/project/handlers.ts, apps/server/src/mcp/toolkits/project/handlers.test.ts	t3_project_clone passes timeoutMs: null to cloneRepository. The test holds the mocked clone beyond ten minutes and checks for the destination path.

Estimated code review effort: 3 (Moderate) | ~20 minutes

Change: Bug fix · Severity of issue fixed: Medium

Possibly related issues

• [Bug]: Clone into the empty folder of an earlier failed clone fails with "Failed to create clone project" after a server restart #33381: The issue describes failed clones that can leave an empty project. It identifies the t3_project_clone timeout as one way a clone can stop part-way, which this change addresses by disabling that timeout for the MCP call.

Suggested reviewers: t3dotgg

Merge Risk: Minimal · previous review a1cb3

The clone timeout change is mergeable after normal checks; the unverified cleanup and cancellation paths remain worth checking during rollout.

Pre-merge checks: 4

Check name	Status	Explanation
Title check		The title clearly and concisely describes the main change: preventing agent repository clones from being interrupted after two minutes.
Description check		The description is complete and directly related to the change. It explains the problem, implementation, scope, focused verification, runtime results, and known limitations. It references the linked i…
Linked Issues check		Issue [#27567] requires the MCP clone path to run beyond 120 seconds and to identify clone timeouts. t3_project_clone now passes { timeoutMs: null }. runClone disables the Git driver deadline, a…
Out of Scope Changes check		The production changes are limited to the MCP clone option and the shared clone timeout/error handling required by [#27567]. The added tests verify these behaviors. No unrelated feature or unrelated c…

Full details: Description check

Explanation

The description is complete and directly related to the change. It explains the problem, implementation, scope, focused verification, runtime results, and known limitations. It references the linked issue, although it does not include explicit maintainer approval or a detailed approval exemption rationale.

Full details: Linked Issues check

Explanation

Issue [#27567] requires the MCP clone path to run beyond 120 seconds and to identify clone timeouts. t3_project_clone now passes { timeoutMs: null }. runClone disables the Git driver deadline, applies the selected deadline with Effect.timeoutOrElse, and returns The clone timed out after ... on expiry. The default remains 120 seconds for callers that omit timeoutMs. The added MCP and service tests cover long-running MCP clones and timeout error text.

Full details: Out of Scope Changes check

Explanation

The production changes are limited to the MCP clone option and the shared clone timeout/error handling required by [#27567]. The added tests verify these behaviors. No unrelated feature or unrelated code change is shown.

Finishing Touches

Generate docstrings

• Commit to this branch
• Create a new PR

Generate unit tests (beta)

• Commit to this branch
• Create a new PR

• Autofix · Keep fixing CodeRabbit findings and required CI, and resolving merge conflicts

Recent review info

Run configuration

• Source mode: Auto
• Repository: pingdotgg/t3code
• Branch: fix/issue-27567
• File: .coderabbit.config.ts
• Commit: a1cb3b9
• Layers: Repository TS config
• Review profile: CHILL
• Plan: Team
• Run ID: 3f7cb954-8c01-4f7a-a1dc-15deb2f66efa

Commits

Reviewing files that changed from the base of the PR and between a9319b8 and a1cb3b9.

Files selected for processing: 4

• apps/server/src/mcp/toolkits/project/handlers.test.ts
• apps/server/src/mcp/toolkits/project/handlers.ts
• apps/server/src/sourceControl/SourceControlRepositoryService.test.ts
• apps/server/src/sourceControl/SourceControlRepositoryService.ts

Included review availability: This review used your included allowance. Your plan provides up to 10 included reviews per hour; 0 remain after this review.

[juliusmarminge]

The automated pipeline stopped on this pull request and will not merge it:

someone else pushed to fix/issue-27567 (head is now a9319b8); the pipeline does not build on commits it did not review

It stays open for a person to finish or close.

[juliusmarminge]

Evidence

Real T3 servers, fresh isolated databases, identical 145-second Git smart-HTTP transfers. Initialize MCP; call t3_project_clone, WebSocket sourceControl.cloneRepository, and the tracked projectClone.start control into three fresh destinations. Verify returned results and checked-out Git HEAD.

Before	After
b3fdf2b10f	fda8222a97
Before recording · Transcript	After recording · Transcript

Base MCP fails at 120.5s; head MCP succeeds at 145.5s. The retained WebSocket deadline changes from generic failure to The clone timed out after 2m. The tracked control completes on both. All transfers use byte-identical upload-pack data, and all successful checkouts have the same Git HEAD. Opening requests remain visible in both stills. Videos render the actual runtime transcripts at original timing; they are not browser captures.

Driver · Seed · Credential setup helper · Capture renderer · Reproduction instructions

AI-assisted; verified with the tests and tools listed above.

Not shown:

• No provider turn or web UI interaction was captured; the real MCP and WebSocket endpoints were driven directly. The tracked Add project control was exercised through its RPC.
• Explicit user cancellation and MCP budget exhaustion were not exercised; the runs demonstrate completion beyond 120 seconds and the retained deadline's explicit timeout response.