diff --git a/bun.lock b/bun.lock
index 485f0d1f..926052df 100644
--- a/bun.lock
+++ b/bun.lock
@@ -4,6 +4,7 @@
     "": {
       "name": "vibesdk",
       "dependencies": {
+        "@ashishkumar472/cf-git": "^1.0.4",
         "@cloudflare/containers": "^0.0.28",
         "@cloudflare/sandbox": "0.4.7",
         "@noble/ciphers": "^1.3.0",
@@ -141,6 +142,8 @@
 
     "@apidevtools/json-schema-ref-parser": ["@apidevtools/json-schema-ref-parser@11.9.3", "", { "dependencies": { "@jsdevtools/ono": "^7.1.3", "@types/json-schema": "^7.0.15", "js-yaml": "^4.1.0" } }, "sha512-60vepv88RwcJtSHrD6MjIL6Ta3SOYbgfnkHb+ppAVK+o9mXprRtulx7VlRl3lN3bbvysAfCS7WMVfhUYemB0IQ=="],
 
+    "@ashishkumar472/cf-git": ["@ashishkumar472/cf-git@1.0.4", "", { "dependencies": { "clean-git-ref": "^2.0.1", "crc-32": "^1.2.0", "diff3": "0.0.3", "ignore": "^5.1.4", "is-git-ref-name-valid": "^1.0.0", "minimisted": "^2.0.0", "pako": "^1.0.10", "pify": "^4.0.1", "readable-stream": "^3.4.0", "simple-get": "^4.0.1" }, "bin": { "isogit": "cli.cjs" } }, "sha512-ss0BXxS51VdA1fbU5xS6F+DffaCss7qlRwkAITHW3kyYj/yuM/W31gyO9tsb4RmpCk/dmf8a+8jR1NDZd7O70Q=="],
+
     "@babel/code-frame": ["@babel/code-frame@7.27.1", "", { "dependencies": { "@babel/helper-validator-identifier": "^7.27.1", "js-tokens": "^4.0.0", "picocolors": "^1.1.1" } }, "sha512-cjQ7ZlQ0Mv3b47hABuTevyTuYN4i+loJKGeV9flcCgIK37cCXRh+L1bd3iBHlynerhQ7BhCkn2BPbQUL+rGqFg=="],
 
     "@babel/compat-data": ["@babel/compat-data@7.28.4", "", {}, "sha512-YsmSKC29MJwf0gF8Rjjrg5LQCmyh+j/nD8/eP7f+BeoQTKYqs9RoWbjGOdy0+1Ekr68RJZMUOPVQaQisnIo4Rw=="],
@@ -1135,6 +1138,8 @@
 
     "class-variance-authority": ["class-variance-authority@0.7.1", "", { "dependencies": { "clsx": "^2.1.1" } }, "sha512-Ka+9Trutv7G8M6WT6SeiRWz792K5qEqIGEGzXKhAE6xOWAY6pPH8U+9IY3oCMv6kqTmLsv7Xh/2w2RigkePMsg=="],
 
+    "clean-git-ref": ["clean-git-ref@2.0.1", "", {}, "sha512-bLSptAy2P0s6hU4PzuIMKmMJJSE6gLXGH1cntDu7bWJUksvuM+7ReOK61mozULErYvP6a15rnYl0zFDef+pyPw=="],
+
     "cliui": ["cliui@8.0.1", "", { "dependencies": { "string-width": "^4.2.0", "strip-ansi": "^6.0.1", "wrap-ansi": "^7.0.0" } }, "sha512-BSeNnyus75C4//NQ9gQt1/csTXyo/8Sb+afLAkzAptFuMsod9HFokGNudZpi/oQV73hnVK+sR+5PVRMd+Dr7YQ=="],
 
     "cloudflare": ["cloudflare@4.5.0", "", { "dependencies": { "@types/node": "^18.11.18", "@types/node-fetch": "^2.6.4", "abort-controller": "^3.0.0", "agentkeepalive": "^4.2.1", "form-data-encoder": "1.7.2", "formdata-node": "^4.3.2", "node-fetch": "^2.6.7" } }, "sha512-fPcbPKx4zF45jBvQ0z7PCdgejVAPBBCZxwqk1k7krQNfpM07Cfj97/Q6wBzvYqlWXx/zt1S9+m8vnfCe06umbQ=="],
@@ -1183,6 +1188,8 @@
 
     "cosmiconfig": ["cosmiconfig@8.3.6", "", { "dependencies": { "import-fresh": "^3.3.0", "js-yaml": "^4.1.0", "parse-json": "^5.2.0", "path-type": "^4.0.0" }, "peerDependencies": { "typescript": ">=4.9.5" }, "optionalPeers": ["typescript"] }, "sha512-kcZ6+W5QzcJ3P1Mt+83OUv/oHFqZHIx8DuxG6eZ5RGMERoLqp4BuGjhHLYGK+Kf5XVkQvqBSmAy/nGWN3qDgEA=="],
 
+    "crc-32": ["crc-32@1.2.2", "", { "bin": { "crc32": "bin/crc32.njs" } }, "sha512-ROmzCKrTnOwybPcJApAA6WBWij23HVfGVNKqqrZpuyZOHqK2CwHSvpGuyt/UNNvaIjEd8X5IFGp4Mh+Ie1IHJQ=="],
+
     "create-ecdh": ["create-ecdh@4.0.4", "", { "dependencies": { "bn.js": "^4.1.0", "elliptic": "^6.5.3" } }, "sha512-mf+TCx8wWc9VpuxfP2ht0iSISLZnt0JgWlrOKZiNqyUZWnjIaCIVNQArMHnCZKfEYRg6IM7A+NeJoN8gf/Ws0A=="],
 
     "create-hash": ["create-hash@1.2.0", "", { "dependencies": { "cipher-base": "^1.0.1", "inherits": "^2.0.1", "md5.js": "^1.3.4", "ripemd160": "^2.0.1", "sha.js": "^2.4.0" } }, "sha512-z00bCGNHDG8mHAkP7CtT1qVu+bFQUPjYq/4Iv3C3kWjTFV10zIjfSoeqXo9Asws8gwSHDGj/hl2u4OGIjapeCg=="],
@@ -1245,6 +1252,8 @@
 
     "decode-named-character-reference": ["decode-named-character-reference@1.2.0", "", { "dependencies": { "character-entities": "^2.0.0" } }, "sha512-c6fcElNV6ShtZXmsgNgFFV5tVX2PaV4g+MOAkb8eXHvn6sryJBrZa9r0zV6+dtTyoCKxtDy5tyQ5ZwQuidtd+Q=="],
 
+    "decompress-response": ["decompress-response@6.0.0", "", { "dependencies": { "mimic-response": "^3.1.0" } }, "sha512-aW35yZM6Bb/4oJlZncMH2LCoZtJXTRxES17vE3hoRiowU2kWHaJKFkSBDnDR+cm9J+9QhXmREyIfv0pji9ejCQ=="],
+
     "dedent": ["dedent@1.7.0", "", { "peerDependencies": { "babel-plugin-macros": "^3.1.0" }, "optionalPeers": ["babel-plugin-macros"] }, "sha512-HGFtf8yhuhGhqO07SV79tRp+br4MnbdjeVxotpn1QBl30pcLLCQjX5b2295ll0fv8RKDKsmWYrl05usHM9CewQ=="],
 
     "deep-eql": ["deep-eql@5.0.2", "", {}, "sha512-h5k/5U50IJJFpzfL6nO9jaaumfjO/f2NjK/oYB2Djzm4p9L+3T9qWpZqZ2hAbLPuuYq9wrU08WQyBTL5GbPk5Q=="],
@@ -1281,6 +1290,8 @@
 
     "diff-sequences": ["diff-sequences@29.6.3", "", {}, "sha512-EjePK1srD3P08o2j4f0ExnylqRs5B9tJjcp9t1krH2qRi8CCdsYfwe9JgSLurFBWwq4uOlipzfk5fHNvwFKr8Q=="],
 
+    "diff3": ["diff3@0.0.3", "", {}, "sha512-iSq8ngPOt0K53A6eVr4d5Kn6GNrM2nQZtC740pzIriHtn4pOQ2lyzEXQMBeVcWERN0ye7fhBsk9PbLLQOnUx/g=="],
+
     "diffie-hellman": ["diffie-hellman@5.0.3", "", { "dependencies": { "bn.js": "^4.1.0", "miller-rabin": "^4.0.0", "randombytes": "^2.0.0" } }, "sha512-kqag/Nl+f3GwyK25fhUMYj81BUOrZ9IuJsjIcDE5icNM9FJHAVm3VcUDxdLPoQtTuUylWm6ZIknYJwwaPxsUzg=="],
 
     "doctrine": ["doctrine@2.1.0", "", { "dependencies": { "esutils": "^2.0.2" } }, "sha512-35mSku4ZXK0vfCuHEDAwt55dg2jNajHZ1odvF+8SSr82EsZY4QmXfuWso8oEd8zRhVObSN18aM0CjSdoBX7zIw=="],
@@ -1641,6 +1652,8 @@
 
     "is-generator-function": ["is-generator-function@1.1.0", "", { "dependencies": { "call-bound": "^1.0.3", "get-proto": "^1.0.0", "has-tostringtag": "^1.0.2", "safe-regex-test": "^1.1.0" } }, "sha512-nPUB5km40q9e8UfN/Zc24eLlzdSf9OfKByBw9CIdw4H1giPMeA0OIJvbchsCu4npfI2QcMVBsGEBHKZ7wLTWmQ=="],
 
+    "is-git-ref-name-valid": ["is-git-ref-name-valid@1.0.0", "", {}, "sha512-2hLTg+7IqMSP9nNp/EVCxzvAOJGsAn0f/cKtF8JaBeivjH5UgE/XZo3iJ0AvibdE7KSF1f/7JbjBTB8Wqgbn/w=="],
+
     "is-glob": ["is-glob@4.0.3", "", { "dependencies": { "is-extglob": "^2.1.1" } }, "sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg=="],
 
     "is-hexadecimal": ["is-hexadecimal@2.0.1", "", {}, "sha512-DgZQp241c8oO6cA1SbTEWiXeoxV42vlcJxgH+B3hi1AiqqKruZR3ZGF8In3fj4+/y/7rHvlOZLZtgJ/4ttYGZg=="],
@@ -1955,6 +1968,8 @@
 
     "mimic-fn": ["mimic-fn@2.1.0", "", {}, "sha512-OqbOk5oEQeAZ8WXWydlu9HJjz9WVdEIvamMCcXmuqUYjTknH/sqsWvhQ3vgwKFRR1HpjvNBKQ37nbJgYzGqGcg=="],
 
+    "mimic-response": ["mimic-response@3.1.0", "", {}, "sha512-z0yWI+4FDrrweS8Zmt4Ej5HdJmky15+L2e6Wgn3+iK5fWzb6T3fhNFq2+MeTRb064c6Wr4N/wv0DzQTjNzHNGQ=="],
+
     "miniflare": ["miniflare@4.20251001.0", "", { "dependencies": { "@cspotcode/source-map-support": "0.8.1", "acorn": "8.14.0", "acorn-walk": "8.3.2", "exit-hook": "2.2.1", "glob-to-regexp": "0.4.1", "sharp": "^0.33.5", "stoppable": "1.1.0", "undici": "7.14.0", "workerd": "1.20251001.0", "ws": "8.18.0", "youch": "4.1.0-beta.10", "zod": "3.22.3" }, "bin": { "miniflare": "bootstrap.js" } }, "sha512-OHd31D2LT8JH+85nVXClV0Z18jxirCohzKNAcZs/fgt4mIkUDtidX3VqR3ovAM0jWooNxrFhB9NSs3iDbiJF7Q=="],
 
     "minimalistic-assert": ["minimalistic-assert@1.0.1", "", {}, "sha512-UtJcAD4yEaGtjPezWuO9wC4nwUnVH/8/Im3yEHQP4b67cXlD/Qr9hdITCU1xDbSEXg2XKNaP8jsReV7vQd00/A=="],
@@ -1965,6 +1980,8 @@
 
     "minimist": ["minimist@1.2.8", "", {}, "sha512-2yyAR8qBkN3YuheJanUpWC5U3bb5osDywNB8RzDVlDwDHbocAJveqqj1u8+SVD7jkWT4yvsHCpWqqWqAxb0zCA=="],
 
+    "minimisted": ["minimisted@2.0.1", "", { "dependencies": { "minimist": "^1.2.5" } }, "sha512-1oPjfuLQa2caorJUM8HV8lGgWCc0qqAO1MNv/k05G4qslmsndV/5WdNZrqCiyqiz3wohia2Ij2B7w2Dr7/IyrA=="],
+
     "minipass": ["minipass@7.1.2", "", {}, "sha512-qOOzS1cBTWYF4BH8fVePDBOO9iptMnGUEZwNc/cMWnTV2nVLZ7VoNWEPHkYczZA0pdoA7dl6e7FL659nX9S2aw=="],
 
     "minizlib": ["minizlib@3.0.2", "", { "dependencies": { "minipass": "^7.1.2" } }, "sha512-oG62iEk+CYt5Xj2YqI5Xi9xWUeZhDI8jjQmC5oThVH5JGCTgIjr7ciJDzC7MBzYd//WvR1OTmP5Q38Q8ShQtVA=="],
@@ -2097,6 +2114,8 @@
 
     "picomatch": ["picomatch@4.0.3", "", {}, "sha512-5gTmgEY/sqK6gFXLIsQNH19lWb4ebPDLA4SdLP7dsWkIXHWlG66oPuVvXSGFPppYZz8ZDZq0dYYrbHfBCVUb1Q=="],
 
+    "pify": ["pify@4.0.1", "", {}, "sha512-uB80kBFb/tfd68bVleG9T5GGsGPjJrLAUpR5PZIrhBnIaRTQRjqdJSsIKkOP6OAIFbj7GOrcudc5pNjZ+geV2g=="],
+
     "pirates": ["pirates@4.0.7", "", {}, "sha512-TfySrs/5nm8fQJDcBDuUng3VOUKsd7S+zqvbOTiGXHfxX4wK31ard+hoNuvkicM/2YFzlpDgABOevKSsB4G/FA=="],
 
     "pkce-challenge": ["pkce-challenge@5.0.0", "", {}, "sha512-ueGLflrrnvwB3xuo/uGob5pd5FN7l0MsLf0Z87o/UQmRtwjvfylfc9MurIxRAWywCYTgrvpXBcqjV4OfCYGCIQ=="],
@@ -2279,6 +2298,10 @@
 
     "signal-exit": ["signal-exit@4.1.0", "", {}, "sha512-bzyZ1e88w9O1iNJbKnOlvYTrWPDl46O1bG0D3XInv+9tkPrxrN8jUUTiFlDkkmKWgn1M6CfIA13SuGqOa9Korw=="],
 
+    "simple-concat": ["simple-concat@1.0.1", "", {}, "sha512-cSFtAPtRhljv69IK0hTVZQ+OfE9nePi/rtJmw5UjHeVyVroEqJXP1sFztKUy1qU+xvz3u/sfYJLa947b7nAN2Q=="],
+
+    "simple-get": ["simple-get@4.0.1", "", { "dependencies": { "decompress-response": "^6.0.0", "once": "^1.3.1", "simple-concat": "^1.0.0" } }, "sha512-brv7p5WgH0jmQJr1ZDDfKDOSeWWg+OVypG99A/5vYGPqJ6pxiaHLy8nxtFjBA7oMa01ebA9gfh1uMCFqOuXxvA=="],
+
     "simple-swizzle": ["simple-swizzle@0.2.2", "", { "dependencies": { "is-arrayish": "^0.3.1" } }, "sha512-JA//kQgZtbuY83m+xT+tXJkmJncGMTFT+C+g2h2R9uxkYIrE2yy9sgmcLhCnw57/WSD+Eh3J97FPEDFnbXnDUg=="],
 
     "sisteransi": ["sisteransi@1.0.5", "", {}, "sha512-bLGGlR1QxBcynn2d5YmDX4MGjlZvy2MRBDRNHLJ8VI6l6+9FUiyTFNJ0IveOSP0bcXgVDPRcfGqA0pjaqUpfVg=="],
diff --git a/package.json b/package.json
index 83d45889..76e8b48c 100644
--- a/package.json
+++ b/package.json
@@ -32,6 +32,7 @@
 		"knip:exports": "knip --exports"
 	},
 	"dependencies": {
+		"@ashishkumar472/cf-git": "1.0.4",
 		"@cloudflare/containers": "^0.0.28",
 		"@cloudflare/sandbox": "0.4.7",
 		"@noble/ciphers": "^1.3.0",
diff --git a/src/components/github-export-modal.tsx b/src/components/github-export-modal.tsx
index 7ce6edff..747f8e06 100644
--- a/src/components/github-export-modal.tsx
+++ b/src/components/github-export-modal.tsx
@@ -1,4 +1,4 @@
-import React, { useState, useCallback } from 'react';
+import React, { useState, useCallback, useMemo } from 'react';
 import { motion, AnimatePresence } from 'framer-motion';
 import { 
     X, 
@@ -10,6 +10,40 @@ import {
     AlertCircle, 
     Loader
 } from 'lucide-react';
+import { apiClient } from '@/lib/api-client';
+
+// Shared button styles
+const BUTTON_STYLES = {
+    primary: 'bg-brand hover:bg-brand/90 text-text-on-brand py-2 px-4 rounded-lg transition-colors',
+    secondary: 'bg-bg-2 hover:bg-border text-text-primary py-2 px-4 rounded-lg transition-colors',
+    ghost: 'bg-transparent hover:bg-bg-2 text-text-primary/60 hover:text-text-primary py-2 px-4 rounded-lg transition-colors',
+    warning: 'bg-yellow-500 hover:bg-yellow-600 text-white py-2 px-4 rounded-lg font-medium transition-colors',
+    danger: 'bg-red-500 hover:bg-red-600 text-white py-2 px-4 rounded-lg transition-colors'
+} as const;
+
+// Helper functions
+const getInitialMode = (existingUrl: string | null | undefined): 'first_export' | 'sync' => 
+    existingUrl ? 'sync' : 'first_export';
+
+const extractRepoName = (url: string): string => url.split('/').pop() || '';
+
+const generateRepoName = (appTitle?: string): string => {
+    if (appTitle) {
+        return appTitle
+            .toLowerCase()
+            .replace(/[^a-z0-9]+/g, '-')
+            .replace(/^-+|-+$/g, '')
+            .slice(0, 100) || 'my-app';
+    }
+    const timestamp = new Date().toISOString().slice(0, 19).replace(/[-:]/g, '').replace('T', '-');
+    return `generated-app-${timestamp}`;
+};
+
+const createExportOptions = (repositoryName: string, isPrivate: boolean, description: string) => ({
+    repositoryName: repositoryName.trim(),
+    isPrivate,
+    description: description.trim() || undefined
+});
 
 interface GitHubExportModalProps {
     isOpen: boolean;
@@ -29,10 +63,80 @@ interface GitHubExportModalProps {
         success: boolean;
         repositoryUrl?: string;
         error?: string;
+        repositoryAlreadyExists?: boolean;
+        existingRepositoryUrl?: string;
     };
     onRetry?: () => void;
+    existingGithubUrl?: string | null;
+    agentId?: string;
+    appTitle?: string;
 }
 
+// Sub-components
+const ModalHeader: React.FC<{ mode: string; existingUrl?: string | null; onClose: () => void; disabled?: boolean }> = 
+    ({ mode, existingUrl, onClose, disabled }) => (
+    <div className="flex items-center justify-between mb-6">
+        <div className="flex items-center gap-3">
+            <div className="p-2 bg-bg-2 rounded-lg">
+                <Github className="w-5 h-5 text-text-secondary" />
+            </div>
+            <div>
+                <h2 className="text-lg font-semibold text-text-secondary">
+                    {mode === 'sync' ? 'Sync to GitHub' : 'Export to GitHub'}
+                </h2>
+                <p className="text-sm text-text-primary/60">
+                    {mode === 'sync' && existingUrl
+                        ? `Update ${extractRepoName(existingUrl)} with your latest changes`
+                        : 'Create a new repository with your generated code'
+                    }
+                </p>
+            </div>
+        </div>
+        {!disabled && (
+            <button onClick={onClose} className="p-1 hover:bg-bg-2 rounded-md transition-colors">
+                <X className="w-5 h-5 text-text-primary/60" />
+            </button>
+        )}
+    </div>
+);
+
+const StatusMessage: React.FC<{ icon: React.ComponentType<any>; iconColor: string; title: string; message: string; children?: React.ReactNode }> = 
+    ({ icon: Icon, iconColor, title, message, children }) => (
+    <div className="text-center py-8">
+        <Icon className={`w-12 h-12 ${iconColor} mx-auto mb-4`} />
+        <h3 className="text-lg font-semibold text-text-primary mb-2">{title}</h3>
+        <p className="text-sm text-text-primary/60 mb-4">{message}</p>
+        {children}
+    </div>
+);
+
+const ProgressStep: React.FC<{ label: string; isActive: boolean; isComplete: boolean }> = 
+    ({ label, isActive, isComplete }) => (
+    <div className={`flex items-center gap-1 ${
+        isActive ? 'text-brand' : isComplete ? 'text-green-500' : 'text-text-primary/40'
+    }`}>
+        <div className="w-2 h-2 rounded-full bg-current" />
+        {label}
+    </div>
+);
+
+const StatusIndicator: React.FC<{ type: 'success' | 'warning' | 'error'; message: string }> = 
+    ({ type, message }) => {
+    const colors = {
+        success: 'text-green-500',
+        warning: 'text-yellow-500',
+        error: 'text-red-500'
+    };
+    const Icon = type === 'success' ? CheckCircle : AlertCircle;
+    
+    return (
+        <div className={`flex items-center gap-1.5 text-xs ${colors[type]}`}>
+            <Icon className="w-3.5 h-3.5" />
+            {message}
+        </div>
+    );
+};
+
 export function GitHubExportModal({
     isOpen,
     onClose,
@@ -40,40 +144,112 @@ export function GitHubExportModal({
     isExporting = false,
     exportProgress,
     exportResult,
-    onRetry
+    onRetry,
+    existingGithubUrl,
+    agentId,
+    appTitle
 }: GitHubExportModalProps) {
     const [repositoryName, setRepositoryName] = useState('');
     const [description, setDescription] = useState('');
     const [isPrivate, setIsPrivate] = useState(false);
+    const [mode, setMode] = useState<'first_export' | 'sync' | 'change_repo'>(
+        getInitialMode(existingGithubUrl)
+    );
+    const [remoteStatus, setRemoteStatus] = useState<{
+        compatible: boolean;
+        behindBy: number;
+        aheadBy: number;
+        divergedCommits: Array<{ sha: string; message: string; author: string; date: string }>;
+    } | null>(null);
+    const [showConflictWarning, setShowConflictWarning] = useState(false);
+    const [isCheckingRemote, setIsCheckingRemote] = useState(false);
+    const [lastExportSuccess, setLastExportSuccess] = useState<{
+        repositoryUrl: string;
+        timestamp: number;
+    } | null>(null);
+
+    React.useEffect(() => {
+        if (isOpen) {
+            setMode(getInitialMode(existingGithubUrl));
+            setRepositoryName('');
+        }
+    }, [isOpen, existingGithubUrl, agentId]);
+
+    React.useEffect(() => {
+        if (exportResult?.success && exportResult.repositoryUrl) {
+            setLastExportSuccess({
+                repositoryUrl: exportResult.repositoryUrl,
+                timestamp: Date.now()
+            });
+        }
+    }, [exportResult]);
+
+    const exportOptions = useMemo(() => 
+        createExportOptions(repositoryName, isPrivate, description),
+        [repositoryName, isPrivate, description]
+    );
+
+    const handleExport = useCallback(() => {
+        onExport(exportOptions);
+    }, [onExport, exportOptions]);
 
     const handleSubmit = useCallback((e: React.FormEvent) => {
         e.preventDefault();
-        
-        if (!repositoryName.trim()) {
-            return;
+        if (repositoryName.trim()) {
+            handleExport();
         }
-
-        // Always call onExport - the parent component will handle OAuth flow
-        onExport({
-            repositoryName: repositoryName.trim(),
-            isPrivate,
-            description: description.trim() || undefined
-        });
-    }, [repositoryName, description, isPrivate, onExport]);
+    }, [repositoryName, handleExport]);
 
     const handleClose = useCallback(() => {
         if (!isExporting) {
+            setMode(getInitialMode(existingGithubUrl));
+            setRepositoryName('');
+            setDescription('');
+            
+            if (lastExportSuccess && Date.now() - lastExportSuccess.timestamp > 10000) {
+                setLastExportSuccess(null);
+            }
+            
             onClose();
         }
-    }, [isExporting, onClose]);
+    }, [isExporting, onClose, existingGithubUrl, lastExportSuccess]);
 
-    // Auto-generate repository name based on current timestamp
     React.useEffect(() => {
         if (isOpen && !repositoryName) {
-            const timestamp = new Date().toISOString().slice(0, 19).replace(/[-:]/g, '').replace('T', '-');
-            setRepositoryName(`generated-app-${timestamp}`);
+            setRepositoryName(
+                existingGithubUrl
+                    ? extractRepoName(existingGithubUrl)
+                    : generateRepoName(appTitle)
+            );
+        }
+    }, [isOpen, repositoryName, existingGithubUrl, appTitle]);
+
+    React.useEffect(() => {
+        if (isOpen && mode === 'sync' && existingGithubUrl && agentId) {
+            setIsCheckingRemote(true);
+            setShowConflictWarning(false);
+            setRemoteStatus(null);
+            
+            apiClient.checkRemoteStatus({
+                repositoryUrl: existingGithubUrl,
+                agentId
+            })
+            .then(response => {
+                if (response.success && response.data) {
+                    setRemoteStatus(response.data);
+                    if (response.data.aheadBy > 0) {
+                        setShowConflictWarning(true);
+                    }
+                }
+            })
+            .catch(error => {
+                console.error('Failed to check remote status:', error);
+            })
+            .finally(() => {
+                setIsCheckingRemote(false);
+            });
         }
-    }, [isOpen, repositoryName]);
+    }, [isOpen, mode, existingGithubUrl, agentId]);
 
     if (!isOpen) return null;
 
@@ -93,74 +269,139 @@ export function GitHubExportModal({
                     className="bg-bg-4 border border-border-primary rounded-xl max-w-md w-full p-6"
                     onClick={(e) => e.stopPropagation()}
                 >
-                    {/* Header */}
-                    <div className="flex items-center justify-between mb-6">
-                        <div className="flex items-center gap-3">
-                            <div className="p-2 bg-bg-2 rounded-lg">
-                                <Github className="w-5 h-5 text-text-secondary" />
+                    <ModalHeader 
+                        mode={mode} 
+                        existingUrl={existingGithubUrl} 
+                        onClose={handleClose} 
+                        disabled={isExporting} 
+                    />
+
+                    {showConflictWarning && remoteStatus && remoteStatus.aheadBy > 0 ? (
+                        <div className="py-6">
+                            <AlertCircle className="w-12 h-12 text-yellow-500 mx-auto mb-4" />
+                            <h3 className="text-lg font-semibold text-text-primary mb-2 text-center">
+                                Repository Has Different History
+                            </h3>
+                            <div className="text-sm text-text-primary/80 space-y-3">
+                                <p>
+                                    Remote has <strong>{remoteStatus.aheadBy} commit(s)</strong> not in your app.
+                                    Your app has <strong>{remoteStatus.behindBy} commit(s)</strong> not on GitHub.
+                                </p>
+                                
+                                {remoteStatus.divergedCommits.length > 0 && (
+                                    <div>
+                                        <p className="font-medium mb-2">Commits that will be lost:</p>
+                                        <div className="bg-bg-2 rounded-lg p-3 max-h-32 overflow-y-auto space-y-2">
+                                            {remoteStatus.divergedCommits.slice(0, 5).map((commit, i) => (
+                                                <div key={i} className="text-xs">
+                                                    <div className="font-medium">{commit.message}</div>
+                                                    <div className="text-text-primary/50">
+                                                        {commit.author} • {new Date(commit.date).toLocaleString()}
+                                                    </div>
+                                                </div>
+                                            ))}
+                                        </div>
+                                    </div>
+                                )}
+                                
+                                <div className="bg-yellow-500/10 border border-yellow-500/20 rounded-lg p-3">
+                                    <p className="text-yellow-600 dark:text-yellow-400 font-medium">
+                                        ⚠️ Force pushing will replace GitHub's history with yours.
+                                        This action cannot be undone.
+                                    </p>
+                                </div>
                             </div>
-                            <div>
-                                <h2 className="text-lg font-semibold text-text-secondary">Export to GitHub</h2>
-                                <p className="text-sm text-text-primary/60">Create a new repository with your generated code</p>
+                            
+                            <div className="flex gap-3 mt-6">
+                                <button
+                                    onClick={() => {
+                                        setShowConflictWarning(false);
+                                        onClose();
+                                    }}
+                                    className={`flex-1 ${BUTTON_STYLES.secondary}`}
+                                >
+                                    Cancel
+                                </button>
+                                <button
+                                    onClick={() => {
+                                        setShowConflictWarning(false);
+                                        handleExport();
+                                    }}
+                                    className={`flex-1 ${BUTTON_STYLES.warning}`}
+                                >
+                                    Force Push Anyway
+                                </button>
                             </div>
                         </div>
-                        {!isExporting && (
-                            <button
-                                onClick={handleClose}
-                                className="p-1 hover:bg-bg-2 rounded-md transition-colors"
+                    ) : exportResult ? (
+                        exportResult.success ? (
+                            <StatusMessage
+                                icon={CheckCircle}
+                                iconColor="text-green-500"
+                                title="Export Successful!"
+                                message="Your code has been successfully exported to GitHub"
                             >
-                                <X className="w-5 h-5 text-text-primary/60" />
-                            </button>
-                        )}
-                    </div>
-
-                    {/* Content */}
-                    {exportResult ? (
-                        /* Export Result */
-                        <div className="text-center py-8">
-                            {exportResult.success ? (
-                                <div>
-                                    <CheckCircle className="w-12 h-12 text-green-500 mx-auto mb-4" />
-                                    <h3 className="text-lg font-semibold text-text-primary mb-2">Export Successful!</h3>
-                                    <p className="text-sm text-text-primary/60 mb-4">
-                                        Your code has been successfully exported to GitHub
-                                    </p>
-                                    <a
-                                        href={exportResult.repositoryUrl}
+                                <a
+                                    href={exportResult.repositoryUrl}
+                                    target="_blank"
+                                    rel="noopener noreferrer"
+                                    className={`inline-flex items-center gap-2 ${BUTTON_STYLES.secondary}`}
+                                >
+                                    <Github className="w-4 h-4" />
+                                    View Repository
+                                </a>
+                            </StatusMessage>
+                        ) : exportResult.repositoryAlreadyExists && exportResult.existingRepositoryUrl ? (
+                            <StatusMessage
+                                icon={AlertCircle}
+                                iconColor="text-orange-500"
+                                title="Repository Already Exists"
+                                message="A repository with this name already exists on your GitHub account:"
+                            >
+                                    <a 
+                                        href={exportResult.existingRepositoryUrl}
                                         target="_blank"
                                         rel="noopener noreferrer"
-                                        className="inline-flex items-center gap-2 bg-bg-2 hover:bg-border text-text-primary py-2 px-4 rounded-lg transition-colors"
+                                        className="text-sm text-brand hover:underline mb-4 block break-all"
                                     >
-                                        <Github className="w-4 h-4" />
-                                        View Repository
+                                        {exportResult.existingRepositoryUrl}
                                     </a>
-                                </div>
-                            ) : (
-                                <div>
-                                    <AlertCircle className="w-12 h-12 text-red-500 mx-auto mb-4" />
-                                    <h3 className="text-lg font-semibold text-text-primary mb-2">Export Failed</h3>
-                                    <p className="text-sm text-text-primary/60 mb-4">
-                                        {exportResult.error || 'An error occurred during export'}
+                                    <p className="text-sm text-text-primary/60 mb-6">
+                                        Would you like to sync your changes to this existing repository?
                                     </p>
-                                    <div className="space-x-2">
-                                        <button
-                                            onClick={onRetry || (() => window.location.reload())}
-                                            className="bg-bg-2 hover:bg-border text-text-primary py-2 px-4 rounded-lg transition-colors"
-                                        >
-                                            Try Again
-                                        </button>
-                                        <button
-                                            onClick={onClose}
-                                            className="bg-transparent hover:bg-bg-2 text-text-primary/60 hover:text-text-primary py-2 px-4 rounded-lg transition-colors"
-                                        >
-                                            Close
-                                        </button>
-                                    </div>
+                                <div className="space-x-2">
+                                    <button onClick={handleExport} className={BUTTON_STYLES.primary}>
+                                        Sync to Existing
+                                    </button>
+                                    <button onClick={onRetry || onClose} className={BUTTON_STYLES.secondary}>
+                                        Change Name
+                                    </button>
+                                    <button onClick={onClose} className={BUTTON_STYLES.ghost}>
+                                        Cancel
+                                    </button>
                                 </div>
-                            )}
-                        </div>
+                            </StatusMessage>
+                        ) : (
+                            <StatusMessage
+                                icon={AlertCircle}
+                                iconColor="text-red-500"
+                                title="Export Failed"
+                                message={exportResult.error || 'An error occurred during export'}
+                            >
+                                <div className="space-x-2">
+                                    <button
+                                        onClick={onRetry || (() => window.location.reload())}
+                                        className={BUTTON_STYLES.secondary}
+                                    >
+                                        Try Again
+                                    </button>
+                                    <button onClick={onClose} className={BUTTON_STYLES.ghost}>
+                                        Close
+                                    </button>
+                                </div>
+                            </StatusMessage>
+                        )
                     ) : isExporting && exportProgress ? (
-                        /* Export Progress */
                         <div className="py-8">
                             <div className="text-center mb-6">
                                 <Loader className="w-8 h-8 text-brand mx-auto mb-4 animate-spin" />
@@ -168,7 +409,6 @@ export function GitHubExportModal({
                                 <p className="text-sm text-text-primary/60">{exportProgress.message}</p>
                             </div>
                             
-                            {/* Progress Bar */}
                             <div className="mb-4">
                                 <div className="flex justify-between text-xs text-text-primary/60 mb-2">
                                     <span>Progress</span>
@@ -184,35 +424,54 @@ export function GitHubExportModal({
                                 </div>
                             </div>
                             
-                            {/* Step Indicators */}
                             <div className="flex justify-between text-xs">
-                                <div className={`flex items-center gap-1 ${
-                                    exportProgress.step === 'creating_repository' ? 'text-brand' : 
-                                    exportProgress.progress > 30 ? 'text-green-500' : 'text-text-primary/40'
-                                }`}>
-                                    <div className="w-2 h-2 rounded-full bg-current" />
-                                    Creating Repository
-                                </div>
-                                <div className={`flex items-center gap-1 ${
-                                    exportProgress.step === 'uploading_files' ? 'text-brand' : 
-                                    exportProgress.progress > 70 ? 'text-green-500' : 'text-text-primary/40'
-                                }`}>
-                                    <div className="w-2 h-2 rounded-full bg-current" />
-                                    Uploading Files
-                                </div>
-                                <div className={`flex items-center gap-1 ${
-                                    exportProgress.step === 'finalizing' ? 'text-brand' : 
-                                    exportProgress.progress > 90 ? 'text-green-500' : 'text-text-primary/40'
-                                }`}>
-                                    <div className="w-2 h-2 rounded-full bg-current" />
-                                    Finalizing
-                                </div>
+                                <ProgressStep 
+                                    label="Creating Repository" 
+                                    isActive={exportProgress.step === 'creating_repository'} 
+                                    isComplete={exportProgress.progress > 30} 
+                                />
+                                <ProgressStep 
+                                    label="Uploading Files" 
+                                    isActive={exportProgress.step === 'uploading_files'} 
+                                    isComplete={exportProgress.progress > 70} 
+                                />
+                                <ProgressStep 
+                                    label="Finalizing" 
+                                    isActive={exportProgress.step === 'finalizing'} 
+                                    isComplete={exportProgress.progress > 90} 
+                                />
                             </div>
                         </div>
                     ) : (
-                        /* Export Form */
                         <form onSubmit={handleSubmit} className="space-y-4">
-                            {/* Repository Name */}
+                            {mode === 'sync' && lastExportSuccess && !exportResult && (
+                                <div className="mb-4 p-3 bg-green-500/10 border border-green-500/20 rounded-lg">
+                                    <div className="flex items-start gap-2">
+                                        <CheckCircle className="w-4 h-4 text-green-500 mt-0.5 flex-shrink-0" />
+                                        <div className="flex-1">
+                                            <p className="text-sm font-medium text-green-600 dark:text-green-400">
+                                                Last sync successful
+                                            </p>
+                                            <a 
+                                                href={lastExportSuccess.repositoryUrl} 
+                                                target="_blank" 
+                                                rel="noopener noreferrer"
+                                                className="text-xs text-green-600/80 dark:text-green-400/80 hover:underline break-all"
+                                            >
+                                                {lastExportSuccess.repositoryUrl}
+                                            </a>
+                                        </div>
+                                        <button
+                                            type="button"
+                                            onClick={() => setLastExportSuccess(null)}
+                                            className="text-green-600/60 hover:text-green-600 dark:text-green-400/60 dark:hover:text-green-400 transition-colors"
+                                        >
+                                            <X className="w-4 h-4" />
+                                        </button>
+                                    </div>
+                                </div>
+                            )}
+
                             <div>
                                 <label className="block text-sm font-medium text-text-primary mb-2">
                                     Repository Name *
@@ -227,73 +486,133 @@ export function GitHubExportModal({
                                 />
                             </div>
 
-                            {/* Description */}
-                            <div>
-                                <label className="block text-sm font-medium text-text-primary mb-2">
-                                    Description (Optional)
-                                </label>
-                                <textarea
-                                    value={description}
-                                    onChange={(e) => setDescription(e.target.value)}
-                                    placeholder="A brief description of your app..."
-                                    rows={3}
-                                    className="w-full px-3 py-2 bg-bg-2 border border-border-primary rounded-lg text-text-primary placeholder:text-text-primary/40 focus:outline-none focus:ring-2 focus:ring-brand/50 focus:border-brand resize-none"
-                                />
-                            </div>
+                            {mode === 'sync' && existingGithubUrl && (
+                                <div className="p-3 bg-bg-2 rounded-lg space-y-2">
+                                    <div className="flex items-center justify-between">
+                                        <p className="text-xs font-medium text-text-primary/60">
+                                            Remote Repository
+                                        </p>
+                                        <button
+                                            type="button"
+                                            onClick={() => setMode('change_repo')}
+                                            className="text-xs text-brand hover:text-brand/80 transition-colors"
+                                        >
+                                            Change
+                                        </button>
+                                    </div>
+                                    
+                                    <a 
+                                        href={existingGithubUrl} 
+                                        target="_blank" 
+                                        rel="noopener noreferrer"
+                                        className="text-xs text-text-primary/60 hover:text-brand transition-colors break-all flex items-center gap-1"
+                                    >
+                                        <Github className="w-3 h-3 flex-shrink-0" />
+                                        {existingGithubUrl}
+                                    </a>
 
-                            {/* Privacy Setting */}
-                            <div>
-                                <label className="block text-sm font-medium text-text-primary mb-3">
-                                    Repository Privacy
-                                </label>
-                                <div className="space-y-2">
-                                    <label className="flex items-center gap-3 p-3 bg-bg-2 rounded-lg cursor-pointer hover:bg-border transition-colors">
-                                        <input
-                                            type="radio"
-                                            name="privacy"
-                                            checked={!isPrivate}
-                                            onChange={() => setIsPrivate(false)}
-                                            className="w-4 h-4 text-brand focus:ring-brand/50"
-                                        />
-                                        <Globe className="w-4 h-4 text-text-primary/60" />
-                                        <div>
-                                            <p className="text-sm font-medium text-text-secondary">Public</p>
-                                            <p className="text-xs text-text-primary/60">Anyone can see this repository</p>
+                                    {isCheckingRemote ? (
+                                        <div className="flex items-center gap-2 text-xs text-text-primary/60 pt-1">
+                                            <Loader className="w-3 h-3 animate-spin" />
+                                            Checking sync status...
                                         </div>
-                                    </label>
-                                    <label className="flex items-center gap-3 p-3 bg-bg-2 rounded-lg cursor-pointer hover:bg-border transition-colors">
-                                        <input
-                                            type="radio"
-                                            name="privacy"
-                                            checked={isPrivate}
-                                            onChange={() => setIsPrivate(true)}
-                                            className="w-4 h-4 text-brand focus:ring-brand/50"
-                                        />
-                                        <Lock className="w-4 h-4 text-text-primary/60" />
-                                        <div>
-                                            <p className="text-sm font-medium text-text-secondary">Private</p>
-                                            <p className="text-xs text-text-primary/60">Only you can see this repository</p>
+                                    ) : remoteStatus ? (
+                                        <div className="pt-1">
+                                            {remoteStatus.compatible ? (
+                                                remoteStatus.behindBy === 0 && remoteStatus.aheadBy === 0 ? (
+                                                    <StatusIndicator type="success" message="Up to date" />
+                                                ) : (
+                                                    <div className="space-y-1">
+                                                        {remoteStatus.behindBy > 0 && (
+                                                            <StatusIndicator 
+                                                                type="warning" 
+                                                                message={`Local has ${remoteStatus.behindBy} unpushed commit${remoteStatus.behindBy !== 1 ? 's' : ''}`} 
+                                                            />
+                                                        )}
+                                                        {remoteStatus.aheadBy > 0 && (
+                                                            <StatusIndicator 
+                                                                type="warning" 
+                                                                message={`Remote has ${remoteStatus.aheadBy} newer commit${remoteStatus.aheadBy !== 1 ? 's' : ''}`} 
+                                                            />
+                                                        )}
+                                                    </div>
+                                                )
+                                            ) : (
+                                                <StatusIndicator 
+                                                    type="error" 
+                                                    message="Incompatible histories - force push required" 
+                                                />
+                                            )}
                                         </div>
+                                    ) : null}
+                                </div>
+                            )}
+
+                            
+                            {mode !== 'sync' && (
+                                <div>
+                                    <label className="block text-sm font-medium text-text-primary mb-2">
+                                        Description (Optional)
                                     </label>
+                                    <textarea
+                                        value={description}
+                                        onChange={(e) => setDescription(e.target.value)}
+                                        placeholder="A brief description of your app..."
+                                        rows={3}
+                                        className="w-full px-3 py-2 bg-bg-2 border border-border-primary rounded-lg text-text-primary placeholder:text-text-primary/40 focus:outline-none focus:ring-2 focus:ring-brand/50 focus:border-brand resize-none"
+                                    />
                                 </div>
-                            </div>
+                            )}
+
+                            {mode !== 'sync' && (
+                                <div>
+                                    <label className="block text-sm font-medium text-text-primary mb-3">
+                                        Repository Privacy
+                                    </label>
+                                    <div className="space-y-2">
+                                        <label className="flex items-center gap-3 p-3 bg-bg-2 rounded-lg cursor-pointer hover:bg-border transition-colors">
+                                            <input
+                                                type="radio"
+                                                name="privacy"
+                                                checked={!isPrivate}
+                                                onChange={() => setIsPrivate(false)}
+                                                className="w-4 h-4 text-brand focus:ring-brand/50"
+                                            />
+                                            <Globe className="w-4 h-4 text-text-primary/60" />
+                                            <div>
+                                                <p className="text-sm font-medium text-text-secondary">Public</p>
+                                                <p className="text-xs text-text-primary/60">Anyone can see this repository</p>
+                                            </div>
+                                        </label>
+                                        <label className="flex items-center gap-3 p-3 bg-bg-2 rounded-lg cursor-pointer hover:bg-border transition-colors">
+                                            <input
+                                                type="radio"
+                                                name="privacy"
+                                                checked={isPrivate}
+                                                onChange={() => setIsPrivate(true)}
+                                                className="w-4 h-4 text-brand focus:ring-brand/50"
+                                            />
+                                            <Lock className="w-4 h-4 text-text-primary/60" />
+                                            <div>
+                                                <p className="text-sm font-medium text-text-secondary">Private</p>
+                                                <p className="text-xs text-text-primary/60">Only you can see this repository</p>
+                                            </div>
+                                        </label>
+                                    </div>
+                                </div>
+                            )}
 
-                            {/* Submit Button */}
                             <div className="flex gap-3 pt-4">
-                                <button
-                                    type="button"
-                                    onClick={handleClose}
-                                    className="flex-1 bg-bg-2 hover:bg-border text-text-primary py-2 px-4 rounded-lg transition-colors"
-                                >
+                                <button type="button" onClick={handleClose} className={`flex-1 ${BUTTON_STYLES.secondary}`}>
                                     Cancel
                                 </button>
                                 <button
                                     type="submit"
-                                    disabled={!repositoryName.trim()}
-                                    className="flex-1 bg-brand hover:bg-brand/90 disabled:bg-brand/50 text-text-on-brand py-2 px-4 rounded-lg transition-colors flex items-center justify-center gap-2"
+                                    disabled={!repositoryName.trim() || isExporting}
+                                    className={`flex-1 ${BUTTON_STYLES.primary} disabled:bg-brand/50 flex items-center justify-center gap-2`}
                                 >
                                     <Upload className="w-4 h-4" />
-                                    Export to GitHub
+                                    {mode === 'sync' ? 'Sync to GitHub' : 'Export to GitHub'}
                                 </button>
                             </div>
                         </form>
diff --git a/src/hooks/use-github-export.ts b/src/hooks/use-github-export.ts
index e73ac8cb..9beaeb46 100644
--- a/src/hooks/use-github-export.ts
+++ b/src/hooks/use-github-export.ts
@@ -25,7 +25,11 @@ export interface GitHubInstallationData {
     repositories?: string[];
 }
 
-export function useGitHubExport(_websocket?: WebSocket | null, agentId?: string): {
+export function useGitHubExport(
+    _websocket?: WebSocket | null, 
+    agentId?: string,
+    onSuccess?: () => void
+): {
     isExporting: boolean;
     progress?: GitHubExportProgress;
     result?: GitHubExportResult;
@@ -43,15 +47,12 @@ export function useGitHubExport(_websocket?: WebSocket | null, agentId?: string)
         isModalOpen: false
     });
 
-    // NOTE: WebSocket-based GitHub export has been replaced with secure OAuth flow
-    // All GitHub export now happens via HTTP API with proper OAuth authorization
-
     // Open the export modal
     const openModal = useCallback(() => {
         setState(prev => ({
             ...prev,
             isModalOpen: true,
-            result: undefined // Clear any previous results
+            result: undefined
         }));
     }, []);
 
@@ -66,7 +67,6 @@ export function useGitHubExport(_websocket?: WebSocket | null, agentId?: string)
         }));
     }, []);
 
-    // Check for GitHub export callback results on component mount
     useEffect(() => {
         const urlParams = new URLSearchParams(window.location.search);
         const githubExport = urlParams.get('github_export');
@@ -76,14 +76,14 @@ export function useGitHubExport(_websocket?: WebSocket | null, agentId?: string)
             setState(prev => ({
                 ...prev,
                 isExporting: false,
-                isModalOpen: true, // Auto-open modal to show success result
+                isModalOpen: true,
                 result: {
                     success: true,
                     repositoryUrl: repositoryUrl || undefined
                 }
             }));
             
-            // Clean up URL
+            onSuccess?.();
             const newUrl = new URL(window.location.href);
             newUrl.searchParams.delete('github_export');
             newUrl.searchParams.delete('repository_url');
@@ -107,9 +107,8 @@ export function useGitHubExport(_websocket?: WebSocket | null, agentId?: string)
             newUrl.searchParams.delete('reason');
             window.history.replaceState({}, '', newUrl.toString());
         }
-    }, []);
+    }, [onSuccess]);
 
-    // Start GitHub export with secure backend flow
     const startExport = useCallback(async (options: GitHubExportOptions) => {
         setState(prev => ({
             ...prev,
@@ -119,20 +118,18 @@ export function useGitHubExport(_websocket?: WebSocket | null, agentId?: string)
         }));
 
         try {
-            // Validate agentId is available (should be from URL params)
             if (!agentId) {
                 setState(prev => ({
                     ...prev,
                     isExporting: false,
                     result: {
                         success: false,
-                        error: 'Invalid chat session. Please ensure you are on a valid chat page.'
+                        error: 'Invalid chat session'
                     }
                 }));
                 return;
             }
 
-            // Initiate GitHub export with OAuth flow
             const response = await apiClient.initiateGitHubExport({
                 repositoryName: options.repositoryName,
                 description: options.description,
@@ -140,13 +137,37 @@ export function useGitHubExport(_websocket?: WebSocket | null, agentId?: string)
                 agentId: agentId
             });
 
+            if (response.data?.alreadyExists && response.data?.existingRepositoryUrl) {
+                setState(prev => ({
+                    ...prev,
+                    isExporting: false,
+                    result: {
+                        success: false,
+                        error: 'Repository already exists',
+                        repositoryAlreadyExists: true,
+                        existingRepositoryUrl: response.data?.existingRepositoryUrl || ''
+                    }
+                }));
+                return;
+            }
+            if (response.data?.skippedOAuth && response.data?.repositoryUrl) {
+                setState(prev => ({
+                    ...prev,
+                    isExporting: false,
+                    result: {
+                        success: true,
+                        repositoryUrl: response.data?.repositoryUrl || ''
+                    }
+                }));
+                onSuccess?.();
+                return;
+            }
+
             if (response.data?.authUrl) {
                 setState(prev => ({
                     ...prev,
                     progress: { message: 'Redirecting to GitHub...', step: 'creating_repository', progress: 25 }
                 }));
-                
-                // Small delay for user feedback, then redirect
                 setTimeout(() => {
                     window.location.href = response.data?.authUrl || '';
                 }, 500);
@@ -160,19 +181,45 @@ export function useGitHubExport(_websocket?: WebSocket | null, agentId?: string)
                     }
                 }));
             }
-        } catch (error: any) {
+        } catch (error: unknown) {
+            const apiError = error as { 
+                response?: { 
+                    data?: { 
+                        alreadyExists?: boolean; 
+                        existingRepositoryUrl?: string;
+                    } 
+                }; 
+                data?: { 
+                    alreadyExists?: boolean; 
+                    existingRepositoryUrl?: string;
+                }; 
+                message?: string;
+            };
+            const errorData = apiError?.response?.data || apiError?.data;
+            if (errorData?.alreadyExists && errorData?.existingRepositoryUrl) {
+                setState(prev => ({
+                    ...prev,
+                    isExporting: false,
+                    result: {
+                        success: false,
+                        error: 'Repository already exists',
+                        repositoryAlreadyExists: true,
+                        existingRepositoryUrl: errorData.existingRepositoryUrl
+                    }
+                }));
+                return;
+            }
+            
             setState(prev => ({
                 ...prev,
                 isExporting: false,
                 result: {
                     success: false,
-                    error: error?.message || 'Failed to initiate GitHub export'
+                    error: apiError?.message || 'Failed to initiate GitHub export'
                 }
             }));
         }
-    }, [agentId]);
-
-    // Retry function that resets state and allows a new export attempt
+    }, [agentId, onSuccess]);
     const retry = useCallback(() => {
         setState(prev => ({
             ...prev,
diff --git a/src/lib/api-client.ts b/src/lib/api-client.ts
index a8c7b883..140d0873 100644
--- a/src/lib/api-client.ts
+++ b/src/lib/api-client.ts
@@ -926,8 +926,38 @@ class ApiClient {
 		description?: string;
 		isPrivate?: boolean;
 		agentId: string;
-	}): Promise<ApiResponse<{ authUrl: string }>> {
-		return this.request<{ authUrl: string }>('/api/github-app/export', {
+	}): Promise<ApiResponse<{ 
+		authUrl?: string;
+		success?: boolean;
+		repositoryUrl?: string;
+		skippedOAuth?: boolean;
+		alreadyExists?: boolean;
+		existingRepositoryUrl?: string;
+	}>> {
+		return this.request('/api/github-app/export', {
+			method: 'POST',
+			body: data,
+		});
+	}
+
+	/**
+	 * Check remote repository status
+	 */
+	async checkRemoteStatus(data: {
+		repositoryUrl: string;
+		agentId: string;
+	}): Promise<ApiResponse<{
+		compatible: boolean;
+		behindBy: number;
+		aheadBy: number;
+		divergedCommits: Array<{
+			sha: string;
+			message: string;
+			author: string;
+			date: string;
+		}>;
+	}>> {
+		return this.request('/api/github-app/check-remote', {
 			method: 'POST',
 			body: data,
 		});
diff --git a/src/routes/chat/chat.tsx b/src/routes/chat/chat.tsx
index 3a97a777..423c219b 100644
--- a/src/routes/chat/chat.tsx
+++ b/src/routes/chat/chat.tsx
@@ -59,7 +59,7 @@ export default function Chat() {
 	}, [searchParams]);
 
 	// Load existing app data if chatId is provided
-	const { app, loading: appLoading } = useApp(urlChatId);
+	const { app, loading: appLoading, refetch: refetchApp } = useApp(urlChatId);
 
 	// If we have an existing app, use its data
 	const displayQuery = app ? app.originalPrompt || app.title : userQuery || '';
@@ -141,7 +141,7 @@ export default function Chat() {
 	});
 
 	// GitHub export functionality - use urlChatId directly from URL params
-	const githubExport = useGitHubExport(websocket, urlChatId);
+	const githubExport = useGitHubExport(websocket, urlChatId, refetchApp);
 
 	const navigate = useNavigate();
 
@@ -1173,6 +1173,9 @@ export default function Chat() {
 				exportProgress={githubExport.progress}
 				exportResult={githubExport.result}
 				onRetry={githubExport.retry}
+				existingGithubUrl={app?.githubRepositoryUrl || null}
+				agentId={urlChatId || undefined}
+				appTitle={app?.title}
 			/>
 		</div>
 	);
diff --git a/tsconfig.worker.json b/tsconfig.worker.json
index 9ee760f5..e01b4811 100644
--- a/tsconfig.worker.json
+++ b/tsconfig.worker.json
@@ -6,5 +6,5 @@
 		"types": ["./worker-configuration.d.ts", "vite/client", "jest"],
 		"lib": ["ES2023"]
 	},
-	"include": ["./worker-configuration.d.ts", "./shared", "./worker"]
+	"include": ["./worker-configuration.d.ts", "./shared", "./worker", "./worker/types"]
 }
diff --git a/vite.config.ts b/vite.config.ts
index 239086d0..31b98a60 100644
--- a/vite.config.ts
+++ b/vite.config.ts
@@ -6,14 +6,13 @@ import path from 'path';
 
 import { cloudflare } from '@cloudflare/vite-plugin';
 import tailwindcss from '@tailwindcss/vite';
-// import { nodePolyfills } from 'vite-plugin-node-polyfills';
 
 // https://vite.dev/config/
 export default defineConfig({
 	optimizeDeps: {
 		exclude: ['format', 'editor.all'],
 		include: ['monaco-editor/esm/vs/editor/editor.api'],
-		force: true, // Force re-optimization on every start
+		force: true,
 	},
 
 	// build: {
@@ -31,16 +30,7 @@ export default defineConfig({
 		cloudflare({
 			configPath: 'wrangler.jsonc',
 			experimental: { remoteBindings: true },
-		}), // Add the node polyfills plugin here
-		// nodePolyfills({
-		//     exclude: [
-		//       'tty', // Exclude 'tty' module
-		//     ],
-		//     // We recommend leaving this as `true` to polyfill `global`.
-		//     globals: {
-		//         global: true,
-		//     },
-		// })
+		}),
 		tailwindcss(),
 		// sentryVitePlugin({
 		// 	org: 'cloudflare-0u',
@@ -50,13 +40,10 @@ export default defineConfig({
 
 	resolve: {
 		alias: {
-			// 'path': 'path-browserify',
-			// Add this line to fix the 'debug' package issue
 			debug: 'debug/src/browser',
-			// "@": path.resolve(__dirname, "./src"),
 			'@': path.resolve(__dirname, './src'),
-            'shared': path.resolve(__dirname, './shared'),
-            'worker': path.resolve(__dirname, './worker'),
+			'shared': path.resolve(__dirname, './shared'),
+			'worker': path.resolve(__dirname, './worker'),
 		},
 	},
 
@@ -82,8 +69,4 @@ export default defineConfig({
 
 	// Clear cache more aggressively
 	cacheDir: 'node_modules/.vite',
-
-	build: {
-		sourcemap: true,
-	},
 });
diff --git a/worker/agents/core/simpleGeneratorAgent.ts b/worker/agents/core/simpleGeneratorAgent.ts
index 45d19608..5c0269ba 100644
--- a/worker/agents/core/simpleGeneratorAgent.ts
+++ b/worker/agents/core/simpleGeneratorAgent.ts
@@ -9,6 +9,7 @@ import {
 } from '../schemas';
 import { GitHubPushRequest, PreviewType, StaticAnalysisResponse, TemplateDetails } from '../../services/sandbox/sandboxTypes';
 import {  GitHubExportResult } from '../../services/github/types';
+import { GitHubService } from '../../services/github/GitHubService';
 import { CodeGenState, CurrentDevState, MAX_PHASES } from './state';
 import { AllIssues, AgentSummary, AgentInitArgs, PhaseExecutionResult, UserContext } from './types';
 import { PREVIEW_EXPIRED_ERROR, WebSocketMessageResponses } from '../constants';
@@ -34,10 +35,10 @@ import { InferenceContext, AgentActionKey } from '../inferutils/config.types';
 import { AGENT_CONFIG } from '../inferutils/config';
 import { ModelConfigService } from '../../database/services/ModelConfigService';
 import { fixProjectIssues } from '../../services/code-fixer';
+import { GitVersionControl } from '../git';
 import { FastCodeFixerOperation } from '../operations/PostPhaseCodeFixer';
 import { looksLikeCommand } from '../utils/common';
 import { generateBlueprint } from '../planning/blueprint';
-import { prepareCloudflareButton } from '../../utils/deployToCf';
 import { AppService } from '../../database';
 import { RateLimitExceededError } from 'shared/types/errors';
 import { ImageAttachment, type ProcessedImageAttachment } from '../../types/image-attachment';
@@ -80,6 +81,7 @@ export class SimpleCodeGeneratorAgent extends Agent<Env, CodeGenState> {
     protected codingAgent: CodingAgentInterface = new CodingAgentInterface(this);
     
     protected deploymentManager!: DeploymentManager;
+    protected git: GitVersionControl;
 
     private previewUrlCache: string = '';
     private templateDetailsCache: TemplateDetails | null = null;
@@ -89,6 +91,13 @@ export class SimpleCodeGeneratorAgent extends Agent<Env, CodeGenState> {
     private generationPromise: Promise<void> | null = null;
     private deepDebugPromise: Promise<{ transcript: string } | { error: string }> | null = null;
     
+    // GitHub token cache (ephemeral, lost on DO eviction)
+    private githubTokenCache: {
+        token: string;
+        username: string;
+        expiresAt: number;
+    } | null = null;
+    
     private currentAbortController?: AbortController;
     
     protected operations: Operations = {
@@ -159,9 +168,12 @@ export class SimpleCodeGeneratorAgent extends Agent<Env, CodeGenState> {
             () => this.state,
             (s) => this.setState(s)
         );
-        
+
+        // Initialize GitVersionControl (bind sql to preserve 'this' context)
+        this.git = new GitVersionControl(this.sql.bind(this));
+
         // Initialize FileManager
-        this.fileManager = new FileManager(this.stateManager, () => this.getTemplateDetails());
+        this.fileManager = new FileManager(this.stateManager, () => this.getTemplateDetails(), this.git);
         
         // Initialize DeploymentManager first (manages sandbox client caching)
         // DeploymentManager will use its own getClient() override for caching
@@ -260,6 +272,8 @@ export class SimpleCodeGeneratorAgent extends Agent<Env, CodeGenState> {
 
     async onStart(_props?: Record<string, unknown> | undefined): Promise<void> {
         this.logger().info(`Agent ${this.getAgentId()} session: ${this.state.sessionId} onStart`);
+        await this.gitInit();
+        
         // Ignore if agent not initialized
         if (!this.state.templateName?.trim()) {
             this.logger().info(`Agent ${this.getAgentId()} session: ${this.state.sessionId} not initialized, ignoring onStart`);
@@ -270,6 +284,25 @@ export class SimpleCodeGeneratorAgent extends Agent<Env, CodeGenState> {
         await this.ensureTemplateDetails();
         this.logger().info(`Agent ${this.getAgentId()} session: ${this.state.sessionId} onStart processed successfully`);
     }
+
+    private async gitInit() {
+        try {
+            await this.git.init();
+            this.logger().info("Git initialized successfully");
+            // Check if there is any commit
+            const head = await this.git.getHead();
+            
+            if (!head) {
+                this.logger().info("No commits found, creating initial commit");
+                // get all generated files and commit them
+                const generatedFiles = this.fileManager.getGeneratedFiles();
+                await this.git.commit(generatedFiles, "Initial commit");
+                this.logger().info("Initial commit created successfully");
+            }
+        } catch (error) {
+            this.logger().error("Error during git init:", error);
+        }
+    }
     
     onStateUpdate(_state: CodeGenState, _source: "server" | Connection) {}
 
@@ -554,7 +587,7 @@ export class SimpleCodeGeneratorAgent extends Agent<Env, CodeGenState> {
 
         const readme = await this.operations.implementPhase.generateReadme(this.getOperationOptions());
 
-        this.fileManager.saveGeneratedFile(readme);
+        await this.fileManager.saveGeneratedFile(readme, "feat: README.md");
 
         this.broadcast(WebSocketMessageResponses.FILE_GENERATED, {
             message: 'README.md generated successfully',
@@ -1138,7 +1171,7 @@ export class SimpleCodeGeneratorAgent extends Agent<Env, CodeGenState> {
         });
     
         // Update state with completed phase
-        this.fileManager.saveGeneratedFiles(finalFiles);
+        await this.fileManager.saveGeneratedFiles(finalFiles, `feat: ${phase.name}`);
 
         this.logger().info("Files generated for phase:", phase.name, finalFiles.map(f => f.filePath));
 
@@ -1303,7 +1336,7 @@ export class SimpleCodeGeneratorAgent extends Agent<Env, CodeGenState> {
             this.getOperationOptions()
         );
 
-        const fileState = this.fileManager.saveGeneratedFile(result);
+        const fileState = await this.fileManager.saveGeneratedFile(result, `fix: ${file.filePath}`);
 
         this.broadcast(WebSocketMessageResponses.FILE_REGENERATED, {
             message: `Regenerated file: ${file.filePath}`,
@@ -1414,7 +1447,7 @@ export class SimpleCodeGeneratorAgent extends Agent<Env, CodeGenState> {
             }, this.getOperationOptions());
 
             if (fastCodeFixer.length > 0) {
-                this.fileManager.saveGeneratedFiles(fastCodeFixer);
+                await this.fileManager.saveGeneratedFiles(fastCodeFixer, "fix: Fast smart code fixes");
                 await this.deployToSandbox(fastCodeFixer);
                 this.logger().info("Fast smart code fixes applied successfully");
             }
@@ -1486,7 +1519,7 @@ export class SimpleCodeGeneratorAgent extends Agent<Env, CodeGenState> {
                             filePurpose: allFiles.find(f => f.filePath === file.filePath)?.filePurpose || '',
                             fileContents: file.fileContents
                     }));
-                    this.fileManager.saveGeneratedFiles(fixedFiles);
+                    await this.fileManager.saveGeneratedFiles(fixedFiles, "fix: applied deterministic fixes");
                     
                     await this.deployToSandbox(fixedFiles, false, "fix: applied deterministic fixes");
                     this.logger().info("Deployed deterministic fixes to sandbox");
@@ -1797,6 +1830,50 @@ export class SimpleCodeGeneratorAgent extends Agent<Env, CodeGenState> {
         }
     }
 
+    /**
+     * Cache GitHub OAuth token in memory for subsequent exports
+     * Token is ephemeral - lost on DO eviction
+     */
+    setGitHubToken(token: string, username: string, ttl: number = 3600000): void {
+        this.githubTokenCache = {
+            token,
+            username,
+            expiresAt: Date.now() + ttl
+        };
+        this.logger().info('GitHub token cached', { 
+            username, 
+            expiresAt: new Date(this.githubTokenCache.expiresAt).toISOString() 
+        });
+    }
+
+    /**
+     * Get cached GitHub token if available and not expired
+     */
+    getGitHubToken(): { token: string; username: string } | null {
+        if (!this.githubTokenCache) {
+            return null;
+        }
+        
+        if (Date.now() >= this.githubTokenCache.expiresAt) {
+            this.logger().info('GitHub token expired, clearing cache');
+            this.githubTokenCache = null;
+            return null;
+        }
+        
+        return {
+            token: this.githubTokenCache.token,
+            username: this.githubTokenCache.username
+        };
+    }
+
+    /**
+     * Clear cached GitHub token
+     */
+    clearGitHubToken(): void {
+        this.githubTokenCache = null;
+        this.logger().info('GitHub token cleared');
+    }
+
     async onMessage(connection: Connection, message: string): Promise<void> {
         handleWebSocketMessage(this, connection, message);
     }
@@ -2002,27 +2079,10 @@ export class SimpleCodeGeneratorAgent extends Agent<Env, CodeGenState> {
 
     /**
      * Export generated code to a GitHub repository
-     * Creates repository and pushes all generated files
      */
     async pushToGitHub(options: GitHubPushRequest): Promise<GitHubExportResult> {
         try {
-            this.logger().info('Starting GitHub export', {
-                fileCount: Object.keys(this.state.generatedFilesMap).length
-            });
-
-            // Prepare README with Cloudflare button BEFORE push (if it exists)
-            const readmeFile = this.fileManager.getGeneratedFile('README.md');
-            if (readmeFile && readmeFile.fileContents.includes('[cloudflarebutton]')) {
-                readmeFile.fileContents = readmeFile.fileContents.replaceAll(
-                    '[cloudflarebutton]', 
-                    prepareCloudflareButton(options.repositoryHtmlUrl, 'markdown')
-                );
-                this.fileManager.saveGeneratedFile(readmeFile);
-                this.logger().info('README prepared with Cloudflare deploy button');
-                
-                // Deploy updated README to sandbox so it's visible in preview
-                await this.deployToSandbox([readmeFile], false, "feat: README updated with Cloudflare deploy button");
-            }
+            this.logger().info('Starting GitHub export using DO git');
 
             // Broadcast export started
             this.broadcast(WebSocketMessageResponses.GITHUB_EXPORT_STARTED, {
@@ -2031,48 +2091,121 @@ export class SimpleCodeGeneratorAgent extends Agent<Env, CodeGenState> {
                 isPrivate: options.isPrivate
             });
 
-            // Update progress for uploading
+            // Export git objects from DO
+            this.broadcast(WebSocketMessageResponses.GITHUB_EXPORT_PROGRESS, {
+                message: 'Preparing git repository...',
+                step: 'preparing',
+                progress: 20
+            });
+
+            const { gitObjects, query, templateDetails } = await this.exportGitObjects();
+            
+            this.logger().info('Git objects exported', {
+                objectCount: gitObjects.length,
+                hasTemplate: !!templateDetails
+            });
+
+            // Get app createdAt timestamp for template base commit
+            let appCreatedAt: Date | undefined = undefined;
+            try {
+                const appId = this.getAgentId();
+                if (appId) {
+                    const appService = new AppService(this.env);
+                    const app = await appService.getAppDetails(appId);
+                    if (app && app.createdAt) {
+                        appCreatedAt = new Date(app.createdAt);
+                        this.logger().info('Using app createdAt for template base', {
+                            createdAt: appCreatedAt.toISOString()
+                        });
+                    }
+                }
+            } catch (error) {
+                this.logger().warn('Failed to get app createdAt, using current time', { error });
+                appCreatedAt = new Date(); // Fallback to current time
+            }
+
+            // Push to GitHub using new service
             this.broadcast(WebSocketMessageResponses.GITHUB_EXPORT_PROGRESS, {
                 message: 'Uploading to GitHub repository...',
                 step: 'uploading_files',
-                progress: 30
+                progress: 40
             });
-            
-            // Call service to handle GitHub push (all files including prepared README)
-            const exportResult = await this.deploymentManager.pushToGitHub(options);
 
-            if (!exportResult?.success) {
-                throw new Error(`Failed to export to GitHub repository: ${exportResult?.error}`);
+            const result = await GitHubService.exportToGitHub({
+                gitObjects,
+                templateDetails,
+                appQuery: query,
+                appCreatedAt,
+                token: options.token,
+                repositoryUrl: options.repositoryHtmlUrl,
+                username: options.username,
+                email: options.email
+            });
+
+            if (!result.success) {
+                throw new Error(result.error || 'Failed to export to GitHub');
             }
 
-            this.logger().info('GitHub export completed successfully', { 
-                repositoryUrl: exportResult.repositoryUrl,
-                cloneUrl: exportResult.cloneUrl
+            this.logger().info('GitHub export completed', { 
+                commitSha: result.commitSha
             });
 
-            // Finalize and update database
+            // Cache token for subsequent exports
+            if (options.token && options.username) {
+                try {
+                    this.setGitHubToken(options.token, options.username);
+                    this.logger().info('GitHub token cached after successful export');
+                } catch (cacheError) {
+                    // Non-fatal - continue with finalization
+                    this.logger().warn('Failed to cache GitHub token', { error: cacheError });
+                }
+            }
+
+            // Update database
             this.broadcast(WebSocketMessageResponses.GITHUB_EXPORT_PROGRESS, {
                 message: 'Finalizing GitHub export...',
                 step: 'finalizing',
                 progress: 90
             });
 
-            this.logger().info('Finalizing GitHub export...');
+            const agentId = this.getAgentId();
+            this.logger().info('[DB Update] Updating app with GitHub repository URL', {
+                agentId,
+                repositoryUrl: options.repositoryHtmlUrl,
+                visibility: options.isPrivate ? 'private' : 'public'
+            });
+
             const appService = new AppService(this.env);
-            await appService.updateGitHubRepository(
-                this.getAgentId() || '',
+            const updateResult = await appService.updateGitHubRepository(
+                agentId || '',
                 options.repositoryHtmlUrl || '',
                 options.isPrivate ? 'private' : 'public'
             );
 
+            this.logger().info('[DB Update] Database update result', {
+                agentId,
+                success: updateResult,
+                repositoryUrl: options.repositoryHtmlUrl
+            });
+
             // Broadcast success
             this.broadcast(WebSocketMessageResponses.GITHUB_EXPORT_COMPLETED, {
                 message: `Successfully exported to GitHub repository: ${options.repositoryHtmlUrl}`,
-                repositoryUrl: options.repositoryHtmlUrl
+                repositoryUrl: options.repositoryHtmlUrl,
+                cloneUrl: options.cloneUrl,
+                commitSha: result.commitSha
             });
 
-            this.logger().info('GitHub export completed successfully', { repositoryUrl: options.repositoryHtmlUrl });
-            return { success: true, repositoryUrl: options.repositoryHtmlUrl };
+            this.logger().info('GitHub export completed successfully', { 
+                repositoryUrl: options.repositoryHtmlUrl,
+                commitSha: result.commitSha
+            });
+            
+            return { 
+                success: true, 
+                repositoryUrl: options.repositoryHtmlUrl,
+                cloneUrl: options.cloneUrl
+            };
 
         } catch (error) {
             this.logger().error('GitHub export failed', error);
@@ -2080,7 +2213,11 @@ export class SimpleCodeGeneratorAgent extends Agent<Env, CodeGenState> {
                 message: `GitHub export failed: ${error instanceof Error ? error.message : 'Unknown error'}`,
                 error: error instanceof Error ? error.message : 'Unknown error'
             });
-            return { success: false, repositoryUrl: options.repositoryHtmlUrl };
+            return { 
+                success: false, 
+                repositoryUrl: options.repositoryHtmlUrl,
+                cloneUrl: options.cloneUrl 
+            };
         }
     }
 
@@ -2334,4 +2471,33 @@ export class SimpleCodeGeneratorAgent extends Agent<Env, CodeGenState> {
             throw new Error(`Screenshot capture failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
         }
     }
+
+    /**
+     * Export git objects
+     * The route handler will build the repo with template rebasing
+     */
+    async exportGitObjects(): Promise<{
+        gitObjects: Array<{ path: string; data: Uint8Array }>;
+        query: string;
+        hasCommits: boolean;
+        templateDetails: TemplateDetails | null;
+    }> {
+        try {
+            // Export git objects efficiently (minimal DO memory usage)
+            const gitObjects = this.git.fs.exportGitObjects();
+            
+            // Ensure template details are available
+            await this.ensureTemplateDetails();
+            
+            return {
+                gitObjects,
+                query: this.state.query || 'N/A',
+                hasCommits: gitObjects.length > 0,
+                templateDetails: this.templateDetailsCache
+            };
+        } catch (error) {
+            this.logger().error('exportGitObjects failed', error);
+            throw error;
+        }
+    }
 }
diff --git a/worker/agents/git/fs-adapter.ts b/worker/agents/git/fs-adapter.ts
new file mode 100644
index 00000000..7eb81a5c
--- /dev/null
+++ b/worker/agents/git/fs-adapter.ts
@@ -0,0 +1,399 @@
+/**
+ * SQLite filesystem adapter for isomorphic-git
+ * One DO = one Git repo, stored directly in SQLite
+ * 
+ * Limits:
+ * - Cloudflare DO SQLite: 10GB total storage
+ * - Max parameter size: ~1MB per SQL statement parameter
+ * - Git objects are base64-encoded to safely store binary data
+ */
+
+export interface SqlExecutor {
+    <T = unknown>(query: TemplateStringsArray, ...values: (string | number | boolean | null)[]): T[];
+}
+
+// 1MB limit for Cloudflare DO SQL parameters, leave some headroom
+const MAX_OBJECT_SIZE = 900 * 1024; // 900KB
+
+export class SqliteFS {
+    private sql!: SqlExecutor;  // Assigned in constructor
+    public promises!: this;  // Set in init(), required by isomorphic-git
+    
+    constructor(sql: SqlExecutor) {
+        this.sql = sql;
+    }
+    
+    /**
+     * Get storage statistics for observability
+     */
+    getStorageStats(): { totalObjects: number; totalBytes: number; largestObject: { path: string; size: number } | null } {
+        const objects = this.sql<{ path: string; data: string; is_dir: number }>`SELECT path, data, is_dir FROM git_objects WHERE is_dir = 0`;
+        
+        if (!objects || objects.length === 0) {
+            return { totalObjects: 0, totalBytes: 0, largestObject: null };
+        }
+        
+        let totalBytes = 0;
+        let largestObject: { path: string; size: number } | null = null;
+        
+        for (const obj of objects) {
+            const size = obj.data.length; // Base64 encoded size
+            totalBytes += size;
+            
+            if (!largestObject || size > largestObject.size) {
+                largestObject = { path: obj.path, size };
+            }
+        }
+        
+        return {
+            totalObjects: objects.length,
+            totalBytes,
+            largestObject
+        };
+    }
+
+    init() {
+        // Create table
+        this.sql`
+            CREATE TABLE IF NOT EXISTS git_objects (
+                path TEXT PRIMARY KEY,
+                parent_path TEXT NOT NULL DEFAULT '',
+                data TEXT NOT NULL,
+                is_dir INTEGER NOT NULL DEFAULT 0,
+                mtime INTEGER NOT NULL
+            )
+        `;
+        
+        // Create indexes for efficient lookups
+        this.sql`CREATE INDEX IF NOT EXISTS idx_git_objects_parent ON git_objects(parent_path, path)`;
+        this.sql`CREATE INDEX IF NOT EXISTS idx_git_objects_is_dir ON git_objects(is_dir, path)`;
+        
+        // Ensure root directory exists
+        this.sql`INSERT OR IGNORE INTO git_objects (path, parent_path, data, is_dir, mtime) VALUES ('', '', '', 1, ${Date.now()})`;
+        
+        // promises property required for isomorphic-git
+        Object.defineProperty(this, 'promises', {
+            value: this,
+            enumerable: true,
+            writable: false,
+            configurable: false
+        });
+    }
+
+    async readFile(path: string, options?: { encoding?: 'utf8' }): Promise<Uint8Array | string> {
+        const normalized = path.replace(/^\/+/, '');
+        const result = this.sql<{ data: string; is_dir: number }>`SELECT data, is_dir FROM git_objects WHERE path = ${normalized}`;
+        if (!result[0]) {
+            const error: NodeJS.ErrnoException = new Error(`ENOENT: no such file or directory, open '${path}'`);
+            error.code = 'ENOENT';
+            error.errno = -2;
+            error.path = path;
+            throw error;
+        }
+        
+        if (result[0].is_dir) {
+            const error: NodeJS.ErrnoException = new Error(`EISDIR: illegal operation on a directory, read '${path}'`);
+            error.code = 'EISDIR';
+            error.errno = -21;
+            error.path = path;
+            throw error;
+        }
+        
+        const base64Data = result[0].data;
+        
+        if (!base64Data) {
+            return options?.encoding === 'utf8' ? '' : new Uint8Array(0);
+        }
+        
+        const binaryString = atob(base64Data);
+        const bytes = new Uint8Array(binaryString.length);
+        for (let i = 0; i < binaryString.length; i++) {
+            bytes[i] = binaryString.charCodeAt(i);
+        }
+        
+        return options?.encoding === 'utf8' ? new TextDecoder().decode(bytes) : bytes;
+    }
+
+    async writeFile(path: string, data: Uint8Array | string): Promise<void> {
+        const normalized = path.replace(/^\/+/, '');
+        
+        if (!normalized) {
+            throw new Error('Cannot write to root');
+        }
+        
+        // Convert to Uint8Array if string
+        const bytes = typeof data === 'string' ? new TextEncoder().encode(data) : data;
+        
+        // Check size limit
+        if (bytes.length > MAX_OBJECT_SIZE) {
+            throw new Error(`File too large: ${path} (${bytes.length} bytes, max ${MAX_OBJECT_SIZE})`);
+        }
+        
+        // Check if path exists as directory
+        const existing = this.sql<{ is_dir: number }>`SELECT is_dir FROM git_objects WHERE path = ${normalized}`;
+        if (existing[0]?.is_dir === 1) {
+            const error: NodeJS.ErrnoException = new Error(`EISDIR: illegal operation on a directory, open '${path}'`);
+            error.code = 'EISDIR';
+            error.errno = -21;
+            error.path = path;
+            throw error;
+        }
+        
+        // Ensure parent directories exist (git implicitly creates them)
+        const parts = normalized.split('/');
+        const parentPath = parts.length > 1 ? parts.slice(0, -1).join('/') : '';
+        
+        if (parts.length > 1) {
+            const now = Date.now();
+            for (let i = 0; i < parts.length - 1; i++) {
+                const dirPath = parts.slice(0, i + 1).join('/');
+                const dirParent = i === 0 ? '' : parts.slice(0, i).join('/');
+                this.sql`INSERT OR IGNORE INTO git_objects (path, parent_path, data, is_dir, mtime) VALUES (${dirPath}, ${dirParent}, '', 1, ${now})`;
+            }
+        }
+        
+        // Encode to base64 for safe storage
+        let base64Content = '';
+        if (bytes.length > 0) {
+            let binaryString = '';
+            for (let i = 0; i < bytes.length; i++) {
+                binaryString += String.fromCharCode(bytes[i]);
+            }
+            base64Content = btoa(binaryString);
+        }
+        
+        this.sql`INSERT OR REPLACE INTO git_objects (path, parent_path, data, is_dir, mtime) VALUES (${normalized}, ${parentPath}, ${base64Content}, 0, ${Date.now()})`;
+    }
+
+    async unlink(path: string): Promise<void> {
+        const normalized = path.replace(/^\/+/, '');
+        
+        const existing = this.sql<{ is_dir: number }>`SELECT is_dir FROM git_objects WHERE path = ${normalized}`;
+        if (!existing[0]) {
+            const error: NodeJS.ErrnoException = new Error(`ENOENT: no such file or directory, unlink '${path}'`);
+            error.code = 'ENOENT';
+            error.errno = -2;
+            error.path = path;
+            throw error;
+        }
+        if (existing[0].is_dir === 1) {
+            const error: NodeJS.ErrnoException = new Error(`EPERM: operation not permitted, unlink '${path}'`);
+            error.code = 'EPERM';
+            error.errno = -1;
+            error.path = path;
+            throw error;
+        }
+        
+        this.sql`DELETE FROM git_objects WHERE path = ${normalized} AND is_dir = 0`;
+    }
+
+    async readdir(path: string): Promise<string[]> {
+        const normalized = path.replace(/^\/+|\/+$/g, '');
+        
+        const dirCheck = this.sql<{ is_dir: number }>`SELECT is_dir FROM git_objects WHERE path = ${normalized}`;
+        if (!dirCheck[0] || !dirCheck[0].is_dir) {
+            const error: NodeJS.ErrnoException = new Error(`ENOENT: no such file or directory, scandir '${path}'`);
+            error.code = 'ENOENT';
+            error.errno = -2;
+            error.path = path;
+            throw error;
+        }
+        
+        const rows = this.sql<{ path: string }>`SELECT path FROM git_objects WHERE parent_path = ${normalized}`;
+        
+        if (!rows || rows.length === 0) return [];
+
+        // Extract just the basename from each path
+        const children = rows.map(row => {
+            const parts = row.path.split('/');
+            return parts[parts.length - 1];
+        });
+
+        return children;
+    }
+
+    async mkdir(path: string, _options?: any): Promise<void> {
+        const normalized = path.replace(/^\/+|\/+$/g, '');
+        
+        if (!normalized) return;
+        
+        const parts = normalized.split('/');
+        const isDirectChildOfRoot = parts.length === 1;
+        
+        if (!isDirectChildOfRoot) {
+            // Check parent exists first (avoid unnecessary queries)
+            const parentPath = parts.slice(0, -1).join('/');
+            const parent = this.sql<{ is_dir: number }>`SELECT is_dir FROM git_objects WHERE path = ${parentPath}`;
+            if (!parent[0] || parent[0].is_dir !== 1) {
+                // Parent doesn't exist - throw ENOENT
+                // Isomorphic-git's FileSystem wrapper will catch this and recursively create parent
+                const error: NodeJS.ErrnoException = new Error(`ENOENT: no such file or directory, mkdir '${path}'`);
+                error.code = 'ENOENT';
+                error.errno = -2;
+                error.path = path;
+                throw error;
+            }
+        }
+        
+        // Check if already exists (after parent check to fail fast on missing parent)
+        const existing = this.sql<{ is_dir: number }>`SELECT is_dir FROM git_objects WHERE path = ${normalized}`;
+        if (existing[0]) {
+            if (existing[0].is_dir === 1) {
+                return;
+            } else {
+                const error: NodeJS.ErrnoException = new Error(`EEXIST: file already exists, mkdir '${path}'`);
+                error.code = 'EEXIST';
+                error.errno = -17;
+                error.path = path;
+                throw error;
+            }
+        }
+        
+        const parentPath = parts.length > 1 ? parts.slice(0, -1).join('/') : '';
+        this.sql`INSERT OR IGNORE INTO git_objects (path, parent_path, data, is_dir, mtime) VALUES (${normalized}, ${parentPath}, '', 1, ${Date.now()})`;
+    }
+
+    async rmdir(path: string): Promise<void> {
+        const normalized = path.replace(/^\/+|\/+$/g, '');
+        
+        if (!normalized) {
+            throw new Error('Cannot remove root directory');
+        }
+        
+        // Check if exists and is a directory
+        const existing = this.sql<{ is_dir: number }>`SELECT is_dir FROM git_objects WHERE path = ${normalized}`;
+        if (!existing[0]) {
+            const error: NodeJS.ErrnoException = new Error(`ENOENT: no such file or directory, rmdir '${path}'`);
+            error.code = 'ENOENT';
+            error.errno = -2;
+            error.path = path;
+            throw error;
+        }
+        if (existing[0].is_dir !== 1) {
+            const error: NodeJS.ErrnoException = new Error(`ENOTDIR: not a directory, rmdir '${path}'`);
+            error.code = 'ENOTDIR';
+            error.errno = -20;
+            error.path = path;
+            throw error;
+        }
+        
+        // Check if directory is empty (has no children)
+        const children = this.sql<{ path: string }>`SELECT path FROM git_objects WHERE path LIKE ${normalized + '/%'} LIMIT 1`;
+        if (children.length > 0) {
+            const error: NodeJS.ErrnoException = new Error(`ENOTEMPTY: directory not empty, rmdir '${path}'`);
+            error.code = 'ENOTEMPTY';
+            error.errno = -39;
+            error.path = path;
+            throw error;
+        }
+        
+        this.sql`DELETE FROM git_objects WHERE path = ${normalized}`;
+    }
+
+    async stat(path: string): Promise<{ type: 'file' | 'dir'; mode: number; size: number; mtimeMs: number }> {
+        const normalized = path.replace(/^\/+/, '');
+        const result = this.sql<{ data: string; mtime: number; is_dir: number }>`SELECT data, mtime, is_dir FROM git_objects WHERE path = ${normalized}`;
+        if (!result[0]) {
+            const error: NodeJS.ErrnoException = new Error(`ENOENT: no such file or directory, stat '${path}'`);
+            error.code = 'ENOENT';
+            error.errno = -2;
+            error.path = path;
+            throw error;
+        }
+        
+        const row = result[0];
+        const isDir = row.is_dir === 1;
+        
+        // Calculate actual size for files (base64 is ~1.33x larger than binary)
+        let size = 0;
+        if (!isDir && row.data) {
+            // Approximate binary size from base64 length
+            size = Math.floor(row.data.length * 0.75);
+        }
+        
+        const statResult = {
+            type: (isDir ? 'dir' : 'file') as 'file' | 'dir',
+            mode: isDir ? 0o040755 : 0o100644,
+            size,
+            mtimeMs: row.mtime,
+            // Add full Node.js stat properties for isomorphic-git
+            dev: 0,
+            ino: 0,
+            uid: 0,
+            gid: 0,
+            ctime: new Date(row.mtime),
+            mtime: new Date(row.mtime),
+            ctimeMs: row.mtime,
+            // Add methods that isomorphic-git expects
+            isFile: () => !isDir,
+            isDirectory: () => isDir,
+            isSymbolicLink: () => false
+        };
+        return statResult;
+    }
+
+    async lstat(path: string) {
+        return await this.stat(path);
+    }
+
+    async symlink(target: string, path: string): Promise<void> {
+        await this.writeFile(path, target);
+    }
+
+    async readlink(path: string): Promise<string> {
+        return (await this.readFile(path, { encoding: 'utf8' })) as string;
+    }
+
+    /**
+     * Check if a file or directory exists
+     * Required by isomorphic-git's init check
+     */
+    async exists(path: string): Promise<boolean> {
+        try {
+            await this.stat(path);
+            return true;
+        } catch (err) {
+            if ((err as NodeJS.ErrnoException).code === 'ENOENT') {
+                return false;
+            }
+            throw err;
+        }
+    }
+
+    /**
+     * Alias for writeFile (isomorphic-git sometimes uses 'write')
+     */
+    async write(path: string, data: Uint8Array | string): Promise<void> {
+        return await this.writeFile(path, data);
+    }
+
+    /**
+     * Export all git objects for cloning
+     * Returns array of {path, data}
+     */
+    exportGitObjects(): Array<{ path: string; data: Uint8Array }> {
+        const objects = this.sql<{ path: string; data: string; is_dir: number }>`
+            SELECT path, data, is_dir FROM git_objects WHERE path LIKE '.git/%'
+        `;
+        
+        const exported: Array<{ path: string; data: Uint8Array }> = [];
+        
+        for (const obj of objects) {
+            if (obj.is_dir === 1) continue; // Skip directories, only export files
+            
+            // Decode base64 to binary
+            const binaryString = atob(obj.data);
+            const bytes = new Uint8Array(binaryString.length);
+            for (let i = 0; i < binaryString.length; i++) {
+                bytes[i] = binaryString.charCodeAt(i);
+            }
+            
+            exported.push({
+                path: obj.path,
+                data: bytes
+            });
+        }
+        
+        return exported;
+    }
+}
\ No newline at end of file
diff --git a/worker/agents/git/git-clone-service.ts b/worker/agents/git/git-clone-service.ts
new file mode 100644
index 00000000..175d864e
--- /dev/null
+++ b/worker/agents/git/git-clone-service.ts
@@ -0,0 +1,356 @@
+/**
+ * Git clone service for building and serving repositories
+ * Handles template rebasing and git HTTP protocol
+ */
+
+import git from '@ashishkumar472/cf-git';
+import { MemFS } from './memfs';
+import { createLogger } from '../../logger';
+import type { TemplateDetails as SandboxTemplateDetails } from '../../services/sandbox/sandboxTypes';
+
+const logger = createLogger('GitCloneService');
+
+export interface RepositoryBuildOptions {
+    gitObjects: Array<{ path: string; data: Uint8Array }>;
+    templateDetails: SandboxTemplateDetails | null | undefined;
+    appQuery: string;
+    appCreatedAt?: Date;  // App creation timestamp for deterministic template commit
+}
+
+export class GitCloneService {
+    /**
+     * Build in-memory git repository by rebasing agent's git history on template files
+     * 
+     * Strategy:
+     * 1. Create base commit with template files
+     * 2. Import exported git objects from agent
+     * 3. Update refs to point to agent's commits
+     * 
+     * Result: Template base + agent's commit history on top
+     */
+    static async buildRepository(options: RepositoryBuildOptions): Promise<MemFS> {
+        const { gitObjects, templateDetails, appQuery, appCreatedAt } = options;
+        const fs = new MemFS();
+        
+        try {
+            logger.info('Building git repository with template rebase', { 
+                templateName: templateDetails?.name,
+                gitObjectCount: gitObjects.length
+            });
+            
+            // If no agent commits yet, just create template base
+            if (gitObjects.length === 0) {
+                await git.init({ fs, dir: '/', defaultBranch: 'main' });
+                
+                if (templateDetails && templateDetails.allFiles) {
+                    // Create template commit
+                    for (const [path, content] of Object.entries(templateDetails.allFiles)) {
+                        await fs.writeFile(path, content as string);
+                        await git.add({ fs, dir: '/', filepath: path });
+                    }
+                    await git.commit({
+                        fs, dir: '/',
+                        message: `Template: ${templateDetails.name}`,
+                        author: { 
+                            name: 'Vibesdk', 
+                            email: 'template@vibesdk.com',
+                            timestamp: appCreatedAt ? Math.floor(appCreatedAt.getTime() / 1000) : 0
+                        }
+                    });
+                }
+                
+                return fs;
+            }
+            
+            await git.init({ fs, dir: '/', defaultBranch: 'main' });
+            
+            // Create template base commit
+            let baseCommit: string | null = null;
+            if (templateDetails && templateDetails.allFiles && Object.keys(templateDetails.allFiles).length > 0) {
+                logger.info('Creating template base', { 
+                    templateName: templateDetails.name,
+                    fileCount: Object.keys(templateDetails.allFiles).length
+                });
+                
+                for (const [path, content] of Object.entries(templateDetails.allFiles)) {
+                    await fs.writeFile(path, content as string);
+                    await git.add({ fs, dir: '/', filepath: path });
+                }
+                
+                baseCommit = await git.commit({
+                    fs, dir: '/',
+                    message: `Template: ${templateDetails.name}\n\nBase template for ${appQuery}`,
+                    author: { 
+                        name: 'Vibesdk', 
+                        email: 'template@vibesdk.com',
+                        timestamp: appCreatedAt ? Math.floor(appCreatedAt.getTime() / 1000) : 0
+                    }
+                });
+                
+                logger.info('Template base created', { baseCommit });
+            }
+            
+            // Find agent's HEAD from exported objects
+            const headFile = gitObjects.find(obj => obj.path === '.git/HEAD');
+            const headContent = headFile ? new TextDecoder().decode(headFile.data).trim() : null;
+            
+            let agentHeadOid: string | null = null;
+            if (headContent && headContent.startsWith('ref: ')) {
+                // HEAD is a ref, resolve it
+                const refPath = headContent.slice(5).trim();
+                const refFile = gitObjects.find(obj => obj.path === `.git/${refPath}`);
+                agentHeadOid = refFile ? new TextDecoder().decode(refFile.data).trim() : null;
+            } else if (headContent && headContent.length === 40) {
+                // HEAD is direct SHA
+                agentHeadOid = headContent;
+            }
+            
+            if (!agentHeadOid) {
+                throw new Error('Could not determine agent HEAD from exported objects');
+            }
+            
+            logger.info('Found agent original HEAD', { agentHeadOid });
+            
+            // Import git objects (skip refs to preserve template base)
+            logger.info('Importing agent git objects', { count: gitObjects.length });
+            let importedCount = 0;
+            for (const obj of gitObjects) {
+                if (obj.path.startsWith('.git/refs/') || obj.path === '.git/HEAD' || obj.path === '.git/packed-refs') {
+                    continue;
+                }
+                await fs.writeFile(obj.path, obj.data);
+                importedCount++;
+            }
+            logger.info('Imported git objects (excluding refs)', { importedCount });
+            
+            // Get agent's commit history (oldest to newest)
+            const agentLog = await git.log({ fs, dir: '/', ref: agentHeadOid });
+            const commitsOldestFirst = agentLog.reverse();
+            
+            logger.info('Replaying agent commits on template base', { 
+                commitCount: commitsOldestFirst.length,
+                hasTemplate: !!baseCommit
+            });
+            
+            // Replay agent commits on top of template base
+            for (const commitInfo of commitsOldestFirst) {
+                // Collect files from agent's commit tree
+                const agentFiles: Array<{ path: string; oid: string }> = [];
+                
+                const walkTree = async (treeOid: string, basePath: string = '') => {
+                    const { tree } = await git.readTree({ fs, dir: '/', oid: treeOid });
+                    
+                    for (const entry of tree) {
+                        const fullPath = basePath ? `${basePath}/${entry.path}` : entry.path;
+                        
+                        if (entry.type === 'blob') {
+                            agentFiles.push({ path: fullPath, oid: entry.oid });
+                        } else if (entry.type === 'tree') {
+                            await walkTree(entry.oid, fullPath);
+                        }
+                    }
+                };
+                
+                await walkTree(commitInfo.commit.tree);
+                
+                // Write agent files
+                for (const file of agentFiles) {
+                    const { blob } = await git.readBlob({ fs, dir: '/', oid: file.oid });
+                    await fs.writeFile(file.path, blob);
+                }
+                
+                // Stage all files (template + agent)
+                const allFiles: string[] = [];
+                const getAllFiles = async (dir: string): Promise<void> => {
+                    const entries = await fs.readdir(dir);
+                    for (const entry of entries) {
+                        const fullPath = dir === '/' ? entry : `${dir}/${entry}`;
+                        if (entry === '.git' || fullPath === '.git') continue;
+                        
+                        const stat = await fs.stat(fullPath);
+                        if (stat.type === 'dir') {
+                            await getAllFiles(fullPath);
+                        } else {
+                            allFiles.push(fullPath.startsWith('/') ? fullPath.slice(1) : fullPath);
+                        }
+                    }
+                };
+                
+                await getAllFiles('/');
+                
+                for (const filepath of allFiles) {
+                    await git.add({ fs, dir: '/', filepath });
+                }
+                
+                // Commit with original metadata
+                await git.commit({
+                    fs,
+                    dir: '/',
+                    message: commitInfo.commit.message,
+                    author: commitInfo.commit.author,
+                    committer: commitInfo.commit.committer || commitInfo.commit.author
+                });
+            }
+            
+            logger.info('Repository built with proper template base and agent commits');
+            return fs;
+        } catch (error) {
+            logger.error('Failed to build git repository', { error });
+            throw new Error(`Failed to build repository: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+
+
+    /**
+     * Handle git info/refs request
+     * Returns advertisement of available refs for git clone
+     */
+    static async handleInfoRefs(fs: MemFS): Promise<string> {
+        try {
+            logger.info('Generating info/refs response');
+            
+            const head = await git.resolveRef({ fs, dir: '/', ref: 'HEAD' });
+            logger.info('Resolved HEAD', { head });
+            
+            // Manually list branches from .git/refs/heads/ to avoid git.listBranches() hanging
+            let branches: string[] = [];
+            try {
+                const headsDir = await fs.readdir('.git/refs/heads');
+                branches = headsDir.filter((name: string) => !name.startsWith('.'));
+                logger.info('Found branches', { branches });
+            } catch (err) {
+                logger.warn('No branches found', { error: err });
+                branches = [];
+            }
+            
+            // Git HTTP protocol: info/refs response format
+            let response = '001e# service=git-upload-pack\n0000';
+            
+            // HEAD ref with capabilities
+            const headLine = `${head} HEAD\0side-band-64k thin-pack ofs-delta agent=git/isomorphic-git\n`;
+            response += this.formatPacketLine(headLine);
+            
+            // Branch refs
+            for (const branch of branches) {
+                try {
+                    const oid = await git.resolveRef({ fs, dir: '/', ref: `refs/heads/${branch}` });
+                    response += this.formatPacketLine(`${oid} refs/heads/${branch}\n`);
+                    logger.info('Added branch ref', { branch, oid });
+                } catch (err) {
+                    logger.warn('Failed to resolve branch', { branch, error: err });
+                }
+            }
+            
+            // Flush packet
+            response += '0000';
+            
+            logger.info('Generated info/refs response', { responseLength: response.length });
+            return response;
+        } catch (error) {
+            logger.error('Failed to handle info/refs', { error });
+            throw new Error(`Failed to get refs: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+
+    /**
+     * Handle git upload-pack request (actual clone operation)
+     * Includes all git objects to ensure template-rebased commits work correctly
+     */
+    static async handleUploadPack(fs: MemFS): Promise<Uint8Array> {
+        try {
+            // Collect all git objects from filesystem
+            const allObjects = new Set<string>();
+            
+            const objectDirs = await fs.readdir('.git/objects');
+            for (const item of objectDirs) {
+                if (item.length === 2 && /[0-9a-f]{2}/.test(item)) {
+                    const objectFiles = await fs.readdir(`.git/objects/${item}`);
+                    for (const file of objectFiles) {
+                        if (file.length === 38 && /[0-9a-f]{38}/.test(file)) {
+                            allObjects.add(item + file);
+                        }
+                    }
+                }
+            }
+            
+            logger.info('Generating packfile', { objectCount: allObjects.size });
+            const packResult = await git.packObjects({ 
+                fs, 
+                dir: '/', 
+                oids: Array.from(allObjects)
+            });
+            
+            const packfile = packResult.packfile;
+            
+            if (!packfile) {
+                throw new Error('Failed to generate packfile');
+            }
+            
+            // NAK packet: "0008NAK\n"
+            const nakPacket = new Uint8Array([
+                0x30, 0x30, 0x30, 0x38,
+                0x4e, 0x41, 0x4b,
+                0x0a
+            ]);
+            
+            // Wrap packfile in sideband format
+            const sideband = this.wrapInSideband(packfile);
+            
+            // Concatenate NAK + sideband packfile
+            const result = new Uint8Array(nakPacket.length + sideband.length);
+            result.set(nakPacket, 0);
+            result.set(sideband, nakPacket.length);
+            
+            return result;
+        } catch (error) {
+            logger.error('Failed to handle upload-pack', { error });
+            throw new Error(`Failed to generate pack: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+
+    /**
+     * Format git packet line (4-byte hex length + data)
+     */
+    private static formatPacketLine(data: string): string {
+        const length = data.length + 4;
+        const hexLength = length.toString(16).padStart(4, '0');
+        return hexLength + data;
+    }
+
+    /**
+     * Wrap packfile in sideband-64k format
+     */
+    private static wrapInSideband(packfile: Uint8Array): Uint8Array {
+        const CHUNK_SIZE = 65515;
+        const chunks: Uint8Array[] = [];
+        let offset = 0;
+        while (offset < packfile.length) {
+            const chunkSize = Math.min(CHUNK_SIZE, packfile.length - offset);
+            const chunk = packfile.slice(offset, offset + chunkSize);
+            
+            const packetLength = 4 + 1 + chunkSize;
+            const lengthHex = packetLength.toString(16).padStart(4, '0');
+            const packet = new Uint8Array(4 + 1 + chunkSize);
+            for (let i = 0; i < 4; i++) {
+                packet[i] = lengthHex.charCodeAt(i);
+            }
+            packet[4] = 0x01;
+            packet.set(chunk, 5);
+            
+            chunks.push(packet);
+            offset += chunkSize;
+        }
+        
+        const flush = new Uint8Array([0x30, 0x30, 0x30, 0x30]);
+        chunks.push(flush);
+        const totalLength = chunks.reduce((sum, chunk) => sum + chunk.length, 0);
+        const result = new Uint8Array(totalLength);
+        let resultOffset = 0;
+        for (const chunk of chunks) {
+            result.set(chunk, resultOffset);
+            resultOffset += chunk.length;
+        }
+        
+        return result;
+    }
+}
diff --git a/worker/agents/git/git.ts b/worker/agents/git/git.ts
new file mode 100644
index 00000000..9f2dcdfd
--- /dev/null
+++ b/worker/agents/git/git.ts
@@ -0,0 +1,189 @@
+/**
+ * Git version control for Durable Objects using isomorphic-git
+ */
+
+import git from '@ashishkumar472/cf-git';
+import { SqliteFS, type SqlExecutor } from './fs-adapter';
+import { FileOutputType } from '../schemas';
+
+export interface CommitInfo {
+    oid: string;
+    message: string;
+    author: string;
+    timestamp: number;
+}
+
+type FileSnapshot = Omit<FileOutputType, 'filePurpose'>;
+
+export class GitVersionControl {
+    public fs: SqliteFS;
+    private author: { name: string; email: string };
+
+    constructor(sql: SqlExecutor, author?: { name: string; email: string }) {
+        this.fs = new SqliteFS(sql);
+        this.author = author || { name: 'Vibesdk', email: 'vibesdk-bot@cloudflare.com' };
+        
+        // Initialize SQLite table synchronously
+        this.fs.init();
+    }
+
+    async init(): Promise<void> {
+        // Initialize git repository (isomorphic-git init is idempotent - safe to call multiple times)
+        try {
+            const startTime = Date.now();
+            console.log('[Git] Initializing repository...');
+            await git.init({ fs: this.fs, dir: '/', defaultBranch: 'main' });
+            const duration = Date.now() - startTime;
+            console.log(`[Git] Repository initialized in ${duration}ms`);
+        } catch (error) {
+            // Init might fail if already initialized, which is fine
+            console.log('[Git] Repository already initialized or init skipped:', error);
+        }
+    }
+
+    async commit(files: FileSnapshot[], message?: string): Promise<string | null> {
+        if (!files.length) throw new Error('Cannot create empty commit');
+
+        console.log(`[Git] Starting commit with ${files.length} files`);
+
+        // Normalize paths (remove leading slashes for git)
+        const normalizedFiles = files.map(f => ({
+            path: f.filePath.startsWith('/') ? f.filePath.slice(1) : f.filePath,
+            content: f.fileContents
+        }));
+
+        // Write and stage files first
+        for (let i = 0; i < normalizedFiles.length; i++) {
+            const file = normalizedFiles[i];
+            try {
+                console.log(`[Git] Processing file ${i + 1}/${normalizedFiles.length}: ${file.path}`);
+                await this.fs.writeFile(file.path, file.content);
+                
+                await git.add({ 
+                    fs: this.fs, 
+                    dir: '/', 
+                    filepath: file.path,
+                    cache: {}
+                });
+                
+                console.log(`[Git] Staged ${i + 1}/${normalizedFiles.length}: ${file.path}`);
+            } catch (error) {
+                console.error(`[Git] Failed to stage file ${file.path}:`, error);
+                throw new Error(`Failed to stage file ${file.path}: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+
+        console.log('[Git] All files written and staged, checking for changes...');
+
+        // Check if there are actual changes (compare staged vs HEAD)
+        let hasChanges = false;
+        try {
+            const status = await git.statusMatrix({ fs: this.fs, dir: '/' });
+            // row[1] = HEAD index, row[2] = STAGE index
+            // If they differ, we have changes to commit
+            hasChanges = status.some(row => row[1] !== row[2]);
+            console.log(`[Git] Status check: ${hasChanges ? 'has changes' : 'no changes'}`);
+        } catch (e) {
+            // First commit or error, assume changes
+            console.log('[Git] Status check failed (likely first commit), assuming changes');
+            hasChanges = true;
+        }
+
+        if (!hasChanges) {
+            console.log('[Git] No actual changes to commit');
+            return null; // No actual changes to commit
+        }
+
+        console.log('[Git] Creating commit...');
+        const oid = await git.commit({
+            fs: this.fs,
+            dir: '/',
+            message: message || `Auto-checkpoint (${new Date().toISOString()})`,
+            author: {
+                name: this.author.name,
+                email: this.author.email,
+                timestamp: Math.floor(Date.now() / 1000)
+            }
+        });
+        console.log(`[Git] Commit created: ${oid}`);
+        return oid;
+    }
+
+    async log(limit = 50): Promise<CommitInfo[]> {
+        try {
+            const commits = await git.log({ fs: this.fs, dir: '/', depth: limit, ref: 'main' });
+            return commits.map(c => ({
+                oid: c.oid,
+                message: c.commit.message,
+                author: `${c.commit.author.name} <${c.commit.author.email}>`,
+                timestamp: c.commit.author.timestamp * 1000
+            }));
+        } catch {
+            return [];
+        }
+    }
+
+    async checkout(oid: string): Promise<FileSnapshot[]> {
+        const { commit } = await git.readCommit({ fs: this.fs, dir: '/', oid });
+        const files: FileSnapshot[] = [];
+        await this.walkTree(commit.tree, '', files);
+        return files;
+    }
+
+    private async walkTree(treeOid: string, prefix: string, files: FileSnapshot[]): Promise<void> {
+        const { tree } = await git.readTree({ fs: this.fs, dir: '/', oid: treeOid });
+
+        for (const entry of tree) {
+            const path = prefix ? `${prefix}/${entry.path}` : entry.path;
+
+            if (entry.type === 'blob') {
+                const { blob } = await git.readBlob({ fs: this.fs, dir: '/', oid: entry.oid });
+                // Git blobs are binary, decode with proper error handling
+                try {
+                    const content = new TextDecoder('utf-8').decode(blob);
+                    // Check if it's valid text by looking for null bytes
+                    if (!content.includes('\0')) {
+                        files.push({ filePath: path, fileContents: content });
+                    }
+                    // Skip binary files (checkout is for reverting code files)
+                } catch {
+                    // Failed to decode, skip binary file
+                }
+            } else if (entry.type === 'tree') {
+                await this.walkTree(entry.oid, path, files);
+            }
+        }
+    }
+
+    async getHead(): Promise<string | null> {
+        try {
+            let timeoutId: ReturnType<typeof setTimeout> | null = null;
+            
+            const timeoutPromise = new Promise<never>((_, reject) => {
+                timeoutId = setTimeout(() => {
+                    reject(new Error('git.resolveRef timed out after 5 seconds'));
+                }, 5000);
+            });
+            
+            const resolvePromise = git.resolveRef({ fs: this.fs, dir: '/', ref: 'HEAD' });
+            
+            try {
+                const result = await Promise.race([resolvePromise, timeoutPromise]);
+                return result;
+            } finally {
+                if (timeoutId !== null) {
+                    clearTimeout(timeoutId);
+                }
+            }
+        } catch {
+            return null;
+        }
+    }
+
+    /**
+     * Get storage statistics for monitoring and observability
+     */
+    getStorageStats(): { totalObjects: number; totalBytes: number; largestObject: { path: string; size: number } | null } {
+        return this.fs.getStorageStats();
+    }
+}
\ No newline at end of file
diff --git a/worker/agents/git/index.ts b/worker/agents/git/index.ts
new file mode 100644
index 00000000..0814f32a
--- /dev/null
+++ b/worker/agents/git/index.ts
@@ -0,0 +1,11 @@
+/**
+ * Git version control for Durable Objects
+ */
+
+export { GitVersionControl } from './git';
+export { GitCloneService } from './git-clone-service';
+export { MemFS } from './memfs';
+export { SqliteFS } from './fs-adapter';
+export type { CommitInfo } from './git';
+export type { SqlExecutor } from './fs-adapter';
+export type { RepositoryBuildOptions } from './git-clone-service';
\ No newline at end of file
diff --git a/worker/agents/git/memfs.ts b/worker/agents/git/memfs.ts
new file mode 100644
index 00000000..8e63642b
--- /dev/null
+++ b/worker/agents/git/memfs.ts
@@ -0,0 +1,169 @@
+/**
+ * In-memory filesystem for git clone operations
+ * Full async implementation for isomorphic-git compatibility
+ */
+
+export class MemFS {
+    private files = new Map<string, Uint8Array>();
+    
+    constructor() {
+        // promises property required for isomorphic-git
+        Object.defineProperty(this, 'promises', {
+            value: this,
+            enumerable: true,
+            writable: false,
+            configurable: false
+        });
+    }
+    
+    async writeFile(path: string, data: string | Uint8Array): Promise<void> {
+        const bytes = typeof data === 'string' 
+            ? new TextEncoder().encode(data) 
+            : data;
+        
+        const normalized = path.startsWith('/') ? path.slice(1) : path;
+        this.files.set(normalized, bytes);
+    }
+    
+    async readFile(path: string, options?: { encoding?: 'utf8' | string }): Promise<Uint8Array | string> {
+        const normalized = path.startsWith('/') ? path.slice(1) : path;
+        const data = this.files.get(normalized);
+        
+        if (!data) {
+            const error: NodeJS.ErrnoException = new Error(`ENOENT: no such file or directory, open '${path}'`);
+            error.code = 'ENOENT';
+            throw error;
+        }
+        
+        if (options?.encoding === 'utf8') {
+            return new TextDecoder().decode(data);
+        }
+        
+        return data;
+    }
+    
+    async readdir(dirPath: string): Promise<string[]> {
+        const normalized = dirPath === '/' ? '' : (dirPath.startsWith('/') ? dirPath.slice(1) : dirPath);
+        const prefix = normalized ? normalized + '/' : '';
+        const results = new Set<string>();
+        
+        for (const filePath of this.files.keys()) {
+            if (filePath.startsWith(prefix)) {
+                const relative = filePath.slice(prefix.length);
+                const firstPart = relative.split('/')[0];
+                if (firstPart) {
+                    results.add(firstPart);
+                }
+            }
+        }
+        
+        return Array.from(results);
+    }
+    
+    async stat(path: string): Promise<{
+        type: 'file' | 'dir';
+        mode: number;
+        size: number;
+        mtimeMs: number;
+        ino: number;
+        uid: number;
+        gid: number;
+        dev: number;
+        ctime: Date;
+        mtime: Date;
+        ctimeMs: number;
+        isFile: () => boolean;
+        isDirectory: () => boolean;
+        isSymbolicLink: () => boolean;
+    }> {
+        const normalized = path.startsWith('/') ? path.slice(1) : path;
+        
+        // Check if it's a file
+        const data = this.files.get(normalized);
+        if (data) {
+            return {
+                type: 'file' as const,
+                mode: 0o100644,
+                size: data.length,
+                mtimeMs: Date.now(),
+                ino: 0,
+                uid: 0,
+                gid: 0,
+                dev: 0,
+                ctime: new Date(),
+                mtime: new Date(),
+                ctimeMs: Date.now(),
+                isFile: () => true,
+                isDirectory: () => false,
+                isSymbolicLink: () => false
+            };
+        }
+        
+        // Check if it's a directory (has children)
+        const prefix = normalized ? normalized + '/' : '';
+        for (const filePath of this.files.keys()) {
+            if (filePath.startsWith(prefix)) {
+                return {
+                    type: 'dir' as const,
+                    mode: 0o040755,
+                    size: 0,
+                    mtimeMs: Date.now(),
+                    ino: 0,
+                    uid: 0,
+                    gid: 0,
+                    dev: 0,
+                    ctime: new Date(),
+                    mtime: new Date(),
+                    ctimeMs: Date.now(),
+                    isFile: () => false,
+                    isDirectory: () => true,
+                    isSymbolicLink: () => false
+                };
+            }
+        }
+        
+        const error: NodeJS.ErrnoException = new Error(`ENOENT: no such file or directory, stat '${path}'`);
+        error.code = 'ENOENT';
+        throw error;
+    }
+    
+    async lstat(path: string) {
+        return this.stat(path);
+    }
+    
+    async mkdir(_path: string, _options?: any): Promise<void> {
+        // No-op: directories implicit in paths
+    }
+    
+    async rmdir(_path: string): Promise<void> {
+        // No-op
+    }
+    
+    async rename(oldPath: string, newPath: string): Promise<void> {
+        const oldNormalized = oldPath.startsWith('/') ? oldPath.slice(1) : oldPath;
+        const newNormalized = newPath.startsWith('/') ? newPath.slice(1) : newPath;
+        
+        const data = this.files.get(oldNormalized);
+        if (data) {
+            this.files.set(newNormalized, data);
+            this.files.delete(oldNormalized);
+        }
+    }
+    
+    async chmod(_path: string, _mode: number): Promise<void> {
+        // No-op
+    }
+    
+    async readlink(_path: string): Promise<string> {
+        throw new Error('Symbolic links not supported in MemFS');
+    }
+    
+    async symlink(_target: string, _path: string): Promise<void> {
+        throw new Error('Symbolic links not supported in MemFS');
+    }
+    
+    async unlink(path: string): Promise<void> {
+        const normalized = path.startsWith('/') ? path.slice(1) : path;
+        this.files.delete(normalized);
+    }
+}
diff --git a/worker/agents/services/implementations/CodingAgent.ts b/worker/agents/services/implementations/CodingAgent.ts
index 978f2835..1becb4be 100644
--- a/worker/agents/services/implementations/CodingAgent.ts
+++ b/worker/agents/services/implementations/CodingAgent.ts
@@ -112,7 +112,7 @@ export class CodingAgentInterface {
         issue: string,
         toolRenderer: RenderToolCall,
         streamCb: (chunk: string) => void,
-        focusPaths?: string[],
+        focusPaths?: string[]
     ): Promise<DeepDebugResult> {
         return this.agentStub.executeDeepDebug(issue, toolRenderer, streamCb, focusPaths);
     }
diff --git a/worker/agents/services/implementations/DeploymentManager.ts b/worker/agents/services/implementations/DeploymentManager.ts
index 7e63b3a7..20f3b6bc 100644
--- a/worker/agents/services/implementations/DeploymentManager.ts
+++ b/worker/agents/services/implementations/DeploymentManager.ts
@@ -5,8 +5,7 @@ import {
     SandboxDeploymentCallbacks,
     CloudflareDeploymentCallbacks
 } from '../interfaces/IDeploymentManager';
-import { BootstrapResponse, GitHubPushRequest, StaticAnalysisResponse, RuntimeError, PreviewType } from '../../../services/sandbox/sandboxTypes';
-import { GitHubExportResult } from '../../../services/github/types';
+import { BootstrapResponse, StaticAnalysisResponse, RuntimeError, PreviewType } from '../../../services/sandbox/sandboxTypes';
 import { FileOutputType } from '../../schemas';
 import { generateId } from '../../../utils/idGenerator';
 import { generateAppProxyToken, generateAppProxyUrl } from '../../../services/aigateway-proxy/controller';
@@ -682,46 +681,4 @@ export class DeploymentManager extends BaseAgentService implements IDeploymentMa
         };
     }
 
-    /**
-     * Push to GitHub repository
-     */
-    async pushToGitHub(options: GitHubPushRequest): Promise<GitHubExportResult> {
-        const state = this.getState();
-        const logger = this.getLog();
-        const client = this.getClient();
-
-        logger.info('Starting GitHub export', {
-            repositoryUrl: options.repositoryHtmlUrl,
-            fileCount: Object.keys(state.generatedFilesMap).length
-        });
-
-        // Check if we have generated files
-        if (!state.generatedFilesMap || Object.keys(state.generatedFilesMap).length === 0) {
-            throw new Error('No generated files available for export');
-        }
-
-        // Ensure sandbox instance exists
-        if (!state.sandboxInstanceId) {
-            throw new Error('No sandbox instance available');
-        }
-
-        const allFiles = this.fileManager.getGeneratedFiles();
-
-        // Push to GitHub
-        const exportResult = await client.pushToGitHub(
-            state.sandboxInstanceId,
-            options,
-            allFiles
-        );
-
-        if (!exportResult?.success) {
-            throw new Error(`Failed to export to GitHub repository: ${exportResult?.error}`);
-        }
-
-        logger.info('GitHub export completed successfully', { 
-            options,
-            commitSha: exportResult.commitSha
-        });
-        return exportResult;
-    }
 }
diff --git a/worker/agents/services/implementations/FileManager.ts b/worker/agents/services/implementations/FileManager.ts
index a1d920d1..02c6940a 100644
--- a/worker/agents/services/implementations/FileManager.ts
+++ b/worker/agents/services/implementations/FileManager.ts
@@ -5,6 +5,7 @@ import { FileOutputType } from '../../schemas';
 import { FileProcessing } from '../../domain/pure/FileProcessing';
 import { FileState } from 'worker/agents/core/state';
 import { TemplateDetails } from '../../../services/sandbox/sandboxTypes';
+import { GitVersionControl } from 'worker/agents/git';
 
 /**
  * Manages file operations for code generation
@@ -13,7 +14,8 @@ import { TemplateDetails } from '../../../services/sandbox/sandboxTypes';
 export class FileManager implements IFileManager {
     constructor(
         private stateManager: IStateManager,
-        private getTemplateDetailsFunc: () => TemplateDetails
+        private getTemplateDetailsFunc: () => TemplateDetails,
+        private git: GitVersionControl
     ) {}
 
     getGeneratedFile(path: string): FileOutputType | null {
@@ -36,11 +38,12 @@ export class FileManager implements IFileManager {
         return FileProcessing.getAllFiles(this.getTemplateDetailsFunc(), state.generatedFilesMap);
     }
 
-    saveGeneratedFile(file: FileOutputType): FileState {
-        return this.saveGeneratedFiles([file])[0];
+    async saveGeneratedFile(file: FileOutputType, commitMessage: string): Promise<FileState> {
+        const results = await this.saveGeneratedFiles([file], commitMessage);
+        return results[0];
     }
 
-    saveGeneratedFiles(files: FileOutputType[]): FileState[] {
+    async saveGeneratedFiles(files: FileOutputType[], commitMessage: string): Promise<FileState[]> {
         const filesMap = { ...this.stateManager.getState().generatedFilesMap };
         const fileStates: FileState[] = [];
         
@@ -56,10 +59,6 @@ export class FileManager implements IFileManager {
             if (oldFileContents !== file.fileContents) {
                 try {
                     lastDiff = Diff.createPatch(file.filePath, oldFileContents, file.fileContents);
-                    if (lastDiff) {
-                        const isNewFile = oldFileContents === '';
-                        console.log(`Generated diff for ${isNewFile ? 'new' : ''} file ${file.filePath}:`, lastDiff);
-                    }
                 } catch (error) {
                     console.error(`Failed to generate diff for file ${file.filePath}:`, error);
                 }
@@ -80,6 +79,14 @@ export class FileManager implements IFileManager {
             ...this.stateManager.getState(),
             generatedFilesMap: filesMap
         });
+
+        try {
+            console.log(`[FileManager] Committing ${fileStates.length} files:`, commitMessage);
+            await this.git.commit(fileStates, commitMessage);
+            console.log(`[FileManager] Commit successful`);
+        } catch (error) {
+            console.error(`[FileManager] Failed to commit files:`, error, commitMessage);
+        }
         return fileStates;
     }
 
diff --git a/worker/agents/services/interfaces/IDeploymentManager.ts b/worker/agents/services/interfaces/IDeploymentManager.ts
index 8384bd5f..6ec44ba0 100644
--- a/worker/agents/services/interfaces/IDeploymentManager.ts
+++ b/worker/agents/services/interfaces/IDeploymentManager.ts
@@ -1,6 +1,5 @@
 import { FileOutputType } from '../../schemas';
-import { GitHubPushRequest, StaticAnalysisResponse, RuntimeError, PreviewType } from '../../../services/sandbox/sandboxTypes';
-import { GitHubExportResult } from '../../../services/github/types';
+import { StaticAnalysisResponse, RuntimeError, PreviewType } from '../../../services/sandbox/sandboxTypes';
 import { DeploymentStartedMessage, DeploymentCompletedMessage, DeploymentFailedMessage } from '../../../api/websocketTypes';
 import { CloudflareDeploymentStartedMessage, CloudflareDeploymentCompletedMessage, CloudflareDeploymentErrorMessage } from '../../../api/websocketTypes';
 
@@ -98,8 +97,4 @@ export interface IDeploymentManager {
      */
     deployToCloudflare(callbacks?: CloudflareDeploymentCallbacks): Promise<{ deploymentUrl: string | null; deploymentId?: string }>;
 
-    /**
-     * Push to GitHub repository 
-     */
-    pushToGitHub(options: GitHubPushRequest): Promise<GitHubExportResult>;
 }
diff --git a/worker/agents/services/interfaces/IFileManager.ts b/worker/agents/services/interfaces/IFileManager.ts
index 02b9af01..84164b34 100644
--- a/worker/agents/services/interfaces/IFileManager.ts
+++ b/worker/agents/services/interfaces/IFileManager.ts
@@ -1,5 +1,5 @@
 import { FileOutputType } from '../../schemas';
-// import { TemplateDetails } from '../../../services/sandbox/sandboxTypes';
+import { FileState } from '../../core/state';
 
 /**
  * Interface for file management operations
@@ -24,12 +24,12 @@ export interface IFileManager {
     /**
      * Save a generated file
      */
-    saveGeneratedFile(file: FileOutputType): void;
+    saveGeneratedFile(file: FileOutputType, commitMessage: string): Promise<FileState>;
 
     /**
      * Save multiple generated files
      */
-    saveGeneratedFiles(files: FileOutputType[]): void;
+    saveGeneratedFiles(files: FileOutputType[], commitMessage: string): Promise<FileState[]>;
 
     /**
      * Delete files from the file manager
diff --git a/worker/api/controllers/appView/controller.ts b/worker/api/controllers/appView/controller.ts
index c42cbdea..7bff976b 100644
--- a/worker/api/controllers/appView/controller.ts
+++ b/worker/api/controllers/appView/controller.ts
@@ -6,11 +6,13 @@ import { getAgentStub } from '../../../agents';
 import { AppService } from '../../../database/services/AppService';
 import { 
     AppDetailsData, 
-    AppStarToggleData, 
+    AppStarToggleData,
+    GitCloneTokenData,
 } from './types';
 import { AgentSummary } from '../../../agents/core/types';
 import { createLogger } from '../../../logger';
 import { buildUserWorkerUrl } from 'worker/utils/urls';
+import { JWTUtils } from '../../../utils/jwtUtils';
 
 export class AppViewController extends BaseController {
     static logger = createLogger('AppViewController');
@@ -159,4 +161,47 @@ export class AppViewController extends BaseController {
     //         return AppViewController.createErrorResponse<ForkAppData>('Internal server error', 500);
     //     }
     // }
+
+    /**
+     * Generate short-lived token for git clone (private repos only)
+     * POST /api/apps/:id/git/token
+     */
+    static async generateGitCloneToken(
+        _request: Request,
+        env: Env,
+        _ctx: ExecutionContext,
+        context: RouteContext
+    ): Promise<ControllerResponse<ApiResponse<GitCloneTokenData>>> {
+        try {
+            const user = context.user!;
+            const appId = context.pathParams.id;
+            
+            if (!appId) {
+                return AppViewController.createErrorResponse<GitCloneTokenData>('App ID is required', 400);
+            }
+
+            // Generate short-lived JWT (1 hour)
+            const jwtUtils = JWTUtils.getInstance(env);
+            const expiresIn = 3600; // 1 hour
+            const token = await jwtUtils.createToken({
+                sub: user.id,
+                email: user.email,
+                type: 'access' as const,
+                sessionId: 'git-clone-' + appId, // Special session for git operations
+            }, expiresIn);
+
+            const responseData: GitCloneTokenData = {
+                token,
+                expiresIn,
+                expiresAt: new Date(Date.now() + expiresIn * 1000).toISOString(),
+                cloneUrl: `https://${token}@${env.CUSTOM_DOMAIN}/app/${appId}.git`
+            };
+
+            return AppViewController.createSuccessResponse(responseData);
+        } catch (error) {
+            this.logger.error('Error generating git clone token:', error);
+            return AppViewController.createErrorResponse<GitCloneTokenData>('Failed to generate token', 500);
+        }
+    }
+
 }
\ No newline at end of file
diff --git a/worker/api/controllers/appView/types.ts b/worker/api/controllers/appView/types.ts
index ec2455c6..e9acc6f1 100644
--- a/worker/api/controllers/appView/types.ts
+++ b/worker/api/controllers/appView/types.ts
@@ -38,6 +38,16 @@ export interface AppStarToggleData {
     starCount: number;
 }
 
+/**
+ * Response data for git clone token generation
+ */
+export interface GitCloneTokenData {
+    token: string;
+    expiresIn: number;
+    expiresAt: string;
+    cloneUrl: string;
+}
+
 // /**
 //  * Response data for forkApp
 //  */
diff --git a/worker/api/controllers/githubExporter/controller.ts b/worker/api/controllers/githubExporter/controller.ts
index 1b042d60..a907f224 100644
--- a/worker/api/controllers/githubExporter/controller.ts
+++ b/worker/api/controllers/githubExporter/controller.ts
@@ -4,6 +4,7 @@ import { GitHubService } from '../../../services/github';
 import { GitHubExporterOAuthProvider } from '../../../services/oauth/github-exporter';
 import { getAgentStub } from '../../../agents';
 import { createLogger } from '../../../logger';
+import { AppService } from '../../../database/services/AppService';
 
 export interface GitHubExportData {
     success: boolean;
@@ -25,7 +26,121 @@ interface GitHubOAuthCallbackState {
 }
 
 export class GitHubExporterController extends BaseController {
-    static logger = createLogger('GitHubExporterController');
+    static readonly logger = createLogger('GitHubExporterController');
+
+    /**
+     * Creates GitHub repository and pushes files from agent
+     * If existingRepositoryUrl is provided, skips creation and syncs to existing repo
+     */
+    private static async createRepositoryAndPush(options: {
+        env: Env;
+        agentId: string;
+        repositoryName: string;
+        description?: string;
+        isPrivate: boolean;
+        token: string;
+        username: string;
+        existingRepositoryUrl?: string;
+    }): Promise<
+        | { success: true; repositoryUrl: string } 
+        | { success: false; error: string; alreadyExists?: boolean; existingRepositoryUrl?: string }
+    > {
+        const { env, agentId, repositoryName, description, isPrivate, token, username, existingRepositoryUrl } = options;
+        
+        try {
+            let repositoryUrl: string;
+            let cloneUrl: string;
+            
+            // Determine repository details (sync to existing or create new)
+            if (existingRepositoryUrl) {
+                this.logger.info('Syncing to existing repository', { agentId, repositoryUrl: existingRepositoryUrl });
+                
+                repositoryUrl = existingRepositoryUrl;
+                
+                // GitHub clone URL is simply the html_url + .git
+                cloneUrl = existingRepositoryUrl.endsWith('.git') 
+                    ? existingRepositoryUrl 
+                    : `${existingRepositoryUrl}.git`;
+                
+                this.logger.info('Using existing repository URLs', { repositoryUrl, cloneUrl });
+            } else {
+                this.logger.info('Creating new repository', { agentId, repositoryName });
+                
+                const createResult = await GitHubService.createUserRepository({
+                    name: repositoryName,
+                    description,
+                    private: isPrivate,
+                    token
+                });
+
+                if (!createResult.success) {
+                    // Repository already exists on GitHub - fetch the actual repository
+                    if (createResult.alreadyExists && createResult.repositoryName) {
+                        this.logger.warn('Repository already exists, fetching repository info', { 
+                            agentId, 
+                            repositoryName: createResult.repositoryName 
+                        });
+                        
+                        const repoResult = await GitHubService.getRepository({
+                            owner: username,
+                            repo: createResult.repositoryName,
+                            token
+                        });
+                        
+                        if (repoResult.success && repoResult.repository) {
+                            return { 
+                                success: false, 
+                                error: 'Repository already exists',
+                                alreadyExists: true,
+                                existingRepositoryUrl: repoResult.repository.html_url
+                            };
+                        }
+                    }
+                    
+                    return { success: false, error: createResult.error || 'Repository creation failed' };
+                }
+
+                if (!createResult.repository) {
+                    return { success: false, error: 'Repository creation failed' };
+                }
+
+                const { repository } = createResult;
+                repositoryUrl = repository.html_url;
+                cloneUrl = repository.clone_url;
+                
+                this.logger.info('Repository created', { agentId, repositoryUrl });
+            }
+
+            // Push files to repository
+            this.logger.info('Pushing files to repository', { agentId, repositoryUrl });
+            
+            const agentStub = await getAgentStub(env, agentId, true, this.logger);
+            const pushResult = await agentStub.pushToGitHub({
+                cloneUrl,
+                repositoryHtmlUrl: repositoryUrl,
+                isPrivate,
+                token,
+                email: 'vibesdk-bot@cloudflare.com',
+                username
+            });
+
+            if (!pushResult?.success) {
+                return { 
+                    success: false, 
+                    error: pushResult?.error || (existingRepositoryUrl ? 'Sync failed' : 'File push failed')
+                };
+            }
+
+            const operationType = existingRepositoryUrl ? 'Sync' : 'Export';
+            this.logger.info(`${operationType} completed`, { agentId, repositoryUrl });
+            
+            return { success: true, repositoryUrl };
+        } catch (error) {
+            this.logger.error('Repository operation failed', { error, agentId, repositoryName });
+            return { success: false, error: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    }
+
     static async handleOAuthCallback(
         request: Request,
         env: Env,
@@ -92,91 +207,28 @@ export class GitHubExporterController extends BaseController {
                 purpose
             });
 
-            if (purpose === 'repository_export' && exportData) {
-                const createResult = await GitHubService.createUserRepository({
-                    name: exportData.repositoryName,
+            if (purpose === 'repository_export' && exportData && agentId) {
+                const result = await this.createRepositoryAndPush({
+                    env,
+                    agentId,
+                    repositoryName: exportData.repositoryName,
                     description: exportData.description,
-                    private: exportData.isPrivate || false,
-                    token: tokenResult.accessToken
+                    isPrivate: exportData.isPrivate || false,
+                    token: tokenResult.accessToken,
+                    username: 'vibesdk-bot'
                 });
 
-                if (!createResult.success || !createResult.repository) {
-                    this.logger.error('Failed to create repository during export', {
-                        error: createResult.error,
-                        userId,
-                        repositoryName: exportData.repositoryName
-                    });
+                if (!result.success) {
                     return Response.redirect(
-                        `${returnUrl}?github_export=error&reason=${encodeURIComponent(createResult.error || 'repository_creation_failed')}`,
+                        `${returnUrl}?github_export=error&reason=${encodeURIComponent(result.error)}`,
                         302,
                     );
                 }
 
-                this.logger.info('Repository created successfully, now pushing files', {
-                    userId,
-                    repositoryUrl: createResult.repository.html_url,
-                    repositoryName: exportData.repositoryName,
-                    agentId
-                });
-
-                if (agentId) {
-                    try {
-                        const agentStub = await getAgentStub(env, agentId, true, this.logger);
-
-                        const pushRequest = {
-                            cloneUrl: createResult.repository.clone_url,
-                            repositoryHtmlUrl: createResult.repository.html_url,
-                            isPrivate: createResult.repository.private,
-                            token: tokenResult.accessToken,
-                            email: 'noreply@vibesdk.com',
-                            username: 'vibesdk-bot',
-                            commitMessage: `Initial commit - Generated app\n\n🤖 Generated with vibesdk\nRepository: ${exportData.repositoryName}`
-                        };
-
-                        this.logger.info('Pushing files to repository via agent', {
-                            agentId,
-                            repositoryUrl: createResult.repository.html_url
-                        });
-
-                        const pushResult = await agentStub.pushToGitHub(pushRequest);
-
-                        if (!pushResult?.success) {
-                            this.logger.error('Failed to push files to repository', {
-                                error: pushResult?.error,
-                                agentId,
-                                repositoryUrl: createResult.repository.html_url
-                            });
-                            return Response.redirect(
-                                `${returnUrl}?github_export=error&reason=${encodeURIComponent(pushResult?.error || 'file_push_failed')}`,
-                                302,
-                            );
-                        }
-
-                        this.logger.info('Successfully completed GitHub export with files', {
-                            userId,
-                            agentId,
-                            repositoryUrl: createResult.repository.html_url,
-                            repositoryName: exportData.repositoryName
-                        });
-                    } catch (pushError) {
-                        this.logger.error('Error during file push', {
-                            error: pushError,
-                            agentId,
-                            repositoryUrl: createResult.repository.html_url
-                        });
-                        return Response.redirect(
-                            `${returnUrl}?github_export=error&reason=${encodeURIComponent('file_push_error')}`,
-                            302,
-                        );
-                    }
-                } else {
-                    this.logger.warn('No agentId provided - repository created but files not pushed', {
-                        repositoryUrl: createResult.repository.html_url
-                    });
-                }
+                this.logger.info('OAuth export completed', { userId, agentId, repositoryUrl: result.repositoryUrl });
 
                 return Response.redirect(
-                    `${returnUrl}?github_export=success&repository_url=${encodeURIComponent(createResult.repository.html_url)}`,
+                    `${returnUrl}?github_export=success&repository_url=${encodeURIComponent(result.repositoryUrl)}`,
                     302,
                 );
             }
@@ -215,6 +267,8 @@ export class GitHubExporterController extends BaseController {
                 agentId: string;
             };
 
+            this.logger.info('Export initiated', { userId: context.user.id, agentId: body.agentId });
+
             if (!body.repositoryName) {
                 return GitHubExporterController.createErrorResponse<never>(
                     'Repository name is required',
@@ -229,6 +283,64 @@ export class GitHubExporterController extends BaseController {
                 );
             }
 
+            const agentStub = await getAgentStub(env, body.agentId, true, this.logger);
+            const cachedToken = await agentStub.getGitHubToken();
+            
+            if (cachedToken) {
+                this.logger.info('Using cached token', { agentId: body.agentId, username: cachedToken.username });
+                
+                // Check if app already has a GitHub repository URL
+                let existingRepoUrl: string | null = null;
+                try {
+                    const appService = new AppService(env);
+                    const app = await appService.getAppDetails(body.agentId);
+                    existingRepoUrl = app?.githubRepositoryUrl || null;
+                    
+                    if (existingRepoUrl) {
+                        this.logger.info('Found existing GitHub repository', { 
+                            agentId: body.agentId, 
+                            repositoryUrl: existingRepoUrl 
+                        });
+                    }
+                } catch (error) {
+                    this.logger.warn('Failed to check for existing repository', { error, agentId: body.agentId });
+                }
+                
+                const result = await this.createRepositoryAndPush({
+                    env,
+                    agentId: body.agentId,
+                    repositoryName: body.repositoryName,
+                    description: body.description,
+                    isPrivate: body.isPrivate ?? false,
+                    token: cachedToken.token,
+                    username: cachedToken.username,
+                    existingRepositoryUrl: existingRepoUrl || undefined
+                });
+                
+                if (result.success) {
+                    this.logger.info('Direct export completed', { repositoryUrl: result.repositoryUrl, agentId: body.agentId });
+                    return GitHubExporterController.createSuccessResponse({
+                        success: true,
+                        repositoryUrl: result.repositoryUrl,
+                        skippedOAuth: true
+                    });
+                }
+                
+                const isTemporaryError = result.error?.includes('rate limit') || 
+                                        result.error?.includes('timeout') ||
+                                        result.error?.includes('ECONNRESET');
+                
+                if (isTemporaryError) {
+                    this.logger.warn('Temporary error, keeping token', { error: result.error, agentId: body.agentId });
+                    return GitHubExporterController.createErrorResponse(
+                        result.error || 'Temporary GitHub error',
+                        503
+                    );
+                }
+            } else {
+                this.logger.info('No cached token, initiating OAuth', { agentId: body.agentId });
+            }
+
             const state: GitHubOAuthCallbackState = {
                 userId: context.user.id,
                 timestamp: Date.now(),
@@ -249,10 +361,7 @@ export class GitHubExporterController extends BaseController {
                 Buffer.from(JSON.stringify(state)).toString('base64')
             );
 
-            this.logger.info('Initiating GitHub export with OAuth', {
-                userId: context.user.id,
-                repositoryName: body.repositoryName,
-            });
+            this.logger.info('Initiating OAuth flow', { userId: context.user.id, agentId: body.agentId });
 
             return GitHubExporterController.createSuccessResponse<{ authUrl: string }>({
                 authUrl
@@ -265,4 +374,77 @@ export class GitHubExporterController extends BaseController {
             );
         }
     }
+
+    static async checkRemoteStatus(
+        request: Request,
+        env: Env,
+        _ctx: ExecutionContext,
+        context: RouteContext,
+    ): Promise<Response> {
+        try {
+            if (!context.user) {
+                return GitHubExporterController.createErrorResponse<never>(
+                    'Authentication required',
+                    401
+                );
+            }
+
+            const body = await request.json() as {
+                repositoryUrl: string;
+                agentId: string;
+            };
+
+            if (!body.repositoryUrl || !body.agentId) {
+                return GitHubExporterController.createErrorResponse<never>(
+                    'Repository URL and agent ID are required',
+                    400
+                );
+            }
+
+            const agentStub = await getAgentStub(env, body.agentId, true, this.logger);
+            
+            // Try to get cached token
+            const cachedToken = await agentStub.getGitHubToken();
+            
+            if (!cachedToken) {
+                return GitHubExporterController.createErrorResponse<never>(
+                    'No cached GitHub token. Please re-authenticate.',
+                    401
+                );
+            }
+
+            // Export git objects and template details
+            const { gitObjects, query, templateDetails } = await agentStub.exportGitObjects();
+            
+            // Get app createdAt
+            let appCreatedAt: Date | undefined;
+            try {
+                const appService = new AppService(env);
+                const app = await appService.getAppDetails(body.agentId);
+                if (app && app.createdAt) {
+                    appCreatedAt = new Date(app.createdAt);
+                }
+            } catch (error) {
+                this.logger.warn('Failed to get app createdAt for sync check', { error });
+            }
+            
+            // Check remote status
+            const status = await GitHubService.checkRemoteStatus({
+                gitObjects,
+                templateDetails,
+                appQuery: query,
+                appCreatedAt,
+                repositoryUrl: body.repositoryUrl,
+                token: cachedToken.token
+            });
+
+            return GitHubExporterController.createSuccessResponse(status);
+        } catch (error) {
+            this.logger.error('Failed to check remote status', error);
+            return GitHubExporterController.createErrorResponse<never>(
+                'Failed to check remote status',
+                500
+            );
+        }
+    }
 }
diff --git a/worker/api/handlers/git-cache.ts b/worker/api/handlers/git-cache.ts
new file mode 100644
index 00000000..bba34c99
--- /dev/null
+++ b/worker/api/handlers/git-cache.ts
@@ -0,0 +1,145 @@
+import { createHash } from 'crypto';
+import type { MemFS } from '../../agents/git/memfs';
+import type { TemplateDetails as SandboxTemplateDetails } from '../../services/sandbox/sandboxTypes';
+
+interface GitCacheMetadata {
+    agentHeadOid: string;
+    templateHash: string;
+    timestamp: number;
+}
+
+interface InMemoryCacheEntry {
+    repo: MemFS;
+    metadata: GitCacheMetadata;
+    timestamp: number;
+}
+
+// Worker-global in-memory cache (survives across requests in same Worker instance)
+const inMemoryCache = new Map<string, InMemoryCacheEntry>();
+
+// Cleanup tracker
+let lastCleanup = Date.now();
+
+function cleanupMemoryCache(): void {
+    const now = Date.now();
+    if (now - lastCleanup < 10000) return; // Only cleanup once per 10 seconds
+    
+    lastCleanup = now;
+    const cutoff = now - 10000; // Remove entries older than 10s
+    
+    for (const [key, entry] of inMemoryCache.entries()) {
+        if (entry.timestamp < cutoff) {
+            inMemoryCache.delete(key);
+        }
+    }
+}
+
+export class GitCache {
+    constructor() {}
+
+    private getTemplateHash(templateDetails: SandboxTemplateDetails | null | undefined): string {
+        if (!templateDetails) return 'no-template';
+        
+        const content = JSON.stringify({
+            name: templateDetails.name,
+            files: Object.keys(templateDetails.allFiles || {}).sort()
+        });
+        
+        return createHash('sha256').update(content).digest('hex').slice(0, 16);
+    }
+
+    private getCacheKey(appId: string): string {
+        return `git-repo:${appId}`;
+    }
+
+    /**
+     * Check if in-memory cache is valid and fresh (< 5 seconds old)
+     */
+    private checkMemoryCache(
+        appId: string,
+        currentHeadOid: string,
+        currentTemplateDetails: SandboxTemplateDetails | null | undefined
+    ): MemFS | null {
+        cleanupMemoryCache();
+        
+        const key = this.getCacheKey(appId);
+        const entry = inMemoryCache.get(key);
+        
+        if (!entry) return null;
+        
+        // Check if too old (5 second TTL)
+        if (Date.now() - entry.timestamp > 5000) {
+            inMemoryCache.delete(key);
+            return null;
+        }
+        
+        // Check if still valid (OID + template hash match)
+        const currentTemplateHash = this.getTemplateHash(currentTemplateDetails);
+        if (entry.metadata.agentHeadOid !== currentHeadOid || 
+            entry.metadata.templateHash !== currentTemplateHash) {
+            inMemoryCache.delete(key);
+            return null;
+        }
+        
+        return entry.repo;
+    }
+
+    /**
+     * Store repository in memory cache
+     */
+    private storeInMemory(
+        appId: string,
+        repo: MemFS,
+        agentHeadOid: string,
+        templateDetails: SandboxTemplateDetails | null | undefined
+    ): void {
+        const key = this.getCacheKey(appId);
+        
+        inMemoryCache.set(key, {
+            repo,
+            metadata: {
+                agentHeadOid,
+                templateHash: this.getTemplateHash(templateDetails),
+                timestamp: Date.now()
+            },
+            timestamp: Date.now()
+        });
+    }
+
+    /**
+     * Get repository from in-memory cache
+     */
+    async getRepository(
+        appId: string,
+        agentHeadOid: string,
+        templateDetails: SandboxTemplateDetails | null | undefined
+    ): Promise<{ repo: MemFS | null; source: 'memory' | 'miss' }> {
+        const memoryRepo = this.checkMemoryCache(appId, agentHeadOid, templateDetails);
+        if (memoryRepo) {
+            return { repo: memoryRepo, source: 'memory' };
+        }
+        
+        return { repo: null, source: 'miss' };
+    }
+
+    /**
+     * Store repository in memory cache
+     */
+    storeRepository(
+        appId: string,
+        repo: MemFS,
+        agentHeadOid: string,
+        templateDetails: SandboxTemplateDetails | null | undefined
+    ): void {
+        // Store in memory immediately (synchronous, no await needed)
+        this.storeInMemory(appId, repo, agentHeadOid, templateDetails);
+    }
+
+    /**
+     * Clear cache for an app
+     */
+    clearCache(appId: string): void {
+        const key = this.getCacheKey(appId);
+        inMemoryCache.delete(key);
+    }
+}
diff --git a/worker/api/handlers/git-protocol.ts b/worker/api/handlers/git-protocol.ts
new file mode 100644
index 00000000..4135ced5
--- /dev/null
+++ b/worker/api/handlers/git-protocol.ts
@@ -0,0 +1,312 @@
+/**
+ * Git Protocol Handler
+ * Handles git clone/fetch operations via HTTP protocol
+ * Route: /apps/:id.git/info/refs and /apps/:id.git/git-upload-pack
+ * 
+ * Architecture: Export git objects from DO, build repo in worker to save DO memory
+ */
+import { getAgentStub } from '../../agents';
+import { createLogger } from '../../logger';
+import { GitCloneService } from '../../agents/git/git-clone-service';
+import { AppService } from '../../database/services/AppService';
+import { JWTUtils } from '../../utils/jwtUtils';
+import { GitCache } from './git-cache';
+
+const logger = createLogger('GitProtocol');
+
+/**
+ * Git protocol route patterns
+ */
+const GIT_INFO_REFS_PATTERN = /^\/apps\/([a-f0-9-]+)\.git\/info\/refs$/;
+const GIT_UPLOAD_PACK_PATTERN = /^\/apps\/([a-f0-9-]+)\.git\/git-upload-pack$/;
+
+/**
+ * Check if request is a Git protocol request
+ */
+export function isGitProtocolRequest(pathname: string): boolean {
+    return GIT_INFO_REFS_PATTERN.test(pathname) || GIT_UPLOAD_PACK_PATTERN.test(pathname);
+}
+
+/**
+ * Extract app ID from Git protocol URL
+ */
+function extractAppId(pathname: string): string | null {
+    const infoRefsMatch = pathname.match(GIT_INFO_REFS_PATTERN);
+    if (infoRefsMatch) return infoRefsMatch[1];
+    
+    const uploadPackMatch = pathname.match(GIT_UPLOAD_PACK_PATTERN);
+    if (uploadPackMatch) return uploadPackMatch[1];
+    
+    return null;
+}
+
+/**
+ * Extract agent HEAD OID from git objects
+ */
+function extractAgentHeadOid(gitObjects: Array<{ path: string; data: Uint8Array }>): string | null {
+    const headFile = gitObjects.find(obj => obj.path === '.git/HEAD');
+    if (!headFile) return null;
+    
+    const headContent = new TextDecoder().decode(headFile.data).trim();
+    
+    if (headContent.startsWith('ref: ')) {
+        const refPath = headContent.slice(5).trim();
+        const refFile = gitObjects.find(obj => obj.path === `.git/${refPath}`);
+        return refFile ? new TextDecoder().decode(refFile.data).trim() : null;
+    }
+    
+    return null;
+}
+
+/**
+ * Verify git access (public apps or owner with valid token)
+ */
+async function verifyGitAccess(
+    request: Request,
+    env: Env,
+    appId: string
+): Promise<{ hasAccess: boolean; appCreatedAt?: Date }> {
+    logger.info('Verifying git access', { appId });
+    const appService = new AppService(env);
+    const app = await appService.getAppDetails(appId);
+    
+    logger.info('App details retrieved', { appId, found: !!app, visibility: app?.visibility });
+    
+    if (!app) {
+        logger.warn('App not found in database', { appId });
+        return { hasAccess: false };
+    }
+
+    // Public apps: anyone can clone
+    if (app.visibility === 'public') {
+        return { hasAccess: true, appCreatedAt: app.createdAt || undefined };
+    }
+
+    // Private apps: require authentication
+    const authHeader = request.headers.get('Authorization');
+    let token: string | null = null;
+
+    if (authHeader?.startsWith('Bearer ')) {
+        token = authHeader.slice(7);
+    } else if (authHeader?.startsWith('Basic ')) {
+        // Git sends credentials as Basic auth
+        const decoded = atob(authHeader.slice(6));
+        const [username, password] = decoded.split(':');
+        token = password || username;
+    }
+
+    if (!token) {
+        return { hasAccess: false };
+    }
+
+    // Verify token using JWTUtils
+    const jwtUtils = JWTUtils.getInstance(env);
+    const payload = await jwtUtils.verifyToken(token);
+
+    if (!payload) {
+        return { hasAccess: false };
+    }
+
+    // Check if user owns the app
+    const hasAccess = payload.sub === app.userId;
+    return { hasAccess, appCreatedAt: hasAccess ? (app.createdAt || undefined) : undefined };
+}
+
+/**
+ * Handle Git info/refs request
+ */
+async function handleInfoRefs(
+    request: Request,
+    env: Env,
+    ctx: ExecutionContext,
+    appId: string
+): Promise<Response> {
+    try {
+        // Verify access first
+        const { hasAccess, appCreatedAt } = await verifyGitAccess(request, env, appId);
+        if (!hasAccess) {
+            return new Response('Repository not found', { status: 404 });
+        }
+        
+        const agentStub = await getAgentStub(env, appId, true, logger);
+        if (!agentStub || !(await agentStub.isInitialized())) {
+            return new Response('Repository not found', { status: 404 });
+        }
+        
+        // Export git objects from DO
+        const { gitObjects, query, hasCommits, templateDetails } = await agentStub.exportGitObjects();
+        
+        if (!hasCommits) {
+            // Return empty advertisement for repos with no commits
+            return new Response('001e# service=git-upload-pack\n0000', {
+                status: 200,
+                headers: {
+                    'Content-Type': 'application/x-git-upload-pack-advertisement',
+                    'Cache-Control': 'no-cache'
+                }
+            });
+        }
+        
+        // Extract HEAD OID for cache validation
+        const agentHeadOid = extractAgentHeadOid(gitObjects);
+        if (!agentHeadOid) {
+            throw new Error('Could not determine agent HEAD OID');
+        }
+        
+        // Try memory cache first
+        const cache = new GitCache();
+        const { repo } = await cache.getRepository(appId, agentHeadOid, templateDetails);
+        
+        if (repo) {
+            logger.info('Cache HIT (memory): info/refs', { appId, agentHeadOid });
+            const response = await GitCloneService.handleInfoRefs(repo);
+            return new Response(response, {
+                status: 200,
+                headers: {
+                    'Content-Type': 'application/x-git-upload-pack-advertisement',
+                    'Cache-Control': 'no-cache',
+                    'X-Cache': 'HIT-MEMORY'
+                }
+            });
+        }
+        
+        logger.info('Cache MISS: building repository', { appId, agentHeadOid });
+        
+        // Build repository in worker
+        const repoFS = await GitCloneService.buildRepository({
+            gitObjects,
+            templateDetails,
+            appQuery: query,
+            appCreatedAt
+        });
+        
+        // Store in memory for subsequent upload-pack request
+        cache.storeRepository(appId, repoFS, agentHeadOid, templateDetails);
+        
+        // Use waitUntil to keep Worker alive for upload-pack request (typically arrives within seconds)
+        ctx.waitUntil(
+            new Promise(resolve => setTimeout(resolve, 5000))
+        );
+        
+        // Generate info/refs response
+        const response = await GitCloneService.handleInfoRefs(repoFS);
+        return new Response(response, {
+            status: 200,
+            headers: {
+                'Content-Type': 'application/x-git-upload-pack-advertisement',
+                'Cache-Control': 'no-cache',
+                'X-Cache': 'MISS'
+            }
+        });
+    } catch (error) {
+        logger.error('Git info/refs error:', error);
+        return new Response('Internal server error', { status: 500 });
+    }
+}
+
+/**
+ * Handle Git upload-pack request
+ */
+async function handleUploadPack(
+    request: Request,
+    env: Env,
+    _ctx: ExecutionContext,
+    appId: string
+): Promise<Response> {
+    try {
+        // Verify access first
+        const { hasAccess, appCreatedAt } = await verifyGitAccess(request, env, appId);
+        if (!hasAccess) {
+            return new Response('Repository not found', { status: 404 });
+        }
+        
+        const agentStub = await getAgentStub(env, appId, true, logger);
+        if (!agentStub || !(await agentStub.isInitialized())) {
+            return new Response('Repository not found', { status: 404 });
+        }
+        
+        // Export git objects from DO
+        const { gitObjects, query, hasCommits, templateDetails } = await agentStub.exportGitObjects();
+        
+        if (!hasCommits) {
+            return new Response('No commits to pack', { status: 404 });
+        }
+        
+        // Extract HEAD OID for cache validation
+        const agentHeadOid = extractAgentHeadOid(gitObjects);
+        if (!agentHeadOid) {
+            throw new Error('Could not determine agent HEAD OID');
+        }
+        
+        // Try memory cache first (HOT PATH - usually hits after info/refs!)
+        const cache = new GitCache();
+        const { repo, source } = await cache.getRepository(appId, agentHeadOid, templateDetails);
+        
+        if (repo) {
+            logger.info(`Cache HIT (${source}): upload-pack`, { appId, agentHeadOid });
+            const packfile = await GitCloneService.handleUploadPack(repo);
+            return new Response(packfile, {
+                status: 200,
+                headers: {
+                    'Content-Type': 'application/x-git-upload-pack-result',
+                    'Cache-Control': 'no-cache',
+                    'X-Cache': `HIT-${source.toUpperCase()}`
+                }
+            });
+        }
+        
+        logger.info('Cache MISS: building repository', { appId, agentHeadOid });
+        
+        // Build repository in worker (cold path - different Worker or timeout)
+        const repoFS = await GitCloneService.buildRepository({
+            gitObjects,
+            templateDetails,
+            appQuery: query,
+            appCreatedAt
+        });
+        
+        // Store in memory for potential retries
+        cache.storeRepository(appId, repoFS, agentHeadOid, templateDetails);
+        
+        // Generate packfile with full commit history
+        const packfile = await GitCloneService.handleUploadPack(repoFS);
+        return new Response(packfile, {
+            status: 200,
+            headers: {
+                'Content-Type': 'application/x-git-upload-pack-result',
+                'Cache-Control': 'no-cache',
+                'X-Cache': 'MISS'
+            }
+        });
+    } catch (error) {
+        logger.error('Git upload-pack error:', error);
+        return new Response('Internal server error', { status: 500 });
+    }
+}
+
+/**
+ * Main handler for Git protocol requests
+ */
+export async function handleGitProtocolRequest(
+    request: Request,
+    env: Env,
+    ctx: ExecutionContext
+): Promise<Response> {
+    const url = new URL(request.url);
+    const pathname = url.pathname;
+    
+    // Extract app ID
+    const appId = extractAppId(pathname);
+    if (!appId) {
+        return new Response('Invalid Git URL', { status: 400 });
+    }
+    
+    // Route to appropriate handler
+    if (GIT_INFO_REFS_PATTERN.test(pathname)) {
+        return handleInfoRefs(request, env, ctx, appId);
+    } else if (GIT_UPLOAD_PACK_PATTERN.test(pathname)) {
+        return handleUploadPack(request, env, ctx, appId);
+    }
+    
+    return new Response('Not found', { status: 404 });
+}
diff --git a/worker/api/routes/appRoutes.ts b/worker/api/routes/appRoutes.ts
index f8fe734d..47d3500d 100644
--- a/worker/api/routes/appRoutes.ts
+++ b/worker/api/routes/appRoutes.ts
@@ -65,6 +65,14 @@ export function setupAppRoutes(app: Hono<AppEnv>): void {
     // Delete app - OWNER ONLY
     appRouter.delete('/:id', setAuthLevel(AuthConfig.ownerOnly), adaptController(AppController, AppController.deleteApp));
     
+    // ========================================
+    // GIT CLONE ROUTES
+    // ========================================
+    
+    // Generate git clone token for private repos - OWNER ONLY
+    appRouter.post('/:id/git/token', setAuthLevel(AuthConfig.ownerOnly), adaptController(AppViewController, AppViewController.generateGitCloneToken));
+    
+    
     // Mount the app router under /api/apps
     app.route('/api/apps', appRouter);
 }
diff --git a/worker/api/routes/githubExporterRoutes.ts b/worker/api/routes/githubExporterRoutes.ts
index db6c4e3d..4ff9a135 100644
--- a/worker/api/routes/githubExporterRoutes.ts
+++ b/worker/api/routes/githubExporterRoutes.ts
@@ -17,4 +17,7 @@ export function setupGitHubExporterRoutes(app: Hono<AppEnv>): void {
     
     // Repository export routes with OAuth flow
     app.post('/api/github-app/export', setAuthLevel(AuthConfig.authenticated), adaptController(GitHubExporterController, GitHubExporterController.initiateGitHubExport));
+    
+    // Check remote repository status
+    app.post('/api/github-app/check-remote', setAuthLevel(AuthConfig.authenticated), adaptController(GitHubExporterController, GitHubExporterController.checkRemoteStatus));
 }
diff --git a/worker/database/services/AppService.ts b/worker/database/services/AppService.ts
index 4aa3428b..eb5a7219 100644
--- a/worker/database/services/AppService.ts
+++ b/worker/database/services/AppService.ts
@@ -239,6 +239,7 @@ export class AppService extends BaseService {
                 .where(eq(schema.apps.id, appId));
             return true;
         } catch (error) {
+            this.logger.error('[AppService] Failed to update app', { appId, error });
             return false;
         }
     }
diff --git a/worker/index.ts b/worker/index.ts
index 69967c87..76171930 100644
--- a/worker/index.ts
+++ b/worker/index.ts
@@ -9,6 +9,7 @@ import { getPreviewDomain } from './utils/urls';
 import { proxyToAiGateway } from './services/aigateway-proxy/controller';
 import { isOriginAllowed } from './config/security';
 import { proxyToSandbox } from './services/sandbox/request-handler';
+import { handleGitProtocolRequest, isGitProtocolRequest } from './api/handlers/git-protocol';
 
 // Durable Object and Service exports
 export { UserAppSandboxService, DeployerService } from './services/sandbox/sandboxSdkClient';
@@ -110,7 +111,7 @@ async function handleUserAppRequest(request: Request, env: Env): Promise<Respons
  */
 const worker = {
 	async fetch(request: Request, env: Env, ctx: ExecutionContext): Promise<Response> {
-        // logger.info(`Received request: ${request.method} ${request.url}`);
+        logger.info(`Received request: ${request.method} ${request.url}`);
 		// --- Pre-flight Checks ---
 
 		// 1. Critical configuration check: Ensure custom domain is set.
@@ -140,6 +141,12 @@ const worker = {
 
 		// Route 1: Main Platform Request (e.g., build.cloudflare.dev or localhost)
 		if (isMainDomainRequest) {
+			// Handle Git protocol endpoints directly
+			// Route: /apps/:id.git/info/refs or /apps/:id.git/git-upload-pack
+			if (isGitProtocolRequest(pathname)) {
+				return handleGitProtocolRequest(request, env, ctx);
+			}
+			
 			// Serve static assets for all non-API routes from the ASSETS binding.
 			if (!pathname.startsWith('/api/')) {
 				return env.ASSETS.fetch(request);
diff --git a/worker/services/github/GitHubService.ts b/worker/services/github/GitHubService.ts
index f5c7ff8f..9ff858a1 100644
--- a/worker/services/github/GitHubService.ts
+++ b/worker/services/github/GitHubService.ts
@@ -1,9 +1,8 @@
 /**
- * GitHub Service - Provides secure API-based GitHub repository operations
- * Handles repository creation, file management, and commit synchronization
+ * GitHub service for repository creation and export
  */
 
-import { Octokit, RestEndpointMethodTypes } from '@octokit/rest';
+import { Octokit } from '@octokit/rest';
 import { createLogger } from '../../logger';
 import {
     GitHubRepository,
@@ -11,68 +10,25 @@ import {
     CreateRepositoryResult,
     GitHubServiceError,
 } from './types';
-import { GitHubPushRequest, GitHubPushResponse } from '../sandbox/sandboxTypes';
+import { GitHubPushResponse, TemplateDetails } from '../sandbox/sandboxTypes';
+import { GitCloneService } from '../../agents/git/git-clone-service';
+import git from '@ashishkumar472/cf-git';
+import { prepareCloudflareButton } from '../../utils/deployToCf';
+import type { MemFS } from '../../agents/git/memfs';
 
-interface FileContent {
-    filePath: string;
-    fileContents: string;
-}
-
-interface LocalCommit {
-    hash: string;
-    message: string;
-    timestamp: string;
-}
-
-interface GitContext {
-    localCommits: LocalCommit[];
-    hasUncommittedChanges: boolean;
-}
-
-interface RemoteCommit {
-    sha: string;
-    message: string;
-    date: string;
-}
-
-type GitHubTree = NonNullable<RestEndpointMethodTypes['git']['createTree']['parameters']['tree']>[number];
 
 export class GitHubService {
     private static readonly logger = createLogger('GitHubService');
-    private static readonly DEFAULT_BOT_NAME = 'vibesdk-bot';
-    private static readonly DEFAULT_BOT_EMAIL = 'noreply@vibesdk.com';
-    private static readonly README_CONTENT = '# Generated App\n\nGenerated with vibesdk';
-
-    private static createAuthorInfo(request: GitHubPushRequest, timestamp?: string) {
-        return {
-            name: request.username || GitHubService.DEFAULT_BOT_NAME,
-            email: request.email || GitHubService.DEFAULT_BOT_EMAIL,
-            ...(timestamp && { date: timestamp })
-        };
-    }
-
-    private static createHeaders(token: string, includeContentType = false): Record<string, string> {
-        const headers: Record<string, string> = {
-            Authorization: `token ${token}`,
-            Accept: 'application/vnd.github.v3+json',
-            'User-Agent': 'vibesdk/1.0',
-        };
-
-        if (includeContentType) {
-            headers['Content-Type'] = 'application/json';
-        }
 
-        return headers;
-    }
-
-    private static createOctokit(token: string): Octokit {
+    static createOctokit(token: string): Octokit {
         if (!token?.trim()) {
             throw new GitHubServiceError('No GitHub token provided', 'NO_TOKEN');
         }
         return new Octokit({ auth: token });
     }
+    
     /**
-     * Creates a new GitHub repository with optional auto-initialization
+     * Create a new GitHub repository
      */
     static async createUserRepository(
         options: CreateRepositoryOptions
@@ -87,381 +43,465 @@ export class GitHubService {
         });
         
         try {
-            const response = await fetch('https://api.github.com/user/repos', {
-                method: 'POST',
-                headers: GitHubService.createHeaders(options.token, true),
-                body: JSON.stringify({
-                    name: options.name,
-                    description: options.description,
-                    private: options.private,
-                    auto_init: autoInit,
-                }),
+            const octokit = GitHubService.createOctokit(options.token);
+            
+            const { data: repository } = await octokit.repos.createForAuthenticatedUser({
+                name: options.name,
+                description: options.description,
+                private: options.private,
+                auto_init: autoInit,
             });
 
-            if (!response.ok) {
-                const error = await response.text();
-                GitHubService.logger.error('Repository creation failed', {
-                    status: response.status,
-                    statusText: response.statusText,
-                    error: error,
-                    endpoint: 'https://api.github.com/user/repos'
-                });
+            GitHubService.logger.info('Successfully created repository', {
+                html_url: repository.html_url
+            });
+
+            return {
+                success: true,
+                repository: repository as GitHubRepository
+            };
+        } catch (error: unknown) {
+            const octokitError = error as { status?: number; message?: string; response?: { data?: { errors?: Array<{ field?: string; message?: string }> } } };
+            
+            GitHubService.logger.error('Repository creation failed', {
+                status: octokitError?.status,
+                message: octokitError?.message,
+                name: options.name
+            });
+            
+            if (octokitError?.status === 403) {
+                return {
+                    success: false,
+                    error: 'GitHub App lacks required permissions. Please ensure the app has Contents: Write and Metadata: Read permissions, then re-install it.'
+                };
+            }
+            
+            // Check if repository already exists (422 Unprocessable Entity)
+            if (octokitError?.status === 422) {
+                const hasNameExistsError = octokitError?.response?.data?.errors?.some((e) => 
+                    e.field === 'name' && e.message?.includes('already exists')
+                );
                 
-                if (response.status === 403) {
+                if (hasNameExistsError) {
                     return {
                         success: false,
-                        error: 'GitHub App lacks required permissions. Please ensure the app has Contents: Write and Metadata: Read permissions, then re-install it.'
+                        error: `Repository '${options.name}' already exists on this account`,
+                        alreadyExists: true,
+                        repositoryName: options.name
                     };
                 }
-                
-                return {
-                    success: false,
-                    error: `Failed to create repository: ${error}`
-                };
             }
-
-            const repository = (await response.json()) as GitHubRepository;
-            GitHubService.logger.info(`Successfully created repository: ${repository.html_url}`);
-
-            return {
-                success: true,
-                repository
-            };
-        } catch (error) {
-            GitHubService.logger.error('Failed to create user repository', error);
+            
             return {
                 success: false,
-                error: error instanceof Error ? error.message : 'Unknown error'
+                error: error instanceof Error ? error.message : 'Failed to create repository'
             };
         }
     }
 
+
     /**
-     * Pushes files to GitHub repository with intelligent commit strategy based on local and remote state
+     * Get repository information from GitHub
      */
-    static async pushFilesToRepository(
-        files: FileContent[],
-        request: GitHubPushRequest,
-        gitContext?: GitContext
-    ): Promise<GitHubPushResponse> {
+    static async getRepository(options: {
+        owner: string;
+        repo: string;
+        token: string;
+    }): Promise<{ success: boolean; repository?: GitHubRepository; error?: string }> {
         try {
-            GitHubService.logger.info('Initiating GitHub push operation', {
-                repositoryUrl: request.repositoryHtmlUrl,
-                fileCount: files.length,
-                localCommitCount: gitContext?.localCommits?.length || 0,
-                hasUncommittedChanges: gitContext?.hasUncommittedChanges || false
-            });
-
-            const octokit = GitHubService.createOctokit(request.token);
+            const octokit = GitHubService.createOctokit(options.token);
             
-            // Parse repository info from URL
-            const repoInfo = GitHubService.extractRepoInfo(request.cloneUrl || request.repositoryHtmlUrl);
-            if (!repoInfo) {
-                throw new GitHubServiceError('Invalid repository URL format', 'INVALID_REPO_URL');
-            }
-
-            const { owner, repo } = repoInfo;
-
-            // Get repository metadata
-            const { data: repository } = await octokit.rest.repos.get({ owner, repo });
-            const defaultBranch = repository.default_branch || 'main';
+            const { data: repository } = await octokit.repos.get({
+                owner: options.owner,
+                repo: options.repo
+            });
 
-            // Fetch remote commit history
-            const remoteCommits = await GitHubService.fetchRemoteCommits(octokit, owner, repo, defaultBranch);
+            GitHubService.logger.info('Successfully fetched repository', {
+                html_url: repository.html_url
+            });
             
-            // Determine base commit SHA - handle both auto-initialized and empty repositories
-            const parentCommitSha = remoteCommits.length > 0 ? remoteCommits[0].sha : '';
+            return { 
+                success: true, 
+                repository: repository as GitHubRepository 
+            };
+        } catch (error: unknown) {
+            const octokitError = error as { status?: number; message?: string };
             
-            GitHubService.logger.info('Repository state analyzed', {
-                defaultBranch,
-                remoteCommitCount: remoteCommits.length,
-                hasParentCommit: !!parentCommitSha,
-                repositoryEmpty: remoteCommits.length === 0
+            GitHubService.logger.error('Failed to fetch repository', {
+                owner: options.owner,
+                repo: options.repo,
+                status: octokitError?.status,
+                message: octokitError?.message
             });
+            return { 
+                success: false, 
+                error: error instanceof Error ? error.message : 'Failed to fetch repository' 
+            };
+        }
+    }
 
-            // Plan commit strategy
-            const commitStrategy = GitHubService.planCommitStrategy(gitContext, remoteCommits, files);
-            
-            GitHubService.logger.info('Commit strategy planned', {
-                strategy: commitStrategy.type,
-                commitsToCreate: commitStrategy.commits.length,
-                remoteCommitCount: remoteCommits.length
-            });
+    /**
+     * Parse owner and repo name from GitHub URL
+     */
+    static extractRepoInfo(url: string): { owner: string; repo: string } | null {
+        try {
+            // Convert SSH URLs to HTTPS
+            let cleanUrl = url;
             
-            if (files.length === 0) {
-                GitHubService.logger.warn('No files to commit');
-                return { success: true, commitSha: parentCommitSha };
+            if (url.startsWith('git@github.com:')) {
+                cleanUrl = url.replace('git@github.com:', 'https://github.com/');
             }
-
-            if (commitStrategy.commits.length === 0) {
-                GitHubService.logger.info('No commits needed - repository is already in sync');
-                return { success: true, commitSha: parentCommitSha };
+            
+            const urlObj = new URL(cleanUrl);
+            const pathParts = urlObj.pathname.split('/').filter(part => part);
+            
+            if (pathParts.length >= 2) {
+                const owner = pathParts[0];
+                const repo = pathParts[1].replace('.git', '');
+                return { owner, repo };
             }
+            
+            return null;
+        } catch (error) {
+            GitHubService.logger.error('Failed to parse repository URL', { url, error });
+            return null;
+        }
+    }
 
-            // Execute commit strategy
-            const finalCommitSha = await GitHubService.executeCommitStrategy(
-                octokit, owner, repo, defaultBranch, commitStrategy, parentCommitSha, request
-            );
+    /**
+     * Export git repository to GitHub
+     */
+    static async exportToGitHub(options: {
+        gitObjects: Array<{ path: string; data: Uint8Array }>;
+        templateDetails: TemplateDetails | null;
+        appQuery: string;
+        appCreatedAt?: Date;
+        token: string;
+        repositoryUrl: string;
+        username: string;
+        email: string;
+    }): Promise<GitHubPushResponse> {
+        try {
+            GitHubService.logger.info('Starting GitHub export from DO git', {
+                gitObjectCount: options.gitObjects.length,
+                repositoryUrl: options.repositoryUrl
+            });
 
-            GitHubService.logger.info('GitHub push completed', {
-                repositoryUrl: request.repositoryHtmlUrl,
-                finalCommitSha,
-                strategy: commitStrategy.type,
-                commitsCreated: commitStrategy.commits.length
+            // Build in-memory repo from DO git objects
+            const fs = await GitCloneService.buildRepository({
+                gitObjects: options.gitObjects,
+                templateDetails: options.templateDetails,
+                appQuery: options.appQuery,
+                appCreatedAt: options.appCreatedAt
             });
 
-            return {
-                success: true,
-                commitSha: finalCommitSha
-            };
+            // Modify README to add GitHub deploy button
+            await GitHubService.modifyReadmeForGitHub(fs, options.repositoryUrl);
 
-        } catch (error) {
-            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-            GitHubService.logger.error('Failed to push files to GitHub', {
-                error: errorMessage,
-                repositoryUrl: request.repositoryHtmlUrl,
+            // Get all commits and files from built repo
+            const commits = await git.log({ fs, dir: '/', depth: 1000 });
+            const files = await GitHubService.getAllFilesFromRepo(fs);
+
+            GitHubService.logger.info('Repository built', {
+                commitCount: commits.length,
                 fileCount: files.length
             });
 
+            // Push to GitHub with force
+            const result = await GitHubService.forcePushToGitHub(
+                options.token,
+                options.repositoryUrl,
+                commits,
+                files,
+                { name: options.username, email: options.email }
+            );
+
+            return result;
+        } catch (error) {
+            GitHubService.logger.error('GitHub export failed', error);
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
             return {
                 success: false,
-                error: `GitHub push failed: ${errorMessage}`,
-                details: {
-                    operation: 'intelligent_push',
-                    stderr: errorMessage
-                }
+                error: `GitHub export failed: ${errorMessage}`
             };
         }
     }
 
     /**
-     * Fetches commit history from remote GitHub repository
+     * Replace [cloudflarebutton] placeholder with deploy button
      */
-    private static async fetchRemoteCommits(
-        octokit: Octokit, 
-        owner: string, 
-        repo: string, 
-        branch: string
-    ): Promise<RemoteCommit[]> {
+    private static async modifyReadmeForGitHub(fs: MemFS, githubRepoUrl: string): Promise<void> {
         try {
-            const { data: commits } = await octokit.rest.repos.listCommits({
-                owner,
-                repo,
-                sha: branch,
-                per_page: 100 // Get recent history
+            // Check if README exists
+            try {
+                await fs.stat('/README.md');
+            } catch {
+                GitHubService.logger.info('No README.md found, skipping modification');
+                return;
+            }
+
+            const contentRaw = await fs.readFile('/README.md', { encoding: 'utf8' });
+            const content = typeof contentRaw === 'string' ? contentRaw : new TextDecoder().decode(contentRaw);
+            
+            if (!content.includes('[cloudflarebutton]')) {
+                GitHubService.logger.info('README.md has no [cloudflarebutton] placeholder');
+                return;
+            }
+
+            const modified = content.replaceAll(
+                '[cloudflarebutton]',
+                prepareCloudflareButton(githubRepoUrl, 'markdown')
+            );
+
+            await fs.writeFile('/README.md', modified);
+            await git.add({ fs, dir: '/', filepath: 'README.md' });
+            await git.commit({
+                fs,
+                dir: '/',
+                message: 'docs: Add Cloudflare deploy button to README',
+                author: { 
+                    name: 'vibesdk-bot', 
+                    email: 'bot@vibesdk.com',
+                    timestamp: Math.floor(Date.now() / 1000)
+                }
             });
 
-            return commits.map(commit => ({
-                sha: commit.sha,
-                message: commit.commit.message,
-                date: commit.commit.author?.date || new Date().toISOString()
-            }));
+            GitHubService.logger.info('README.md modified and committed');
         } catch (error) {
-            const githubError = error as { status?: number };
-            if (githubError.status === 409 || githubError.status === 404) {
-                // Empty repository or branch doesn't exist
-                GitHubService.logger.info('Remote repository is empty or branch does not exist');
-                return [];
-            }
-            throw error;
+            GitHubService.logger.warn('Failed to modify README, continuing without', error);
         }
     }
 
     /**
-     * Determines optimal commit strategy based on local and remote repository state
+     * Recursively get all files from repository
      */
-    private static planCommitStrategy(
-        gitContext: GitContext | undefined,
-        remoteCommits: RemoteCommit[],
-        files: FileContent[]
-    ): {
-        type: 'single_commit' | 'multi_commit' | 'incremental';
-        commits: Array<{
-            message: string;
-            timestamp: string;
-            files: FileContent[];
-        }>;
-    } {
-        const localCommits = gitContext?.localCommits || [];
+    private static async getAllFilesFromRepo(fs: MemFS): Promise<Array<{ path: string; content: string }>> {
+        const files: Array<{ path: string; content: string }> = [];
         
-        // Strategy 1: No local history - single commit
-        if (localCommits.length === 0) {
-            return {
-                type: 'single_commit',
-                commits: [{
-                    message: 'Generated app',
-                    timestamp: new Date().toISOString(),
-                    files
-                }]
-            };
-        }
-
-        // Strategy 2: Remote is empty - push all local commits
-        if (remoteCommits.length === 0) {
-            return {
-                type: 'multi_commit',
-                commits: localCommits.map(commit => ({
-                    message: commit.message,
-                    timestamp: commit.timestamp,
-                    files // All files in final commit (simplified)
-                }))
-            };
-        }
-
-        // Strategy 3: Both exist - find what's new and create incremental commits
-        const newLocalCommits = localCommits.filter(local => 
-            !remoteCommits.some(remote => remote.message === local.message)
-        );
-
-        if (newLocalCommits.length > 0) {
-            return {
-                type: 'incremental',
-                commits: newLocalCommits.map(commit => ({
-                    message: commit.message,
-                    timestamp: commit.timestamp,
-                    files
-                }))
-            };
-        }
-
-        // Strategy 4: Everything is in sync - only commit if there are uncommitted changes
-        if (gitContext?.hasUncommittedChanges) {
-            return {
-                type: 'single_commit',
-                commits: [{
-                    message: 'Update generated app',
-                    timestamp: new Date().toISOString(),
-                    files
-                }]
-            };
-        }
-
-        // Strategy 5: Everything is perfectly in sync - no commit needed
-        return {
-            type: 'single_commit',
-            commits: []
+        const walkDir = async (dir: string) => {
+            const entries = await fs.readdir(dir);
+            
+            for (const entry of entries) {
+                const fullPath = dir === '/' ? `/${entry}` : `${dir}/${entry}`;
+                
+                // Skip .git
+                if (fullPath === '/.git') continue;
+                
+                const stat = await fs.lstat(fullPath);
+                
+                if (stat.type === 'dir') {
+                    await walkDir(fullPath);
+                } else if (stat.type === 'file') {
+                    const contentRaw = await fs.readFile(fullPath, { encoding: 'utf8' });
+                    const content = typeof contentRaw === 'string' ? contentRaw : new TextDecoder().decode(contentRaw);
+                    // Strip leading slash
+                    const relativePath = fullPath.slice(1);
+                    files.push({ path: relativePath, content });
+                }
+            }
         };
+        
+        await walkDir('/');
+        return files;
     }
 
     /**
-     * Executes the planned commit strategy for the given repository
+     * Force push to GitHub while preserving commit history
      */
-    private static async executeCommitStrategy(
-        octokit: Octokit,
-        owner: string,
-        repo: string,
-        branch: string,
-        strategy: ReturnType<typeof GitHubService.planCommitStrategy>,
-        initialParentSha: string,
-        request: GitHubPushRequest
-    ): Promise<string> {
-        let parentCommitSha = initialParentSha;
-
-        for (const commitPlan of strategy.commits) {
-            if (!parentCommitSha) {
-                // Empty repository - create README to bootstrap, then use normal flow
-                GitHubService.logger.info('Bootstrapping empty repository with README', { 
-                    owner, repo, branch
-                });
-                
-                const { data: readmeCommit } = await octokit.rest.repos.createOrUpdateFileContents({
-                    owner,
-                    repo,
-                    path: 'README.md',
-                    message: 'Initial commit',
-                    content: Buffer.from(GitHubService.README_CONTENT, 'utf8').toString('base64'),
-                    branch,
-                    author: GitHubService.createAuthorInfo(request),
-                    committer: GitHubService.createAuthorInfo(request)
-                });
-
-                if (!readmeCommit.commit.sha) {
-                    throw new GitHubServiceError('Failed to get commit SHA from README creation', 'COMMIT_SHA_MISSING');
-                }
-                parentCommitSha = readmeCommit.commit.sha;
-                
-                GitHubService.logger.info('Repository bootstrapped successfully', { 
-                    owner, repo,
-                    bootstrapCommitSha: parentCommitSha 
-                });
-                
-                // Now fall through to use the normal tree-based approach below
+    private static async forcePushToGitHub(
+        token: string,
+        repoUrl: string,
+        commits: Awaited<ReturnType<typeof git.log>>,
+        files: Array<{ path: string; content: string }>,
+        author: { name: string; email: string }
+    ): Promise<GitHubPushResponse> {
+        try {
+            const repoInfo = GitHubService.extractRepoInfo(repoUrl);
+            if (!repoInfo) {
+                throw new GitHubServiceError('Invalid repository URL format', 'INVALID_REPO_URL');
             }
-            
-            // Repository has commits (either existing or just bootstrapped) - use tree-based approach
-            GitHubService.logger.info('Creating tree-based commit', { 
-                owner, repo, 
-                baseTreeSha: parentCommitSha,
-                fileCount: commitPlan.files.length 
-            });
-            
-            // Create tree entries for all files
-            const treeEntries: GitHubTree[] = commitPlan.files.map(file => ({
-                path: file.filePath,
-                mode: '100644',
-                type: 'blob',
-                content: file.fileContents
-            }));
-
-            const { data: tree } = await octokit.rest.git.createTree({
+
+            const { owner, repo } = repoInfo;
+            const octokit = GitHubService.createOctokit(token);
+
+            // Get repository and default branch
+            const { data: repository } = await octokit.rest.repos.get({ owner, repo });
+            const branch = repository.default_branch || 'main';
+
+            GitHubService.logger.info('Pushing to GitHub', {
                 owner,
                 repo,
-                tree: treeEntries,
-                base_tree: parentCommitSha
+                branch,
+                commitCount: commits.length,
+                fileCount: files.length
             });
 
-            const { data: commit } = await octokit.rest.git.createCommit({
+            // Create file blobs
+            const blobPromises = files.map(file =>
+                octokit.git.createBlob({
+                    owner,
+                    repo,
+                    content: Buffer.from(file.content, 'utf8').toString('base64'),
+                    encoding: 'base64'
+                })
+            );
+            const blobs = await Promise.all(blobPromises);
+
+            GitHubService.logger.info('Blobs created', { blobCount: blobs.length });
+
+            // Create tree
+            const { data: tree } = await octokit.git.createTree({
                 owner,
                 repo,
-                message: commitPlan.message,
-                tree: tree.sha,
-                parents: [parentCommitSha],
-                author: GitHubService.createAuthorInfo(request, commitPlan.timestamp),
-                committer: GitHubService.createAuthorInfo(request, commitPlan.timestamp)
+                tree: files.map((file, i) => ({
+                    path: file.path,
+                    mode: '100644' as '100644',
+                    type: 'blob' as 'blob',
+                    sha: blobs[i].data.sha
+                }))
             });
 
-            parentCommitSha = commit.sha;
+            GitHubService.logger.info('Tree created', { treeSha: tree.sha });
+
+            // Replay commits in order
+            let parentSha: string | undefined;
+            const reversedCommits = [...commits].reverse();
+            
+            for (const commit of reversedCommits) {
+                const { data: newCommit } = await octokit.git.createCommit({
+                    owner,
+                    repo,
+                    message: commit.commit.message,
+                    tree: tree.sha,
+                    parents: parentSha ? [parentSha] : [],
+                    author: {
+                        name: commit.commit.author.name,
+                        email: commit.commit.author.email,
+                        date: new Date(commit.commit.author.timestamp * 1000).toISOString()
+                    },
+                    committer: {
+                        name: commit.commit.committer?.name || author.name,
+                        email: commit.commit.committer?.email || author.email,
+                        date: new Date((commit.commit.committer?.timestamp || commit.commit.author.timestamp) * 1000).toISOString()
+                    }
+                });
+                parentSha = newCommit.sha;
+            }
+
+            if (!parentSha) {
+                throw new Error('No commits were created');
+            }
 
-            // Update branch reference
-            await octokit.rest.git.updateRef({
+            // Update branch
+            await octokit.git.updateRef({
                 owner,
                 repo,
                 ref: `heads/${branch}`,
-                sha: parentCommitSha,
+                sha: parentSha,
                 force: true
             });
-        }
 
-        return parentCommitSha;
+            GitHubService.logger.info('Force push completed', {
+                finalCommitSha: parentSha,
+                branch
+            });
+
+            return {
+                success: true,
+                commitSha: parentSha
+            };
+        } catch (error) {
+            GitHubService.logger.error('Force push failed', error);
+            throw error;
+        }
     }
 
     /**
-     * Extracts owner and repository name from GitHub URL
+     * Check remote repository status vs local commits
+     * Builds local repo with template to match export structure
      */
-    private static extractRepoInfo(url: string): { owner: string; repo: string } | null {
+    static async checkRemoteStatus(options: {
+        gitObjects: Array<{ path: string; data: Uint8Array }>;
+        templateDetails: TemplateDetails | null;
+        appQuery: string;
+        appCreatedAt?: Date;
+        repositoryUrl: string;
+        token: string;
+    }): Promise<{
+        compatible: boolean;
+        behindBy: number;
+        aheadBy: number;
+        divergedCommits: Array<{
+            sha: string;
+            message: string;
+            author: string;
+            date: string;
+        }>;
+    }> {
         try {
-            // Normalize SSH format to HTTPS
-            let cleanUrl = url;
-            
-            if (url.startsWith('git@github.com:')) {
-                cleanUrl = url.replace('git@github.com:', 'https://github.com/');
+            const repoInfo = GitHubService.extractRepoInfo(options.repositoryUrl);
+            if (!repoInfo) {
+                throw new GitHubServiceError('Invalid repository URL', 'INVALID_REPO_URL');
             }
+
+            const { owner, repo } = repoInfo;
+            const octokit = GitHubService.createOctokit(options.token);
+
+            // Get remote commits
+            const { data: remoteCommits } = await octokit.repos.listCommits({
+                owner,
+                repo,
+                per_page: 100
+            });
+
+            // Build local repo with same template as export
+            const fs = await GitCloneService.buildRepository({
+                gitObjects: options.gitObjects,
+                templateDetails: options.templateDetails,
+                appQuery: options.appQuery,
+                appCreatedAt: options.appCreatedAt
+            });
+
+            const localCommits = await git.log({ fs, dir: '/', depth: 100 });
+
+            // Find divergence
+            // Normalize commit messages by trimming whitespace (git.log adds trailing \n, GitHub API doesn't)
+            const normalizeMessage = (msg: string) => msg.trim();
             
-            const urlObj = new URL(cleanUrl);
-            const pathParts = urlObj.pathname.split('/').filter(part => part);
-            
-            if (pathParts.length >= 2) {
-                const owner = pathParts[0];
-                const repo = pathParts[1].replace('.git', '');
-                return { owner, repo };
-            }
+            // Ignore system-generated commits that we add to GitHub but don't track locally
+            const isSystemGeneratedCommit = (message: string) => {
+                return normalizeMessage(message).startsWith('docs: Add Cloudflare deploy button');
+            };
             
-            return null;
+            const localMessages = new Set(localCommits.map(c => normalizeMessage(c.commit.message)));
+            const remoteMessages = new Set(remoteCommits.map(c => normalizeMessage(c.commit.message)));
+
+            const hasCommonCommit = localCommits.some(local =>
+                remoteCommits.some(remote => 
+                    normalizeMessage(remote.commit.message) === normalizeMessage(local.commit.message)
+                )
+            );
+
+            const localOnly = localCommits.filter(c => !remoteMessages.has(normalizeMessage(c.commit.message)));
+            const remoteOnly = remoteCommits.filter(c => 
+                !localMessages.has(normalizeMessage(c.commit.message)) && !isSystemGeneratedCommit(c.commit.message)
+            );
+
+            return {
+                compatible: hasCommonCommit || remoteCommits.length === 0,
+                behindBy: localOnly.length,
+                aheadBy: remoteOnly.length,
+                divergedCommits: remoteOnly.map(c => ({
+                    sha: c.sha,
+                    message: c.commit.message,
+                    author: c.commit.author?.name || 'Unknown',
+                    date: c.commit.author?.date || new Date().toISOString()
+                }))
+            };
         } catch (error) {
-            GitHubService.logger.error('Failed to parse repository URL', { url, error });
-            return null;
+            GitHubService.logger.error('Failed to check remote status', error);
+            throw error;
         }
     }
 
-
 }
\ No newline at end of file
diff --git a/worker/services/github/types.ts b/worker/services/github/types.ts
index 66c0dce1..432801d6 100644
--- a/worker/services/github/types.ts
+++ b/worker/services/github/types.ts
@@ -40,6 +40,8 @@ export interface CreateRepositoryResult {
     success: boolean;
     repository?: GitHubRepository;
     error?: string;
+    alreadyExists?: boolean;
+    repositoryName?: string;
 }
 
 export interface GitHubTokenResult {
diff --git a/worker/services/sandbox/BaseSandboxService.ts b/worker/services/sandbox/BaseSandboxService.ts
index 5690df1e..f1056391 100644
--- a/worker/services/sandbox/BaseSandboxService.ts
+++ b/worker/services/sandbox/BaseSandboxService.ts
@@ -27,14 +27,11 @@ import {
     
     GetLogsResponse,
     ListInstancesResponse,
-    GitHubPushRequest,
-    GitHubPushResponse,
     TemplateDetails,
 } from './sandboxTypes';
   
 import { createObjectLogger, StructuredLogger } from '../../logger';
 import { env } from 'cloudflare:workers'
-import { FileOutputType } from 'worker/agents/schemas';
 import { ZipExtractor } from './zipExtractor';
 import { FileTreeBuilder } from './fileTreeBuilder';
 
@@ -314,8 +311,4 @@ export abstract class BaseSandboxService {
     // GITHUB INTEGRATION (Required)
     // ==========================================
 
-    /**
-     * Push instance files to existing GitHub repository
-     */
-    abstract pushToGitHub(instanceId: string, request: GitHubPushRequest, files: FileOutputType[]): Promise<GitHubPushResponse>
 }
\ No newline at end of file
diff --git a/worker/services/sandbox/sandboxSdkClient.ts b/worker/services/sandbox/sandboxSdkClient.ts
index ae9ca61d..4921fe45 100644
--- a/worker/services/sandbox/sandboxSdkClient.ts
+++ b/worker/services/sandbox/sandboxSdkClient.ts
@@ -19,7 +19,6 @@ import {
     CodeIssue,
     InstanceDetails,
     LintSeverity,
-    GitHubPushRequest, GitHubPushResponse,
     GetLogsResponse,
     ListInstancesResponse,
     StoredError,
@@ -43,10 +42,8 @@ import { generateId } from '../../utils/idGenerator';
 import { ResourceProvisioner } from './resourceProvisioner';
 import { TemplateParser } from './templateParser';
 import { ResourceProvisioningResult } from './types';
-import { GitHubService } from '../github/GitHubService';
 import { getPreviewDomain } from '../../utils/urls';
-import { isDev } from 'worker/utils/envs';
-import { FileOutputType } from 'worker/agents/schemas';
+import { isDev } from 'worker/utils/envs'
 import { FileTreeBuilder } from './fileTreeBuilder';
 // Export the Sandbox class in your Worker
 export { Sandbox as UserAppSandboxService, Sandbox as DeployerService} from "@cloudflare/sandbox";
@@ -2146,270 +2143,5 @@ export class SandboxSdkClient extends BaseSandboxService {
         throw new Error(`Git rev-parse failed: ${hashResult.stderr}`);
     }
 
-    /**
-     * Push files to GitHub using secure API-based approach
-     * Extracts git context from sandbox and delegates to GitHubService
-     */
-    async pushToGitHub(instanceId: string, request: GitHubPushRequest, allFiles: FileOutputType[]): Promise<GitHubPushResponse> {
-        // Validate required parameters
-        if (!instanceId?.trim()) {
-            return {
-                success: false,
-                error: 'Instance ID is required'
-            };
-        }
-
-        if (!request?.cloneUrl?.trim()) {
-            return {
-                success: false,
-                error: 'Clone URL is required'
-            };
-        }
-
-        if (!request?.token?.trim()) {
-            return {
-                success: false,
-                error: 'GitHub token is required'
-            };
-        }
-
-        if (!request?.email?.trim() || !request?.username?.trim()) {
-            return {
-                success: false,
-                error: 'Git user email and username are required'
-            };
-        }
-
-        try {
-            this.logger.info(`Starting GitHub push for instance ${instanceId}`);
-
-            // Extract git context from local repository
-            const gitContext = await this.extractGitContext(instanceId);
-            
-            if (!gitContext.isGitRepo) {
-                this.logger.error('No git repository found in sandbox');
-                return {
-                    success: false,
-                    error: 'No git repository found in sandbox instance'
-                };
-            }
-
-            // Auto-commit any uncommitted or untracked changes before push
-            let finalGitContext = gitContext;
-            if (gitContext.hasUncommittedChanges || gitContext.hasUntrackedFiles) {
-                this.logger.info('Auto-committing changes before GitHub push', {
-                    hasUncommittedChanges: gitContext.hasUncommittedChanges,
-                    hasUntrackedFiles: gitContext.hasUntrackedFiles,
-                    untrackedFileCount: gitContext.untrackedFiles.length
-                });
-                
-                try {
-                    // Auto-commit all changes
-                    await this.createLatestCommit(instanceId, 'Auto-commit before GitHub push');
-                    
-                    // Re-extract git context after commit
-                    finalGitContext = await this.extractGitContext(instanceId);
-                    this.logger.info('Auto-commit successful', {
-                        newCommitCount: finalGitContext.localCommits.length
-                    });
-                } catch (error) {
-                    this.logger.error('Auto-commit failed', error);
-                    return {
-                        success: false,
-                        error: `Failed to auto-commit changes: ${error instanceof Error ? error.message : 'Unknown error'}`
-                    };
-                }
-            }
-
-            // Use broader file selection - all files if we have any, otherwise tracked files
-            const filesToUse = finalGitContext.allFiles.length > 0 ? finalGitContext.allFiles : finalGitContext.trackedFiles;
-            const filesToUseSet = new Set(filesToUse);
-            const cachedFiles = allFiles.filter(file => filesToUseSet.has(file.filePath) && file.fileContents.trim() !== '[REDACTED]');
-            const cachedFilePaths = new Set(cachedFiles.map((file: {filePath: string; fileContents: string}) => file.filePath));
-            const filesToFetch = filesToUse.filter((file: string) => !cachedFilePaths.has(file));
-            const filesNotCached = await this.getFileDirect(instanceId, filesToFetch);
-            const files = [...cachedFiles, ...filesNotCached];
-
-            this.logger.info(`Total files to push: ${files.length}`, {
-                cachedFilePaths,
-                filesToFetch,
-                filesToUse,
-            });
-            
-            if (files.length === 0) {
-                this.logger.warn('No files found to push');
-                return {
-                    success: true,
-                    commitSha: undefined
-                };
-            }
-
-            // Delegate to secure GitHub service
-            const result = await GitHubService.pushFilesToRepository(files, request, {
-                localCommits: finalGitContext.localCommits,
-                hasUncommittedChanges: finalGitContext.hasUncommittedChanges
-            });
-            
-            this.logger.info('GitHub push completed', { 
-                instanceId, 
-                success: result.success, 
-                commitSha: result.commitSha,
-                localCommitCount: finalGitContext.localCommits.length,
-                fileCount: files.length
-            });
-
-            return result;
 
-        } catch (error) {
-            this.logger.error('pushToGitHub failed', error, { instanceId, repositoryUrl: request.repositoryHtmlUrl });
-            
-            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-            
-            return {
-                success: false,
-                error: `Secure GitHub push failed: ${errorMessage}`,
-                details: {
-                    operation: 'secure_api_push',
-                    stderr: errorMessage
-                }
-            };
-        }
-    }
-
-    /**
-     * Read contents of any file
-     */
-    private async getFileDirect(instanceId: string, filePaths: string[]): Promise<{
-        filePath: string;
-        fileContents: string;
-    }[]> {
-        const files: { filePath: string; fileContents: string; }[] = [];
-        const session = await this.getInstanceSession(instanceId);
-
-        this.logger.info(`Reading ${filePaths.length} files`, { instanceId });
-
-        for (const filePath of filePaths) {
-            try {
-                const readResult = await session.readFile(`/workspace/${instanceId}/${filePath}`);
-                if (readResult.success && readResult.content) {
-                    files.push({
-                        filePath,
-                        fileContents: readResult.content
-                    });
-                    this.logger.debug(`Successfully read file: ${filePath}`, { sizeBytes: readResult.content.length });
-                } else {
-                    this.logger.warn(`File read failed or empty: ${filePath}`);
-                }
-            } catch (error) {
-                this.logger.warn(`Failed to read file ${filePath}`, error);
-            }
-        }
-
-        this.logger.info(`Successfully read ${files.length}/${filePaths.length} files`);
-        return files;
-    }
-
-    /**
-     * Extract git history and file tracking information from local repository
-     */
-    private async extractGitContext(instanceId: string): Promise<{
-        localCommits: Array<{
-            hash: string;
-            message: string;
-            timestamp: string;
-        }>;
-        trackedFiles: string[];
-        untrackedFiles: string[];
-        allFiles: string[];
-        hasUncommittedChanges: boolean;
-        hasUntrackedFiles: boolean;
-        isGitRepo: boolean;
-    }> {
-        try {
-            // First check if this is even a git repository
-            const gitCheckResult = await this.executeCommand(instanceId, 'git status');
-            if (gitCheckResult.exitCode !== 0) {
-                this.logger.warn('Not a git repository or git not initialized', { instanceId });
-                return {
-                    localCommits: [],
-                    trackedFiles: [],
-                    untrackedFiles: [],
-                    allFiles: [],
-                    hasUncommittedChanges: false,
-                    hasUntrackedFiles: false,
-                    isGitRepo: false
-                };
-            }
-
-            // Get full commit history (oldest first to preserve order for GitHub)
-            const logResult = await this.executeCommand(instanceId, 'git log --oneline --reverse --pretty=format:"%H|%s|%cI"');
-            const localCommits: Array<{hash: string; message: string; timestamp: string}> = [];
-            
-            if (logResult.exitCode === 0 && logResult.stdout.trim()) {
-                const commitLines = logResult.stdout.trim().split('\n');
-                for (const line of commitLines) {
-                    const [hash, message, timestamp] = (line as string).split('|');
-                    if (hash && message) {
-                        localCommits.push({
-                            hash: hash.trim(),
-                            message: message.trim(),
-                            timestamp: timestamp?.trim() || new Date().toISOString()
-                        });
-                    }
-                }
-            }
-
-            // Get git-tracked files (respects .gitignore)
-            const lsFilesResult = await this.executeCommand(instanceId, 'git ls-files');
-            const trackedFiles = lsFilesResult.exitCode === 0 
-                ? lsFilesResult.stdout.trim().split('\n').filter((f: string) => f.trim())
-                : [];
-
-            // Get untracked files (respects .gitignore)
-            const untrackedResult = await this.executeCommand(instanceId, 'git ls-files --others --exclude-standard');
-            const untrackedFiles = untrackedResult.exitCode === 0
-                ? untrackedResult.stdout.trim().split('\n').filter((f: string) => f.trim())
-                : [];
-
-            // Combine all files
-            const allFiles = [...trackedFiles, ...untrackedFiles];
-
-            // Check if there are uncommitted changes (staged or modified)
-            const statusResult = await this.executeCommand(instanceId, 'git status --porcelain');
-            const hasUncommittedChanges = statusResult.exitCode === 0 && statusResult.stdout.trim().length > 0;
-            const hasUntrackedFiles = untrackedFiles.length > 0;
-
-            this.logger.info('Full git context extracted', {
-                instanceId,
-                localCommitCount: localCommits.length,
-                trackedFileCount: trackedFiles.length,
-                untrackedFileCount: untrackedFiles.length,
-                totalFileCount: allFiles.length,
-                hasUncommittedChanges,
-                hasUntrackedFiles,
-                latestCommit: localCommits[localCommits.length - 1]?.message
-            });
-
-            return { 
-                localCommits, 
-                trackedFiles,
-                untrackedFiles,
-                allFiles,
-                hasUncommittedChanges,
-                hasUntrackedFiles,
-                isGitRepo: true 
-            };
-        } catch (error) {
-            this.logger.warn('Failed to extract git context, using defaults', error);
-            return {
-                localCommits: [],
-                trackedFiles: [],
-                untrackedFiles: [],
-                allFiles: [],
-                hasUncommittedChanges: false,
-                hasUntrackedFiles: false,
-                isGitRepo: false
-            };
-        }
-    }
 }
\ No newline at end of file