feat(image): complete reviewed generation delivery

mindspace-image-generation.test.mjs

@@ -3,6 +3,21 @@ import fs from 'node:fs';
 import test from 'node:test';
 import { createMindSpaceImageGenerationService } from './mindspace-image-generation.mjs';
 
+function passingReviewService(overrides = {}) {
+  return {
+    async review() {
+      return {
+        ok: true,
+        pass: true,
+        verdict: 'pass',
+        relevanceScore: 92,
+        minimumScore: 70,
+        ...overrides,
+      };
+    },
+  };
+}
+
 test('MindSpace asset schema accepts image_make as a source type', () => {
   const schemaSql = fs.readFileSync(new URL('./schema.sql', import.meta.url), 'utf8');
   const dbSource = fs.readFileSync(new URL('./db.mjs', import.meta.url), 'utf8');
@@ -44,18 +59,31 @@ test('MindSpace image generation stores the result before acknowledging temporar
       },
       async acknowledge(jobId, assetId) { order.push(['ack', jobId, assetId]); },
     },
+    imageReviewService: {
+      async review() {
+        order.push(['review']);
+        return passingReviewService().review();
+      },
+    },
     assetService: {
       async createChatAsset(userId, input) {
         order.push(['store', userId, input.sourceType, input.categoryCode]);
-        return { id: 'asset-1', publicUrl: 'https://example.test/image.webp' };
+        return {
+          id: 'asset-1',
+          publicUrl: 'https://example.test/image.webp',
+          workspaceRelativePath: 'public/images/2026-07-20/hero.webp',
+        };
       },
     },
   });
   const result = await service.generate({ userId: 'user-1', purpose: 'hero', prompt: 'x' });
   assert.equal(result.ok, true);
   assert.equal(result.asset.id, 'asset-1');
+  assert.equal(result.asset.workspaceRelativePath, 'public/images/2026-07-20/hero.webp');
+  assert.equal(result.asset.htmlSrc, 'images/2026-07-20/hero.webp');
   assert.deepEqual(order, [
     ['generate', 'memind_dark_hero'],
+    ['review'],
     ['store', 'user-1', 'image_make', 'public'],
     ['ack', 'job-1', 'asset-1'],
   ]);
@@ -76,3 +104,173 @@ test('MindSpace image generation converts provider failures into an explicit fal
     message: '图片生成暂不可用，已保留原有流程',
   });
 });
+
+test('MindSpace image generation does not return success without an HTML-ready source path', async () => {
+  const service = createMindSpaceImageGenerationService({
+    configService: { async resolveImageGenerationPurpose() { return { ok: true, presetId: 'x' }; } },
+    assetService: { async createChatAsset() { return { id: 'asset-1' }; } },
+    imageMakeClient: {
+      async generateImage() {
+        return {
+          jobId: 'job-1', buffer: Buffer.from('image'), mimeType: 'image/webp',
+          sha256: 'abc', width: 512, height: 512,
+        };
+      },
+      async acknowledge() {},
+    },
+    imageReviewService: passingReviewService(),
+    logger: { warn() {} },
+  });
+
+  const result = await service.generate({ userId: 'user-1', purpose: 'hero', prompt: 'x' });
+  assert.deepEqual(result, {
+    ok: false,
+    fallback: true,
+    code: 'IMAGE_ASSET_PATH_UNAVAILABLE',
+    message: '图片生成暂不可用，已保留原有流程',
+  });
+});
+
+test('MindSpace image generation applies an optional per-purpose size override', async () => {
+  let request = null;
+  const service = createMindSpaceImageGenerationService({
+    configService: { async resolveImageGenerationPurpose() { return { ok: true, presetId: 'memind_dark_hero' }; } },
+    assetService: {
+      async createChatAsset() {
+        return { id: 'asset-1', workspaceRelativePath: 'public/images/2026-07-20/hero.webp' };
+      },
+    },
+    imageMakeClient: {
+      async generateImage(input) {
+        request = input;
+        return {
+          jobId: 'job-1', buffer: Buffer.from('image'), mimeType: 'image/webp',
+          sha256: 'abc', width: input.width, height: input.height,
+        };
+      },
+      async acknowledge() {},
+    },
+    imageReviewService: passingReviewService(),
+    env: { IMAGE_MAKE_HERO_WIDTH: '768', IMAGE_MAKE_HERO_HEIGHT: '432' },
+  });
+
+  const result = await service.generate({ userId: 'user-1', purpose: 'hero', prompt: 'x' });
+  assert.equal(result.ok, true);
+  assert.equal(request.width, 768);
+  assert.equal(request.height, 432);
+});
+
+test('MindSpace image generation retries a semantic mismatch and stores only a reviewed result', async () => {
+  const generatedRequests = [];
+  let reviewCount = 0;
+  let storeCount = 0;
+  const service = createMindSpaceImageGenerationService({
+    configService: { async resolveImageGenerationPurpose() { return { ok: true, presetId: 'hero' }; } },
+    assetService: {
+      async createChatAsset() {
+        storeCount += 1;
+        return { id: 'asset-pass', workspaceRelativePath: 'public/images/hero-pass.webp' };
+      },
+    },
+    imageMakeClient: {
+      async generateImage(input) {
+        generatedRequests.push(input);
+        return {
+          jobId: `job-${generatedRequests.length}`,
+          buffer: Buffer.from(`image-${generatedRequests.length}`),
+          mimeType: 'image/webp', sha256: 'abc', width: 768, height: 432,
+        };
+      },
+      async acknowledge() {},
+    },
+    imageReviewService: {
+      async review() {
+        reviewCount += 1;
+        if (reviewCount === 1) {
+          return {
+            ok: true, pass: false, verdict: 'reject', relevanceScore: 0, minimumScore: 70,
+            observedSubjects: ['人物', '沙发'],
+            missingRequiredElements: ['竹海'],
+            reason: '主体不符',
+          };
+        }
+        return passingReviewService().review();
+      },
+    },
+    env: { IMAGE_MAKE_SEMANTIC_REVIEW_MAX_ATTEMPTS: '3' },
+    logger: { warn() {} },
+  });
+
+  const result = await service.generate({
+    userId: 'user-1', purpose: 'hero', prompt: '安吉竹海', idempotencyKey: 'imgreq-review',
+  });
+  assert.equal(result.ok, true);
+  assert.equal(result.jobId, 'job-2');
+  assert.equal(storeCount, 1);
+  assert.equal(generatedRequests.length, 2);
+  assert.equal(generatedRequests[0].idempotencyKey, 'imgreq-review');
+  assert.equal(generatedRequests[1].idempotencyKey, 'imgreq-review-review-2');
+  assert.match(generatedRequests[1].prompt, /必须修正上次错误/);
+  assert.match(generatedRequests[1].prompt, /缺失元素：竹海/);
+});
+
+test('MindSpace image generation blocks storage after all semantic review attempts fail', async () => {
+  let generateCount = 0;
+  let storeCount = 0;
+  const service = createMindSpaceImageGenerationService({
+    configService: { async resolveImageGenerationPurpose() { return { ok: true, presetId: 'hero' }; } },
+    assetService: { async createChatAsset() { storeCount += 1; } },
+    imageMakeClient: {
+      async generateImage() {
+        generateCount += 1;
+        return {
+          jobId: `job-${generateCount}`, buffer: Buffer.from('bad'), mimeType: 'image/webp',
+          sha256: 'abc', width: 768, height: 432,
+        };
+      },
+    },
+    imageReviewService: {
+      async review() {
+        return {
+          ok: true, pass: false, verdict: 'reject', relevanceScore: 5, minimumScore: 70,
+          observedSubjects: ['人物'], missingRequiredElements: ['竹海'], reason: '图文不符',
+        };
+      },
+    },
+    env: { IMAGE_MAKE_SEMANTIC_REVIEW_MAX_ATTEMPTS: '2' },
+    logger: { warn() {} },
+  });
+
+  const result = await service.generate({ userId: 'user-1', purpose: 'hero', prompt: '安吉竹海' });
+  assert.deepEqual(result, {
+    ok: false,
+    fallback: true,
+    code: 'IMAGE_SEMANTIC_MISMATCH',
+    message: '生成图片与页面内容不符，已阻止使用',
+  });
+  assert.equal(generateCount, 2);
+  assert.equal(storeCount, 0);
+});
+
+test('MindSpace image generation fails closed when semantic review is unavailable', async () => {
+  let storeCount = 0;
+  const service = createMindSpaceImageGenerationService({
+    configService: { async resolveImageGenerationPurpose() { return { ok: true, presetId: 'hero' }; } },
+    assetService: { async createChatAsset() { storeCount += 1; } },
+    imageMakeClient: {
+      async generateImage() {
+        return {
+          jobId: 'job-1', buffer: Buffer.from('image'), mimeType: 'image/webp',
+          sha256: 'abc', width: 768, height: 432,
+        };
+      },
+    },
+    imageReviewService: { async review() { return { ok: false, code: 'IMAGE_REVIEW_UNAVAILABLE' }; } },
+    logger: { warn() {} },
+  });
+
+  const result = await service.generate({ userId: 'user-1', purpose: 'hero', prompt: '安吉竹海' });
+  assert.equal(result.ok, false);
+  assert.equal(result.code, 'IMAGE_REVIEW_UNAVAILABLE');
+  assert.equal(storeCount, 0);
+});