diff --git a/.gitignore b/.gitignore
index cd81520..cd19e93 100644
--- a/.gitignore
+++ b/.gitignore
@@ -28,6 +28,15 @@ Thumbs.db
 /docs
 /CLAUDE.md
 
+# AI tool configurations
+/.cursor
+/.gemini
+/.junie
+/.mcp.json
+/GEMINI.md
+/boost.json
+
 # SQLite test databases
 planforge_test_*
 planforge
+.env.testing
diff --git a/app/Enums/ExternalLinkSyncStatus.php b/app/Enums/ExternalLinkSyncStatus.php
new file mode 100644
index 0000000..e07b7f5
--- /dev/null
+++ b/app/Enums/ExternalLinkSyncStatus.php
@@ -0,0 +1,12 @@
+<?php
+
+namespace App\Enums;
+
+enum ExternalLinkSyncStatus: string
+{
+    case Pending = 'pending';
+    case Synced = 'synced';
+    case Failed = 'failed';
+    case Orphaned = 'orphaned';
+    case Conflict = 'conflict';
+}
diff --git a/app/Enums/IntegrationProvider.php b/app/Enums/IntegrationProvider.php
new file mode 100644
index 0000000..38fe1a3
--- /dev/null
+++ b/app/Enums/IntegrationProvider.php
@@ -0,0 +1,11 @@
+<?php
+
+namespace App\Enums;
+
+enum IntegrationProvider: string
+{
+    case GitHub = 'github';
+    case Jira = 'jira';
+    case Trello = 'trello';
+    case Linear = 'linear';
+}
diff --git a/app/Enums/IntegrationStatus.php b/app/Enums/IntegrationStatus.php
new file mode 100644
index 0000000..143fc33
--- /dev/null
+++ b/app/Enums/IntegrationStatus.php
@@ -0,0 +1,11 @@
+<?php
+
+namespace App\Enums;
+
+enum IntegrationStatus: string
+{
+    case Pending = 'pending';
+    case Connected = 'connected';
+    case Error = 'error';
+    case Disabled = 'disabled';
+}
diff --git a/app/Enums/SyncRunStatus.php b/app/Enums/SyncRunStatus.php
new file mode 100644
index 0000000..440c056
--- /dev/null
+++ b/app/Enums/SyncRunStatus.php
@@ -0,0 +1,11 @@
+<?php
+
+namespace App\Enums;
+
+enum SyncRunStatus: string
+{
+    case Running = 'running';
+    case Completed = 'completed';
+    case Failed = 'failed';
+    case Partial = 'partial';
+}
diff --git a/app/Events/TasksChanged.php b/app/Events/TasksChanged.php
new file mode 100644
index 0000000..7f574b4
--- /dev/null
+++ b/app/Events/TasksChanged.php
@@ -0,0 +1,17 @@
+<?php
+
+namespace App\Events;
+
+use App\Models\Project;
+use Illuminate\Foundation\Events\Dispatchable;
+use Illuminate\Queue\SerializesModels;
+
+class TasksChanged
+{
+    use Dispatchable, SerializesModels;
+
+    public function __construct(
+        public Project $project,
+        public string $changeType = 'updated'
+    ) {}
+}
diff --git a/app/Exceptions/GitHubApiException.php b/app/Exceptions/GitHubApiException.php
new file mode 100644
index 0000000..536167d
--- /dev/null
+++ b/app/Exceptions/GitHubApiException.php
@@ -0,0 +1,11 @@
+<?php
+
+namespace App\Exceptions;
+
+class GitHubApiException extends \Exception
+{
+    public function __construct(string $message, int $statusCode = 0)
+    {
+        parent::__construct($message, $statusCode);
+    }
+}
diff --git a/app/Exceptions/GitHubAuthException.php b/app/Exceptions/GitHubAuthException.php
new file mode 100644
index 0000000..109fc8d
--- /dev/null
+++ b/app/Exceptions/GitHubAuthException.php
@@ -0,0 +1,5 @@
+<?php
+
+namespace App\Exceptions;
+
+class GitHubAuthException extends GitHubApiException {}
diff --git a/app/Exceptions/GitHubRateLimitException.php b/app/Exceptions/GitHubRateLimitException.php
new file mode 100644
index 0000000..300d233
--- /dev/null
+++ b/app/Exceptions/GitHubRateLimitException.php
@@ -0,0 +1,14 @@
+<?php
+
+namespace App\Exceptions;
+
+class GitHubRateLimitException extends GitHubApiException
+{
+    public int $retryAfter;
+
+    public function __construct(string $message, int $retryAfter = 60)
+    {
+        parent::__construct($message, 429);
+        $this->retryAfter = $retryAfter;
+    }
+}
diff --git a/app/Http/Controllers/GitHubIntegrationController.php b/app/Http/Controllers/GitHubIntegrationController.php
new file mode 100644
index 0000000..9745036
--- /dev/null
+++ b/app/Http/Controllers/GitHubIntegrationController.php
@@ -0,0 +1,238 @@
+<?php
+
+namespace App\Http\Controllers;
+
+use App\Enums\IntegrationProvider;
+use App\Enums\IntegrationStatus;
+use App\Models\Integration;
+use App\Models\Project;
+use App\Models\User;
+use App\Services\GitHub\GitHubApiService;
+use App\Services\GitHub\GitHubSyncService;
+use Illuminate\Foundation\Auth\Access\AuthorizesRequests;
+use Illuminate\Http\JsonResponse;
+use Illuminate\Http\RedirectResponse;
+use Illuminate\Http\Request;
+use Illuminate\View\View;
+
+class GitHubIntegrationController extends Controller
+{
+    use AuthorizesRequests;
+
+    /**
+     * Redirect to GitHub App installation.
+     */
+    public function install(Request $request, Project $project): RedirectResponse
+    {
+        $this->authorize('update', $project);
+
+        $state = encrypt([
+            'project_id' => $project->id,
+            'user_id' => auth()->id(),
+        ]);
+
+        $appSlug = config('services.github.app_slug');
+
+        return redirect("https://github.com/apps/{$appSlug}/installations/new?state={$state}");
+    }
+
+    /**
+     * Handle callback after GitHub App installation.
+     *
+     * Note: This route runs without auth middleware since it's called by GitHub.
+     * We re-authenticate the user from the encrypted state.
+     */
+    public function callback(Request $request): RedirectResponse
+    {
+        $installationId = $request->input('installation_id');
+
+        if (! $installationId) {
+            return redirect()->route('projects.index')
+                ->with('error', 'GitHub installation was cancelled.');
+        }
+
+        try {
+            $state = decrypt($request->input('state'));
+        } catch (\Exception $e) {
+            return redirect()->route('projects.index')
+                ->with('error', 'Invalid state parameter. Please try again.');
+        }
+
+        $project = Project::findOrFail($state['project_id']);
+        $user = User::findOrFail($state['user_id']);
+
+        // Re-authenticate the user from state
+        auth()->login($user);
+
+        // Now we can authorize
+        $this->authorize('update', $project);
+
+        // Store installation ID temporarily
+        session(['github_installation_id' => $installationId]);
+
+        return redirect()->route('integrations.github.select-repo', $project);
+    }
+
+    /**
+     * Show repository selection page.
+     */
+    public function selectRepo(Request $request, Project $project, GitHubApiService $api): View|RedirectResponse
+    {
+        $this->authorize('update', $project);
+
+        $installationId = session('github_installation_id');
+
+        if (! $installationId) {
+            return redirect()->route('integrations.github.install', $project)
+                ->with('error', 'GitHub installation expired. Please try again.');
+        }
+
+        try {
+            $repos = $api->listRepositories($installationId);
+        } catch (\Exception $e) {
+            return redirect()->route('projects.workspace', $project)
+                ->with('error', 'Failed to fetch repositories: '.$e->getMessage());
+        }
+
+        return view('integrations.github.select-repo', [
+            'project' => $project,
+            'repositories' => $repos['repositories'] ?? [],
+        ]);
+    }
+
+    /**
+     * Complete setup with selected repository.
+     */
+    public function setup(Request $request, Project $project): RedirectResponse
+    {
+        $this->authorize('update', $project);
+
+        $validated = $request->validate([
+            'owner' => 'required|string',
+            'repo' => 'required|string',
+            'default_labels' => 'nullable|array',
+            'sync_closed_as' => 'nullable|string|in:done',
+            'sync_reopened_as' => 'nullable|string|in:doing,todo',
+        ]);
+
+        $installationId = session('github_installation_id');
+
+        if (! $installationId) {
+            return redirect()->route('integrations.github.install', $project)
+                ->with('error', 'GitHub installation expired. Please try again.');
+        }
+
+        Integration::updateOrCreate(
+            [
+                'project_id' => $project->id,
+                'provider' => IntegrationProvider::GitHub,
+            ],
+            [
+                'status' => IntegrationStatus::Connected,
+                'settings' => [
+                    'installation_id' => $installationId,
+                    'owner' => $validated['owner'],
+                    'repo' => $validated['repo'],
+                    'default_labels' => $validated['default_labels'] ?? ['planforge'],
+                    'sync_closed_as' => $validated['sync_closed_as'] ?? 'done',
+                    'sync_reopened_as' => $validated['sync_reopened_as'] ?? 'doing',
+                ],
+                'error_message' => null,
+            ]
+        );
+
+        session()->forget('github_installation_id');
+
+        return redirect()->route('projects.workspace', $project)
+            ->with('success', 'GitHub integration connected successfully!');
+    }
+
+    /**
+     * Disconnect GitHub integration.
+     */
+    public function disconnect(Request $request, Project $project): RedirectResponse
+    {
+        $this->authorize('update', $project);
+
+        $integration = $project->gitHubIntegration();
+
+        if ($integration) {
+            $integration->update([
+                'status' => IntegrationStatus::Disabled,
+                'error_message' => 'Disconnected by user',
+            ]);
+        }
+
+        return redirect()->route('projects.workspace', $project)
+            ->with('success', 'GitHub integration disconnected.');
+    }
+
+    /**
+     * Trigger manual sync to GitHub.
+     */
+    public function sync(Request $request, Project $project, GitHubSyncService $syncService): JsonResponse|RedirectResponse
+    {
+        $this->authorize('update', $project);
+
+        $integration = $project->gitHubIntegration();
+
+        if (! $integration || ! $integration->isConnected()) {
+            if ($request->wantsJson()) {
+                return response()->json([
+                    'error' => 'GitHub integration not connected',
+                ], 400);
+            }
+
+            return redirect()->back()
+                ->with('error', 'GitHub integration not connected.');
+        }
+
+        $syncRun = $syncService->syncProject($integration, auth()->id());
+
+        if ($request->wantsJson()) {
+            return response()->json([
+                'message' => 'Sync started',
+                'sync_run_id' => $syncRun->id,
+                'total_tasks' => $syncRun->total_count,
+            ]);
+        }
+
+        return redirect()->back()
+            ->with('success', "Syncing {$syncRun->total_count} tasks to GitHub...");
+    }
+
+    /**
+     * Get sync status.
+     */
+    public function syncStatus(Request $request, Project $project): JsonResponse
+    {
+        $this->authorize('view', $project);
+
+        $integration = $project->gitHubIntegration();
+
+        if (! $integration) {
+            return response()->json([
+                'connected' => false,
+            ]);
+        }
+
+        $latestRun = $integration->syncRuns()->latest()->first();
+
+        return response()->json([
+            'connected' => $integration->isConnected(),
+            'status' => $integration->status->value,
+            'repo' => $integration->getRepoFullName(),
+            'last_synced_at' => $integration->last_synced_at?->toISOString(),
+            'latest_run' => $latestRun ? [
+                'id' => $latestRun->id,
+                'status' => $latestRun->status->value,
+                'total' => $latestRun->total_count,
+                'created' => $latestRun->created_count,
+                'updated' => $latestRun->updated_count,
+                'failed' => $latestRun->failed_count,
+                'started_at' => $latestRun->started_at->toISOString(),
+                'completed_at' => $latestRun->completed_at?->toISOString(),
+            ] : null,
+        ]);
+    }
+}
diff --git a/app/Http/Controllers/GitHubWebhookController.php b/app/Http/Controllers/GitHubWebhookController.php
new file mode 100644
index 0000000..b6a01de
--- /dev/null
+++ b/app/Http/Controllers/GitHubWebhookController.php
@@ -0,0 +1,180 @@
+<?php
+
+namespace App\Http\Controllers;
+
+use App\Enums\IntegrationProvider;
+use App\Enums\TaskStatus;
+use App\Models\ExternalLink;
+use App\Models\Integration;
+use Illuminate\Http\JsonResponse;
+use Illuminate\Http\Request;
+use Illuminate\Support\Facades\Log;
+
+class GitHubWebhookController extends Controller
+{
+    /**
+     * Handle incoming GitHub webhooks.
+     */
+    public function handle(Request $request): JsonResponse
+    {
+        // Verify webhook signature
+        if (! $this->verifySignature($request)) {
+            Log::warning('GitHub webhook signature verification failed');
+
+            return response()->json(['error' => 'Invalid signature'], 401);
+        }
+
+        $event = $request->header('X-GitHub-Event');
+        $payload = $request->all();
+
+        Log::info('GitHub webhook received', [
+            'event' => $event,
+            'action' => $payload['action'] ?? null,
+        ]);
+
+        return match ($event) {
+            'issues' => $this->handleIssueEvent($payload),
+            'ping' => $this->handlePing($payload),
+            default => response()->json(['message' => 'Event ignored']),
+        };
+    }
+
+    /**
+     * Verify the webhook signature from GitHub.
+     */
+    private function verifySignature(Request $request): bool
+    {
+        $secret = config('services.github.webhook_secret');
+
+        // Skip verification if no secret is configured (dev mode)
+        if (empty($secret)) {
+            return true;
+        }
+
+        $signature = $request->header('X-Hub-Signature-256');
+        if (! $signature) {
+            return false;
+        }
+
+        $payload = $request->getContent();
+        $expectedSignature = 'sha256='.hash_hmac('sha256', $payload, $secret);
+
+        return hash_equals($expectedSignature, $signature);
+    }
+
+    /**
+     * Handle issue events (opened, closed, reopened, etc.).
+     */
+    private function handleIssueEvent(array $payload): JsonResponse
+    {
+        $action = $payload['action'] ?? null;
+        $issue = $payload['issue'] ?? null;
+        $repository = $payload['repository'] ?? null;
+
+        if (! $issue || ! $repository) {
+            return response()->json(['error' => 'Invalid payload'], 400);
+        }
+
+        $issueNodeId = $issue['node_id'];
+        $issueNumber = $issue['number'];
+        $issueState = $issue['state'];
+        $repoFullName = $repository['full_name'];
+
+        // Find the external link for this issue by node_id (most reliable)
+        $externalLink = ExternalLink::where('provider', IntegrationProvider::GitHub)
+            ->where('external_id', $issueNodeId)
+            ->first();
+
+        if (! $externalLink) {
+            // Fallback: find by issue number and matching integration
+            [$owner, $repo] = explode('/', $repoFullName) + [null, null];
+
+            if ($owner && $repo) {
+                $externalLink = ExternalLink::where('provider', IntegrationProvider::GitHub)
+                    ->where('external_number', $issueNumber)
+                    ->whereHas('integration', function ($query) use ($owner, $repo) {
+                        $query->where('provider', IntegrationProvider::GitHub)
+                            ->where('settings->owner', $owner)
+                            ->where('settings->repo', $repo);
+                    })
+                    ->first();
+            }
+        }
+
+        if (! $externalLink) {
+            Log::info('GitHub webhook: No matching external link found', [
+                'issue_node_id' => $issueNodeId,
+                'issue_number' => $issueNumber,
+                'repo' => $repoFullName,
+            ]);
+
+            return response()->json(['message' => 'Issue not tracked']);
+        }
+
+        $task = $externalLink->task;
+        $integration = $externalLink->integration;
+
+        if (! $task || ! $integration) {
+            return response()->json(['message' => 'Task or integration not found']);
+        }
+
+        // Update external link state
+        $externalLink->update([
+            'external_state' => $issueState,
+        ]);
+
+        // Handle status changes based on action
+        $settings = $integration->settings;
+
+        if ($action === 'closed') {
+            $newStatus = match ($settings['sync_closed_as'] ?? 'done') {
+                'done' => TaskStatus::Done,
+                default => TaskStatus::Done,
+            };
+
+            if ($task->status !== $newStatus) {
+                $task->updateQuietly(['status' => $newStatus]);
+
+                Log::info('GitHub webhook: Task status updated to done', [
+                    'task_id' => $task->id,
+                    'issue_number' => $issueNumber,
+                ]);
+            }
+        } elseif ($action === 'reopened') {
+            $newStatus = match ($settings['sync_reopened_as'] ?? 'doing') {
+                'doing' => TaskStatus::Doing,
+                'todo' => TaskStatus::Todo,
+                default => TaskStatus::Doing,
+            };
+
+            if ($task->status === TaskStatus::Done) {
+                $task->updateQuietly(['status' => $newStatus]);
+
+                Log::info('GitHub webhook: Task status updated from done', [
+                    'task_id' => $task->id,
+                    'issue_number' => $issueNumber,
+                    'new_status' => $newStatus->value,
+                ]);
+            }
+        }
+
+        return response()->json([
+            'message' => 'Webhook processed',
+            'action' => $action,
+            'task_id' => $task->id,
+        ]);
+    }
+
+    /**
+     * Handle ping event (sent when webhook is first configured).
+     */
+    private function handlePing(array $payload): JsonResponse
+    {
+        Log::info('GitHub webhook ping received', [
+            'zen' => $payload['zen'] ?? null,
+            'hook_id' => $payload['hook_id'] ?? null,
+        ]);
+
+        return response()->json(['message' => 'pong']);
+    }
+}
diff --git a/app/Jobs/CheckSyncRunCompletion.php b/app/Jobs/CheckSyncRunCompletion.php
new file mode 100644
index 0000000..51ab08f
--- /dev/null
+++ b/app/Jobs/CheckSyncRunCompletion.php
@@ -0,0 +1,49 @@
+<?php
+
+namespace App\Jobs;
+
+use App\Enums\SyncRunStatus;
+use App\Models\SyncRun;
+use Illuminate\Bus\Queueable;
+use Illuminate\Contracts\Queue\ShouldQueue;
+use Illuminate\Foundation\Bus\Dispatchable;
+use Illuminate\Queue\InteractsWithQueue;
+use Illuminate\Queue\SerializesModels;
+
+class CheckSyncRunCompletion implements ShouldQueue
+{
+    use Dispatchable, InteractsWithQueue, Queueable, SerializesModels;
+
+    public function __construct(
+        public string $syncRunId
+    ) {}
+
+    public function handle(): void
+    {
+        $syncRun = SyncRun::find($this->syncRunId);
+
+        if (! $syncRun || $syncRun->status !== SyncRunStatus::Running) {
+            return;
+        }
+
+        $processed = $syncRun->created_count +
+                     $syncRun->updated_count +
+                     $syncRun->skipped_count +
+                     $syncRun->failed_count;
+
+        if ($processed >= $syncRun->total_count) {
+            $status = $syncRun->failed_count > 0
+                ? SyncRunStatus::Partial
+                : SyncRunStatus::Completed;
+
+            $syncRun->update([
+                'status' => $status,
+                'completed_at' => now(),
+            ]);
+        } else {
+            // Still processing, check again in 30 seconds
+            self::dispatch($this->syncRunId)
+                ->delay(now()->addSeconds(30));
+        }
+    }
+}
diff --git a/app/Jobs/DebouncedGitHubSync.php b/app/Jobs/DebouncedGitHubSync.php
new file mode 100644
index 0000000..6e0f0d8
--- /dev/null
+++ b/app/Jobs/DebouncedGitHubSync.php
@@ -0,0 +1,78 @@
+<?php
+
+namespace App\Jobs;
+
+use App\Models\Integration;
+use App\Models\Project;
+use App\Services\GitHub\GitHubSyncService;
+use Illuminate\Bus\Queueable;
+use Illuminate\Contracts\Queue\ShouldQueue;
+use Illuminate\Foundation\Bus\Dispatchable;
+use Illuminate\Queue\InteractsWithQueue;
+use Illuminate\Queue\SerializesModels;
+use Illuminate\Support\Facades\Cache;
+
+class DebouncedGitHubSync implements ShouldQueue
+{
+    use Dispatchable, InteractsWithQueue, Queueable, SerializesModels;
+
+    public int $tries = 1;
+
+    public function __construct(
+        public string $projectId,
+        public string $integrationId,
+        public string $syncId
+    ) {}
+
+    public function handle(GitHubSyncService $syncService): void
+    {
+        // Check if this is still the latest sync request (debounce check)
+        $cacheKey = "github_sync_pending_{$this->projectId}";
+        $latestSyncId = Cache::get($cacheKey);
+
+        if ($latestSyncId !== $this->syncId) {
+            // A newer sync was requested, skip this one
+            logger()->debug('Skipping debounced GitHub sync - newer request exists', [
+                'project_id' => $this->projectId,
+                'sync_id' => $this->syncId,
+                'latest_sync_id' => $latestSyncId,
+            ]);
+
+            return;
+        }
+
+        // Clear the pending sync marker
+        Cache::forget($cacheKey);
+
+        // Load the models
+        $project = Project::find($this->projectId);
+        $integration = Integration::find($this->integrationId);
+
+        if (! $project || ! $integration) {
+            logger()->warning('DebouncedGitHubSync: Project or integration not found', [
+                'project_id' => $this->projectId,
+                'integration_id' => $this->integrationId,
+            ]);
+
+            return;
+        }
+
+        // Verify integration is still connected
+        if (! $integration->isConnected()) {
+            logger()->debug('DebouncedGitHubSync: Integration not connected', [
+                'integration_id' => $this->integrationId,
+            ]);
+
+            return;
+        }
+
+        // Execute the sync (no user_id for auto-triggered syncs)
+        $syncRun = $syncService->syncProject($integration, null);
+
+        logger()->info('Auto-sync triggered for GitHub', [
+            'project_id' => $this->projectId,
+            'sync_run_id' => $syncRun->id,
+            'total_tasks' => $syncRun->total_count,
+        ]);
+    }
+}
diff --git a/app/Jobs/GenerateTasksJob.php b/app/Jobs/GenerateTasksJob.php
index 7149fc6..1fa3b6e 100644
--- a/app/Jobs/GenerateTasksJob.php
+++ b/app/Jobs/GenerateTasksJob.php
@@ -20,6 +20,8 @@
 use Illuminate\Queue\Middleware\RateLimited;
 use Illuminate\Queue\SerializesModels;
 use Illuminate\Support\Facades\DB;
+use Illuminate\Support\Facades\Log;
+use Prism\Prism\Enums\Provider;
 use Prism\Prism\Exceptions\PrismRateLimitedException;
 use Prism\Prism\Facades\Prism;
 use Relaticle\Flowforge\Services\Rank;
@@ -81,6 +83,11 @@ public function handle(): void
 
             $response = $this->callAI($run, $techSpec, $prdSummary);
 
+            Log::info('Task generation completed', [
+                'project_id' => $run->project_id,
+                'tasks_count' => count($response->structured['tasks'] ?? []),
+            ]);
+
             $this->storeRateLimits($step, $response);
             $this->persistTasks($run->project_id, $taskSet, $response->structured);
 
diff --git a/app/Jobs/SyncTaskToGitHub.php b/app/Jobs/SyncTaskToGitHub.php
new file mode 100644
index 0000000..43e205c
--- /dev/null
+++ b/app/Jobs/SyncTaskToGitHub.php
@@ -0,0 +1,81 @@
+<?php
+
+namespace App\Jobs;
+
+use App\Models\Integration;
+use App\Models\SyncRun;
+use App\Models\Task;
+use App\Services\GitHub\GitHubSyncService;
+use Illuminate\Bus\Queueable;
+use Illuminate\Contracts\Queue\ShouldQueue;
+use Illuminate\Foundation\Bus\Dispatchable;
+use Illuminate\Queue\InteractsWithQueue;
+use Illuminate\Queue\Middleware\WithoutOverlapping;
+use Illuminate\Queue\SerializesModels;
+
+class SyncTaskToGitHub implements ShouldQueue
+{
+    use Dispatchable, InteractsWithQueue, Queueable, SerializesModels;
+
+    public int $tries = 3;
+
+    public int $maxExceptions = 2;
+
+    public array $backoff = [30, 60, 120];
+
+    public function __construct(
+        public Task $task,
+        public Integration $integration,
+        public string $syncRunId
+    ) {}
+
+    /**
+     * @return array<int, object>
+     */
+    public function middleware(): array
+    {
+        // Prevent overlapping syncs for the same task
+        return [
+            (new WithoutOverlapping($this->task->id))->dontRelease(),
+        ];
+    }
+
+    public function handle(GitHubSyncService $syncService): void
+    {
+        $result = $syncService->syncTask(
+            $this->task,
+            $this->integration,
+            $this->syncRunId
+        );
+
+        // Update sync run stats
+        $this->updateSyncRunStats($result['action']);
+
+        // Add delay between requests to respect rate limits
+        usleep(500000); // 0.5 second delay
+    }
+
+    public function failed(\Throwable $exception): void
+    {
+        $this->updateSyncRunStats('failed');
+
+        logger()->error('Task sync to GitHub failed', [
+            'task_id' => $this->task->id,
+            'integration_id' => $this->integration->id,
+            'error' => $exception->getMessage(),
+        ]);
+    }
+
+    private function updateSyncRunStats(string $action): void
+    {
+        $syncRun = SyncRun::find($this->syncRunId);
+        if ($syncRun) {
+            $syncRun->incrementStat($action);
+        }
+    }
+
+    public function retryUntil(): \DateTime
+    {
+        return now()->addHours(1);
+    }
+}
diff --git a/app/Listeners/QueueGitHubSync.php b/app/Listeners/QueueGitHubSync.php
new file mode 100644
index 0000000..f324697
--- /dev/null
+++ b/app/Listeners/QueueGitHubSync.php
@@ -0,0 +1,36 @@
+<?php
+
+namespace App\Listeners;
+
+use App\Enums\IntegrationStatus;
+use App\Events\TasksChanged;
+use App\Jobs\DebouncedGitHubSync;
+use Illuminate\Support\Facades\Cache;
+
+class QueueGitHubSync
+{
+    private const DEBOUNCE_SECONDS = 30;
+
+    public function handle(TasksChanged $event): void
+    {
+        $project = $event->project;
+
+        // Check if project has a connected GitHub integration
+        $integration = $project->gitHubIntegration();
+
+        if (! $integration || $integration->status !== IntegrationStatus::Connected) {
+            return;
+        }
+
+        // Use cache to implement debounce
+        $cacheKey = "github_sync_pending_{$project->id}";
+        $syncId = uniqid('sync_', true);
+
+        // Store the latest sync request ID
+        Cache::put($cacheKey, $syncId, now()->addMinutes(5));
+
+        // Dispatch a delayed job that will only run if this is still the latest request
+        DebouncedGitHubSync::dispatch($project->id, $integration->id, $syncId)
+            ->delay(now()->addSeconds(self::DEBOUNCE_SECONDS));
+    }
+}
diff --git a/app/Livewire/Projects/Tabs/Integrations.php b/app/Livewire/Projects/Tabs/Integrations.php
new file mode 100644
index 0000000..c37951d
--- /dev/null
+++ b/app/Livewire/Projects/Tabs/Integrations.php
@@ -0,0 +1,132 @@
+<?php
+
+namespace App\Livewire\Projects\Tabs;
+
+use App\Models\Integration;
+use App\Models\Project;
+use App\Services\GitHub\GitHubSyncService;
+use Illuminate\Support\Facades\Auth;
+use Illuminate\Support\Facades\Log;
+use Livewire\Attributes\Computed;
+use Livewire\Attributes\On;
+use Livewire\Component;
+
+class Integrations extends Component
+{
+    public string $projectId;
+
+    public bool $isSyncing = false;
+
+    public ?string $syncMessage = null;
+
+    public function mount(string $projectId): void
+    {
+        $this->projectId = $projectId;
+    }
+
+    #[Computed]
+    public function project(): Project
+    {
+        return Project::findOrFail($this->projectId);
+    }
+
+    #[Computed]
+    public function githubIntegration(): ?Integration
+    {
+        return $this->project->gitHubIntegration();
+    }
+
+    #[Computed]
+    public function recentSyncRuns(): array
+    {
+        $integration = $this->githubIntegration;
+
+        if (! $integration) {
+            return [];
+        }
+
+        return $integration->syncRuns()
+            ->latest()
+            ->limit(5)
+            ->get()
+            ->map(fn ($run) => [
+                'id' => $run->id,
+                'status' => $run->status->value,
+                'trigger' => $run->trigger,
+                'total' => $run->total_count,
+                'created' => $run->created_count,
+                'updated' => $run->updated_count,
+                'skipped' => $run->skipped_count,
+                'failed' => $run->failed_count,
+                'started_at' => $run->started_at->diffForHumans(),
+                'completed_at' => $run->completed_at?->diffForHumans(),
+            ])
+            ->toArray();
+    }
+
+    #[Computed]
+    public function lastSyncedAt(): ?string
+    {
+        $integration = $this->githubIntegration;
+
+        if (! $integration) {
+            return null;
+        }
+
+        $lastCompletedSync = $integration->syncRuns()
+            ->whereNotNull('completed_at')
+            ->latest('completed_at')
+            ->first();
+
+        return $lastCompletedSync?->completed_at->diffForHumans();
+    }
+
+    #[Computed]
+    public function hasRunningSyncs(): bool
+    {
+        $integration = $this->githubIntegration;
+
+        if (! $integration) {
+            return false;
+        }
+
+        return $integration->syncRuns()
+            ->where('status', \App\Enums\SyncRunStatus::Running)
+            ->exists();
+    }
+
+    #[On('triggerSync')]
+    public function triggerSync(): void
+    {
+        $integration = $this->githubIntegration;
+
+        if (! $integration || ! $integration->isConnected()) {
+            $this->syncMessage = 'GitHub integration is not connected.';
+
+            return;
+        }
+
+        $this->isSyncing = true;
+
+        try {
+            $syncService = app(GitHubSyncService::class);
+            $syncRun = $syncService->syncProject($integration, Auth::id());
+
+            $this->syncMessage = "Syncing {$syncRun->total_count} tasks to GitHub...";
+        } catch (\Exception $e) {
+            $this->syncMessage = 'Sync failed: '.$e->getMessage();
+
+            Log::error('GitHub sync failed', [
+                'error' => $e->getMessage(),
+                'project_id' => $this->projectId,
+            ]);
+        }
+
+        $this->isSyncing = false;
+    }
+
+    public function render()
+    {
+        return view('livewire.projects.tabs.integrations');
+    }
+}
diff --git a/app/Livewire/Projects/Workspace.php b/app/Livewire/Projects/Workspace.php
index 4e0df58..7abc2ef 100644
--- a/app/Livewire/Projects/Workspace.php
+++ b/app/Livewire/Projects/Workspace.php
@@ -87,6 +87,15 @@ public function refreshProject(): void
         unset($this->project);
     }
 
+    /**
+     * Proxy method to handle stale Livewire requests after OAuth redirects.
+     * Dispatches to the child Integrations component.
+     */
+    public function triggerSync(): void
+    {
+        $this->dispatch('triggerSync')->to('projects.tabs.integrations');
+    }
+
     public function render()
     {
         return view('livewire.projects.workspace');
diff --git a/app/Models/ExternalLink.php b/app/Models/ExternalLink.php
new file mode 100644
index 0000000..9271779
--- /dev/null
+++ b/app/Models/ExternalLink.php
@@ -0,0 +1,49 @@
+<?php
+
+namespace App\Models;
+
+use App\Enums\ExternalLinkSyncStatus;
+use App\Enums\IntegrationProvider;
+use Illuminate\Database\Eloquent\Concerns\HasUlids;
+use Illuminate\Database\Eloquent\Factories\HasFactory;
+use Illuminate\Database\Eloquent\Model;
+use Illuminate\Database\Eloquent\Relations\BelongsTo;
+
+class ExternalLink extends Model
+{
+    use HasFactory, HasUlids;
+
+    protected $fillable = [
+        'integration_id',
+        'task_id',
+        'provider',
+        'external_id',
+        'external_number',
+        'external_url',
+        'external_state',
+        'sync_status',
+        'sync_error',
+        'last_synced_at',
+        'last_synced_hash',
+    ];
+
+    protected function casts(): array
+    {
+        return [
+            'external_number' => 'integer',
+            'last_synced_at' => 'datetime',
+            'provider' => IntegrationProvider::class,
+            'sync_status' => ExternalLinkSyncStatus::class,
+        ];
+    }
+
+    public function integration(): BelongsTo
+    {
+        return $this->belongsTo(Integration::class);
+    }
+
+    public function task(): BelongsTo
+    {
+        return $this->belongsTo(Task::class);
+    }
+}
diff --git a/app/Models/Integration.php b/app/Models/Integration.php
new file mode 100644
index 0000000..68828fd
--- /dev/null
+++ b/app/Models/Integration.php
@@ -0,0 +1,72 @@
+<?php
+
+namespace App\Models;
+
+use App\Enums\IntegrationProvider;
+use App\Enums\IntegrationStatus;
+use Illuminate\Database\Eloquent\Concerns\HasUlids;
+use Illuminate\Database\Eloquent\Factories\HasFactory;
+use Illuminate\Database\Eloquent\Model;
+use Illuminate\Database\Eloquent\Relations\BelongsTo;
+use Illuminate\Database\Eloquent\Relations\HasMany;
+
+class Integration extends Model
+{
+    use HasFactory, HasUlids;
+
+    protected $fillable = [
+        'project_id',
+        'provider',
+        'status',
+        'credentials',
+        'settings',
+        'error_message',
+        'last_synced_at',
+    ];
+
+    protected $hidden = ['credentials'];
+
+    protected function casts(): array
+    {
+        return [
+            'settings' => 'array',
+            'credentials' => 'encrypted:array',
+            'last_synced_at' => 'datetime',
+            'provider' => IntegrationProvider::class,
+            'status' => IntegrationStatus::class,
+        ];
+    }
+
+    public function project(): BelongsTo
+    {
+        return $this->belongsTo(Project::class);
+    }
+
+    public function externalLinks(): HasMany
+    {
+        return $this->hasMany(ExternalLink::class);
+    }
+
+    public function syncRuns(): HasMany
+    {
+        return $this->hasMany(SyncRun::class);
+    }
+
+    public function isConnected(): bool
+    {
+        return $this->status === IntegrationStatus::Connected;
+    }
+
+    public function getInstallationId(): ?string
+    {
+        return $this->settings['installation_id'] ?? null;
+    }
+
+    public function getRepoFullName(): ?string
+    {
+        $owner = $this->settings['owner'] ?? null;
+        $repo = $this->settings['repo'] ?? null;
+
+        return $owner && $repo ? "{$owner}/{$repo}" : null;
+    }
+}
diff --git a/app/Models/Project.php b/app/Models/Project.php
index acf9cc7..3ef3a2d 100644
--- a/app/Models/Project.php
+++ b/app/Models/Project.php
@@ -2,6 +2,7 @@
 
 namespace App\Models;
 
+use App\Enums\IntegrationProvider;
 use App\Enums\ProjectStatus;
 use Illuminate\Database\Eloquent\Concerns\HasUlids;
 use Illuminate\Database\Eloquent\Factories\HasFactory;
@@ -66,4 +67,16 @@ public function latestTaskSet(): ?TaskSet
     {
         return $this->taskSets()->latest()->first();
     }
+
+    public function integrations(): HasMany
+    {
+        return $this->hasMany(Integration::class);
+    }
+
+    public function gitHubIntegration(): ?Integration
+    {
+        return $this->integrations()
+            ->where('provider', IntegrationProvider::GitHub)
+            ->first();
+    }
 }
diff --git a/app/Models/SyncRun.php b/app/Models/SyncRun.php
new file mode 100644
index 0000000..f12a6f0
--- /dev/null
+++ b/app/Models/SyncRun.php
@@ -0,0 +1,62 @@
+<?php
+
+namespace App\Models;
+
+use App\Enums\SyncRunStatus;
+use Illuminate\Database\Eloquent\Concerns\HasUlids;
+use Illuminate\Database\Eloquent\Factories\HasFactory;
+use Illuminate\Database\Eloquent\Model;
+use Illuminate\Database\Eloquent\Relations\BelongsTo;
+
+class SyncRun extends Model
+{
+    use HasFactory, HasUlids;
+
+    protected $fillable = [
+        'integration_id',
+        'user_id',
+        'direction',
+        'trigger',
+        'status',
+        'total_count',
+        'created_count',
+        'updated_count',
+        'skipped_count',
+        'failed_count',
+        'error_message',
+        'started_at',
+        'completed_at',
+    ];
+
+    protected function casts(): array
+    {
+        return [
+            'total_count' => 'integer',
+            'created_count' => 'integer',
+            'updated_count' => 'integer',
+            'skipped_count' => 'integer',
+            'failed_count' => 'integer',
+            'started_at' => 'datetime',
+            'completed_at' => 'datetime',
+            'status' => SyncRunStatus::class,
+        ];
+    }
+
+    public function integration(): BelongsTo
+    {
+        return $this->belongsTo(Integration::class);
+    }
+
+    public function user(): BelongsTo
+    {
+        return $this->belongsTo(User::class);
+    }
+
+    public function incrementStat(string $type): void
+    {
+        $column = "{$type}_count";
+        if (in_array($column, ['created_count', 'updated_count', 'skipped_count', 'failed_count'])) {
+            $this->increment($column);
+        }
+    }
+}
diff --git a/app/Models/Task.php b/app/Models/Task.php
index 37caf07..97df1da 100644
--- a/app/Models/Task.php
+++ b/app/Models/Task.php
@@ -5,16 +5,57 @@
 use App\Enums\TaskCategory;
 use App\Enums\TaskPriority;
 use App\Enums\TaskStatus;
+use App\Events\TasksChanged;
 use Illuminate\Database\Eloquent\Concerns\HasUlids;
 use Illuminate\Database\Eloquent\Factories\HasFactory;
 use Illuminate\Database\Eloquent\Model;
 use Illuminate\Database\Eloquent\Relations\BelongsTo;
+use Illuminate\Database\Eloquent\Relations\HasMany;
 use Illuminate\Database\Eloquent\SoftDeletes;
 
 class Task extends Model
 {
     use HasFactory, HasUlids, SoftDeletes;
 
+    /**
+     * Fields that trigger GitHub sync when changed.
+     */
+    private const SYNC_TRIGGER_FIELDS = [
+        'title',
+        'description',
+        'acceptance_criteria',
+        'status',
+        'category',
+        'priority',
+    ];
+
+    protected static function booted(): void
+    {
+        static::created(function (Task $task) {
+            // New task created - always dispatch
+            if ($task->project) {
+                TasksChanged::dispatch($task->project, 'created');
+            }
+        });
+
+        static::updated(function (Task $task) {
+            // Only trigger sync if sync-relevant fields changed
+            // Use getDirty() because getChanges() is not populated until after syncChanges()
+            $changedFields = array_keys($task->getDirty());
+            $syncTriggerChanged = array_intersect($changedFields, self::SYNC_TRIGGER_FIELDS);
+
+            if (! empty($syncTriggerChanged) && $task->project) {
+                TasksChanged::dispatch($task->project, 'updated');
+            }
+        });
+
+        static::deleted(function (Task $task) {
+            if ($task->project) {
+                TasksChanged::dispatch($task->project, 'deleted');
+            }
+        });
+    }
+
     protected $fillable = [
         'project_id',
         'epic_id',
@@ -77,4 +118,16 @@ public function taskSet(): BelongsTo
     {
         return $this->belongsTo(TaskSet::class);
     }
+
+    public function externalLinks(): HasMany
+    {
+        return $this->hasMany(ExternalLink::class);
+    }
+
+    public function getGitHubIssueUrl(): ?string
+    {
+        return $this->externalLinks()
+            ->where('provider', 'github')
+            ->value('external_url');
+    }
 }
diff --git a/app/Providers/AppServiceProvider.php b/app/Providers/AppServiceProvider.php
index 1d9de07..a9ffe23 100644
--- a/app/Providers/AppServiceProvider.php
+++ b/app/Providers/AppServiceProvider.php
@@ -2,7 +2,10 @@
 
 namespace App\Providers;
 
+use App\Events\TasksChanged;
+use App\Listeners\QueueGitHubSync;
 use Illuminate\Cache\RateLimiting\Limit;
+use Illuminate\Support\Facades\Event;
 use Illuminate\Support\Facades\RateLimiter;
 use Illuminate\Support\ServiceProvider;
 
@@ -26,5 +29,8 @@ public function boot(): void
         RateLimiter::for('llm:requests', function ($job) {
             return Limit::perMinute(30)->by('llm:global');
         });
+
+        // Register GitHub sync event listener
+        Event::listen(TasksChanged::class, QueueGitHubSync::class);
     }
 }
diff --git a/app/Services/GitHub/GitHubApiService.php b/app/Services/GitHub/GitHubApiService.php
new file mode 100644
index 0000000..99347d2
--- /dev/null
+++ b/app/Services/GitHub/GitHubApiService.php
@@ -0,0 +1,189 @@
+<?php
+
+namespace App\Services\GitHub;
+
+use App\Exceptions\GitHubApiException;
+use App\Exceptions\GitHubRateLimitException;
+use Illuminate\Http\Client\Response;
+use Illuminate\Support\Facades\Http;
+
+class GitHubApiService
+{
+    public function __construct(
+        private GitHubAuthService $auth,
+        private GitHubRateLimiter $rateLimiter
+    ) {}
+
+    /**
+     * Create a new issue.
+     *
+     * @return array<string, mixed>
+     */
+    public function createIssue(string $installationId, string $owner, string $repo, array $data): array
+    {
+        return $this->post(
+            $installationId,
+            "/repos/{$owner}/{$repo}/issues",
+            $data
+        );
+    }
+
+    /**
+     * Update an existing issue.
+     *
+     * @return array<string, mixed>
+     */
+    public function updateIssue(string $installationId, string $owner, string $repo, int $issueNumber, array $data): array
+    {
+        return $this->patch(
+            $installationId,
+            "/repos/{$owner}/{$repo}/issues/{$issueNumber}",
+            $data
+        );
+    }
+
+    /**
+     * Close an issue.
+     *
+     * @return array<string, mixed>
+     */
+    public function closeIssue(string $installationId, string $owner, string $repo, int $issueNumber): array
+    {
+        return $this->updateIssue($installationId, $owner, $repo, $issueNumber, [
+            'state' => 'closed',
+        ]);
+    }
+
+    /**
+     * Get issue by number.
+     *
+     * @return array<string, mixed>
+     */
+    public function getIssue(string $installationId, string $owner, string $repo, int $issueNumber): array
+    {
+        return $this->get(
+            $installationId,
+            "/repos/{$owner}/{$repo}/issues/{$issueNumber}"
+        );
+    }
+
+    /**
+     * List available repositories for installation.
+     *
+     * @return array<string, mixed>
+     */
+    public function listRepositories(string $installationId): array
+    {
+        return $this->get($installationId, '/installation/repositories');
+    }
+
+    /**
+     * List labels for a repository.
+     *
+     * @return array<string, mixed>
+     */
+    public function listLabels(string $installationId, string $owner, string $repo): array
+    {
+        return $this->get($installationId, "/repos/{$owner}/{$repo}/labels");
+    }
+
+    /**
+     * Create a label if it doesn't exist.
+     *
+     * @return array<string, mixed>
+     */
+    public function createLabel(string $installationId, string $owner, string $repo, string $name, string $color = 'ededed'): array
+    {
+        return $this->post($installationId, "/repos/{$owner}/{$repo}/labels", [
+            'name' => $name,
+            'color' => $color,
+        ]);
+    }
+
+    // ─────────────────────────────────────────────────────────────
+    // HTTP Methods
+    // ─────────────────────────────────────────────────────────────
+
+    /**
+     * @return array<string, mixed>
+     */
+    private function get(string $installationId, string $endpoint): array
+    {
+        return $this->request('GET', $installationId, $endpoint);
+    }
+
+    /**
+     * @return array<string, mixed>
+     */
+    private function post(string $installationId, string $endpoint, array $data): array
+    {
+        $this->checkRateLimit();
+
+        return $this->request('POST', $installationId, $endpoint, $data);
+    }
+
+    /**
+     * @return array<string, mixed>
+     */
+    private function patch(string $installationId, string $endpoint, array $data): array
+    {
+        $this->checkRateLimit();
+
+        return $this->request('PATCH', $installationId, $endpoint, $data);
+    }
+
+    /**
+     * @return array<string, mixed>
+     */
+    private function request(string $method, string $installationId, string $endpoint, array $data = []): array
+    {
+        $token = $this->auth->getInstallationToken($installationId);
+
+        $response = Http::withHeaders([
+            'Authorization' => "Bearer {$token}",
+            'Accept' => 'application/vnd.github+json',
+            'X-GitHub-Api-Version' => '2022-11-28',
+        ])->{strtolower($method)}("https://api.github.com{$endpoint}", $data);
+
+        $this->handleRateLimitHeaders($response);
+
+        if ($response->status() === 403 && str_contains($response->body(), 'rate limit')) {
+            $this->auth->invalidateToken($installationId);
+            throw new GitHubRateLimitException($response->json('message'));
+        }
+
+        if ($response->failed()) {
+            throw new GitHubApiException(
+                $response->json('message', 'Unknown error'),
+                $response->status()
+            );
+        }
+
+        return $response->json();
+    }
+
+    private function checkRateLimit(): void
+    {
+        if (! $this->rateLimiter->canMakeRequest()) {
+            throw new GitHubRateLimitException(
+                'Rate limit reached. Remaining: '.
+                $this->rateLimiter->getRemainingHour().'/hour'
+            );
+        }
+
+        $this->rateLimiter->recordRequest();
+    }
+
+    private function handleRateLimitHeaders(Response $response): void
+    {
+        $remaining = $response->header('X-RateLimit-Remaining');
+        $reset = $response->header('X-RateLimit-Reset');
+
+        if ($remaining !== null && (int) $remaining < 100) {
+            logger()->warning('GitHub API rate limit low', [
+                'remaining' => $remaining,
+                'reset' => $reset,
+            ]);
+        }
+    }
+}
diff --git a/app/Services/GitHub/GitHubAuthService.php b/app/Services/GitHub/GitHubAuthService.php
new file mode 100644
index 0000000..640f6dd
--- /dev/null
+++ b/app/Services/GitHub/GitHubAuthService.php
@@ -0,0 +1,70 @@
+<?php
+
+namespace App\Services\GitHub;
+
+use App\Exceptions\GitHubAuthException;
+use Firebase\JWT\JWT;
+use Illuminate\Support\Facades\Cache;
+use Illuminate\Support\Facades\Http;
+
+class GitHubAuthService
+{
+    private readonly ?string $appId;
+
+    private readonly ?string $privateKey;
+
+    public function __construct(?string $appId = null, ?string $privateKey = null)
+    {
+        $this->appId = $appId ?? config('services.github.app_id');
+        $this->privateKey = $privateKey ?? config('services.github.private_key');
+    }
+
+    /**
+     * Generate JWT for GitHub App authentication.
+     * JWT expires in 10 minutes (GitHub maximum).
+     */
+    public function generateJWT(): string
+    {
+        $now = time();
+
+        $payload = [
+            'iat' => $now - 60,        // Issued 60s ago (clock drift)
+            'exp' => $now + (10 * 60), // Expires in 10 minutes
+            'iss' => $this->appId,     // GitHub App ID
+        ];
+
+        return JWT::encode($payload, $this->privateKey, 'RS256');
+    }
+
+    /**
+     * Get installation access token (cached for 50 minutes).
+     */
+    public function getInstallationToken(string $installationId): string
+    {
+        $cacheKey = "github_installation_token_{$installationId}";
+
+        return Cache::remember($cacheKey, now()->addMinutes(50), function () use ($installationId) {
+            $jwt = $this->generateJWT();
+
+            $response = Http::withHeaders([
+                'Authorization' => "Bearer {$jwt}",
+                'Accept' => 'application/vnd.github+json',
+                'X-GitHub-Api-Version' => '2022-11-28',
+            ])->post("https://api.github.com/app/installations/{$installationId}/access_tokens");
+
+            if ($response->failed()) {
+                throw new GitHubAuthException('Failed to get installation token: '.$response->body());
+            }
+
+            return $response->json('token');
+        });
+    }
+
+    /**
+     * Invalidate cached token (call when token fails).
+     */
+    public function invalidateToken(string $installationId): void
+    {
+        Cache::forget("github_installation_token_{$installationId}");
+    }
+}
diff --git a/app/Services/GitHub/GitHubRateLimiter.php b/app/Services/GitHub/GitHubRateLimiter.php
new file mode 100644
index 0000000..839e4f2
--- /dev/null
+++ b/app/Services/GitHub/GitHubRateLimiter.php
@@ -0,0 +1,54 @@
+<?php
+
+namespace App\Services\GitHub;
+
+use Illuminate\Support\Facades\RateLimiter;
+
+class GitHubRateLimiter
+{
+    private const MINUTE_LIMIT = 60;
+
+    private const HOUR_LIMIT = 400;
+
+    private const MINUTE_KEY = 'github_api_minute';
+
+    private const HOUR_KEY = 'github_api_hour';
+
+    public function canMakeRequest(): bool
+    {
+        return ! RateLimiter::tooManyAttempts(self::MINUTE_KEY, self::MINUTE_LIMIT)
+            && ! RateLimiter::tooManyAttempts(self::HOUR_KEY, self::HOUR_LIMIT);
+    }
+
+    public function recordRequest(): void
+    {
+        RateLimiter::hit(self::MINUTE_KEY, 60);  // Decays after 1 minute
+        RateLimiter::hit(self::HOUR_KEY, 3600); // Decays after 1 hour
+    }
+
+    public function getRemainingMinute(): int
+    {
+        return RateLimiter::remaining(self::MINUTE_KEY, self::MINUTE_LIMIT);
+    }
+
+    public function getRemainingHour(): int
+    {
+        return RateLimiter::remaining(self::HOUR_KEY, self::HOUR_LIMIT);
+    }
+
+    public function getRetryAfterMinute(): int
+    {
+        return RateLimiter::availableIn(self::MINUTE_KEY);
+    }
+
+    public function getRetryAfterHour(): int
+    {
+        return RateLimiter::availableIn(self::HOUR_KEY);
+    }
+
+    public function clear(): void
+    {
+        RateLimiter::clear(self::MINUTE_KEY);
+        RateLimiter::clear(self::HOUR_KEY);
+    }
+}
diff --git a/app/Services/GitHub/GitHubSyncService.php b/app/Services/GitHub/GitHubSyncService.php
new file mode 100644
index 0000000..46b4942
--- /dev/null
+++ b/app/Services/GitHub/GitHubSyncService.php
@@ -0,0 +1,153 @@
+<?php
+
+namespace App\Services\GitHub;
+
+use App\Enums\SyncRunStatus;
+use App\Enums\TaskStatus;
+use App\Jobs\CheckSyncRunCompletion;
+use App\Jobs\SyncTaskToGitHub;
+use App\Models\Integration;
+use App\Models\SyncRun;
+use App\Models\Task;
+
+class GitHubSyncService
+{
+    public function __construct(
+        private GitHubApiService $api,
+        private TaskToIssueMapper $mapper
+    ) {}
+
+    /**
+     * Start a sync run for all tasks in a project.
+     */
+    public function syncProject(Integration $integration, ?int $userId = null): SyncRun
+    {
+        // Only sync tasks from the latest TaskSet
+        $latestTaskSet = $integration->project->latestTaskSet();
+
+        $tasksQuery = $integration->project->tasks()
+            ->whereIn('status', [
+                TaskStatus::Todo,
+                TaskStatus::Doing,
+                TaskStatus::Done,
+            ]);
+
+        // If there's a latest TaskSet, only sync those tasks
+        if ($latestTaskSet) {
+            $tasksQuery->where('task_set_id', $latestTaskSet->id);
+        }
+
+        $tasks = $tasksQuery->get();
+
+        // Create sync run record
+        $syncRun = SyncRun::create([
+            'integration_id' => $integration->id,
+            'user_id' => $userId,
+            'direction' => 'push',
+            'trigger' => $userId ? 'manual' : 'scheduled',
+            'status' => SyncRunStatus::Running,
+            'started_at' => now(),
+            'total_count' => $tasks->count(),
+        ]);
+
+        // Dispatch individual sync jobs
+        foreach ($tasks as $task) {
+            SyncTaskToGitHub::dispatch($task, $integration, $syncRun->id);
+        }
+
+        // Dispatch completion checker (30 seconds should be enough for most syncs)
+        CheckSyncRunCompletion::dispatch($syncRun->id)
+            ->delay(now()->addSeconds(30));
+
+        return $syncRun;
+    }
+
+    /**
+     * Sync a single task to GitHub.
+     *
+     * @return array<string, mixed>
+     */
+    public function syncTask(Task $task, Integration $integration, string $syncRunId): array
+    {
+        $settings = $integration->settings;
+        $installationId = $settings['installation_id'];
+        $owner = $settings['owner'];
+        $repo = $settings['repo'];
+
+        // Check if task already has an external link
+        $externalLink = $task->externalLinks()
+            ->where('integration_id', $integration->id)
+            ->first();
+
+        // Generate current content hash
+        $currentHash = $this->mapper->generateHash($task);
+
+        // Skip if unchanged
+        if ($externalLink && $externalLink->last_synced_hash === $currentHash) {
+            return ['action' => 'skipped', 'reason' => 'unchanged'];
+        }
+
+        $issueData = $this->mapper->toIssue($task, $integration);
+
+        try {
+            if ($externalLink && $externalLink->external_number) {
+                // Update existing issue
+                $issue = $this->api->updateIssue(
+                    $installationId,
+                    $owner,
+                    $repo,
+                    $externalLink->external_number,
+                    $issueData
+                );
+                $action = 'updated';
+            } else {
+                // Create new issue
+                $issue = $this->api->createIssue(
+                    $installationId,
+                    $owner,
+                    $repo,
+                    $issueData
+                );
+                $action = 'created';
+            }
+
+            // Update or create external link
+            $task->externalLinks()->updateOrCreate(
+                ['integration_id' => $integration->id],
+                [
+                    'provider' => 'github',
+                    'external_id' => $issue['node_id'],
+                    'external_number' => $issue['number'],
+                    'external_url' => $issue['html_url'],
+                    'external_state' => $issue['state'],
+                    'sync_status' => 'synced',
+                    'sync_error' => null,
+                    'last_synced_at' => now(),
+                    'last_synced_hash' => $currentHash,
+                ]
+            );
+
+            return ['action' => $action, 'issue_number' => $issue['number']];
+
+        } catch (\Exception $e) {
+            // Record failure
+            if ($externalLink) {
+                $externalLink->update([
+                    'sync_status' => 'failed',
+                    'sync_error' => $e->getMessage(),
+                ]);
+            } else {
+                // Create a pending external link to track the failure
+                $task->externalLinks()->create([
+                    'integration_id' => $integration->id,
+                    'provider' => 'github',
+                    'external_id' => 'pending_'.uniqid(),
+                    'sync_status' => 'failed',
+                    'sync_error' => $e->getMessage(),
+                ]);
+            }
+
+            throw $e;
+        }
+    }
+}
diff --git a/app/Services/GitHub/TaskToIssueMapper.php b/app/Services/GitHub/TaskToIssueMapper.php
new file mode 100644
index 0000000..d9801a2
--- /dev/null
+++ b/app/Services/GitHub/TaskToIssueMapper.php
@@ -0,0 +1,112 @@
+<?php
+
+namespace App\Services\GitHub;
+
+use App\Models\Integration;
+use App\Models\Task;
+
+class TaskToIssueMapper
+{
+    /**
+     * Map a PlanForge task to GitHub issue format.
+     *
+     * @return array<string, mixed>
+     */
+    public function toIssue(Task $task, Integration $integration): array
+    {
+        $settings = $integration->settings;
+
+        return [
+            'title' => $this->formatTitle($task),
+            'body' => $this->formatBody($task),
+            'labels' => $this->mapLabels($task, $settings),
+        ];
+    }
+
+    /**
+     * Generate content hash for change detection.
+     */
+    public function generateHash(Task $task): string
+    {
+        $content = json_encode([
+            'title' => $task->title,
+            'description' => $task->description,
+            'acceptance_criteria' => $task->acceptance_criteria,
+            'status' => $task->status->value,
+            'category' => $task->category?->value,
+        ]);
+
+        return hash('sha256', $content);
+    }
+
+    private function formatTitle(Task $task): string
+    {
+        $prefix = '';
+
+        // Add category prefix if exists
+        if ($task->category) {
+            $prefix = "[{$task->category->value}] ";
+        }
+
+        return $prefix.$task->title;
+    }
+
+    private function formatBody(Task $task): string
+    {
+        $body = [];
+
+        // Description
+        if ($task->description) {
+            $body[] = "## Description\n\n{$task->description}";
+        }
+
+        // Acceptance Criteria (array field)
+        if (! empty($task->acceptance_criteria)) {
+            $criteria = $this->formatAcceptanceCriteria($task->acceptance_criteria);
+            $body[] = "## Acceptance Criteria\n\n{$criteria}";
+        }
+
+        // Estimate
+        if ($task->estimate) {
+            $body[] = "**Estimate:** {$task->estimate}";
+        }
+
+        // Metadata footer
+        $appUrl = config('app.url');
+        $body[] = '---';
+        $body[] = "_Synced from [PlanForge]({$appUrl}/projects/{$task->project_id})_";
+
+        return implode("\n\n", $body);
+    }
+
+    /**
+     * @param  array<int, string>  $criteria
+     */
+    private function formatAcceptanceCriteria(array $criteria): string
+    {
+        return collect($criteria)
+            ->map(fn ($item) => "- [ ] {$item}")
+            ->implode("\n");
+    }
+
+    /**
+     * @param  array<string, mixed>  $settings
+     * @return array<int, string>
+     */
+    private function mapLabels(Task $task, array $settings): array
+    {
+        $labels = $settings['default_labels'] ?? ['planforge'];
+
+        // Map task category to label
+        if ($task->category) {
+            $labels[] = $task->category->value;
+        }
+
+        // Map priority to label
+        if ($task->priority?->value === 'high') {
+            $labels[] = 'priority:high';
+        }
+
+        return array_values(array_unique($labels));
+    }
+}
diff --git a/app/Services/ProviderService.php b/app/Services/ProviderService.php
index 8ceff6a..286af22 100644
--- a/app/Services/ProviderService.php
+++ b/app/Services/ProviderService.php
@@ -4,6 +4,7 @@
 
 use App\Enums\AiProvider;
 use Illuminate\Support\Collection;
+use Illuminate\Support\Facades\Log;
 use Prism\Prism\Enums\Provider;
 
 class ProviderService
@@ -83,7 +84,7 @@ public function resolveProvider(?string $providerString): Provider
         $aiProvider = AiProvider::tryFrom($providerString);
 
         if (! $aiProvider) {
-            \Log::warning("Unknown provider '{$providerString}', falling back to default");
+            Log::warning("Unknown AI provider '{$providerString}', falling back to default");
 
             return $this->getDefaultProviderOrFail()->toPrismProvider();
         }
diff --git a/composer.json b/composer.json
index 7599aef..b0e22f4 100644
--- a/composer.json
+++ b/composer.json
@@ -8,6 +8,7 @@
     "require": {
         "php": "^8.2",
         "filament/filament": "^4.0",
+        "firebase/php-jwt": "^7.0",
         "laravel/framework": "^12.0",
         "laravel/tinker": "^2.10.1",
         "livewire/livewire": "^3.6.4",
@@ -17,6 +18,7 @@
     },
     "require-dev": {
         "fakerphp/faker": "^1.23",
+        "laravel/boost": "^1.8",
         "laravel/breeze": "^2.3",
         "laravel/pail": "^1.2.2",
         "laravel/pint": "^1.24",
diff --git a/composer.lock b/composer.lock
index 132c9a8..4bb1c80 100644
--- a/composer.lock
+++ b/composer.lock
@@ -4,7 +4,7 @@
         "Read more about it at https://getcomposer.org/doc/01-basic-usage.md#installing-dependencies",
         "This file is @generated automatically"
     ],
-    "content-hash": "ed7ed2941be60d97b25c3ee38fe36844",
+    "content-hash": "ab53984dc2e43392e17f25cd02aca89e",
     "packages": [
         {
             "name": "anourvalar/eloquent-serialize",
@@ -1475,6 +1475,69 @@
             },
             "time": "2025-12-30T13:02:08+00:00"
         },
+        {
+            "name": "firebase/php-jwt",
+            "version": "v7.0.2",
+            "source": {
+                "type": "git",
+                "url": "https://github.com/firebase/php-jwt.git",
+                "reference": "5645b43af647b6947daac1d0f659dd1fbe8d3b65"
+            },
+            "dist": {
+                "type": "zip",
+                "url": "https://api.github.com/repos/firebase/php-jwt/zipball/5645b43af647b6947daac1d0f659dd1fbe8d3b65",
+                "reference": "5645b43af647b6947daac1d0f659dd1fbe8d3b65",
+                "shasum": ""
+            },
+            "require": {
+                "php": "^8.0"
+            },
+            "require-dev": {
+                "guzzlehttp/guzzle": "^7.4",
+                "phpspec/prophecy-phpunit": "^2.0",
+                "phpunit/phpunit": "^9.5",
+                "psr/cache": "^2.0||^3.0",
+                "psr/http-client": "^1.0",
+                "psr/http-factory": "^1.0"
+            },
+            "suggest": {
+                "ext-sodium": "Support EdDSA (Ed25519) signatures",
+                "paragonie/sodium_compat": "Support EdDSA (Ed25519) signatures when libsodium is not present"
+            },
+            "type": "library",
+            "autoload": {
+                "psr-4": {
+                    "Firebase\\JWT\\": "src"
+                }
+            },
+            "notification-url": "https://packagist.org/downloads/",
+            "license": [
+                "BSD-3-Clause"
+            ],
+            "authors": [
+                {
+                    "name": "Neuman Vong",
+                    "email": "neuman+pear@twilio.com",
+                    "role": "Developer"
+                },
+                {
+                    "name": "Anant Narayanan",
+                    "email": "anant@php.net",
+                    "role": "Developer"
+                }
+            ],
+            "description": "A simple library to encode and decode JSON Web Tokens (JWT) in PHP. Should conform to the current spec.",
+            "homepage": "https://github.com/firebase/php-jwt",
+            "keywords": [
+                "jwt",
+                "php"
+            ],
+            "support": {
+                "issues": "https://github.com/firebase/php-jwt/issues",
+                "source": "https://github.com/firebase/php-jwt/tree/v7.0.2"
+            },
+            "time": "2025-12-16T22:17:28+00:00"
+        },
         {
             "name": "fruitcake/php-cors",
             "version": "v1.4.0",
@@ -8869,6 +8932,72 @@
             },
             "time": "2025-03-19T14:43:43+00:00"
         },
+        {
+            "name": "laravel/boost",
+            "version": "v1.8.7",
+            "source": {
+                "type": "git",
+                "url": "https://github.com/laravel/boost.git",
+                "reference": "7a5709a8134ed59d3e7f34fccbd74689830e296c"
+            },
+            "dist": {
+                "type": "zip",
+                "url": "https://api.github.com/repos/laravel/boost/zipball/7a5709a8134ed59d3e7f34fccbd74689830e296c",
+                "reference": "7a5709a8134ed59d3e7f34fccbd74689830e296c",
+                "shasum": ""
+            },
+            "require": {
+                "guzzlehttp/guzzle": "^7.9",
+                "illuminate/console": "^10.49.0|^11.45.3|^12.41.1",
+                "illuminate/contracts": "^10.49.0|^11.45.3|^12.41.1",
+                "illuminate/routing": "^10.49.0|^11.45.3|^12.41.1",
+                "illuminate/support": "^10.49.0|^11.45.3|^12.41.1",
+                "laravel/mcp": "^0.5.1",
+                "laravel/prompts": "0.1.25|^0.3.6",
+                "laravel/roster": "^0.2.9",
+                "php": "^8.1"
+            },
+            "require-dev": {
+                "laravel/pint": "^1.20.0",
+                "mockery/mockery": "^1.6.12",
+                "orchestra/testbench": "^8.36.0|^9.15.0|^10.6",
+                "pestphp/pest": "^2.36.0|^3.8.4|^4.1.5",
+                "phpstan/phpstan": "^2.1.27",
+                "rector/rector": "^2.1"
+            },
+            "type": "library",
+            "extra": {
+                "laravel": {
+                    "providers": [
+                        "Laravel\\Boost\\BoostServiceProvider"
+                    ]
+                },
+                "branch-alias": {
+                    "dev-master": "1.x-dev"
+                }
+            },
+            "autoload": {
+                "psr-4": {
+                    "Laravel\\Boost\\": "src/"
+                }
+            },
+            "notification-url": "https://packagist.org/downloads/",
+            "license": [
+                "MIT"
+            ],
+            "description": "Laravel Boost accelerates AI-assisted development by providing the essential context and structure that AI needs to generate high-quality, Laravel-specific code.",
+            "homepage": "https://github.com/laravel/boost",
+            "keywords": [
+                "ai",
+                "dev",
+                "laravel"
+            ],
+            "support": {
+                "issues": "https://github.com/laravel/boost/issues",
+                "source": "https://github.com/laravel/boost"
+            },
+            "time": "2025-12-19T15:04:12+00:00"
+        },
         {
             "name": "laravel/breeze",
             "version": "v2.3.8",
@@ -8930,6 +9059,79 @@
             },
             "time": "2025-07-18T18:49:59+00:00"
         },
+        {
+            "name": "laravel/mcp",
+            "version": "v0.5.1",
+            "source": {
+                "type": "git",
+                "url": "https://github.com/laravel/mcp.git",
+                "reference": "10dedea054fa4eeaa9ef2ccbfdad6c3e1dbd17a4"
+            },
+            "dist": {
+                "type": "zip",
+                "url": "https://api.github.com/repos/laravel/mcp/zipball/10dedea054fa4eeaa9ef2ccbfdad6c3e1dbd17a4",
+                "reference": "10dedea054fa4eeaa9ef2ccbfdad6c3e1dbd17a4",
+                "shasum": ""
+            },
+            "require": {
+                "ext-json": "*",
+                "ext-mbstring": "*",
+                "illuminate/console": "^10.49.0|^11.45.3|^12.41.1",
+                "illuminate/container": "^10.49.0|^11.45.3|^12.41.1",
+                "illuminate/contracts": "^10.49.0|^11.45.3|^12.41.1",
+                "illuminate/http": "^10.49.0|^11.45.3|^12.41.1",
+                "illuminate/json-schema": "^12.41.1",
+                "illuminate/routing": "^10.49.0|^11.45.3|^12.41.1",
+                "illuminate/support": "^10.49.0|^11.45.3|^12.41.1",
+                "illuminate/validation": "^10.49.0|^11.45.3|^12.41.1",
+                "php": "^8.1"
+            },
+            "require-dev": {
+                "laravel/pint": "^1.20",
+                "orchestra/testbench": "^8.36|^9.15|^10.8",
+                "pestphp/pest": "^2.36.0|^3.8.4|^4.1.0",
+                "phpstan/phpstan": "^2.1.27",
+                "rector/rector": "^2.2.4"
+            },
+            "type": "library",
+            "extra": {
+                "laravel": {
+                    "aliases": {
+                        "Mcp": "Laravel\\Mcp\\Server\\Facades\\Mcp"
+                    },
+                    "providers": [
+                        "Laravel\\Mcp\\Server\\McpServiceProvider"
+                    ]
+                }
+            },
+            "autoload": {
+                "psr-4": {
+                    "Laravel\\Mcp\\": "src/",
+                    "Laravel\\Mcp\\Server\\": "src/Server/"
+                }
+            },
+            "notification-url": "https://packagist.org/downloads/",
+            "license": [
+                "MIT"
+            ],
+            "authors": [
+                {
+                    "name": "Taylor Otwell",
+                    "email": "taylor@laravel.com"
+                }
+            ],
+            "description": "Rapidly build MCP servers for your Laravel applications.",
+            "homepage": "https://github.com/laravel/mcp",
+            "keywords": [
+                "laravel",
+                "mcp"
+            ],
+            "support": {
+                "issues": "https://github.com/laravel/mcp/issues",
+                "source": "https://github.com/laravel/mcp"
+            },
+            "time": "2025-12-17T06:14:23+00:00"
+        },
         {
             "name": "laravel/pail",
             "version": "v1.2.4",
@@ -9076,6 +9278,67 @@
             },
             "time": "2025-11-25T21:15:52+00:00"
         },
+        {
+            "name": "laravel/roster",
+            "version": "v0.2.9",
+            "source": {
+                "type": "git",
+                "url": "https://github.com/laravel/roster.git",
+                "reference": "82bbd0e2de614906811aebdf16b4305956816fa6"
+            },
+            "dist": {
+                "type": "zip",
+                "url": "https://api.github.com/repos/laravel/roster/zipball/82bbd0e2de614906811aebdf16b4305956816fa6",
+                "reference": "82bbd0e2de614906811aebdf16b4305956816fa6",
+                "shasum": ""
+            },
+            "require": {
+                "illuminate/console": "^10.0|^11.0|^12.0",
+                "illuminate/contracts": "^10.0|^11.0|^12.0",
+                "illuminate/routing": "^10.0|^11.0|^12.0",
+                "illuminate/support": "^10.0|^11.0|^12.0",
+                "php": "^8.1|^8.2",
+                "symfony/yaml": "^6.4|^7.2"
+            },
+            "require-dev": {
+                "laravel/pint": "^1.14",
+                "mockery/mockery": "^1.6",
+                "orchestra/testbench": "^8.22.0|^9.0|^10.0",
+                "pestphp/pest": "^2.0|^3.0",
+                "phpstan/phpstan": "^2.0"
+            },
+            "type": "library",
+            "extra": {
+                "laravel": {
+                    "providers": [
+                        "Laravel\\Roster\\RosterServiceProvider"
+                    ]
+                },
+                "branch-alias": {
+                    "dev-master": "1.x-dev"
+                }
+            },
+            "autoload": {
+                "psr-4": {
+                    "Laravel\\Roster\\": "src/"
+                }
+            },
+            "notification-url": "https://packagist.org/downloads/",
+            "license": [
+                "MIT"
+            ],
+            "description": "Detect packages & approaches in use within a Laravel project",
+            "homepage": "https://github.com/laravel/roster",
+            "keywords": [
+                "dev",
+                "laravel"
+            ],
+            "support": {
+                "issues": "https://github.com/laravel/roster/issues",
+                "source": "https://github.com/laravel/roster"
+            },
+            "time": "2025-10-20T09:56:46+00:00"
+        },
         {
             "name": "laravel/sail",
             "version": "v1.51.0",
diff --git a/config/services.php b/config/services.php
index 6a90eb8..ecb014b 100644
--- a/config/services.php
+++ b/config/services.php
@@ -35,4 +35,13 @@
         ],
     ],
 
+    'github' => [
+        'app_id' => env('GITHUB_APP_ID'),
+        'app_slug' => env('GITHUB_APP_SLUG'),
+        'client_id' => env('GITHUB_APP_CLIENT_ID'),
+        'client_secret' => env('GITHUB_APP_CLIENT_SECRET'),
+        'private_key' => env('GITHUB_APP_PRIVATE_KEY'),
+        'webhook_secret' => env('GITHUB_WEBHOOK_SECRET'),
+    ],
+
 ];
diff --git a/database/factories/ExternalLinkFactory.php b/database/factories/ExternalLinkFactory.php
new file mode 100644
index 0000000..d33df77
--- /dev/null
+++ b/database/factories/ExternalLinkFactory.php
@@ -0,0 +1,61 @@
+<?php
+
+namespace Database\Factories;
+
+use App\Enums\ExternalLinkSyncStatus;
+use App\Enums\IntegrationProvider;
+use App\Models\ExternalLink;
+use App\Models\Integration;
+use App\Models\Task;
+use Illuminate\Database\Eloquent\Factories\Factory;
+
+/**
+ * @extends Factory<ExternalLink>
+ */
+class ExternalLinkFactory extends Factory
+{
+    protected $model = ExternalLink::class;
+
+    public function definition(): array
+    {
+        return [
+            'integration_id' => Integration::factory(),
+            'task_id' => Task::factory(),
+            'provider' => IntegrationProvider::GitHub,
+            'external_id' => 'I_'.$this->faker->unique()->regexify('[a-zA-Z0-9]{10}'),
+            'external_number' => $this->faker->unique()->numberBetween(1, 10000),
+            'external_url' => $this->faker->url(),
+            'external_state' => 'open',
+            'sync_status' => ExternalLinkSyncStatus::Synced,
+            'sync_error' => null,
+            'last_synced_at' => now(),
+            'last_synced_hash' => hash('sha256', $this->faker->sentence()),
+        ];
+    }
+
+    public function pending(): static
+    {
+        return $this->state(fn (array $attributes) => [
+            'sync_status' => ExternalLinkSyncStatus::Pending,
+            'last_synced_at' => null,
+            'last_synced_hash' => null,
+        ]);
+    }
+
+    public function failed(): static
+    {
+        return $this->state(fn (array $attributes) => [
+            'sync_status' => ExternalLinkSyncStatus::Failed,
+            'sync_error' => 'API request failed',
+        ]);
+    }
+
+    public function orphaned(): static
+    {
+        return $this->state(fn (array $attributes) => [
+            'sync_status' => ExternalLinkSyncStatus::Orphaned,
+            'external_state' => 'deleted',
+            'sync_error' => 'Issue was deleted in GitHub',
+        ]);
+    }
+}
diff --git a/database/factories/IntegrationFactory.php b/database/factories/IntegrationFactory.php
new file mode 100644
index 0000000..90a93b2
--- /dev/null
+++ b/database/factories/IntegrationFactory.php
@@ -0,0 +1,61 @@
+<?php
+
+namespace Database\Factories;
+
+use App\Enums\IntegrationProvider;
+use App\Enums\IntegrationStatus;
+use App\Models\Integration;
+use App\Models\Project;
+use Illuminate\Database\Eloquent\Factories\Factory;
+
+/**
+ * @extends Factory<Integration>
+ */
+class IntegrationFactory extends Factory
+{
+    protected $model = Integration::class;
+
+    public function definition(): array
+    {
+        return [
+            'project_id' => Project::factory(),
+            'provider' => IntegrationProvider::GitHub,
+            'status' => IntegrationStatus::Pending,
+            'settings' => [],
+            'credentials' => null,
+            'error_message' => null,
+            'last_synced_at' => null,
+        ];
+    }
+
+    public function github(): static
+    {
+        return $this->state(fn (array $attributes) => [
+            'provider' => IntegrationProvider::GitHub,
+        ]);
+    }
+
+    public function connected(): static
+    {
+        return $this->state(fn (array $attributes) => [
+            'status' => IntegrationStatus::Connected,
+        ]);
+    }
+
+    public function withGitHubSettings(
+        string $installationId = '12345',
+        string $owner = 'test-owner',
+        string $repo = 'test-repo'
+    ): static {
+        return $this->state(fn (array $attributes) => [
+            'settings' => [
+                'installation_id' => $installationId,
+                'owner' => $owner,
+                'repo' => $repo,
+                'default_labels' => ['planforge'],
+                'sync_closed_as' => 'done',
+                'sync_reopened_as' => 'doing',
+            ],
+        ]);
+    }
+}
diff --git a/database/factories/SyncRunFactory.php b/database/factories/SyncRunFactory.php
new file mode 100644
index 0000000..57a8d9a
--- /dev/null
+++ b/database/factories/SyncRunFactory.php
@@ -0,0 +1,62 @@
+<?php
+
+namespace Database\Factories;
+
+use App\Enums\SyncRunStatus;
+use App\Models\Integration;
+use App\Models\SyncRun;
+use App\Models\User;
+use Illuminate\Database\Eloquent\Factories\Factory;
+
+/**
+ * @extends Factory<SyncRun>
+ */
+class SyncRunFactory extends Factory
+{
+    protected $model = SyncRun::class;
+
+    public function definition(): array
+    {
+        return [
+            'integration_id' => Integration::factory(),
+            'user_id' => User::factory(),
+            'direction' => 'push',
+            'trigger' => 'manual',
+            'status' => SyncRunStatus::Running,
+            'total_count' => 0,
+            'created_count' => 0,
+            'updated_count' => 0,
+            'skipped_count' => 0,
+            'failed_count' => 0,
+            'error_message' => null,
+            'started_at' => now(),
+            'completed_at' => null,
+        ];
+    }
+
+    public function completed(): static
+    {
+        return $this->state(fn (array $attributes) => [
+            'status' => SyncRunStatus::Completed,
+            'completed_at' => now(),
+        ]);
+    }
+
+    public function failed(): static
+    {
+        return $this->state(fn (array $attributes) => [
+            'status' => SyncRunStatus::Failed,
+            'error_message' => 'Sync failed',
+            'completed_at' => now(),
+        ]);
+    }
+
+    public function partial(): static
+    {
+        return $this->state(fn (array $attributes) => [
+            'status' => SyncRunStatus::Partial,
+            'failed_count' => 1,
+            'completed_at' => now(),
+        ]);
+    }
+}
diff --git a/database/migrations/2026_01_02_081824_create_integrations_table.php b/database/migrations/2026_01_02_081824_create_integrations_table.php
new file mode 100644
index 0000000..c1555bc
--- /dev/null
+++ b/database/migrations/2026_01_02_081824_create_integrations_table.php
@@ -0,0 +1,36 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Support\Facades\Schema;
+
+return new class extends Migration
+{
+    public function up(): void
+    {
+        Schema::create('integrations', function (Blueprint $table) {
+            $table->ulid('id')->primary();
+            $table->foreignUlid('project_id')->constrained()->cascadeOnDelete();
+            $table->string('provider', 50); // github, jira, trello, linear
+            $table->string('status', 20)->default('pending'); // pending, connected, error, disabled
+
+            // Provider-specific credentials (encrypted)
+            $table->text('credentials')->nullable();
+
+            // Provider-specific settings
+            $table->json('settings')->nullable();
+
+            $table->text('error_message')->nullable();
+            $table->timestamp('last_synced_at')->nullable();
+            $table->timestamps();
+
+            $table->unique(['project_id', 'provider']);
+            $table->index(['provider', 'status']);
+        });
+    }
+
+    public function down(): void
+    {
+        Schema::dropIfExists('integrations');
+    }
+};
diff --git a/database/migrations/2026_01_02_081825_create_external_links_table.php b/database/migrations/2026_01_02_081825_create_external_links_table.php
new file mode 100644
index 0000000..4b71c8a
--- /dev/null
+++ b/database/migrations/2026_01_02_081825_create_external_links_table.php
@@ -0,0 +1,42 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Support\Facades\Schema;
+
+return new class extends Migration
+{
+    public function up(): void
+    {
+        Schema::create('external_links', function (Blueprint $table) {
+            $table->ulid('id')->primary();
+            $table->foreignUlid('integration_id')->constrained()->cascadeOnDelete();
+            $table->foreignUlid('task_id')->constrained()->cascadeOnDelete();
+
+            $table->string('provider', 50); // Denormalized for faster queries
+            $table->string('external_id', 255); // GitHub node_id
+            $table->unsignedInteger('external_number')->nullable(); // Issue #123
+            $table->string('external_url', 500)->nullable();
+            $table->string('external_state', 50)->nullable(); // open, closed
+
+            $table->string('sync_status', 20)->default('pending'); // pending, synced, failed, orphaned, conflict
+            $table->text('sync_error')->nullable();
+            $table->timestamp('last_synced_at')->nullable();
+
+            // Track what was last synced to detect changes
+            $table->string('last_synced_hash', 64)->nullable(); // SHA256 of synced content
+
+            $table->timestamps();
+
+            $table->unique(['integration_id', 'task_id']);
+            $table->unique(['provider', 'external_id']);
+            $table->index(['task_id', 'provider']);
+            $table->index(['sync_status']);
+        });
+    }
+
+    public function down(): void
+    {
+        Schema::dropIfExists('external_links');
+    }
+};
diff --git a/database/migrations/2026_01_02_081825_create_sync_runs_table.php b/database/migrations/2026_01_02_081825_create_sync_runs_table.php
new file mode 100644
index 0000000..d85bb91
--- /dev/null
+++ b/database/migrations/2026_01_02_081825_create_sync_runs_table.php
@@ -0,0 +1,40 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Support\Facades\Schema;
+
+return new class extends Migration
+{
+    public function up(): void
+    {
+        Schema::create('sync_runs', function (Blueprint $table) {
+            $table->ulid('id')->primary();
+            $table->foreignUlid('integration_id')->constrained()->cascadeOnDelete();
+            $table->foreignId('user_id')->nullable()->constrained()->nullOnDelete();
+
+            $table->string('direction', 20); // push, pull, both
+            $table->string('trigger', 20); // manual, scheduled, webhook
+            $table->string('status', 20)->default('running'); // running, completed, failed, partial
+
+            // Stats
+            $table->unsignedInteger('total_count')->default(0);
+            $table->unsignedInteger('created_count')->default(0);
+            $table->unsignedInteger('updated_count')->default(0);
+            $table->unsignedInteger('skipped_count')->default(0);
+            $table->unsignedInteger('failed_count')->default(0);
+
+            $table->text('error_message')->nullable();
+            $table->timestamp('started_at');
+            $table->timestamp('completed_at')->nullable();
+            $table->timestamps();
+
+            $table->index(['integration_id', 'created_at']);
+        });
+    }
+
+    public function down(): void
+    {
+        Schema::dropIfExists('sync_runs');
+    }
+};
diff --git a/phpunit.xml b/phpunit.xml
index d703241..1ea2b2b 100644
--- a/phpunit.xml
+++ b/phpunit.xml
@@ -23,8 +23,8 @@
         <env name="BCRYPT_ROUNDS" value="4"/>
         <env name="BROADCAST_CONNECTION" value="null"/>
         <env name="CACHE_STORE" value="array"/>
-        <env name="DB_CONNECTION" value="sqlite"/>
-        <env name="DB_DATABASE" value=":memory:"/>
+        <env name="DB_CONNECTION" value="mysql"/>
+        <env name="DB_DATABASE" value="planforge_test"/>
         <env name="MAIL_MAILER" value="array"/>
         <env name="QUEUE_CONNECTION" value="sync"/>
         <env name="SESSION_DRIVER" value="array"/>
diff --git a/resources/views/components/layouts/app.blade.php b/resources/views/components/layouts/app.blade.php
index 5ab257a..95f511b 100644
--- a/resources/views/components/layouts/app.blade.php
+++ b/resources/views/components/layouts/app.blade.php
@@ -12,7 +12,7 @@
     @filamentScripts
     <div class="min-h-screen flex">
         <!-- Sidebar -->
-        <aside class="w-64 bg-gray-900 text-white flex-shrink-0 relative flex flex-col">
+        <aside class="w-64 bg-gray-900 text-white flex-shrink-0 sticky top-0 h-screen flex flex-col">
             <div class="p-4">
                 <a href="{{ route('projects.index') }}" wire:navigate class="flex items-center gap-2">
                     <svg class="w-8 h-8 text-indigo-400" fill="none" stroke="currentColor" viewBox="0 0 24 24">
diff --git a/resources/views/integrations/github/select-repo.blade.php b/resources/views/integrations/github/select-repo.blade.php
new file mode 100644
index 0000000..a74103c
--- /dev/null
+++ b/resources/views/integrations/github/select-repo.blade.php
@@ -0,0 +1,100 @@
+<x-layouts.app>
+    <x-slot name="header">
+        <h2 class="font-semibold text-xl text-gray-800 leading-tight">
+            Connect GitHub Repository
+        </h2>
+    </x-slot>
+
+    <div class="py-12">
+        <div class="max-w-3xl mx-auto sm:px-6 lg:px-8">
+            <div class="bg-white overflow-hidden shadow-sm sm:rounded-lg">
+                <div class="p-6">
+                    <h3 class="text-lg font-medium text-gray-900 mb-4">
+                        Select a repository for "{{ $project->name }}"
+                    </h3>
+
+                    @if(count($repositories) === 0)
+                        <div class="rounded-md bg-yellow-50 p-4 mb-6">
+                            <div class="flex">
+                                <div class="flex-shrink-0">
+                                    <svg class="h-5 w-5 text-yellow-400" viewBox="0 0 20 20" fill="currentColor">
+                                        <path fill-rule="evenodd" d="M8.485 2.495c.673-1.167 2.357-1.167 3.03 0l6.28 10.875c.673 1.167-.17 2.625-1.516 2.625H3.72c-1.347 0-2.189-1.458-1.515-2.625L8.485 2.495zM10 5a.75.75 0 01.75.75v3.5a.75.75 0 01-1.5 0v-3.5A.75.75 0 0110 5zm0 9a1 1 0 100-2 1 1 0 000 2z" clip-rule="evenodd" />
+                                    </svg>
+                                </div>
+                                <div class="ml-3">
+                                    <h3 class="text-sm font-medium text-yellow-800">
+                                        No repositories available
+                                    </h3>
+                                    <p class="mt-2 text-sm text-yellow-700">
+                                        The GitHub App doesn't have access to any repositories.
+                                        Please update the installation permissions on GitHub.
+                                    </p>
+                                </div>
+                            </div>
+                        </div>
+                        <a href="{{ route('projects.workspace', $project) }}" class="text-indigo-600 hover:text-indigo-500">
+                            &larr; Back to project
+                        </a>
+                    @else
+                        <form action="{{ route('integrations.github.setup', $project) }}" method="POST">
+                            @csrf
+
+                            <div class="space-y-4">
+                                <div>
+                                    <label for="repo" class="block text-sm font-medium text-gray-700">
+                                        Repository
+                                    </label>
+                                    <select name="repo" id="repo" required
+                                        class="mt-1 block w-full pl-3 pr-10 py-2 text-base border-gray-300 focus:outline-none focus:ring-indigo-500 focus:border-indigo-500 sm:text-sm rounded-md"
+                                        onchange="updateOwner(this)">
+                                        <option value="">Select a repository...</option>
+                                        @foreach($repositories as $repo)
+                                            <option value="{{ $repo['name'] }}" data-owner="{{ $repo['owner']['login'] }}">
+                                                {{ $repo['full_name'] }}
+                                            </option>
+                                        @endforeach
+                                    </select>
+                                    <input type="hidden" name="owner" id="owner">
+                                </div>
+
+                                <div>
+                                    <label class="block text-sm font-medium text-gray-700 mb-2">
+                                        Default Labels (optional)
+                                    </label>
+                                    <div class="flex gap-2">
+                                        <label class="inline-flex items-center">
+                                            <input type="checkbox" name="default_labels[]" value="planforge" checked
+                                                class="rounded border-gray-300 text-indigo-600 focus:ring-indigo-500">
+                                            <span class="ml-2 text-sm text-gray-600">planforge</span>
+                                        </label>
+                                    </div>
+                                    <p class="mt-1 text-xs text-gray-500">
+                                        These labels will be added to all synced issues.
+                                    </p>
+                                </div>
+
+                                <div class="pt-4 flex items-center justify-between">
+                                    <a href="{{ route('projects.workspace', $project) }}"
+                                        class="text-sm text-gray-600 hover:text-gray-500">
+                                        Cancel
+                                    </a>
+                                    <button type="submit"
+                                        class="inline-flex items-center px-4 py-2 border border-transparent text-sm font-medium rounded-md shadow-sm text-white bg-indigo-600 hover:bg-indigo-700 focus:outline-none focus:ring-2 focus:ring-offset-2 focus:ring-indigo-500">
+                                        Connect Repository
+                                    </button>
+                                </div>
+                            </div>
+                        </form>
+
+                        <script>
+                            function updateOwner(select) {
+                                const option = select.selectedOptions[0];
+                                document.getElementById('owner').value = option?.dataset?.owner || '';
+                            }
+                        </script>
+                    @endif
+                </div>
+            </div>
+        </div>
+    </div>
+</x-layouts.app>
diff --git a/resources/views/livewire/projects/tabs/integrations.blade.php b/resources/views/livewire/projects/tabs/integrations.blade.php
new file mode 100644
index 0000000..2ad7e38
--- /dev/null
+++ b/resources/views/livewire/projects/tabs/integrations.blade.php
@@ -0,0 +1,416 @@
+<div class="h-full p-6" @if($this->hasRunningSyncs) wire:poll.5s @endif>
+    <script>
+        window.copyToClipboard = function(text) {
+            if (navigator.clipboard && window.isSecureContext) {
+                navigator.clipboard.writeText(text);
+            } else {
+                const textarea = document.createElement('textarea');
+                textarea.value = text;
+                textarea.style.position = 'fixed';
+                textarea.style.left = '-9999px';
+                document.body.appendChild(textarea);
+                textarea.select();
+                document.execCommand('copy');
+                document.body.removeChild(textarea);
+            }
+        }
+    </script>
+    <div class="mb-6">
+        <h2 class="text-lg font-semibold text-gray-900">Integrations</h2>
+        <p class="text-sm text-gray-500">Connect external services to sync your tasks</p>
+    </div>
+
+    <!-- GitHub Integration Card -->
+    <div class="bg-white rounded-xl border border-gray-200 p-6 max-w-2xl" x-data="{ showSetup: false }">
+        <div class="flex items-start justify-between mb-6">
+            <div class="flex items-center gap-4">
+                <div class="p-3 bg-gray-900 rounded-lg">
+                    <svg class="w-6 h-6 text-white" viewBox="0 0 24 24" fill="currentColor">
+                        <path d="M12 0C5.374 0 0 5.373 0 12c0 5.302 3.438 9.8 8.207 11.387.599.111.793-.261.793-.577v-2.234c-3.338.726-4.033-1.416-4.033-1.416-.546-1.387-1.333-1.756-1.333-1.756-1.089-.745.083-.729.083-.729 1.205.084 1.839 1.237 1.839 1.237 1.07 1.834 2.807 1.304 3.492.997.107-.775.418-1.305.762-1.604-2.665-.305-5.467-1.334-5.467-5.931 0-1.311.469-2.381 1.236-3.221-.124-.303-.535-1.524.117-3.176 0 0 1.008-.322 3.301 1.23A11.509 11.509 0 0112 5.803c1.02.005 2.047.138 3.006.404 2.291-1.552 3.297-1.23 3.297-1.23.653 1.653.242 2.874.118 3.176.77.84 1.235 1.911 1.235 3.221 0 4.609-2.807 5.624-5.479 5.921.43.372.823 1.102.823 2.222v3.293c0 .319.192.694.801.576C20.566 21.797 24 17.3 24 12c0-6.627-5.373-12-12-12z"/>
+                    </svg>
+                </div>
+                <div>
+                    <h3 class="font-semibold text-gray-900">GitHub Issues</h3>
+                    <p class="text-sm text-gray-500">Sync tasks to GitHub Issues</p>
+                </div>
+            </div>
+
+            @if($this->githubIntegration?->isConnected())
+                <span class="inline-flex items-center gap-1.5 px-2.5 py-1 rounded-full text-xs font-medium bg-green-100 text-green-700">
+                    <span class="w-1.5 h-1.5 bg-green-500 rounded-full"></span>
+                    Connected
+                </span>
+            @else
+                <span class="inline-flex items-center gap-1.5 px-2.5 py-1 rounded-full text-xs font-medium bg-gray-100 text-gray-600">
+                    <span class="w-1.5 h-1.5 bg-gray-400 rounded-full"></span>
+                    Not Connected
+                </span>
+            @endif
+        </div>
+
+        @if($this->githubIntegration?->isConnected())
+            <!-- Connected State -->
+            <div class="space-y-4">
+                <!-- Repository Info -->
+                <div class="flex items-center justify-between p-4 bg-gray-50 rounded-lg">
+                    <div class="flex items-center gap-3">
+                        <svg class="w-5 h-5 text-gray-400" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+                            <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M3 7v10a2 2 0 002 2h14a2 2 0 002-2V9a2 2 0 00-2-2h-6l-2-2H5a2 2 0 00-2 2z"/>
+                        </svg>
+                        <div>
+                            <p class="text-sm font-medium text-gray-900">{{ $this->githubIntegration->getRepoFullName() }}</p>
+                            <p class="text-xs text-gray-500">
+                                @if($this->lastSyncedAt)
+                                    Last synced {{ $this->lastSyncedAt }}
+                                @else
+                                    Never synced
+                                @endif
+                            </p>
+                        </div>
+                    </div>
+                    <a
+                        href="https://github.com/{{ $this->githubIntegration->getRepoFullName() }}/issues"
+                        target="_blank"
+                        class="text-sm text-indigo-600 hover:text-indigo-700 flex items-center gap-1"
+                    >
+                        View Issues
+                        <svg class="w-4 h-4" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+                            <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M10 6H6a2 2 0 00-2 2v10a2 2 0 002 2h10a2 2 0 002-2v-4M14 4h6m0 0v6m0-6L10 14"/>
+                        </svg>
+                    </a>
+                </div>
+
+                <!-- Sync Message -->
+                @if($syncMessage)
+                    <div class="p-3 bg-blue-50 border border-blue-100 rounded-lg">
+                        <p class="text-sm text-blue-700">{{ $syncMessage }}</p>
+                    </div>
+                @endif
+
+                <!-- Actions -->
+                <div class="flex items-center gap-3">
+                    <button
+                        wire:click="triggerSync"
+                        wire:loading.attr="disabled"
+                        wire:loading.class="opacity-50 cursor-not-allowed"
+                        class="px-4 py-2 bg-indigo-600 text-white text-sm font-medium rounded-lg hover:bg-indigo-700 transition flex items-center gap-2"
+                    >
+                        <svg wire:loading wire:target="triggerSync" class="w-4 h-4 animate-spin" fill="none" viewBox="0 0 24 24">
+                            <circle class="opacity-25" cx="12" cy="12" r="10" stroke="currentColor" stroke-width="4"></circle>
+                            <path class="opacity-75" fill="currentColor" d="M4 12a8 8 0 018-8V0C5.373 0 0 5.373 0 12h4zm2 5.291A7.962 7.962 0 014 12H0c0 3.042 1.135 5.824 3 7.938l3-2.647z"></path>
+                        </svg>
+                        <svg wire:loading.remove wire:target="triggerSync" class="w-4 h-4" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+                            <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M4 4v5h.582m15.356 2A8.001 8.001 0 004.582 9m0 0H9m11 11v-5h-.581m0 0a8.003 8.003 0 01-15.357-2m15.357 2H15"/>
+                        </svg>
+                        <span wire:loading.remove wire:target="triggerSync">Sync Now</span>
+                        <span wire:loading wire:target="triggerSync">Syncing...</span>
+                    </button>
+
+                    <form action="{{ route('integrations.github.disconnect', $this->project) }}" method="POST" class="inline">
+                        @csrf
+                        @method('DELETE')
+                        <button
+                            type="submit"
+                            onclick="return confirm('Are you sure you want to disconnect GitHub?')"
+                            class="px-4 py-2 border border-gray-300 text-gray-700 text-sm font-medium rounded-lg hover:bg-gray-50 transition"
+                        >
+                            Disconnect
+                        </button>
+                    </form>
+                </div>
+
+                <!-- Recent Sync Runs -->
+                @if(count($this->recentSyncRuns) > 0)
+                    <div class="mt-6 pt-6 border-t border-gray-200">
+                        <h4 class="text-sm font-medium text-gray-900 mb-3">Recent Syncs</h4>
+                        <div class="space-y-2">
+                            @foreach($this->recentSyncRuns as $run)
+                                <div class="flex items-center justify-between p-3 bg-gray-50 rounded-lg text-sm">
+                                    <div class="flex items-center gap-3">
+                                        @if($run['status'] === 'completed')
+                                            <span class="w-2 h-2 bg-green-500 rounded-full"></span>
+                                        @elseif($run['status'] === 'running')
+                                            <span class="w-2 h-2 bg-blue-500 rounded-full animate-pulse"></span>
+                                        @else
+                                            <span class="w-2 h-2 bg-red-500 rounded-full"></span>
+                                        @endif
+                                        <span class="text-gray-600">{{ ucfirst($run['trigger']) }}</span>
+                                        <span class="text-gray-400">{{ $run['started_at'] }}</span>
+                                    </div>
+                                    <div class="flex items-center gap-4 text-xs">
+                                        @if($run['created'] > 0)
+                                            <span class="text-green-600">+{{ $run['created'] }} created</span>
+                                        @endif
+                                        @if($run['updated'] > 0)
+                                            <span class="text-blue-600">{{ $run['updated'] }} updated</span>
+                                        @endif
+                                        @if($run['skipped'] > 0)
+                                            <span class="text-gray-500">{{ $run['skipped'] }} unchanged</span>
+                                        @endif
+                                        @if($run['failed'] > 0)
+                                            <span class="text-red-600">{{ $run['failed'] }} failed</span>
+                                        @endif
+                                    </div>
+                                </div>
+                            @endforeach
+                        </div>
+                    </div>
+                @endif
+            </div>
+        @else
+            <!-- Not Connected State -->
+            <div class="text-center py-6">
+                <p class="text-sm text-gray-500 mb-4">
+                    Connect a GitHub repository to automatically sync your tasks as GitHub Issues.
+                </p>
+                <a
+                    href="{{ route('integrations.github.install', $this->project) }}"
+                    class="inline-flex items-center gap-2 px-4 py-2 bg-gray-900 text-white text-sm font-medium rounded-lg hover:bg-gray-800 transition"
+                >
+                    <svg class="w-5 h-5" viewBox="0 0 24 24" fill="currentColor">
+                        <path d="M12 0C5.374 0 0 5.373 0 12c0 5.302 3.438 9.8 8.207 11.387.599.111.793-.261.793-.577v-2.234c-3.338.726-4.033-1.416-4.033-1.416-.546-1.387-1.333-1.756-1.333-1.756-1.089-.745.083-.729.083-.729 1.205.084 1.839 1.237 1.839 1.237 1.07 1.834 2.807 1.304 3.492.997.107-.775.418-1.305.762-1.604-2.665-.305-5.467-1.334-5.467-5.931 0-1.311.469-2.381 1.236-3.221-.124-.303-.535-1.524.117-3.176 0 0 1.008-.322 3.301 1.23A11.509 11.509 0 0112 5.803c1.02.005 2.047.138 3.006.404 2.291-1.552 3.297-1.23 3.297-1.23.653 1.653.242 2.874.118 3.176.77.84 1.235 1.911 1.235 3.221 0 4.609-2.807 5.624-5.479 5.921.43.372.823 1.102.823 2.222v3.293c0 .319.192.694.801.576C20.566 21.797 24 17.3 24 12c0-6.627-5.373-12-12-12z"/>
+                    </svg>
+                    Connect GitHub
+                </a>
+            </div>
+
+            <!-- Features List -->
+            <div class="mt-6 pt-6 border-t border-gray-200">
+                <h4 class="text-sm font-medium text-gray-900 mb-3">Features</h4>
+                <ul class="space-y-2 text-sm text-gray-600">
+                    <li class="flex items-center gap-2">
+                        <svg class="w-4 h-4 text-green-500" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+                            <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M5 13l4 4L19 7"/>
+                        </svg>
+                        Sync tasks to GitHub Issues automatically
+                    </li>
+                    <li class="flex items-center gap-2">
+                        <svg class="w-4 h-4 text-green-500" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+                            <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M5 13l4 4L19 7"/>
+                        </svg>
+                        Close issues when tasks are marked done
+                    </li>
+                    <li class="flex items-center gap-2">
+                        <svg class="w-4 h-4 text-green-500" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+                            <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M5 13l4 4L19 7"/>
+                        </svg>
+                        Update task status when issues are closed on GitHub
+                    </li>
+                    <li class="flex items-center gap-2">
+                        <svg class="w-4 h-4 text-green-500" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+                            <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M5 13l4 4L19 7"/>
+                        </svg>
+                        Smart change detection - only sync what changed
+                    </li>
+                </ul>
+            </div>
+        @endif
+
+        <!-- Setup Guide (inside the card) -->
+        <div class="mt-6 pt-6 border-t border-gray-200">
+            <button
+                @click="showSetup = !showSetup"
+                class="w-full flex items-center justify-between text-left group"
+            >
+                <div class="flex items-center gap-3">
+                    <div class="p-2 bg-blue-100 rounded-lg group-hover:bg-blue-200 transition">
+                        <svg class="w-4 h-4 text-blue-600" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+                            <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M13 16h-1v-4h-1m1-4h.01M21 12a9 9 0 11-18 0 9 9 0 0118 0z"/>
+                        </svg>
+                    </div>
+                    <div>
+                        <h4 class="text-sm font-medium text-gray-900">Setup Guide</h4>
+                        <p class="text-xs text-gray-500">How to configure the GitHub integration</p>
+                    </div>
+                </div>
+                <svg
+                    class="w-5 h-5 text-gray-400 transition-transform duration-200"
+                    :class="{ 'rotate-180': showSetup }"
+                    fill="none"
+                    stroke="currentColor"
+                    viewBox="0 0 24 24"
+                >
+                    <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M19 9l-7 7-7-7"/>
+                </svg>
+            </button>
+
+            <div x-show="showSetup" x-collapse class="mt-4">
+                <!-- Step 1: Create GitHub App -->
+                <div class="mb-6">
+                    <h5 class="text-sm font-semibold text-gray-900 mb-2 flex items-center gap-2">
+                        <span class="w-5 h-5 bg-indigo-600 text-white rounded-full text-xs flex items-center justify-center">1</span>
+                        Create a GitHub App
+                    </h5>
+                    <p class="text-sm text-gray-600 mb-3">
+                        Go to <a href="https://github.com/settings/apps/new" target="_blank" class="text-indigo-600 hover:underline">GitHub Settings &rarr; Developer settings &rarr; GitHub Apps</a> and create a new app with these settings:
+                    </p>
+                    <div class="space-y-2 text-sm">
+                        <div class="flex items-center justify-between p-2 bg-gray-50 rounded-lg">
+                            <div>
+                                <span class="text-gray-600">Homepage URL:</span>
+                                <code class="ml-2 text-xs text-gray-800">{{ config('app.url') }}</code>
+                            </div>
+                            <button
+                                x-data="{ copied: false }"
+                                @click="window.copyToClipboard('{{ config('app.url') }}'); copied = true; setTimeout(() => copied = false, 2000)"
+                                class="p-1.5 text-gray-400 hover:text-gray-600 hover:bg-gray-200 rounded transition"
+                                title="Copy to clipboard"
+                            >
+                                <svg x-show="!copied" class="w-4 h-4" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+                                    <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M8 16H6a2 2 0 01-2-2V6a2 2 0 012-2h8a2 2 0 012 2v2m-6 12h8a2 2 0 002-2v-8a2 2 0 00-2-2h-8a2 2 0 00-2 2v8a2 2 0 002 2z"/>
+                                </svg>
+                                <svg x-show="copied" x-cloak class="w-4 h-4 text-green-500" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+                                    <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M5 13l4 4L19 7"/>
+                                </svg>
+                            </button>
+                        </div>
+                        <div class="flex items-center justify-between p-2 bg-gray-50 rounded-lg">
+                            <div class="min-w-0 flex-1">
+                                <span class="text-gray-600">Callback URL:</span>
+                                <code class="ml-2 text-xs text-gray-800 break-all">{{ route('integrations.github.callback') }}</code>
+                            </div>
+                            <button
+                                x-data="{ copied: false }"
+                                @click="window.copyToClipboard('{{ route('integrations.github.callback') }}'); copied = true; setTimeout(() => copied = false, 2000)"
+                                class="p-1.5 text-gray-400 hover:text-gray-600 hover:bg-gray-200 rounded transition flex-shrink-0 ml-2"
+                                title="Copy to clipboard"
+                            >
+                                <svg x-show="!copied" class="w-4 h-4" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+                                    <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M8 16H6a2 2 0 01-2-2V6a2 2 0 012-2h8a2 2 0 012 2v2m-6 12h8a2 2 0 002-2v-8a2 2 0 00-2-2h-8a2 2 0 00-2 2v8a2 2 0 002 2z"/>
+                                </svg>
+                                <svg x-show="copied" x-cloak class="w-4 h-4 text-green-500" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+                                    <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M5 13l4 4L19 7"/>
+                                </svg>
+                            </button>
+                        </div>
+                        <div class="flex items-center justify-between p-2 bg-gray-50 rounded-lg">
+                            <div class="min-w-0 flex-1">
+                                <span class="text-gray-600">Webhook URL:</span>
+                                <code class="ml-2 text-xs text-gray-800 break-all">{{ route('webhooks.github') }}</code>
+                            </div>
+                            <button
+                                x-data="{ copied: false }"
+                                @click="window.copyToClipboard('{{ route('webhooks.github') }}'); copied = true; setTimeout(() => copied = false, 2000)"
+                                class="p-1.5 text-gray-400 hover:text-gray-600 hover:bg-gray-200 rounded transition flex-shrink-0 ml-2"
+                                title="Copy to clipboard"
+                            >
+                                <svg x-show="!copied" class="w-4 h-4" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+                                    <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M8 16H6a2 2 0 01-2-2V6a2 2 0 012-2h8a2 2 0 012 2v2m-6 12h8a2 2 0 002-2v-8a2 2 0 00-2-2h-8a2 2 0 00-2 2v8a2 2 0 002 2z"/>
+                                </svg>
+                                <svg x-show="copied" x-cloak class="w-4 h-4 text-green-500" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+                                    <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M5 13l4 4L19 7"/>
+                                </svg>
+                            </button>
+                        </div>
+                        <div class="p-2 bg-gray-50 rounded-lg">
+                            <span class="text-gray-600">Webhook events:</span>
+                            <span class="ml-2 text-gray-800">Issues</span>
+                        </div>
+                        <div class="p-2 bg-gray-50 rounded-lg">
+                            <span class="text-gray-600">Permissions:</span>
+                            <span class="ml-2 text-gray-800">Issues (Read & write), Metadata (Read-only)</span>
+                        </div>
+                    </div>
+                </div>
+
+                <!-- Step 2: Environment Variables -->
+                <div class="mb-6">
+                    <h5 class="text-sm font-semibold text-gray-900 mb-2 flex items-center gap-2">
+                        <span class="w-5 h-5 bg-indigo-600 text-white rounded-full text-xs flex items-center justify-center">2</span>
+                        Configure Environment Variables
+                    </h5>
+                    <p class="text-sm text-gray-600 mb-2">Add these to your <code class="bg-gray-100 px-1.5 py-0.5 rounded text-xs">.env</code> file:</p>
+                    <div class="relative" x-data="{ copied: false }">
+                        <div class="bg-gray-900 rounded-lg p-3 text-sm font-mono text-gray-100 overflow-x-auto">
+                            <div>GITHUB_APP_ID=<span class="text-gray-500">your_app_id</span></div>
+                            <div>GITHUB_APP_SLUG=<span class="text-gray-500">your-app-slug</span></div>
+                            <div>GITHUB_APP_CLIENT_ID=<span class="text-gray-500">your_client_id</span></div>
+                            <div>GITHUB_APP_CLIENT_SECRET=<span class="text-gray-500">your_client_secret</span></div>
+                            <div>GITHUB_APP_PRIVATE_KEY=<span class="text-gray-500">"-----BEGIN RSA..."</span></div>
+                            <div>GITHUB_WEBHOOK_SECRET=<span class="text-gray-500">your_webhook_secret</span></div>
+                        </div>
+                        <button
+                            @click="window.copyToClipboard('GITHUB_APP_ID=your_app_id\nGITHUB_APP_SLUG=your-app-slug\nGITHUB_APP_CLIENT_ID=your_client_id\nGITHUB_APP_CLIENT_SECRET=your_client_secret\nGITHUB_APP_PRIVATE_KEY=-----BEGIN RSA...\nGITHUB_WEBHOOK_SECRET=your_webhook_secret'); copied = true; setTimeout(() => copied = false, 2000)"
+                            class="absolute top-2 right-2 p-1.5 text-gray-400 hover:text-white hover:bg-gray-700 rounded transition"
+                            title="Copy to clipboard"
+                        >
+                            <svg x-show="!copied" class="w-4 h-4" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+                                <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M8 16H6a2 2 0 01-2-2V6a2 2 0 012-2h8a2 2 0 012 2v2m-6 12h8a2 2 0 002-2v-8a2 2 0 00-2-2h-8a2 2 0 00-2 2v8a2 2 0 002 2z"/>
+                            </svg>
+                            <svg x-show="copied" x-cloak class="w-4 h-4 text-green-400" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+                                <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M5 13l4 4L19 7"/>
+                            </svg>
+                        </button>
+                    </div>
+                    <p class="text-xs text-gray-500 mt-2">
+                        The private key should be the full PEM content with newlines as <code class="bg-gray-100 px-1 rounded">\n</code>
+                    </p>
+                </div>
+
+                <!-- Step 3: Queue Worker -->
+                <div class="mb-6">
+                    <h5 class="text-sm font-semibold text-gray-900 mb-2 flex items-center gap-2">
+                        <span class="w-5 h-5 bg-indigo-600 text-white rounded-full text-xs flex items-center justify-center">3</span>
+                        Run the Queue Worker
+                    </h5>
+                    <p class="text-sm text-gray-600 mb-2">Sync jobs run in the background. Start the queue worker:</p>
+                    <div class="relative" x-data="{ copied: false }">
+                        <div class="bg-gray-900 rounded-lg p-3 text-sm font-mono text-gray-100">
+                            php artisan queue:work
+                        </div>
+                        <button
+                            @click="window.copyToClipboard('php artisan queue:work'); copied = true; setTimeout(() => copied = false, 2000)"
+                            class="absolute top-2 right-2 p-1.5 text-gray-400 hover:text-white hover:bg-gray-700 rounded transition"
+                            title="Copy to clipboard"
+                        >
+                            <svg x-show="!copied" class="w-4 h-4" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+                                <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M8 16H6a2 2 0 01-2-2V6a2 2 0 012-2h8a2 2 0 012 2v2m-6 12h8a2 2 0 002-2v-8a2 2 0 00-2-2h-8a2 2 0 00-2 2v8a2 2 0 002 2z"/>
+                            </svg>
+                            <svg x-show="copied" x-cloak class="w-4 h-4 text-green-400" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+                                <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M5 13l4 4L19 7"/>
+                            </svg>
+                        </button>
+                    </div>
+                </div>
+
+                <!-- Step 4: Connect -->
+                <div>
+                    <h5 class="text-sm font-semibold text-gray-900 mb-2 flex items-center gap-2">
+                        <span class="w-5 h-5 bg-indigo-600 text-white rounded-full text-xs flex items-center justify-center">4</span>
+                        Connect Your Repository
+                    </h5>
+                    <p class="text-sm text-gray-600">
+                        Click the "Connect GitHub" button above to install the app on your repository and start syncing tasks.
+                    </p>
+                </div>
+
+                <!-- Webhook Info (when connected) -->
+                @if($this->githubIntegration?->isConnected())
+                    <div class="mt-6 pt-4 border-t border-gray-100">
+                        <h5 class="text-sm font-semibold text-gray-900 mb-2">Webhook Configuration</h5>
+                        <p class="text-sm text-gray-600 mb-2">Ensure your GitHub App webhook is configured to send <strong>Issues</strong> events to:</p>
+                        <div class="flex items-center justify-between p-2 bg-gray-100 rounded-lg">
+                            <code class="text-sm text-gray-700 break-all">{{ route('webhooks.github') }}</code>
+                            <button
+                                x-data="{ copied: false }"
+                                @click="window.copyToClipboard('{{ route('webhooks.github') }}'); copied = true; setTimeout(() => copied = false, 2000)"
+                                class="p-1.5 text-gray-400 hover:text-gray-600 hover:bg-gray-200 rounded transition flex-shrink-0 ml-2"
+                                title="Copy to clipboard"
+                            >
+                                <svg x-show="!copied" class="w-4 h-4" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+                                    <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M8 16H6a2 2 0 01-2-2V6a2 2 0 012-2h8a2 2 0 012 2v2m-6 12h8a2 2 0 002-2v-8a2 2 0 00-2-2h-8a2 2 0 00-2 2v8a2 2 0 002 2z"/>
+                                </svg>
+                                <svg x-show="copied" x-cloak class="w-4 h-4 text-green-500" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+                                    <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M5 13l4 4L19 7"/>
+                                </svg>
+                            </button>
+                        </div>
+                        <p class="text-xs text-gray-500 mt-2">
+                            When issues are closed or reopened on GitHub, task statuses will update automatically.
+                        </p>
+                    </div>
+                @endif
+            </div>
+        </div>
+    </div>
+</div>
diff --git a/resources/views/livewire/projects/workspace.blade.php b/resources/views/livewire/projects/workspace.blade.php
index 77a24b8..667bbd6 100644
--- a/resources/views/livewire/projects/workspace.blade.php
+++ b/resources/views/livewire/projects/workspace.blade.php
@@ -117,7 +117,7 @@ class="p-2 text-gray-500 hover:text-gray-700 hover:bg-gray-100 rounded-lg transi
 
         <!-- Tabs -->
         <nav class="flex gap-1 mt-4 -mb-px">
-            @foreach(['prd' => 'PRD', 'tech' => 'Tech Spec', 'kanban' => 'Kanban', 'export' => 'Export'] as $key => $label)
+            @foreach(['prd' => 'PRD', 'tech' => 'Tech Spec', 'kanban' => 'Kanban', 'integrations' => 'Integrations', 'export' => 'Export'] as $key => $label)
                 <button
                     wire:click="setTab('{{ $key }}')"
                     @class([
@@ -147,6 +147,10 @@ class="p-2 text-gray-500 hover:text-gray-700 hover:bg-gray-100 rounded-lg transi
                 <livewire:projects.tabs.kanban-board :project-id="$projectId" :key="'kanban-'.$projectId" />
                 @break
 
+            @case('integrations')
+                <livewire:projects.tabs.integrations :project-id="$projectId" :key="'integrations-'.$projectId" />
+                @break
+
             @case('export')
                 <livewire:projects.tabs.export :project-id="$projectId" :key="'export-'.$projectId" />
                 @break
diff --git a/routes/web.php b/routes/web.php
index 47f3905..d77833c 100644
--- a/routes/web.php
+++ b/routes/web.php
@@ -1,5 +1,7 @@
 <?php
 
+use App\Http\Controllers\GitHubIntegrationController;
+use App\Http\Controllers\GitHubWebhookController;
 use App\Http\Controllers\ProjectExportController;
 use App\Livewire\Actions\Logout;
 use App\Livewire\Projects\Index as ProjectsIndex;
@@ -36,6 +38,31 @@
 
         return redirect('/');
     })->name('logout');
+
+    // GitHub Integration
+    Route::prefix('projects/{project}/integrations/github')->group(function () {
+        Route::get('install', [GitHubIntegrationController::class, 'install'])
+            ->name('integrations.github.install');
+        Route::get('select-repo', [GitHubIntegrationController::class, 'selectRepo'])
+            ->name('integrations.github.select-repo');
+        Route::post('setup', [GitHubIntegrationController::class, 'setup'])
+            ->name('integrations.github.setup');
+        Route::delete('disconnect', [GitHubIntegrationController::class, 'disconnect'])
+            ->name('integrations.github.disconnect');
+        Route::post('sync', [GitHubIntegrationController::class, 'sync'])
+            ->name('integrations.github.sync');
+        Route::get('status', [GitHubIntegrationController::class, 'syncStatus'])
+            ->name('integrations.github.status');
+    });
 });
 
+// GitHub callback - runs without auth since it's called by GitHub
+Route::get('integrations/github/callback', [GitHubIntegrationController::class, 'callback'])
+    ->name('integrations.github.callback');
+
+// GitHub webhook - no CSRF, no auth - handles incoming webhooks from GitHub
+Route::post('webhooks/github', [GitHubWebhookController::class, 'handle'])
+    ->name('webhooks.github')
+    ->withoutMiddleware(\Illuminate\Foundation\Http\Middleware\ValidateCsrfToken::class);
+
 require __DIR__.'/auth.php';
diff --git a/tests/Feature/GitHubAutoSyncTest.php b/tests/Feature/GitHubAutoSyncTest.php
new file mode 100644
index 0000000..72e054a
--- /dev/null
+++ b/tests/Feature/GitHubAutoSyncTest.php
@@ -0,0 +1,266 @@
+<?php
+
+use App\Enums\IntegrationStatus;
+use App\Enums\TaskStatus;
+use App\Events\TasksChanged;
+use App\Jobs\DebouncedGitHubSync;
+use App\Listeners\QueueGitHubSync;
+use App\Models\Integration;
+use App\Models\Project;
+use App\Models\Task;
+use App\Models\User;
+use Illuminate\Support\Facades\Cache;
+use Illuminate\Support\Facades\Event;
+use Illuminate\Support\Facades\Queue;
+
+beforeEach(function () {
+    Queue::fake();
+    $this->user = User::factory()->create();
+    $this->project = Project::factory()->for($this->user)->create();
+});
+
+describe('TasksChanged Event Dispatching', function () {
+    it('dispatches event when task title is updated', function () {
+        Event::fake([TasksChanged::class]);
+
+        $task = Task::factory()->create([
+            'project_id' => $this->project->id,
+            'title' => 'Original Title',
+        ]);
+
+        $task->update(['title' => 'Updated Title']);
+
+        Event::assertDispatched(TasksChanged::class, function ($event) {
+            return $event->project->id === $this->project->id
+                && $event->changeType === 'updated';
+        });
+    });
+
+    it('dispatches event when task status changes', function () {
+        Event::fake([TasksChanged::class]);
+
+        $task = Task::factory()->create([
+            'project_id' => $this->project->id,
+            'status' => TaskStatus::Todo,
+        ]);
+
+        $task->update(['status' => TaskStatus::Done]);
+
+        Event::assertDispatched(TasksChanged::class);
+    });
+
+    it('does not dispatch event for non-sync fields', function () {
+        Event::fake([TasksChanged::class]);
+
+        $task = Task::factory()->create([
+            'project_id' => $this->project->id,
+            'position' => 1,
+        ]);
+
+        // Clear any events from creation
+        Event::assertDispatched(TasksChanged::class);
+
+        // Reset fake
+        Event::fake([TasksChanged::class]);
+
+        $task->update(['position' => 2]);
+
+        Event::assertNotDispatched(TasksChanged::class);
+    });
+
+    it('dispatches event with created type for new tasks', function () {
+        Event::fake([TasksChanged::class]);
+
+        Task::factory()->create([
+            'project_id' => $this->project->id,
+            'title' => 'New Task',
+        ]);
+
+        Event::assertDispatched(TasksChanged::class, function ($event) {
+            return $event->changeType === 'created';
+        });
+    });
+
+    it('dispatches event when task is deleted', function () {
+        $task = Task::factory()->create([
+            'project_id' => $this->project->id,
+        ]);
+
+        Event::fake([TasksChanged::class]);
+
+        $task->delete();
+
+        Event::assertDispatched(TasksChanged::class, function ($event) {
+            return $event->changeType === 'deleted';
+        });
+    });
+});
+
+describe('QueueGitHubSync Listener', function () {
+    it('queues debounced sync job for connected integration', function () {
+        $integration = Integration::factory()
+            ->for($this->project)
+            ->github()
+            ->connected()
+            ->withGitHubSettings()
+            ->create();
+
+        $event = new TasksChanged($this->project, 'updated');
+        $listener = new QueueGitHubSync;
+        $listener->handle($event);
+
+        Queue::assertPushed(DebouncedGitHubSync::class, function ($job) {
+            return $job->projectId === $this->project->id;
+        });
+    });
+
+    it('does not queue job when no integration exists', function () {
+        $event = new TasksChanged($this->project, 'updated');
+        $listener = new QueueGitHubSync;
+        $listener->handle($event);
+
+        Queue::assertNotPushed(DebouncedGitHubSync::class);
+    });
+
+    it('does not queue job when integration is disabled', function () {
+        Integration::factory()
+            ->for($this->project)
+            ->github()
+            ->create(['status' => IntegrationStatus::Disabled]);
+
+        $event = new TasksChanged($this->project, 'updated');
+        $listener = new QueueGitHubSync;
+        $listener->handle($event);
+
+        Queue::assertNotPushed(DebouncedGitHubSync::class);
+    });
+
+    it('stores sync id in cache for debouncing', function () {
+        $integration = Integration::factory()
+            ->for($this->project)
+            ->github()
+            ->connected()
+            ->withGitHubSettings()
+            ->create();
+
+        $event = new TasksChanged($this->project, 'updated');
+        $listener = new QueueGitHubSync;
+        $listener->handle($event);
+
+        $cacheKey = "github_sync_pending_{$this->project->id}";
+        expect(Cache::has($cacheKey))->toBeTrue();
+    });
+});
+
+describe('DebouncedGitHubSync Job', function () {
+    it('skips when newer sync id exists', function () {
+        $integration = Integration::factory()
+            ->for($this->project)
+            ->github()
+            ->connected()
+            ->withGitHubSettings()
+            ->create();
+
+        $cacheKey = "github_sync_pending_{$this->project->id}";
+
+        // Put a "newer" sync id in cache
+        Cache::put($cacheKey, 'newer_sync_id', now()->addMinutes(5));
+
+        $job = new DebouncedGitHubSync(
+            $this->project->id,
+            $integration->id,
+            'older_sync_id'
+        );
+
+        // Run without Queue fake to actually execute
+        Queue::fake();
+        $job->handle(app(\App\Services\GitHub\GitHubSyncService::class));
+
+        // Should not have dispatched any sync jobs
+        Queue::assertNotPushed(\App\Jobs\SyncTaskToGitHub::class);
+    });
+
+    it('clears cache when executing sync', function () {
+        Queue::fake();
+
+        $integration = Integration::factory()
+            ->for($this->project)
+            ->github()
+            ->connected()
+            ->withGitHubSettings()
+            ->create();
+
+        $syncId = 'test_sync_id';
+        $cacheKey = "github_sync_pending_{$this->project->id}";
+
+        Cache::put($cacheKey, $syncId, now()->addMinutes(5));
+
+        $job = new DebouncedGitHubSync(
+            $this->project->id,
+            $integration->id,
+            $syncId
+        );
+
+        $job->handle(app(\App\Services\GitHub\GitHubSyncService::class));
+
+        expect(Cache::has($cacheKey))->toBeFalse();
+    });
+});
+
+describe('Manual Sync Endpoint', function () {
+    it('triggers sync for authenticated user', function () {
+        Queue::fake();
+
+        $integration = Integration::factory()
+            ->for($this->project)
+            ->github()
+            ->connected()
+            ->withGitHubSettings()
+            ->create();
+
+        // Create some tasks
+        Task::factory()->count(3)->create([
+            'project_id' => $this->project->id,
+            'status' => TaskStatus::Todo,
+        ]);
+
+        $response = $this->actingAs($this->user)
+            ->postJson(route('integrations.github.sync', $this->project));
+
+        $response->assertSuccessful();
+        $response->assertJsonStructure(['message', 'sync_run_id', 'total_tasks']);
+
+        $this->assertDatabaseHas('sync_runs', [
+            'integration_id' => $integration->id,
+            'user_id' => $this->user->id,
+            'trigger' => 'manual',
+        ]);
+    });
+
+    it('returns error when not connected', function () {
+        $response = $this->actingAs($this->user)
+            ->postJson(route('integrations.github.sync', $this->project));
+
+        $response->assertStatus(400);
+        $response->assertJson(['error' => 'GitHub integration not connected']);
+    });
+
+    it('returns sync status', function () {
+        $integration = Integration::factory()
+            ->for($this->project)
+            ->github()
+            ->connected()
+            ->withGitHubSettings('12345', 'owner', 'repo')
+            ->create();
+
+        $response = $this->actingAs($this->user)
+            ->getJson(route('integrations.github.status', $this->project));
+
+        $response->assertSuccessful();
+        $response->assertJson([
+            'connected' => true,
+            'status' => 'connected',
+            'repo' => 'owner/repo',
+        ]);
+    });
+});
diff --git a/tests/Feature/GitHubSyncQueueTest.php b/tests/Feature/GitHubSyncQueueTest.php
new file mode 100644
index 0000000..00386fd
--- /dev/null
+++ b/tests/Feature/GitHubSyncQueueTest.php
@@ -0,0 +1,159 @@
+<?php
+
+declare(strict_types=1);
+
+use App\Enums\IntegrationStatus;
+use App\Enums\SyncRunStatus;
+use App\Enums\TaskStatus;
+use App\Jobs\CheckSyncRunCompletion;
+use App\Jobs\SyncTaskToGitHub;
+use App\Models\Integration;
+use App\Models\Project;
+use App\Models\SyncRun;
+use App\Models\Task;
+use App\Models\TaskSet;
+use App\Models\User;
+use App\Services\GitHub\GitHubSyncService;
+use Illuminate\Support\Facades\Queue;
+
+test('sync dispatches jobs to queue', function () {
+    Queue::fake();
+
+    $user = User::factory()->create();
+    $project = Project::factory()->create(['user_id' => $user->id]);
+    $taskSet = TaskSet::factory()->create(['project_id' => $project->id]);
+
+    $tasks = Task::factory()->count(3)->create([
+        'project_id' => $project->id,
+        'task_set_id' => $taskSet->id,
+        'status' => TaskStatus::Todo,
+    ]);
+
+    $integration = Integration::factory()->create([
+        'project_id' => $project->id,
+        'provider' => 'github',
+        'status' => IntegrationStatus::Connected,
+        'settings' => [
+            'installation_id' => '12345',
+            'owner' => 'test-owner',
+            'repo' => 'test-repo',
+        ],
+    ]);
+
+    $syncService = app(GitHubSyncService::class);
+    $syncRun = $syncService->syncProject($integration, $user->id);
+
+    // Assert jobs were dispatched
+    Queue::assertPushed(SyncTaskToGitHub::class, 3);
+    Queue::assertPushed(CheckSyncRunCompletion::class, 1);
+
+    // Assert sync run was created
+    expect($syncRun)->toBeInstanceOf(SyncRun::class);
+    expect($syncRun->status)->toBe(SyncRunStatus::Running);
+    expect($syncRun->total_count)->toBe(3);
+});
+
+test('check sync run completion marks sync as completed', function () {
+    $user = User::factory()->create();
+    $project = Project::factory()->create(['user_id' => $user->id]);
+
+    $integration = Integration::factory()->create([
+        'project_id' => $project->id,
+        'provider' => 'github',
+        'status' => IntegrationStatus::Connected,
+    ]);
+
+    $syncRun = SyncRun::create([
+        'integration_id' => $integration->id,
+        'user_id' => $user->id,
+        'direction' => 'push',
+        'trigger' => 'manual',
+        'status' => SyncRunStatus::Running,
+        'started_at' => now(),
+        'total_count' => 10,
+        'created_count' => 3,
+        'updated_count' => 2,
+        'skipped_count' => 5,
+        'failed_count' => 0,
+    ]);
+
+    $job = new CheckSyncRunCompletion($syncRun->id);
+    $job->handle();
+
+    $syncRun->refresh();
+
+    expect($syncRun->status)->toBe(SyncRunStatus::Completed);
+    expect($syncRun->completed_at)->not->toBeNull();
+});
+
+test('check sync run completion marks sync as partial when there are failures', function () {
+    $user = User::factory()->create();
+    $project = Project::factory()->create(['user_id' => $user->id]);
+
+    $integration = Integration::factory()->create([
+        'project_id' => $project->id,
+        'provider' => 'github',
+        'status' => IntegrationStatus::Connected,
+    ]);
+
+    $syncRun = SyncRun::create([
+        'integration_id' => $integration->id,
+        'user_id' => $user->id,
+        'direction' => 'push',
+        'trigger' => 'manual',
+        'status' => SyncRunStatus::Running,
+        'started_at' => now(),
+        'total_count' => 10,
+        'created_count' => 3,
+        'updated_count' => 2,
+        'skipped_count' => 3,
+        'failed_count' => 2,
+    ]);
+
+    $job = new CheckSyncRunCompletion($syncRun->id);
+    $job->handle();
+
+    $syncRun->refresh();
+
+    expect($syncRun->status)->toBe(SyncRunStatus::Partial);
+    expect($syncRun->completed_at)->not->toBeNull();
+});
+
+test('check sync run completion reschedules if not all tasks processed', function () {
+    Queue::fake();
+
+    $user = User::factory()->create();
+    $project = Project::factory()->create(['user_id' => $user->id]);
+
+    $integration = Integration::factory()->create([
+        'project_id' => $project->id,
+        'provider' => 'github',
+        'status' => IntegrationStatus::Connected,
+    ]);
+
+    $syncRun = SyncRun::create([
+        'integration_id' => $integration->id,
+        'user_id' => $user->id,
+        'direction' => 'push',
+        'trigger' => 'manual',
+        'status' => SyncRunStatus::Running,
+        'started_at' => now(),
+        'total_count' => 10,
+        'created_count' => 2,
+        'updated_count' => 1,
+        'skipped_count' => 2,
+        'failed_count' => 0,
+    ]);
+
+    $job = new CheckSyncRunCompletion($syncRun->id);
+    $job->handle();
+
+    $syncRun->refresh();
+
+    // Should still be running
+    expect($syncRun->status)->toBe(SyncRunStatus::Running);
+    expect($syncRun->completed_at)->toBeNull();
+
+    // Should reschedule itself
+    Queue::assertPushed(CheckSyncRunCompletion::class, 1);
+});
diff --git a/tests/Feature/GitHubSyncTest.php b/tests/Feature/GitHubSyncTest.php
new file mode 100644
index 0000000..2f39113
--- /dev/null
+++ b/tests/Feature/GitHubSyncTest.php
@@ -0,0 +1,270 @@
+<?php
+
+use App\Enums\IntegrationProvider;
+use App\Enums\TaskStatus;
+use App\Models\Integration;
+use App\Models\Project;
+use App\Models\Task;
+use App\Models\User;
+use App\Services\GitHub\GitHubApiService;
+use App\Services\GitHub\GitHubSyncService;
+use App\Services\GitHub\TaskToIssueMapper;
+use Illuminate\Support\Facades\Queue;
+
+beforeEach(function () {
+    Queue::fake();
+    $this->user = User::factory()->create();
+    $this->project = Project::factory()->for($this->user)->create();
+});
+
+describe('GitHub Sync', function () {
+    it('syncs a task to a new GitHub issue', function () {
+        $this->mock(GitHubApiService::class, function ($mock) {
+            $mock->shouldReceive('createIssue')
+                ->once()
+                ->andReturn([
+                    'node_id' => 'I_abc123',
+                    'number' => 42,
+                    'html_url' => 'https://github.com/owner/repo/issues/42',
+                    'state' => 'open',
+                ]);
+        });
+
+        $integration = Integration::factory()
+            ->for($this->project)
+            ->github()
+            ->connected()
+            ->withGitHubSettings()
+            ->create();
+
+        $task = Task::factory()->create([
+            'project_id' => $this->project->id,
+            'title' => 'Test Task',
+            'status' => TaskStatus::Todo,
+        ]);
+
+        $syncService = app(GitHubSyncService::class);
+        $result = $syncService->syncTask($task, $integration, 'test-run-id');
+
+        expect($result)
+            ->action->toBe('created')
+            ->issue_number->toBe(42);
+
+        $this->assertDatabaseHas('external_links', [
+            'task_id' => $task->id,
+            'provider' => IntegrationProvider::GitHub->value,
+            'external_number' => 42,
+            'sync_status' => 'synced',
+        ]);
+    });
+
+    it('updates an existing GitHub issue when task changes', function () {
+        $this->mock(GitHubApiService::class, function ($mock) {
+            $mock->shouldReceive('updateIssue')
+                ->once()
+                ->andReturn([
+                    'node_id' => 'I_abc123',
+                    'number' => 42,
+                    'html_url' => 'https://github.com/owner/repo/issues/42',
+                    'state' => 'open',
+                ]);
+        });
+
+        $integration = Integration::factory()
+            ->for($this->project)
+            ->github()
+            ->connected()
+            ->withGitHubSettings()
+            ->create();
+
+        $task = Task::factory()->create([
+            'project_id' => $this->project->id,
+            'title' => 'Test Task',
+            'status' => TaskStatus::Todo,
+        ]);
+
+        // Create existing external link with old hash
+        $task->externalLinks()->create([
+            'integration_id' => $integration->id,
+            'provider' => IntegrationProvider::GitHub,
+            'external_id' => 'I_abc123',
+            'external_number' => 42,
+            'external_url' => 'https://github.com/owner/repo/issues/42',
+            'external_state' => 'open',
+            'sync_status' => 'synced',
+            'last_synced_hash' => 'old-hash-that-no-longer-matches',
+            'last_synced_at' => now(),
+        ]);
+
+        $syncService = app(GitHubSyncService::class);
+        $result = $syncService->syncTask($task, $integration, 'test-run-id');
+
+        expect($result)
+            ->action->toBe('updated')
+            ->issue_number->toBe(42);
+    });
+
+    it('skips syncing an unchanged task', function () {
+        $integration = Integration::factory()
+            ->for($this->project)
+            ->github()
+            ->connected()
+            ->withGitHubSettings()
+            ->create();
+
+        $task = Task::factory()->create([
+            'project_id' => $this->project->id,
+            'title' => 'Test Task',
+        ]);
+
+        // Create existing external link with matching hash
+        $mapper = app(TaskToIssueMapper::class);
+        $hash = $mapper->generateHash($task);
+
+        $task->externalLinks()->create([
+            'integration_id' => $integration->id,
+            'provider' => IntegrationProvider::GitHub,
+            'external_id' => 'I_existing',
+            'external_number' => 1,
+            'external_url' => 'https://github.com/owner/repo/issues/1',
+            'external_state' => 'open',
+            'sync_status' => 'synced',
+            'last_synced_hash' => $hash,
+            'last_synced_at' => now(),
+        ]);
+
+        $syncService = app(GitHubSyncService::class);
+        $result = $syncService->syncTask($task, $integration, 'test-run-id');
+
+        expect($result)
+            ->action->toBe('skipped')
+            ->reason->toBe('unchanged');
+    });
+
+    it('records failure when API throws exception', function () {
+        // Create the integration and task first
+        $integration = Integration::factory()
+            ->for($this->project)
+            ->github()
+            ->connected()
+            ->withGitHubSettings()
+            ->create();
+
+        $task = Task::factory()->create([
+            'project_id' => $this->project->id,
+            'title' => 'Test Task',
+            'status' => TaskStatus::Todo,
+        ]);
+
+        // Mock the API service to throw an exception
+        $this->mock(GitHubApiService::class, function ($mock) {
+            $mock->shouldReceive('createIssue')
+                ->once()
+                ->andThrow(new \App\Exceptions\GitHubApiException('Rate limit exceeded', 403));
+        });
+
+        $syncService = app(GitHubSyncService::class);
+
+        try {
+            $syncService->syncTask($task, $integration, 'test-run-id');
+        } catch (\App\Exceptions\GitHubApiException $e) {
+            // Expected exception
+        }
+
+        $this->assertDatabaseHas('external_links', [
+            'task_id' => $task->id,
+            'sync_status' => 'failed',
+        ]);
+    });
+});
+
+describe('Task to Issue Mapper', function () {
+    it('formats task title with category prefix', function () {
+        $integration = Integration::factory()
+            ->github()
+            ->connected()
+            ->withGitHubSettings()
+            ->create();
+
+        $task = Task::factory()->create([
+            'title' => 'Implement backend feature',
+            'category' => \App\Enums\TaskCategory::Backend,
+        ]);
+
+        $mapper = app(TaskToIssueMapper::class);
+        $issue = $mapper->toIssue($task, $integration);
+
+        expect($issue['title'])->toBe('[backend] Implement backend feature');
+    });
+
+    it('includes acceptance criteria as checklist', function () {
+        $integration = Integration::factory()
+            ->github()
+            ->connected()
+            ->withGitHubSettings()
+            ->create();
+
+        $task = Task::factory()->create([
+            'title' => 'Test Task',
+            'description' => 'Task description',
+            'acceptance_criteria' => ['Criterion 1', 'Criterion 2'],
+        ]);
+
+        $mapper = app(TaskToIssueMapper::class);
+        $issue = $mapper->toIssue($task, $integration);
+
+        expect($issue['body'])
+            ->toContain('## Acceptance Criteria')
+            ->toContain('- [ ] Criterion 1')
+            ->toContain('- [ ] Criterion 2');
+    });
+
+    it('generates consistent hash for change detection', function () {
+        $task = Task::factory()->create([
+            'title' => 'Test Task',
+            'description' => 'Description',
+        ]);
+
+        $mapper = app(TaskToIssueMapper::class);
+        $hash1 = $mapper->generateHash($task);
+        $hash2 = $mapper->generateHash($task);
+
+        expect($hash1)->toBe($hash2);
+
+        // Modify task
+        $task->title = 'Modified Title';
+        $hash3 = $mapper->generateHash($task);
+
+        expect($hash3)->not->toBe($hash1);
+    });
+});
+
+describe('Integration Model', function () {
+    it('can check if connected', function () {
+        $connected = Integration::factory()
+            ->connected()
+            ->create();
+
+        $pending = Integration::factory()
+            ->create();
+
+        expect($connected->isConnected())->toBeTrue();
+        expect($pending->isConnected())->toBeFalse();
+    });
+
+    it('returns repo full name', function () {
+        $integration = Integration::factory()
+            ->withGitHubSettings('12345', 'acme', 'project')
+            ->create();
+
+        expect($integration->getRepoFullName())->toBe('acme/project');
+    });
+
+    it('returns installation id', function () {
+        $integration = Integration::factory()
+            ->withGitHubSettings('99999', 'owner', 'repo')
+            ->create();
+
+        expect($integration->getInstallationId())->toBe('99999');
+    });
+});
diff --git a/tests/Feature/GitHubWebhookTest.php b/tests/Feature/GitHubWebhookTest.php
new file mode 100644
index 0000000..809f6c5
--- /dev/null
+++ b/tests/Feature/GitHubWebhookTest.php
@@ -0,0 +1,300 @@
+<?php
+
+use App\Enums\IntegrationProvider;
+use App\Enums\TaskStatus;
+use App\Models\ExternalLink;
+use App\Models\Integration;
+use App\Models\Project;
+use App\Models\Task;
+use App\Models\User;
+use Illuminate\Support\Facades\Queue;
+
+beforeEach(function () {
+    Queue::fake();
+    $this->user = User::factory()->create();
+    $this->project = Project::factory()->for($this->user)->create();
+});
+
+describe('Webhook Signature Verification', function () {
+    it('accepts requests without signature when secret is not configured', function () {
+        config(['services.github.webhook_secret' => null]);
+
+        $response = $this->postJson(route('webhooks.github'), [
+            'action' => 'ping',
+        ], [
+            'X-GitHub-Event' => 'ping',
+        ]);
+
+        $response->assertSuccessful();
+    });
+
+    it('rejects requests with invalid signature when secret is configured', function () {
+        config(['services.github.webhook_secret' => 'test-secret']);
+
+        $response = $this->postJson(route('webhooks.github'), [
+            'action' => 'ping',
+        ], [
+            'X-GitHub-Event' => 'ping',
+            'X-Hub-Signature-256' => 'sha256=invalid',
+        ]);
+
+        $response->assertStatus(401);
+    });
+
+    it('accepts requests with valid signature', function () {
+        $secret = 'test-secret';
+        config(['services.github.webhook_secret' => $secret]);
+
+        $payload = json_encode(['action' => 'ping', 'zen' => 'Test']);
+        $signature = 'sha256='.hash_hmac('sha256', $payload, $secret);
+
+        $response = $this->call(
+            'POST',
+            route('webhooks.github'),
+            [],
+            [],
+            [],
+            [
+                'HTTP_X-GitHub-Event' => 'ping',
+                'HTTP_X-Hub-Signature-256' => $signature,
+                'CONTENT_TYPE' => 'application/json',
+            ],
+            $payload
+        );
+
+        $response->assertSuccessful();
+    });
+});
+
+describe('Ping Event', function () {
+    it('responds to ping with pong', function () {
+        config(['services.github.webhook_secret' => null]);
+
+        $response = $this->postJson(route('webhooks.github'), [
+            'zen' => 'Non-blocking is better than blocking.',
+            'hook_id' => 12345,
+        ], [
+            'X-GitHub-Event' => 'ping',
+        ]);
+
+        $response->assertSuccessful();
+        $response->assertJson(['message' => 'pong']);
+    });
+});
+
+describe('Issue Closed Event', function () {
+    it('updates task status to done when issue is closed', function () {
+        config(['services.github.webhook_secret' => null]);
+
+        $integration = Integration::factory()
+            ->for($this->project)
+            ->github()
+            ->connected()
+            ->withGitHubSettings('12345', 'owner', 'repo')
+            ->create();
+
+        $task = Task::factory()->create([
+            'project_id' => $this->project->id,
+            'title' => 'Test Task',
+            'status' => TaskStatus::Doing,
+        ]);
+
+        ExternalLink::factory()->create([
+            'task_id' => $task->id,
+            'integration_id' => $integration->id,
+            'provider' => IntegrationProvider::GitHub,
+            'external_id' => 'I_node123',
+            'external_number' => 42,
+            'external_url' => 'https://github.com/owner/repo/issues/42',
+            'external_state' => 'open',
+        ]);
+
+        $response = $this->postJson(route('webhooks.github'), [
+            'action' => 'closed',
+            'issue' => [
+                'node_id' => 'I_node123',
+                'number' => 42,
+                'state' => 'closed',
+                'title' => 'Test Task',
+            ],
+            'repository' => [
+                'full_name' => 'owner/repo',
+            ],
+        ], [
+            'X-GitHub-Event' => 'issues',
+        ]);
+
+        $response->assertSuccessful();
+        $response->assertJson(['action' => 'closed']);
+
+        $task->refresh();
+        expect($task->status)->toBe(TaskStatus::Done);
+    });
+});
+
+describe('Issue Reopened Event', function () {
+    it('updates task status when issue is reopened', function () {
+        config(['services.github.webhook_secret' => null]);
+
+        $integration = Integration::factory()
+            ->for($this->project)
+            ->github()
+            ->connected()
+            ->withGitHubSettings('12345', 'owner', 'repo')
+            ->create();
+
+        $task = Task::factory()->create([
+            'project_id' => $this->project->id,
+            'title' => 'Test Task',
+            'status' => TaskStatus::Done,
+        ]);
+
+        ExternalLink::factory()->create([
+            'task_id' => $task->id,
+            'integration_id' => $integration->id,
+            'provider' => IntegrationProvider::GitHub,
+            'external_id' => 'I_node456',
+            'external_number' => 99,
+            'external_url' => 'https://github.com/owner/repo/issues/99',
+            'external_state' => 'closed',
+        ]);
+
+        $response = $this->postJson(route('webhooks.github'), [
+            'action' => 'reopened',
+            'issue' => [
+                'node_id' => 'I_node456',
+                'number' => 99,
+                'state' => 'open',
+                'title' => 'Test Task',
+            ],
+            'repository' => [
+                'full_name' => 'owner/repo',
+            ],
+        ], [
+            'X-GitHub-Event' => 'issues',
+        ]);
+
+        $response->assertSuccessful();
+        $response->assertJson(['action' => 'reopened']);
+
+        $task->refresh();
+        expect($task->status)->toBe(TaskStatus::Doing);
+    });
+
+    it('respects sync_reopened_as setting', function () {
+        config(['services.github.webhook_secret' => null]);
+
+        $integration = Integration::factory()
+            ->for($this->project)
+            ->github()
+            ->connected()
+            ->create([
+                'settings' => [
+                    'installation_id' => '12345',
+                    'owner' => 'owner',
+                    'repo' => 'repo',
+                    'sync_reopened_as' => 'todo',
+                ],
+            ]);
+
+        $task = Task::factory()->create([
+            'project_id' => $this->project->id,
+            'status' => TaskStatus::Done,
+        ]);
+
+        ExternalLink::factory()->create([
+            'task_id' => $task->id,
+            'integration_id' => $integration->id,
+            'provider' => IntegrationProvider::GitHub,
+            'external_id' => 'I_node789',
+            'external_number' => 100,
+            'external_state' => 'closed',
+        ]);
+
+        $response = $this->postJson(route('webhooks.github'), [
+            'action' => 'reopened',
+            'issue' => [
+                'node_id' => 'I_node789',
+                'number' => 100,
+                'state' => 'open',
+            ],
+            'repository' => [
+                'full_name' => 'owner/repo',
+            ],
+        ], [
+            'X-GitHub-Event' => 'issues',
+        ]);
+
+        $response->assertSuccessful();
+
+        $task->refresh();
+        expect($task->status)->toBe(TaskStatus::Todo);
+    });
+});
+
+describe('Untracked Issues', function () {
+    it('ignores issues not tracked in the system', function () {
+        config(['services.github.webhook_secret' => null]);
+
+        $response = $this->postJson(route('webhooks.github'), [
+            'action' => 'closed',
+            'issue' => [
+                'node_id' => 'I_unknown',
+                'number' => 9999,
+                'state' => 'closed',
+            ],
+            'repository' => [
+                'full_name' => 'unknown/repo',
+            ],
+        ], [
+            'X-GitHub-Event' => 'issues',
+        ]);
+
+        $response->assertSuccessful();
+        $response->assertJson(['message' => 'Issue not tracked']);
+    });
+});
+
+describe('External Link State Update', function () {
+    it('updates external link state on issue events', function () {
+        config(['services.github.webhook_secret' => null]);
+
+        $integration = Integration::factory()
+            ->for($this->project)
+            ->github()
+            ->connected()
+            ->withGitHubSettings('12345', 'owner', 'repo')
+            ->create();
+
+        $task = Task::factory()->create([
+            'project_id' => $this->project->id,
+            'status' => TaskStatus::Doing,
+        ]);
+
+        $externalLink = ExternalLink::factory()->create([
+            'task_id' => $task->id,
+            'integration_id' => $integration->id,
+            'provider' => IntegrationProvider::GitHub,
+            'external_id' => 'I_statetest',
+            'external_number' => 50,
+            'external_state' => 'open',
+        ]);
+
+        $this->postJson(route('webhooks.github'), [
+            'action' => 'closed',
+            'issue' => [
+                'node_id' => 'I_statetest',
+                'number' => 50,
+                'state' => 'closed',
+            ],
+            'repository' => [
+                'full_name' => 'owner/repo',
+            ],
+        ], [
+            'X-GitHub-Event' => 'issues',
+        ]);
+
+        $externalLink->refresh();
+        expect($externalLink->external_state)->toBe('closed');
+    });
+});
diff --git a/tests/Pest.php b/tests/Pest.php
index 40d096b..2af2c3b 100644
--- a/tests/Pest.php
+++ b/tests/Pest.php
@@ -12,7 +12,7 @@
 */
 
 pest()->extend(Tests\TestCase::class)
-    ->use(Illuminate\Foundation\Testing\RefreshDatabase::class)
+    ->use(Illuminate\Foundation\Testing\LazilyRefreshDatabase::class)
     ->in('Feature');
 
 /*