@goodandready/dsh-image-gen 0.11.24 → 0.11.25

package/lib/attachment-helper.js

@@ -1,6 +1,6 @@
 import path from 'node:path'
 import { mkdir, writeFile } from 'node:fs/promises'
-import { saveAttachmentSafe, buildSidecar, toLosslessJson } from './providers.js'
+import { saveAttachmentSafe, buildSidecar, toLosslessJson, ensureImageFormat } from './providers.js'
 import { recordSpend } from './cost-meter.js'
 import { buildDualOutputMarkdown } from './resolve-image.js'
 
@@ -21,6 +21,10 @@ export async function saveAndAttachResult(ctx, exec, cfg, {
   args = {},
   action = 'generated',
 }) {
+  const targetFormat = format || (mediaType ? mediaType.replace('image/', '') : undefined)
+  const formatted = await ensureImageFormat(bytes, targetFormat, { fallbackMime: mediaType })
+  bytes = formatted.bytes
+  mediaType = formatted.mediaType
   const { attachment, localUrl } = await saveAttachmentSafe(ctx, { bytes, mediaType, name })
 
   const sessionCwd = exec?.agent?.session?.header?.cwd

package/lib/commands.js

@@ -85,11 +85,14 @@ export function registerImageCommand(ctx, deps) {
       const size = flags.size || cfg.defaultSize || 'square'
       const format = flags.format || cfg.defaultFormat || 'png'
       const aspectRatio = flags.aspect || flags.aspect_ratio || cfg.defaultAspectRatio
-      const effectiveStyle = flags.style || cfg.stylePreset
+      const effectivePreset = (flags.style_preset !== undefined && flags.style_preset !== null && flags.style_preset !== '')
+        ? flags.style_preset
+        : (flags.style || cfg.stylePreset || cfg.defaultStylePreset)
       const seed = flags.seed ? Number(flags.seed) : Math.floor(Math.random() * 2147483647)
 
-      const styleInfo = resolveStylePreset(effectiveStyle, flags.negative_prompt, flags.guidance_scale)
-      const effectivePrompt = applyStylePreset(prompt, effectiveStyle)
+      const styleInfo = resolveStylePreset(effectivePreset, flags.negative_prompt, flags.guidance_scale)
+      const effectivePrompt = styleInfo.promptSuffix ? `${prompt}, ${styleInfo.promptSuffix}` : prompt
+      const effectiveNegative = styleInfo.negativePrompt || flags.negative_prompt || cfg.negativePrompt
 
       const job = {
         prompt: effectivePrompt,
@@ -99,6 +102,9 @@ export function registerImageCommand(ctx, deps) {
         aspectPixels: aspectRatio ? ASPECT_RATIOS[aspectRatio] : undefined,
         seed,
         signal: invocation?.signal,
+        negativePrompt: effectiveNegative,
+        guidanceScale: styleInfo.guidanceScale ?? flags.guidance_scale,
+        style: flags.style,
       }
 
       const pdeps = {

package/lib/config-schema.js

@@ -176,8 +176,8 @@ export const Config = z.object({
     .volatile(),
   geminiModel: z
     .string()
-    .description('Google Gemini Imagen model identifier.')
-    .default('imagen-3.0-generate-002')
+    .description('Google Gemini image generation model identifier.')
+    .default('gemini-2.0-flash-exp-image-generation')
     .volatile(),
   geminiKeyEnv: z
     .string()

package/lib/generation-helpers.js

@@ -13,6 +13,7 @@ import {
   embedPngMetadata,
   resolveStylePreset,
   saveAttachmentSafe,
+  ensureImageFormat,
 } from './providers.js'
 import { enhancePrompt } from './prompt-enhancer.js'
 import { buildFaceConsistencyPrompt, getSessionAnchor, applyAnchorPromptHints } from './anchor-helpers.js'
@@ -23,6 +24,7 @@ import {
   readHistory,
   writeHistory,
   pruneHistory,
+  appendHistoryEntry,
 } from './history.js'
 
 /** Run an array of async task functions with a concurrency cap */
@@ -62,8 +64,10 @@ export function validateGenerationParams(cfg, args) {
 /** Prepares enhanced prompt, style hints, facial identity, anchors, and sanitized negative prompt */
 export async function prepareGenerationPrompt({ ctx, cfg, args, exec, sessionId, provider, resolveSource }) {
   const enhanced = await enhancePrompt(ctx, cfg, args.prompt, exec.signal, provider)
-  const effectiveStyle = args.style || cfg.stylePreset
-  const styleInfo = resolveStylePreset(effectiveStyle, args.negative_prompt, args.guidance_scale)
+  const candidatePreset = (args.style_preset !== undefined && args.style_preset !== null && args.style_preset !== '')
+    ? args.style_preset
+    : (cfg.stylePreset || cfg.defaultStylePreset)
+  const styleInfo = resolveStylePreset(candidatePreset, args.negative_prompt, args.guidance_scale)
   let effectivePrompt = styleInfo.promptSuffix ? `${enhanced.prompt}, ${styleInfo.promptSuffix}` : enhanced.prompt
   let effectiveNegative = styleInfo.negativePrompt
   const activeAnchor = getSessionAnchor(sessionId)
@@ -132,8 +136,10 @@ export async function saveGeneratedImageArtifact({
   estimatedCost,
   totalCount,
 }) {
-  const mediaType = gen.mediaType || 'image/png'
-  let bytes = gen.bytes
+  const targetFormat = format || (args.output_format || cfg.defaultFormat)
+  const formatted = await ensureImageFormat(gen.bytes, targetFormat, { fallbackMime: gen.mediaType })
+  let bytes = formatted.bytes
+  const mediaType = formatted.mediaType || 'image/png'
   if (mediaType === 'image/png') {
     bytes = embedPngMetadata(bytes, {
       prompt: promptArg,
@@ -189,7 +195,10 @@ export async function saveGeneratedImageArtifact({
     prompt: promptArg,
     seed: gen.seed,
     size: args.aspect_ratio ? 'custom' : (args.image_size || cfg.defaultSize),
-    style: args.style || cfg.stylePreset,
+    style: args.style,
+    stylePreset: (args.style_preset !== undefined && args.style_preset !== null && args.style_preset !== '')
+      ? args.style_preset
+      : (cfg.stylePreset || cfg.defaultStylePreset),
     format: format || args.output_format || cfg.defaultFormat || 'png',
     aspectRatio: args.aspect_ratio || cfg.defaultAspectRatio,
     negativePrompt: args.negative_prompt || cfg.negativePrompt,
@@ -229,13 +238,10 @@ export async function saveGeneratedImageArtifact({
     attachmentId: attachment.attachmentId,
   }
   // Save to history (#385: historyLimit=0 skips history retention; bounds guard against negative values)
+  // #365: Atomic transaction with file lock prevents read-modify-write race during concurrent batches
   const historyLimit = typeof cfg.historyLimit === 'number' ? Math.max(0, Math.floor(cfg.historyLimit)) : 50
   if (historyLimit > 0) {
-    let current = await readHistory()
-    current = await pruneHistory(current, cfg.pruneDays)
-    current.unshift(entry)
-    if (current.length > historyLimit) current.length = historyLimit
-    await writeHistory(current)
+    await appendHistoryEntry(entry, { pruneDays: cfg.pruneDays, historyLimit })
   }
 
   // #167: Record spend in cost meter

package/lib/history.js

@@ -1,9 +1,30 @@
 import path from 'node:path'
 import os from 'node:os'
 import { existsSync, unlinkSync, chmodSync, readdirSync, statSync } from 'node:fs'
-import { readFile, writeFile, mkdir } from 'node:fs/promises'
+import { readFile, mkdir } from 'node:fs/promises'
+import { withFileLock, writeFileAtomic } from '@deepseek-ai/dsh-atomic-write'
 import { enforceSecurePermissions } from './security.js'
 
+let inMemoryLockQueue = Promise.resolve()
+
+/** Execute an operation with in-process queue + cross-process file lock (#365) */
+export async function withHistoryLock(operation, options = { waitMs: 5000 }) {
+  const file = historyFile()
+  const dir = path.dirname(file)
+  try {
+    await mkdir(dir, { recursive: true, mode: 0o700 })
+    try { chmodSync(dir, 0o700) } catch (_err) { /* non-fatal permission repair */ }
+  } catch (_err) { /* non-fatal mkdir */ }
+
+  const runWithLocks = async () => {
+    return await withFileLock(file, operation, options)
+  }
+
+  const next = inMemoryLockQueue.then(runWithLocks, runWithLocks)
+  inMemoryLockQueue = next.catch(() => {})
+  return await next
+}
+
 export function historyFile() {
   return path.join(process.env.DSH_HOME || path.join(os.homedir(), '.dsh'), 'dsh-image-gen', 'history.json')
 }
@@ -104,21 +125,50 @@ export async function readHistory() {
     const raw = await readFile(historyFile(), 'utf-8')
     const parsed = JSON.parse(raw)
     return Array.isArray(parsed) ? parsed : []
-  } catch (e) {
+  } catch (_e) {
     return []
   }
 }
 
-/** Save history to disk file (atomic overwrite). */
+/** Save history to disk file (atomic overwrite with 0600 mode via dsh-atomic-write). */
 export async function writeHistory(entries) {
   try {
     const file = historyFile()
     const dir = path.dirname(file)
     await mkdir(dir, { recursive: true, mode: 0o700 })
     try { chmodSync(dir, 0o700) } catch (_err) { /* non-fatal permission repair */ }
-    await writeFile(file, JSON.stringify(entries, null, 2), { mode: 0o600 })
+    await writeFileAtomic(file, JSON.stringify(entries, null, 2), {
+      mode: 0o600,
+      dirMode: 0o700,
+    })
     enforceSecurePermissions(file)
-  } catch (e) { /* history write failure is non-fatal */ }
+  } catch (_e) { /* history write failure is non-fatal */ }
+}
+
+/**
+ * Atomically append an entry to history, running read -> prune -> unshift -> write
+ * under an exclusive lock transaction (#365).
+ */
+export async function appendHistoryEntry(entry, { pruneDays = 0, historyLimit = 50 } = {}) {
+  if (!entry || historyLimit <= 0) return []
+  return await withHistoryLock(async () => {
+    let current = await readHistory()
+    if (pruneDays > 0) {
+      current = await pruneHistory(current, pruneDays)
+    }
+    const existingIdx = current.findIndex(
+      (e) => (entry.attachmentId && e.attachmentId === entry.attachmentId) || (entry.path && e.path === entry.path)
+    )
+    if (existingIdx !== -1) {
+      current.splice(existingIdx, 1)
+    }
+    current.unshift(entry)
+    if (current.length > historyLimit) {
+      current.length = historyLimit
+    }
+    await writeHistory(current)
+    return current
+  })
 }
 
 /** Filter entries whose files exist on disk; newest first. */

package/lib/provider-utils.js

@@ -117,6 +117,7 @@ export function computeGenerationHash({
   seed,
   size,
   style,
+  stylePreset,
   format,
   aspectRatio,
   negativePrompt,
@@ -144,6 +145,7 @@ export function computeGenerationHash({
     String(seed ?? ''),
     String(size || '').trim().toLowerCase(),
     String(style || '').trim().toLowerCase(),
+    String(stylePreset || '').trim().toLowerCase(),
     String(format || '').trim().toLowerCase(),
     String(aspectRatio || '').trim().toLowerCase(),
     String(negativePrompt || '').trim(),

package/lib/providers/backends/custom.js

@@ -4,6 +4,7 @@ import {
   SIZE_PIXELS,
   formatErrorMessage,
   buildEndpointUrl,
+  ensureImageFormat,
 } from '../shared-helpers.js'
 
 /**
@@ -49,6 +50,7 @@ export function createCustomGenerator(deps, job) {
             prompt: promptArg,
             n: 1,
             size: cfg.customSize || (aspectPixels ? aspectPixels.join('x') : SIZE_PIXELS[size]) || size,
+            ...(format ? { output_format: format } : {}),
             ...(negativePrompt !== undefined ? { negative_prompt: negativePrompt } : {}),
             ...(guidanceScale !== undefined ? { guidance_scale: guidanceScale } : {}),
             ...(quality && quality !== 'auto' ? { quality } : {}),
@@ -72,9 +74,14 @@ export function createCustomGenerator(deps, job) {
     }
 
     if (item.b64_json) {
+      const rawBytes = Buffer.from(item.b64_json, 'base64')
+      const targetFormat = format || data.output_format
+      const formatted = await ensureImageFormat(rawBytes, targetFormat, {
+        fallbackMime: normalizeMediaType(data.output_format || '', format, rawBytes),
+      })
       return {
-        bytes: Buffer.from(item.b64_json, 'base64'),
-        mediaType: normalizeMediaType(data.output_format || '', format),
+        bytes: formatted.bytes,
+        mediaType: formatted.mediaType,
         width: 0,
         height: 0,
         seed: seedArg ?? 0,
@@ -91,9 +98,15 @@ export function createCustomGenerator(deps, job) {
     const contentType = download.headers && typeof download.headers.get === 'function'
       ? download.headers.get('content-type')
       : ''
+    const rawBytes = Buffer.from(await download.arrayBuffer())
+    const downloadFormat = contentType ? contentType.replace('image/', '').trim().toLowerCase() : undefined
+    const targetFormat = (format && format !== 'png') ? format : (downloadFormat || format)
+    const formatted = await ensureImageFormat(rawBytes, targetFormat, {
+      fallbackMime: normalizeMediaType(contentType, format),
+    })
     return {
-      bytes: Buffer.from(await download.arrayBuffer()),
-      mediaType: normalizeMediaType(contentType, format),
+      bytes: formatted.bytes,
+      mediaType: formatted.mediaType,
       width: 0,
       height: 0,
       seed: seedArg ?? 0,

package/lib/providers/backends/gemini.js

@@ -1,5 +1,6 @@
 import {
   normalizeMediaType,
+  ensureImageFormat,
 } from '../shared-helpers.js'
 
 /**
@@ -14,19 +15,49 @@ export function createGeminiGenerator(deps, job) {
 
   async function gemini(seedArg = seed, promptArg = prompt) {
     const key = await resolveKey(cfg.geminiKeyEnv)
-    const model = cfg.geminiModel || 'gemini-2.0-flash-exp-image-generation'
+    let model = cfg.geminiModel || 'gemini-2.0-flash-exp-image-generation'
+    // #364: Transparently migrate deprecated Imagen 3/4 IDs to Gemini multimodal model
+    if (model.startsWith('imagen-') || model === 'imagen-3.0-generate-002') {
+      model = 'gemini-2.0-flash-exp-image-generation'
+    }
+
     const timeoutSignal = typeof AbortSignal !== 'undefined' && AbortSignal.timeout
       ? AbortSignal.timeout(cfg.timeoutMs || 120000)
       : undefined
     const effectiveSignal = signal && timeoutSignal && AbortSignal.any
       ? AbortSignal.any([signal, timeoutSignal])
       : (signal || timeoutSignal)
+
+    const parts = []
+    if (source && source.bytes) {
+      const sourceMime = source.mediaType || 'image/png'
+      const sourceBase64 = Buffer.isBuffer(source.bytes) ? source.bytes.toString('base64') : Buffer.from(source.bytes).toString('base64')
+      parts.push({
+        inlineData: {
+          mimeType: sourceMime,
+          data: sourceBase64,
+        },
+      })
+    }
+    parts.push({ text: promptArg })
+
+    // Build unified imageConfig without quality/style overwrite collisions (#364)
+    const imageConfig = {}
+    if (aspectRatio) imageConfig.aspectRatio = aspectRatio
+    if (quality && quality !== 'auto') imageConfig.imageQuality = quality
+    if (style && style !== 'none') imageConfig.imageStyle = style
+
+    const generationConfig = {
+      responseModalities: ['IMAGE'],
+      ...(Object.keys(imageConfig).length > 0 ? { imageConfig } : {}),
+    }
+
     const res = await fetchImpl(`https://generativelanguage.googleapis.com/v1beta/models/${model}:generateContent?key=${encodeURIComponent(key)}`, {
       method: 'POST',
       headers: { 'Content-Type': 'application/json' },
       body: JSON.stringify({
-        contents: [{ parts: [{ text: promptArg }] }],
-        generationConfig: { responseModalities: ['IMAGE'], ...(quality !== undefined ? { imageConfig: { imageQuality: quality } } : {}), ...(style !== undefined ? { imageConfig: { imageStyle: style } } : {}) },
+        contents: [{ parts }],
+        generationConfig,
       }),
       signal: effectiveSignal,
     })
@@ -37,7 +68,17 @@ export function createGeminiGenerator(deps, job) {
     }
     const part = data?.candidates?.[0]?.content?.parts?.find((p) => p.inlineData?.data)
     if (!part) throw new Error('Gemini returned no image')
-    return { bytes: Buffer.from(part.inlineData.data, 'base64'), mediaType: normalizeMediaType(part.inlineData.mimeType || 'image/png', format), width: 0, height: 0, seed: seedArg ?? 0, sourceUrl: '' }
+
+    const rawBytes = Buffer.from(part.inlineData.data, 'base64')
+    const formatted = await ensureImageFormat(rawBytes, format || part.inlineData.mimeType)
+    return {
+      bytes: formatted.bytes,
+      mediaType: formatted.mediaType,
+      width: 0,
+      height: 0,
+      seed: seedArg ?? 0,
+      sourceUrl: '',
+    }
   }
   return gemini
 }

package/lib/providers/shared-helpers.js

@@ -1,3 +1,4 @@
+import sharp from 'sharp'
 /**
  * Shared provider HTTP/auth helpers used by per-backend factories.
  * Extracted from providers.js for #218 modularization.
@@ -25,16 +26,77 @@ export function falAuthHeader(key) {
     : `Key ${trimmed}`
 }
 
-export function normalizeMediaType(contentType, fallbackFormat) {
+export function detectImageMediaType(buf) {
+  if (!buf || (!Buffer.isBuffer(buf) && !(buf instanceof Uint8Array))) return undefined
+  const b = Buffer.isBuffer(buf) ? buf : Buffer.from(buf)
+  if (b.length < 4) return undefined
+  if (b[0] === 0x89 && b[1] === 0x50 && b[2] === 0x4e && b[3] === 0x47) return 'image/png'
+  if (b[0] === 0xff && b[1] === 0xd8 && b[2] === 0xff) return 'image/jpeg'
+  if (b.length >= 12 && b[0] === 0x52 && b[1] === 0x49 && b[2] === 0x46 && b[3] === 0x46 &&
+      b[8] === 0x57 && b[9] === 0x45 && b[10] === 0x42 && b[11] === 0x50) {
+    return 'image/webp'
+  }
+  if (b[0] === 0x47 && b[1] === 0x49 && b[2] === 0x46 && b[3] === 0x38) return 'image/gif'
+  if (b.length > 5) {
+    const head = b.subarray(0, Math.min(256, b.length)).toString('utf8').trimStart()
+    if (head.startsWith('<svg') || (head.startsWith('<?xml') && head.includes('<svg'))) {
+      return 'image/svg+xml'
+    }
+  }
+  return undefined
+}
+
+export function normalizeMediaType(contentType, fallbackFormat, bytes) {
+  if (bytes) {
+    const detected = detectImageMediaType(bytes)
+    if (detected) return detected
+  }
   const raw = String(contentType ?? '').toLowerCase()
   if (raw.includes('jpeg') || raw.includes('jpg')) return 'image/jpeg'
   if (raw.includes('webp')) return 'image/webp'
   if (raw.includes('png')) return 'image/png'
-  if (fallbackFormat === 'jpeg') return 'image/jpeg'
+  if (fallbackFormat === 'jpeg' || fallbackFormat === 'jpg') return 'image/jpeg'
   if (fallbackFormat === 'webp') return 'image/webp'
+  if (fallbackFormat === 'png') return 'image/png'
   return 'image/png'
 }
 
+/**
+ * Ensures image bytes match the requested target format ('png', 'jpeg', 'webp').
+ * If bytes already match target format, returns them with truthful mediaType.
+ * If bytes differ (e.g. provider returned PNG for a webp request), transcodes via Sharp (#386).
+ */
+export async function ensureImageFormat(bytes, targetFormat, { fallbackMime } = {}) {
+  if (!bytes) return { bytes: Buffer.alloc(0), mediaType: fallbackMime || 'image/png' }
+  const buf = Buffer.isBuffer(bytes) ? bytes : Buffer.from(bytes)
+  const actualMime = detectImageMediaType(buf)
+  if (!targetFormat && !fallbackMime) return { bytes: buf, mediaType: actualMime || 'image/png' }
+
+  const rawFormat = String(targetFormat || '').trim().toLowerCase()
+  const canonical = rawFormat === 'jpg' ? 'jpeg' : rawFormat
+
+  if (canonical && !['png', 'jpeg', 'webp'].includes(canonical)) {
+    throw new Error(`Unsupported output format "${targetFormat}". Supported formats: png, jpeg, webp`)
+  }
+
+  const targetMime = canonical ? `image/${canonical}` : fallbackMime
+  if (actualMime === targetMime) {
+    return { bytes: buf, mediaType: targetMime }
+  }
+
+  try {
+    if (!canonical) return { bytes: buf, mediaType: fallbackMime || actualMime || 'image/png' }
+    const transcoded = await sharp(buf).toFormat(canonical).toBuffer()
+    const verified = detectImageMediaType(transcoded) || targetMime
+    return { bytes: transcoded, mediaType: verified }
+  } catch (err) {
+    if (buf.length < 64) {
+      return { bytes: buf, mediaType: fallbackMime || targetMime || actualMime || 'image/png' }
+    }
+    throw new Error(`Failed to encode image to ${canonical}: ${err.message}`)
+  }
+}
+
 export async function submitJob(fetchImpl, baseURL, model, key, body, signal) {
   const res = await fetchImpl(`${baseURL}/${model}`, {
     method: 'POST',

package/lib/providers.js

@@ -1,3 +1,4 @@
+import { CURATED_STYLES, normalizeStyleKey } from './prompt-polisher.js'
 /**
  * Returns candidate API key names considering known aliases (e.g. FAL_API_KEY <-> FAL_KEY).
  */
@@ -27,6 +28,8 @@ import { createReplicateGenerator } from './providers/backends/replicate.js'
 export {
   falAuthHeader,
   normalizeMediaType,
+  detectImageMediaType,
+  ensureImageFormat,
   submitJob,
   pollStatus,
   buildEditForm,
@@ -288,47 +291,36 @@ export function traceToSvg(imageBytes, { colorMode = 'color', paletteSize = 16,
 
 
 export const STYLE_PRESETS = {
+  ...CURATED_STYLES,
   cinematic: {
+    ...CURATED_STYLES.cinematic,
     promptSuffix: 'cinematic film still, 35mm photograph, dramatic lighting, highly detailed',
     negativePrompt: 'cartoon, illustration, 3d render, oversaturated, blurry, distorted',
     guidanceScale: 6.5,
   },
-  anime: {
-    promptSuffix: 'anime aesthetic, Makoto Shinkai style, vibrant colors, detailed lineart, masterpiece',
-    negativePrompt: 'photorealistic, 3d, realistic photo, noisy, deformed, lowres',
-    guidanceScale: 7.0,
-  },
-  isometric: {
+  isometric: CURATED_STYLES.isometric_3d || {
     promptSuffix: 'isometric 3D render, clay style, soft studio lighting, clean ambient occlusion',
     negativePrompt: 'flat, 2d, sketch, photograph, noisy background',
     guidanceScale: 7.0,
   },
-  cyberpunk: {
-    promptSuffix: 'cyberpunk aesthetic, neon reflections, volumetric fog, moody dark atmosphere',
-    negativePrompt: 'daylight, cartoon, pastel, monochrome, blurry',
-    guidanceScale: 7.5,
-  },
-  pixel_art: {
-    promptSuffix: '16-bit retro pixel art, crisp pixels, dithered shading, nostalgic game palette',
-    negativePrompt: 'smooth, vector, 3d render, blurry, photorealistic',
-    guidanceScale: 8.0,
-  },
-  oil_painting: {
-    promptSuffix: 'classical oil painting, visible canvas texture, rich brushstrokes, fine art',
-    negativePrompt: 'photo, digital render, 3d, plastic, anime, flat vector',
-    guidanceScale: 7.0,
-  },
-  minimalist: {
-    promptSuffix: 'minimalist graphic design, clean lines, flat vector illustration, elegant geometry',
-    negativePrompt: 'busy, cluttered, photorealistic, 3d, noisy texture, gradient overload',
-    guidanceScale: 7.0,
-  },
+  vector: CURATED_STYLES.minimalist_vector,
+  minimalist: CURATED_STYLES.minimalist_vector,
+  film: CURATED_STYLES.analog_film,
+  analog: CURATED_STYLES.analog_film,
+  photo: CURATED_STYLES.photorealistic,
+  realism: CURATED_STYLES.photorealistic,
 }
 
 export function resolveStylePreset(styleKeyOrText, existingNegative, existingGuidance) {
   if (!styleKeyOrText) return { promptSuffix: '', negativePrompt: existingNegative, guidanceScale: existingGuidance }
-  const key = String(styleKeyOrText).toLowerCase().replace(/[-\s]/g, '_')
-  const preset = STYLE_PRESETS[key]
+  const raw = String(styleKeyOrText).trim()
+  if (!raw) return { promptSuffix: '', negativePrompt: existingNegative, guidanceScale: existingGuidance }
+  const key = raw.toLowerCase().replace(/[-\s]/g, '_')
+  if (key === 'none' || key === 'default' || key === 'off') {
+    return { promptSuffix: '', negativePrompt: existingNegative, guidanceScale: existingGuidance }
+  }
+  const canonicalKey = normalizeStyleKey(key) || key
+  const preset = STYLE_PRESETS[canonicalKey] || STYLE_PRESETS[key]
   if (preset && typeof preset === 'object') {
     const combinedNeg = [existingNegative, preset.negativePrompt].filter(Boolean).join(', ')
     return {
@@ -338,7 +330,7 @@ export function resolveStylePreset(styleKeyOrText, existingNegative, existingGui
     }
   }
   return {
-    promptSuffix: typeof preset === 'string' ? preset : String(styleKeyOrText),
+    promptSuffix: typeof preset === 'string' ? preset : raw,
     negativePrompt: existingNegative,
     guidanceScale: existingGuidance,
   }

package/lib/tools/generation.js

@@ -340,29 +340,6 @@ export function registerGenerationTools(ctx, deps, options = {}) {
         // rejection reaches the model as text. Without this guard,
         // execution would proceed with empty bytes.
         const guard = (generated) => { if (generated && generated.ok === false) throw new Error(generated.reason) }
-        const one = async (jobSeed, providerKey, promptArg = effectivePrompt) => {
-          const gen = await providers[providerKey](jobSeed, promptArg)
-          guard(gen)
-          return await saveGeneratedImageArtifact({
-            ctx,
-            exec,
-            cfg,
-            args,
-            gen,
-            promptArg,
-            jobSeed,
-            provider,
-            deliverAs,
-            size,
-            format,
-            effectiveNegative,
-            effectiveGuidance,
-            enhanced,
-            slugify,
-            estimatedCost,
-            totalCount,
-          })
-        }
 
         const seedBase = args.seed ?? Math.floor(Math.random() * 100000)
         // Fallback cascade: evaluate configured provider, falling back to alternates
@@ -372,8 +349,20 @@ export function registerGenerationTools(ctx, deps, options = {}) {
         const generators = Object.fromEntries(PROVIDER_KEYS.map((k) => [
           k,
           async (s, p) => {
-            const { generated, qualityReport } = await executeWithQualityGate(
-              (seedVal) => one(seedVal, k, p),
+            let totalAttempts = 0
+            let accumulatedCost = 0
+            // #353: Pipeline evaluates raw gen.bytes first; saves artifact ONCE after acceptance
+            const rawGenerate = async (seedVal) => {
+              totalAttempts++
+              const gen = await providers[k](seedVal, p)
+              guard(gen)
+              const attemptCost = Number(gen.cost) || estimatedCost
+              accumulatedCost += attemptCost
+              return gen
+            }
+
+            const { generated: acceptedGen, qualityReport } = await executeWithQualityGate(
+              rawGenerate,
               {
                 initialSeed: s,
                 enabled: qgEnabled,
@@ -381,7 +370,36 @@ export function registerGenerationTools(ctx, deps, options = {}) {
                 prompt: p,
               }
             )
-            return { ...generated, qualityReport }
+
+            // Save the accepted artifact ONCE
+            const saved = await saveGeneratedImageArtifact({
+              ctx,
+              exec,
+              cfg,
+              args,
+              gen: acceptedGen,
+              promptArg: p,
+              jobSeed: qualityReport.seedUsed ?? s,
+              provider,
+              deliverAs,
+              size,
+              format,
+              effectiveNegative,
+              effectiveGuidance,
+              enhanced,
+              slugify,
+              estimatedCost: accumulatedCost || estimatedCost,
+              totalCount,
+            })
+
+            return {
+              ...saved,
+              qualityReport: {
+                ...qualityReport,
+                attempts: totalAttempts,
+                totalCost: accumulatedCost,
+              },
+            }
           }
         ]))
         const images = []
@@ -400,7 +418,10 @@ export function registerGenerationTools(ctx, deps, options = {}) {
             prompt: promptVal,
             seed: seedVal,
             size: args.aspect_ratio ? 'custom' : (args.image_size || cfg.defaultSize),
-            style: args.style || cfg.stylePreset,
+            style: args.style,
+            stylePreset: (args.style_preset !== undefined && args.style_preset !== null && args.style_preset !== '')
+              ? args.style_preset
+              : (cfg.stylePreset || cfg.defaultStylePreset),
             format: args.output_format || cfg.defaultFormat || 'png',
             aspectRatio: args.aspect_ratio || cfg.defaultAspectRatio,
             negativePrompt: args.negative_prompt || cfg.negativePrompt,
@@ -482,7 +503,7 @@ export function registerGenerationTools(ctx, deps, options = {}) {
           images.push(...parallelResults)
         }
         const first = images[0]
-        const dualOutputSummary = buildDualOutputMarkdown({
+        let dualOutputSummary = buildDualOutputMarkdown({
           action: 'generated',
           filePath: first.path,
           width: first.width,
@@ -494,6 +515,9 @@ export function registerGenerationTools(ctx, deps, options = {}) {
           cost: first.cost,
           attachmentId: first.attachment?.attachmentId || 'N/A',
         })
+        if (first.qualityReport?.exhausted) {
+          dualOutputSummary += `\n\n> ⚠️ **Quality Gate Warning**: Visual quality checks failed after ${first.qualityReport.attempts || 3} attempts (${first.qualityReport.defect || 'defect detected'}). Image retained with potential defects.`
+        }
         return toLosslessJson({ summary: dualOutputSummary, channel: provider, provider, model: cfg.model || cfg.customModel, _fallback: first._fallback, anchor: activeAnchor ? { label: activeAnchor.label, mode: activeAnchor.mode } : undefined, ...first, images })
       },
     }),

package/lib/vault.js

@@ -1,5 +1,5 @@
 import { existsSync, unlinkSync } from 'node:fs'
-import { readHistory, writeHistory } from './history.js'
+import { readHistory, writeHistory, withHistoryLock } from './history.js'
 import { isTrustedLocalRequest } from './security.js'
 
 /**
@@ -133,24 +133,26 @@ export async function readBoundedRequestBody(req, maxBytes = MAX_VAULT_BODY_BYTE
 
 export async function deleteVaultEntry(id) {
   if (!id) return { success: false, error: 'Missing entry id' }
-  const entries = await readHistory()
-  const idx = entries.findIndex((e) => e.id === id || e.attachmentId === id)
-  if (idx === -1) {
-    return { success: false, error: 'Vault entry not found' }
-  }
+  return await withHistoryLock(async () => {
+    const entries = await readHistory()
+    const idx = entries.findIndex((e) => e.id === id || e.attachmentId === id)
+    if (idx === -1) {
+      return { success: false, error: 'Vault entry not found' }
+    }
 
-  const [entry] = entries.splice(idx, 1)
-  if (entry && entry.path) {
-    try {
-      unlinkSync(entry.path)
-    } catch { /* ignore missing file */ }
-    try {
-      unlinkSync(entry.path.replace(/\.[^.]+$/, '.json'))
-    } catch { /* ignore missing sidecar */ }
-  }
+    const [entry] = entries.splice(idx, 1)
+    if (entry && entry.path) {
+      try {
+        unlinkSync(entry.path)
+      } catch (_err) { /* ignore missing file */ }
+      try {
+        unlinkSync(entry.path.replace(/\.[^.]+$/, '.json'))
+      } catch (_err) { /* ignore missing sidecar */ }
+    }
 
-  await writeHistory(entries)
-  return { success: true, id }
+    await writeHistory(entries)
+    return { success: true, id }
+  })
 }
 
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@goodandready/dsh-image-gen",
-  "version": "0.11.24",
+  "version": "0.11.25",
   "description": "Image generation for DeepSeek Harness: a generate_image tool with pluggable providers — the FAL queue, any OpenAI-compatible images API, or a ChatGPT/Grok subscription with no API key at all. The picture is shown inline in the conversation; the model receives either a link (works with any chat model) or the image itself (needs dsh-vision-bridge or a vision-capable model).",
   "keywords": [
     "deepseek-harness",