@@ -26,41 +26,57 @@ function tryParseJson<T>(text: string): T | null {
   }
 }
 
+const ASSET_SESSION_MAX_RETRIES = 3;
+const ASSET_SESSION_RETRY_DELAY_MS = 1000;
+
 /**
  * Step 1: Create an asset upload session with CF.
  * Sends the asset manifest (path → {hash, size}) and receives a completion JWT
  * plus "buckets" — groups of hashes that CF needs uploaded.
+ *
+ * CF's WfP assets API sometimes returns plain text (e.g. "Assets have already
+ * been uploaded") instead of JSON when all asset hashes already exist. This is
+ * a CF bug — the response varies by edge node. Retrying typically hits a
+ * different node that returns proper JSON.
  */
 export async function createAssetUploadSession(
   accountId: string,
   apiToken: string,
   namespace: string,
   workerName: string,
   manifest: Record<string, AssetManifestEntry>,
+  { retryDelayMs = ASSET_SESSION_RETRY_DELAY_MS }: { retryDelayMs?: number } = {},
 ): Promise<{ jwt: string; buckets: string[][] }> {
-  const response = await fetch(
-    `https://api.cloudflare.com/client/v4/accounts/${accountId}/workers/dispatch/namespaces/${namespace}/scripts/${workerName}/assets-upload-session`,
-    {
-      method: "POST",
-      headers: {
-        Authorization: `Bearer ${apiToken}`,
-        "Content-Type": "application/json",
-      },
-      body: JSON.stringify({ manifest }),
-    },
-  );
+  const url = `https://api.cloudflare.com/client/v4/accounts/${accountId}/workers/dispatch/namespaces/${namespace}/scripts/${workerName}/assets-upload-session`;
+  const headers = {
+    Authorization: `Bearer ${apiToken}`,
+    "Content-Type": "application/json",
+  };
+  const body = JSON.stringify({ manifest });
 
-  if (!response.ok) {
-    const error = await response.text();
-    throw new Error(`asset upload session failed: ${error}`);
-  }
+  let lastText = "";
+  for (let attempt = 0; attempt <= ASSET_SESSION_MAX_RETRIES; attempt++) {
+    if (attempt > 0) {
+      await new Promise((r) => setTimeout(r, retryDelayMs * attempt));
+    }
+
+    const response = await fetch(url, { method: "POST", headers, body });
+
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`asset upload session failed: ${error}`);
+    }
 
-  const text = await response.text();
-  const data = tryParseJson<UploadSessionResponse>(text);
-  if (!data?.result?.jwt || !Array.isArray(data.result.buckets)) {
-    throw new Error(`asset upload session returned invalid response: ${text}`);
+    const text = await response.text();
+    const data = tryParseJson<UploadSessionResponse>(text);
+    if (data?.result?.jwt && Array.isArray(data.result.buckets)) {
+      return { jwt: data.result.jwt, buckets: data.result.buckets };
+    }
+
+    lastText = text;
   }
-  return { jwt: data.result.jwt, buckets: data.result.buckets };
+
+  throw new Error(`asset upload session returned invalid response: ${lastText}`);
 }
 
 /**
 
@@ -220,15 +220,6 @@ app.post("/:id/deploy", async (c) => {
     await updateDeploymentStatus(c.get("db"), activeDeploy.id, "failed", "timed out");
   }
 
-  // Enforce deploy count limit
-  const planLimits = getPlanLimits(user?.plan ?? "free");
-  if (planLimits.deploysPerDay > 0) {
-    const todayCount = await countUserDeploymentsToday(c.get("db"), c.get("userId"));
-    if (!isWithinLimit(planLimits.deploysPerDay, todayCount)) {
-      return c.json({ error: "deploy limit exceeded", limit: planLimits.deploysPerDay }, 429);
-    }
-  }
-
   const formData = await c.req.formData();
   const manifestRaw = formData.get("manifest") as string | null;
   const incomingManifest: DeployManifest = manifestRaw
@@ -258,6 +249,61 @@ app.post("/:id/deploy", async (c) => {
   const manifest = enrichedManifestResult.manifest;
   const finalManifestRaw = JSON.stringify(manifest);
 
+  // Skip deploy if identical to the current live deployment (same manifest + same assets).
+  // Secrets are not checked: the secrets API already live-pushes values to the active
+  // worker via putWorkerSecret.
+  if (currentLiveDeployment && currentLiveDeployment.status === "live") {
+    const sameManifest = currentLiveDeployment.manifest === finalManifestRaw;
+    const incomingAssetManifest = formData.get("assetManifest") as string | null;
+    const sameAssets =
+      incomingAssetManifest != null &&
+      currentLiveDeployment.asset_hashes != null &&
+      incomingAssetManifest === currentLiveDeployment.asset_hashes;
+    if (sameManifest && sameAssets) {
+      const siteDomain = c.env.SITE_DOMAIN ?? SITE_DOMAIN;
+      const projectDomains = await getDomainsByProjectId(c.get("db"), projectId);
+      const activeDomains = projectDomains.filter((d) => d.status === "active");
+      const fullUrl =
+        activeDomains.length > 0
+          ? `https://${activeDomains[0].hostname}`
+          : `https://${project.slug}.${siteDomain}`;
+
+      const encoder = new TextEncoder();
+      const stream = new ReadableStream({
+        start(controller) {
+          const emit = (event: DeployEvent) => {
+            controller.enqueue(encoder.encode(JSON.stringify(event) + "\n"));
+          };
+          emit({ event: "start", deploymentId: currentLiveDeployment.id });
+          emit({
+            event: "done",
+            deployment: currentLiveDeployment.id,
+            url: fullUrl,
+            urls: [
+              ...activeDomains.map((d) => `https://${d.hostname}`),
+              `https://${project.slug}.${siteDomain}`,
+            ],
+            assets: 0,
+            workers: 0,
+          });
+          controller.close();
+        },
+      });
+      return new Response(stream, {
+        headers: { "Content-Type": "application/x-ndjson" },
+      });
+    }
+  }
+
+  // Enforce deploy count limit
+  const planLimits = getPlanLimits(user?.plan ?? "free");
+  if (planLimits.deploysPerDay > 0) {
+    const todayCount = await countUserDeploymentsToday(c.get("db"), c.get("userId"));
+    if (!isWithinLimit(planLimits.deploysPerDay, todayCount)) {
+      return c.json({ error: "deploy limit exceeded", limit: planLimits.deploysPerDay }, 429);
+    }
+  }
+
   const source = (formData.get("source") as string | null) ?? null;
   const commit = (formData.get("commit") as string | null) ?? null;
 
 
@@ -959,33 +959,167 @@ describe("POST /projects/:id/deploy", () => {
     expect(events.at(-1)).toMatchObject({ event: "done" });
   });
 
-  it("does not leak raw Cloudflare asset text into deploy error events", async () => {
+  it(
+    "sanitizes error after retries exhausted on persistent plain-text session response",
+    { timeout: 15_000 },
+    async () => {
+      const user = await createTestUser(env.db);
+      const project = await createTestProject(env.db, user.id, "asset-text-error-test");
+      mockCfApi({
+        assetUploadSession: () => new Response("Assets have already been uploaded."),
+      });
+
+      const res = await app.fetch(
+        new Request(`http://localhost/projects/${project.id}/deploy`, {
+          method: "POST",
+          headers: { Authorization: `Bearer ${user.jwt}` },
+          body: buildDeployForm({
+            assets: { "index.html": "<h1>hi</h1>" },
+          }),
+        }),
+        env,
+      );
+
+      expect(res.status).toBe(200);
+      const raw = await res.text();
+      expect(raw).not.toContain("Assets have already been uploaded");
+      const events = parseDeployStream(raw);
+      expect(events.at(-1)).toMatchObject({
+        event: "error",
+        step: "asset_upload",
+        message: "asset upload returned an unexpected Cloudflare response",
+      });
+    },
+  );
+});
+
+describe("Deploy deduplication (skip identical deploys)", () => {
+  const manifest = { version: 3, bindings: {} };
+  const assetManifest = { "/index.html": { hash: "abc12345678901234567890123456789", size: 100 } };
+
+  it("skips deploy when manifest and assets are identical to live deployment", async () => {
     const user = await createTestUser(env.db);
-    const project = await createTestProject(env.db, user.id, "asset-text-error-test");
-    mockCfApi({
-      assetUploadSession: () => new Response("Assets have already been uploaded."),
+    const project = await createTestProject(env.db, user.id, "dedupe-app");
+
+    // Insert a live deployment with known manifest and asset_hashes
+    const liveDeployId = "dpl_live_dedupe";
+    await env.db.insert(deployments).values({
+      id: liveDeployId,
+      project_id: project.id,
+      status: "live",
+      manifest: JSON.stringify(manifest),
+      asset_hashes: JSON.stringify(assetManifest),
+      created_at: sql`now()`,
     });
+    await env.db
+      .update(projects)
+      .set({ active_deployment_id: liveDeployId })
+      .where(eq(projects.id, project.id));
+
+    // Deploy with the same manifest and assetManifest
+    const form = buildDeployForm({ manifest, assets: { "index.html": "<h1>hi</h1>" } });
+    form.append("assetManifest", JSON.stringify(assetManifest));
+    form.append("preflight", "true");
 
+    // No CF API mock needed — deploy should be skipped entirely
     const res = await app.fetch(
       new Request(`http://localhost/projects/${project.id}/deploy`, {
         method: "POST",
         headers: { Authorization: `Bearer ${user.jwt}` },
-        body: buildDeployForm({
-          assets: { "index.html": "<h1>hi</h1>" },
-        }),
+        body: form,
       }),
       env,
     );
 
     expect(res.status).toBe(200);
-    const raw = await res.text();
-    expect(raw).not.toContain("Assets have already been uploaded");
-    const events = parseDeployStream(raw);
-    expect(events.at(-1)).toMatchObject({
-      event: "error",
-      step: "asset_upload",
-      message: "asset upload returned an unexpected Cloudflare response",
+    const events = parseDeployStream(await res.text());
+    expect(events).toHaveLength(2); // start + done only
+    expect(events[0]).toMatchObject({ event: "start", deploymentId: liveDeployId });
+    expect(events[1]).toMatchObject({ event: "done", deployment: liveDeployId });
+  });
+
+  it("skips deploy even when secrets changed (secrets are live-pushed via API)", async () => {
+    const user = await createTestUser(env.db);
+    const project = await createTestProject(env.db, user.id, "dedupe-secret-app");
+
+    // Insert a live deployment created in the past
+    const liveDeployId = "dpl_live_secret";
+    await env.db.insert(deployments).values({
+      id: liveDeployId,
+      project_id: project.id,
+      status: "live",
+      manifest: JSON.stringify(manifest),
+      asset_hashes: JSON.stringify(assetManifest),
+      created_at: sql`now() - interval '1 hour'`,
     });
+    await env.db
+      .update(projects)
+      .set({ active_deployment_id: liveDeployId })
+      .where(eq(projects.id, project.id));
+
+    // Add a secret AFTER the deployment — secrets API already pushed it to the worker
+    await createTestProjectSecret(env.db, env, project.id, "API_KEY", "secret-value");
+
+    // Deploy with the same manifest — should still be skipped
+    const form = buildDeployForm({ manifest, assets: { "index.html": "<h1>hi</h1>" } });
+    form.append("assetManifest", JSON.stringify(assetManifest));
+    form.append("preflight", "true");
+
+    // No CF API mock needed — deploy should be skipped entirely
+    const res = await app.fetch(
+      new Request(`http://localhost/projects/${project.id}/deploy`, {
+        method: "POST",
+        headers: { Authorization: `Bearer ${user.jwt}` },
+        body: form,
+      }),
+      env,
+    );
+
+    expect(res.status).toBe(200);
+    const events = parseDeployStream(await res.text());
+    expect(events).toHaveLength(2); // start + done only
+    expect(events[0]).toMatchObject({ event: "start", deploymentId: liveDeployId });
+    expect(events[1]).toMatchObject({ event: "done", deployment: liveDeployId });
+  });
+
+  it("proceeds with deploy when manifest differs from live deployment", async () => {
+    const user = await createTestUser(env.db);
+    const project = await createTestProject(env.db, user.id, "dedupe-manifest-app");
+    mockCfApi();
+
+    // Insert a live deployment with a different manifest
+    const liveDeployId = "dpl_live_diff";
+    await env.db.insert(deployments).values({
+      id: liveDeployId,
+      project_id: project.id,
+      status: "live",
+      manifest: JSON.stringify({ version: 3, bindings: { d1: ["DB"] } }),
+      asset_hashes: JSON.stringify(assetManifest),
+      created_at: sql`now()`,
+    });
+    await env.db
+      .update(projects)
+      .set({ active_deployment_id: liveDeployId })
+      .where(eq(projects.id, project.id));
+
+    // Deploy with a different manifest (no d1 binding)
+    const form = buildDeployForm({ manifest, assets: { "index.html": "<h1>hi</h1>" } });
+    form.append("assetManifest", JSON.stringify(assetManifest));
+    form.append("preflight", "true");
+
+    const res = await app.fetch(
+      new Request(`http://localhost/projects/${project.id}/deploy`, {
+        method: "POST",
+        headers: { Authorization: `Bearer ${user.jwt}` },
+        body: form,
+      }),
+      env,
+    );
+
+    expect(res.status).toBe(200);
+    const events = parseDeployStream(await res.text());
+    expect(events.length).toBeGreaterThan(2);
+    expect(events.at(-1)).toMatchObject({ event: "done" });
   });
 });