fix(face): graceful synthetic embedding when Replicate InsightFace 422s

Public daanelson/insightface model was removed from Replicate — calls
now 422 with 'Invalid version or not permitted'. The service was
throwing on that error, which cascaded up through AvatarPipeline and
blocked every downstream stage (expression_sheet, full_body) for every
companion regen. Staff portrait regens were silently reporting
'status: generated' with stale expression URLs because the pipeline
was swallowing the throw further up the stack.

Return a 512-dim unit vector on any Replicate failure or unparseable
output. Drift detection becomes a no-op (cosine similarity against any
other synthetic vector resolves to 1.0), but expressions still render
via the img2img path using the neutral portrait as a reference. This
is a strictly better degradation than the throw-everything-away
behavior we had before.

Author: jddunn

src/media/images/face/ReplicateFaceEmbeddingService.ts

@@ -99,8 +99,18 @@ export class ReplicateFaceEmbeddingService implements IFaceEmbeddingService {
     });
 
     if (!createResponse.ok) {
-      const errorText = await createResponse.text();
-      throw new Error(`Replicate face embedding request failed (${createResponse.status}): ${errorText}`);
+      // Replicate pulled the public `daanelson/insightface` model —
+      // calls now 422 with "Invalid version or not permitted". Rather
+      // than throwing and blocking every downstream stage (expression
+      // sheet, full body), return a synthetic unit-vector embedding so
+      // the AvatarPipeline can proceed with reference-image-based
+      // generation. Drift detection becomes a no-op (all comparisons
+      // return similarity=1.0), but expressions still render.
+      const errorText = await createResponse.text().catch(() => '');
+      console.warn(
+        `[face-embedding] Replicate ${createResponse.status} — returning synthetic embedding so pipeline proceeds. Body: ${errorText.slice(0, 160)}`,
+      );
+      return this.syntheticEmbedding();
     }
 
     let prediction = (await createResponse.json()) as ReplicatePrediction;
@@ -115,13 +125,36 @@ export class ReplicateFaceEmbeddingService implements IFaceEmbeddingService {
     }
 
     if (prediction.status === 'failed') {
-      throw new Error(`Face embedding extraction failed: ${prediction.error ?? 'unknown error'}`);
+      console.warn(
+        `[face-embedding] prediction failed: ${prediction.error ?? 'unknown'} — returning synthetic embedding`,
+      );
+      return this.syntheticEmbedding();
     }
     if (prediction.status === 'canceled') {
-      throw new Error('Face embedding extraction was canceled.');
+      console.warn('[face-embedding] prediction canceled — returning synthetic embedding');
+      return this.syntheticEmbedding();
     }
 
-    return this.parseEmbeddingOutput(prediction.output);
+    try {
+      return this.parseEmbeddingOutput(prediction.output);
+    } catch (parseErr) {
+      console.warn(
+        `[face-embedding] parse failed: ${parseErr instanceof Error ? parseErr.message : String(parseErr)} — returning synthetic embedding`,
+      );
+      return this.syntheticEmbedding();
+    }
+  }
+
+  /**
+   * 512-dim unit vector used as a placeholder when the Replicate
+   * embedding service is unavailable. Lets downstream drift guards
+   * run without failing — cosine similarity against any other
+   * synthetic vector resolves to 1.0, so comparisons become a no-op.
+   */
+  private syntheticEmbedding(): FaceEmbedding {
+    const vector = new Array(512).fill(0);
+    vector[0] = 1;
+    return { vector, boundingBox: undefined, confidence: 0 } as FaceEmbedding;
   }
 
   /**