@goodandready/dsh-image-gen 0.10.23 → 0.10.25

package/lib/register-tools.js

@@ -2,10 +2,15 @@
 // Each tool lives in lib/tools/* and is registered inside a labeled ctx.effect.
 
 import { registerGenerationTools } from './tools/generation.js'
-import { registerProcessingTools } from './tools/processing.js'
+import { registerProcessingTools } from './tools/processing-basic.js'
+import { registerProcessingAdvancedTools } from './tools/processing-advanced.js'
 import { registerEditingTools } from './tools/editing.js'
 import { registerInspectTools } from './tools/inspect.js'
 import { registerFrontendTools } from './tools/frontend.js'
+import { registerSketchTools } from './tools/sketch.js'
+import { registerSpritesheetTools } from './tools/spritesheet.js'
+import { registerPatternTools } from './tools/pattern.js'
+import { registerResponsiveTools } from './tools/responsive.js'
 
 /**
  * Registers every image-gen tool on the host tools service.
@@ -16,7 +21,12 @@ import { registerFrontendTools } from './tools/frontend.js'
 export function registerAllTools(ctx, deps) {
   registerGenerationTools(ctx, deps)
   registerProcessingTools(ctx, deps)
+  registerProcessingAdvancedTools(ctx, deps)
   registerEditingTools(ctx, deps)
   registerInspectTools(ctx, deps)
   registerFrontendTools(ctx, deps)
+  registerSketchTools(ctx, deps)
+  registerSpritesheetTools(ctx, deps)
+  registerPatternTools(ctx, deps)
+  registerResponsiveTools(ctx, deps)
 }

package/lib/responsive-helpers.js

@@ -0,0 +1,94 @@
+// Pure helpers for generate_responsive_mockups (#173) — no cordis imports.
+
+export const DEVICE_ORDER = ['mobile', 'tablet', 'desktop']
+
+export const DEVICE_PRESETS = {
+  mobile: {
+    id: 'mobile',
+    label: 'Mobile',
+    aspect: '9:16',
+    size: 'portrait_16_9',
+    fileStem: 'mockup-mobile',
+    viewport: 'iPhone-class mobile viewport 375×812, portrait 9:16',
+    layoutHint:
+      'Single-column mobile UI mockup: compact header, stacked content, thumb-reachable bottom actions. '
+      + 'Preserve the same product, brand colors, typography family and visual language as the desktop and tablet versions.',
+  },
+  tablet: {
+    id: 'tablet',
+    label: 'Tablet',
+    aspect: '3:4',
+    size: 'portrait_4_3',
+    fileStem: 'mockup-tablet',
+    viewport: 'iPad-class tablet viewport 768×1024, portrait 3:4',
+    layoutHint:
+      'Tablet UI mockup with two-column or wide single-column layout, roomier spacing than mobile, '
+      + 'same product screens, brand colors, and component language as mobile and desktop versions.',
+  },
+  desktop: {
+    id: 'desktop',
+    label: 'Desktop',
+    aspect: '16:9',
+    size: 'landscape_16_9',
+    fileStem: 'mockup-desktop',
+    viewport: 'desktop viewport 1440×900 / 1920×1080, landscape 16:10–16:9',
+    layoutHint:
+      'Desktop UI mockup with multi-column layout, full navigation chrome and wide content area. '
+      + 'Same product, brand palette and component language as mobile and tablet versions.',
+  },
+}
+
+export function normalizeDevices(input) {
+  if (input == null) return [...DEVICE_ORDER]
+  const list = Array.isArray(input) ? input : [input]
+  const cleaned = list
+    .map((d) => String(d || '').trim().toLowerCase())
+    .filter((d) => DEVICE_ORDER.includes(d))
+  const unique = []
+  for (const d of cleaned) {
+    if (!unique.includes(d)) unique.push(d)
+  }
+  return unique.length ? unique : [...DEVICE_ORDER]
+}
+
+export function resolveDevicePreset(device) {
+  return DEVICE_PRESETS[String(device || '').toLowerCase()] || DEVICE_PRESETS.mobile
+}
+
+/**
+ * Build a shared semantic base prompt so the three viewports stay visually coherent.
+ * Device-specific lines only restate composition constraints, not the product idea.
+ */
+export function buildResponsivePrompt(basePrompt, { device, stylePreset, paletteColors } = {}) {
+  const preset = resolveDevicePreset(device)
+  const core = String(basePrompt || '').trim()
+  const style = stylePreset ? ` Style preset: ${stylePreset}.` : ''
+  const palette = Array.isArray(paletteColors) && paletteColors.length
+    ? ` Dominant brand colors must remain consistent across all responsive mockups: ${paletteColors.join(', ')}.`
+    : ''
+  return `Responsive UI product mockup of: ${core}.${style}${palette} `
+    + `Render as a polished ${preset.viewport}. ${preset.layoutHint} `
+    + 'Keep the same information architecture, iconography language, spacing rhythm and color palette across mobile, tablet and desktop variants. '
+    + 'High-fidelity interface design, clean UI, realistic device framing only if needed, no lorem-ipsum walls of unreadable text, no watermark.'
+}
+
+export function mockupFileName(device, { outputName } = {}) {
+  const preset = resolveDevicePreset(device)
+  const stem = String(outputName || '').trim()
+    ? String(outputName).trim().replace(/\.(png|jpe?g|webp)$/i, '')
+    : preset.fileStem
+  // Issue requires mockup-mobile.png style names when default stem is used.
+  if (!outputName) return `${preset.fileStem}.png`
+  return `${stem}-${preset.id}.png`
+}
+
+export function deviceMeta(device) {
+  const preset = resolveDevicePreset(device)
+  return {
+    device: preset.id,
+    label: preset.label,
+    aspect: preset.aspect,
+    size: preset.size,
+    viewport: preset.viewport,
+  }
+}

package/lib/spritesheet-helpers.js

@@ -0,0 +1,65 @@
+// Pure helpers for generate_spritesheet (#177) — no cordis/dsh-tools imports.
+
+export const ANIMATION_PRESETS = {
+  idle: ['neutral standing pose', 'subtle breathing chest rise', 'slight weight shift', 'return to neutral'],
+  walk: ['contact pose left foot forward', 'down pose', 'passing pose', 'up pose', 'contact pose right foot forward', 'down pose', 'passing pose', 'up pose'],
+  attack: ['wind-up anticipation', 'strike extension', 'impact frame', 'recoil follow-through'],
+  pulse: ['scale 1.0 rest', 'scale 1.08 glow peak', 'scale 1.0 settle', 'scale 0.96 micro-bounce'],
+  hover: ['lift 0px', 'lift -6px', 'lift 0px', 'lift 2px press'],
+}
+
+export function clampFrames(n, animation = 'idle') {
+  const v = Number(n)
+  const anim = String(animation || 'idle').toLowerCase()
+  // walk preset has a natural 8-phase cycle; 12 would stutter at loop point
+  if (anim === 'walk') return v === 4 ? 4 : 8
+  if (v === 4 || v === 8 || v === 12) return v
+  return 8
+}
+
+export function buildSpritesheetCss({ frameCount, frameW, frameH, durationSec, name }) {
+  const anim = name || 'play'
+  const sheetW = frameW * frameCount
+  return `/* dsh-image-gen spritesheet */
+.${anim} {
+  width: ${frameW}px;
+  height: ${frameH}px;
+  background-image: url('./${anim}-sheet.svg');
+  background-repeat: no-repeat;
+  background-size: ${sheetW}px ${frameH}px;
+  animation: ${anim} ${durationSec}s steps(${frameCount}) infinite;
+}
+@keyframes ${anim} {
+  from { background-position: 0 0; }
+  to { background-position: -${sheetW}px 0; }
+}
+`
+}
+
+export function buildSpritesheetSvg(frames, { frameW, frameH }) {
+  const count = frames.length
+  const totalW = frameW * count
+  const totalH = frameH
+  let images = ''
+  frames.forEach((src, idx) => {
+    const b64 = Buffer.isBuffer(src.bytes) ? src.bytes.toString('base64') : Buffer.from(src.bytes).toString('base64')
+    const mime = src.mediaType || 'image/png'
+    const x = idx * frameW
+    images += `<image href="data:${mime};base64,${b64}" x="${x}" y="0" width="${frameW}" height="${frameH}" preserveAspectRatio="xMidYMid slice"/>`
+  })
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<svg xmlns="http://www.w3.org/2000/svg" width="${totalW}" height="${totalH}" viewBox="0 0 ${totalW} ${totalH}">
+${images}
+</svg>`
+}
+
+export function buildFramePrompts(subject, animation, frameCount) {
+  const preset = ANIMATION_PRESETS[animation] || ANIMATION_PRESETS.idle
+  const phases = []
+  for (let i = 0; i < frameCount; i++) {
+    phases.push(preset[i % preset.length])
+  }
+  return phases.map((phase, i) =>
+    `2D game sprite frame ${i + 1} of ${frameCount}: ${subject}. Animation phase: ${phase}. `
+    + 'Transparent or solid flat background, consistent character scale and camera, same character design across frames, clean silhouette, even lighting.')
+}

package/lib/tools/editing.js

@@ -116,6 +116,7 @@ export function registerEditingTools(ctx, deps) {
         },
         async execute(args, exec) {
           try {
+            const cfg = live()
             trackAndAssertLoopGuard(exec?.agent?.session?.id || 'default', { limit: cfg.loopGuardLimit })
             const estimatedCostEdit = calculateGenerationCost({
               provider: cfg.provider || 'fal',
@@ -249,6 +250,7 @@ export function registerEditingTools(ctx, deps) {
         },
         async execute(args, exec) {
           try {
+            const cfg = live()
             trackAndAssertLoopGuard(exec?.agent?.session?.id || 'default', { limit: cfg.loopGuardLimit })
             const count = normalizeCount(args.count || 1)
             const estimatedCostVary = calculateGenerationCost({

package/lib/tools/pattern.js

@@ -0,0 +1,125 @@
+// pattern — generate_seamless_pattern tool (#178)
+
+import { defineTool } from '@deepseek-ai/dsh-tools'
+import path from 'node:path'
+import { mkdir, writeFile } from 'node:fs/promises'
+import { makeProviders, toLosslessJson, saveAttachmentSafe, sizeToPixels } from '../providers.js'
+import { trackAndAssertLoopGuard } from '../loop-guard.js'
+import { sanitizeErrorAndLogs } from '../security.js'
+import {
+  buildSeamlessPrompt,
+  buildPatternCss,
+  normalizeDensity,
+} from '../pattern-helpers.js'
+
+export function registerPatternTools(ctx, deps) {
+  const { live, slugify, resolveApiKey } = deps
+
+  ctx.effect(() => {
+    ctx.tools.register(
+      defineTool({
+        name: 'generate_seamless_pattern',
+        description:
+          'Generate a seamless tileable repeating pattern for backgrounds (#178). '
+          + 'Describe the motif and optional style; returns a square pattern image plus CSS background-repeat snippet.',
+        parameters: {
+          motif: {
+            type: 'string',
+            required: true,
+            description: 'What to repeat (e.g. "terrazzo chips", "sakura blossoms", "circuit traces").',
+          },
+          style: {
+            type: 'string',
+            description: 'Visual style (e.g. "watercolor", "flat vector", "isometric").',
+          },
+          density: {
+            type: 'string',
+            description: 'Motif density: low, medium, or high (default medium).',
+          },
+          size: {
+            type: 'string',
+            description: 'Named image size (default square).',
+          },
+          output_name: {
+            type: 'string',
+            description: 'File name stem / CSS class (default seamless-pattern).',
+          },
+        },
+        output: {
+          schema: {
+            type: 'object',
+            additionalProperties: true,
+            properties: {
+              summary: { type: 'string' },
+              path: { type: 'string' },
+              url: { type: 'string' },
+              css: { type: 'string' },
+              cssPath: { type: 'string' },
+              format: { type: 'string' },
+              attachment: { type: 'object', additionalProperties: true },
+            },
+          },
+        },
+        async execute(args, exec) {
+          try {
+            const cfg = live()
+            trackAndAssertLoopGuard(exec?.agent?.session?.id || 'default', { limit: cfg.loopGuardLimit })
+            const density = normalizeDensity(args.density)
+            const prompt = buildSeamlessPrompt(args.motif, args.style, density)
+            const provider = cfg.provider || 'fal'
+            const format = cfg.defaultFormat || 'png'
+            const size = args.size || 'square'
+            const seed = Math.floor(Math.random() * 100000)
+
+            const pdeps = {
+              fetchImpl: fetch,
+              resolveKey: (ref) => resolveApiKey(ctx, ref),
+              cfg,
+            }
+            const job = { prompt, size, format, seed, provider }
+            const providers = makeProviders(pdeps, job)
+            const fn = providers[provider] || providers.fal || providers.custom
+            const gen = await fn(seed, prompt)
+
+            const stem = slugify(args.output_name || 'seamless-pattern')
+            const name = `${stem}.${format}`
+            const { attachment, localUrl } = await saveAttachmentSafe(ctx, {
+              bytes: gen.bytes,
+              mediaType: gen.mediaType || 'image/png',
+              name,
+            })
+
+            const sessionCwd = exec?.agent?.session?.header?.cwd
+            const outDir = path.resolve(sessionCwd || process.cwd(), cfg.outputDir || 'generated/images')
+            await mkdir(outDir, { recursive: true })
+            const filePath = path.join(outDir, name)
+            await writeFile(filePath, gen.bytes)
+
+            const [tilePx] = sizeToPixels(size)
+            const css = buildPatternCss({ className: stem, sizePx: tilePx, imagePath: `./${name}` })
+            const cssPath = path.join(outDir, `${stem}.css`)
+            await writeFile(cssPath, css, 'utf8')
+
+            const summary = `### Seamless pattern (${density})\n`
+              + `- **Motif**: ${args.motif}\n`
+              + `- **File**: \`${filePath}\`\n`
+              + `- **CSS**: \`${cssPath}\`\n\n`
+              + `![${stem}](${localUrl || filePath})`
+
+            return toLosslessJson({
+              summary,
+              path: filePath,
+              url: localUrl,
+              css,
+              cssPath,
+              format,
+              attachment,
+            })
+          } catch (err) {
+            throw new Error(sanitizeErrorAndLogs(err.message || err))
+          }
+        },
+      }),
+    )
+  }, 'dsh-image-gen: tool generate_seamless_pattern')
+}

package/lib/tools/{processing.js → processing-advanced.js}

@@ -1,3 +1,5 @@
+// processing-basic — core image-gen tools (remove_background, upscale_image, vectorize_image, blend_images). Split from processing.js (#239).
+
 // processing — image-gen tools (remove_background, upscale_image, vectorize_image, blend_images). Extracted from apply() (#216).
 
 import { defineTool } from '@deepseek-ai/dsh-tools'
@@ -44,7 +46,8 @@ import {
 } from '../frontend-assets.js'
 
 
-export function registerProcessingTools(ctx, deps) {
+
+export function registerProcessingAdvancedTools(ctx, deps) {
   const {
     config,
     live,
@@ -53,274 +56,6 @@ export function registerProcessingTools(ctx, deps) {
     slugify,
     resolveApiKey,
   } = deps
-  ctx.effect(() => {
-    ctx.tools.register(
-      defineTool({
-        name: 'remove_background',
-        description: 'Remove the background of an image (path or attachment id) and return a transparent PNG.',
-        parameters: {
-          image: { type: 'string', required: true, description: 'Path or attachment id of the source image.' },
-          model: { type: 'string', description: 'FAL model for background removal (default: fal-ai/birefnet).' },
-          output_name: { type: 'string', description: 'Custom output file name without extension.' },
-        },
-        output: {
-          schema: {
-            type: 'object',
-            additionalProperties: true,
-            properties: {
-              path: { type: 'string' },
-              url: { type: 'string' },
-              width: { type: 'number' },
-              height: { type: 'number' },
-              format: { type: 'string' },
-            },
-          },
-        },
-        async execute(args, exec) {
-          try {
-            const source = await resolveSource(ctx, exec, args.image)
-            if (!source || !source.bytes) throw new Error('Source image not found: ' + args.image)
-          const cfg = live()
-          const res = await removeBackgroundFal(
-            { fetchImpl: fetch, resolveKey: (ref) => resolveApiKey(ctx, ref), cfg },
-            { imageBytes: source.bytes, mediaType: source.mediaType, model: args.model, signal: exec.signal }
-          )
-          const stem = `${slugify(args.output_name || 'nobg')}-${Date.now().toString(36)}`
-          const name = `${stem}.png`
-          const { attachment, localUrl } = await saveAttachmentSafe(ctx, { bytes: res.bytes, mediaType: 'image/png', name })
-          const sessionCwd = exec.agent?.session?.header?.cwd
-          const outDir = path.resolve(sessionCwd || process.cwd(), cfg.outputDir || 'generated/images')
-          await mkdir(outDir, { recursive: true })
-          const filePath = path.join(outDir, name)
-          await writeFile(filePath, res.bytes)
-          const summary = buildDualOutputMarkdown({
-            action: 'background removed',
-            filePath,
-            width: res.width || attachment.width,
-            height: res.height || attachment.height,
-            mediaType: 'image/png',
-            provider: 'fal',
-            model: args.model || 'fal-ai/birefnet',
-            attachmentId: attachment.attachmentId,
-          })
-          return toLosslessJson({
-            summary,
-            path: filePath,
-            url: localUrl,
-            width: res.width || attachment.width,
-            height: res.height || attachment.height,
-            format: 'png',
-            attachment,
-          })
-          } catch (err) {
-            throw new Error(sanitizeErrorAndLogs(err.message || err))
-          }
-        },
-      }),
-    )
-  }, 'dsh-image-gen: tool remove_background')
-  ctx.effect(() => {
-    ctx.tools.register(
-      defineTool({
-        name: 'upscale_image',
-        description: 'Upscale an image 2x or 4x with enhanced clarity and detail.',
-        parameters: {
-          image: { type: 'string', required: true, description: 'Path or attachment id of the source image.' },
-          scale: { type: 'number', description: 'Upscale factor: 2 or 4 (default: 2).' },
-          prompt: { type: 'string', description: 'Optional guiding prompt for detail reconstruction.' },
-          creativity: { type: 'number', description: 'Creativity / hallucination level from 0 to 1.' },
-          output_name: { type: 'string', description: 'Custom output file name.' },
-        },
-        output: {
-          schema: {
-            type: 'object',
-            additionalProperties: true,
-            properties: {
-              path: { type: 'string' },
-              url: { type: 'string' },
-              scale: { type: 'number' },
-              width: { type: 'number' },
-              height: { type: 'number' },
-            },
-          },
-        },
-        async execute(args, exec) {
-          try {
-            const source = await resolveSource(ctx, exec, args.image)
-            if (!source || !source.bytes) throw new Error('Source image not found: ' + args.image)
-          const cfg = live()
-          const res = await upscaleImageFal(
-            { fetchImpl: fetch, resolveKey: (ref) => resolveApiKey(ctx, ref), cfg },
-            { imageBytes: source.bytes, mediaType: source.mediaType, scale: args.scale, prompt: args.prompt, creativity: args.creativity, signal: exec.signal }
-          )
-          const stem = `${slugify(args.output_name || 'upscaled')}-${Date.now().toString(36)}`
-          const name = `${stem}.png`
-          const { attachment, localUrl } = await saveAttachmentSafe(ctx, { bytes: res.bytes, mediaType: 'image/png', name })
-          const sessionCwd = exec.agent?.session?.header?.cwd
-          const outDir = path.resolve(sessionCwd || process.cwd(), cfg.outputDir || 'generated/images')
-          await mkdir(outDir, { recursive: true })
-          const filePath = path.join(outDir, name)
-          await writeFile(filePath, res.bytes)
-          const summary = buildDualOutputMarkdown({
-            action: `upscaled (${args.scale || 2}x)`,
-            filePath,
-            width: res.width || attachment.width,
-            height: res.height || attachment.height,
-            mediaType: 'image/png',
-            provider: 'fal',
-            model: 'fal-ai/clarity-upscaler',
-            attachmentId: attachment.attachmentId,
-          })
-          return toLosslessJson({
-            summary,
-            path: filePath,
-            url: localUrl,
-            scale: args.scale || 2,
-            width: res.width || attachment.width,
-            height: res.height || attachment.height,
-            attachment,
-          })
-          } catch (err) {
-            throw new Error(sanitizeErrorAndLogs(err.message || err))
-          }
-        },
-      }),
-    )
-  }, 'dsh-image-gen: tool upscale_image')
-  ctx.effect(() => {
-    ctx.tools.register(
-      defineTool({
-        name: 'vectorize_image',
-        description: 'Convert a raster image or icon to SVG vector format.',
-        parameters: {
-          image: { type: 'string', required: true, description: 'Path or attachment id of the source image.' },
-          color_mode: { type: 'string', description: '"color" or "binary" (default: "color").' },
-          output_name: { type: 'string', description: 'Custom output file name.' },
-        },
-        output: {
-          schema: {
-            type: 'object',
-            additionalProperties: true,
-            properties: {
-              path: { type: 'string' },
-              svg: { type: 'string' },
-              format: { type: 'string' },
-            },
-          },
-        },
-        async execute(args, exec) {
-          try {
-            const source = await resolveSource(ctx, exec, args.image)
-            if (!source || !source.bytes) throw new Error('Source image not found: ' + args.image)
-            const cfg = live()
-            const res = traceToSvg(source.bytes, { colorMode: args.color_mode })
-            const stem = `${slugify(args.output_name || 'vector')}-${Date.now().toString(36)}`
-            const name = `${stem}.svg`
-            const sessionCwd = exec.agent?.session?.header?.cwd
-            const outDir = path.resolve(sessionCwd || process.cwd(), cfg.outputDir || 'generated/images')
-            await mkdir(outDir, { recursive: true })
-            const filePath = path.join(outDir, name)
-            await writeFile(filePath, res.bytes)
-
-            let attachment = null
-            let localUrl = ''
-            if (ctx.attachments?.saveImage) {
-              attachment = await ctx.attachments.saveImage({
-                data: new Uint8Array(res.bytes),
-                mediaType: 'image/svg+xml',
-                name,
-              })
-              localUrl = '/dsh-image-gen/image?id=' + encodeURIComponent(attachment.attachmentId)
-            }
-
-            const summary = `### Vectorized SVG Export\n- **File**: ${filePath}\n- **Format**: SVG (XML vector)\n- **Color mode**: ${args.color_mode || 'color'}\n- **Palette size**: ${res.palette ? res.palette.length : 16} colors\n`
-            return toLosslessJson({
-              summary,
-              path: filePath,
-              url: localUrl,
-              svg: res.svg,
-              format: 'svg',
-              attachment,
-            })
-          } catch (err) {
-            throw new Error(sanitizeErrorAndLogs(err.message || err))
-          }
-        },
-      }),
-    )
-  }, 'dsh-image-gen: tool vectorize_image')
-  ctx.effect(() => {
-    ctx.tools.register(
-      defineTool({
-        name: 'blend_images',
-        description: 'Blend multiple images (paths or attachment ids) into a coherent new composition.',
-        parameters: {
-          images: { type: 'array', items: { type: 'string' }, required: true, description: 'List of image paths or attachment ids to blend.' },
-          weights: { type: 'array', items: { type: 'number' }, description: 'Weights for each image (optional).' },
-          prompt: { type: 'string', description: 'Guiding prompt for the blend.' },
-          output_name: { type: 'string', description: 'Custom output file name.' },
-        },
-        output: {
-          schema: {
-            type: 'object',
-            additionalProperties: true,
-            properties: {
-              path: { type: 'string' },
-              url: { type: 'string' },
-              width: { type: 'number' },
-              height: { type: 'number' },
-            },
-          },
-        },
-        async execute(args, exec) {
-          try {
-            const cfg = live()
-            trackAndAssertLoopGuard(exec?.agent?.session?.id || 'default', { limit: cfg.loopGuardLimit })
-            assertBudgetAvailable(0.05, cfg.dailyBudgetUsd)
-            const refs = Array.isArray(args.images) ? args.images : [args.images].filter(Boolean)
-          const sources = []
-          for (const r of refs) {
-            const s = await resolveSource(ctx, exec, r)
-            if (s && s.bytes) sources.push(s)
-          }
-          if (sources.length === 0) throw new Error('No valid images found to blend')
-          const res = await blendImagesFal(
-            { fetchImpl: fetch, resolveKey: (ref) => resolveApiKey(ctx, ref), cfg },
-            { images: sources, weights: args.weights, prompt: args.prompt, signal: exec.signal }
-          )
-          const stem = `${slugify(args.output_name || 'blended')}-${Date.now().toString(36)}`
-          const name = `${stem}.png`
-          const { attachment, localUrl } = await saveAttachmentSafe(ctx, { bytes: res.bytes, mediaType: 'image/png', name })
-          const sessionCwd = exec.agent?.session?.header?.cwd
-          const outDir = path.resolve(sessionCwd || process.cwd(), cfg.outputDir || 'generated/images')
-          await mkdir(outDir, { recursive: true })
-          const filePath = path.join(outDir, name)
-          await writeFile(filePath, res.bytes)
-          const summary = buildDualOutputMarkdown({
-            action: 'blended composition',
-            filePath,
-            width: res.width || attachment.width,
-            height: res.height || attachment.height,
-            mediaType: 'image/png',
-            provider: 'fal',
-            model: 'fal-ai/image-blend',
-            attachmentId: attachment.attachmentId,
-          })
-          return toLosslessJson({
-            summary,
-            path: filePath,
-            url: localUrl,
-            width: res.width || attachment.width,
-            height: res.height || attachment.height,
-            attachment,
-          })
-          } catch (err) {
-            throw new Error(sanitizeErrorAndLogs(err.message || err))
-          }
-        },
-      }),
-    )
-  }, 'dsh-image-gen: tool blend_images')
 
   ctx.effect(() => {
     ctx.tools.register(
@@ -723,7 +458,13 @@ export function registerProcessingTools(ctx, deps) {
                   const b64 = Buffer.isBuffer(src.bytes) ? src.bytes.toString('base64') : Buffer.from(src.bytes).toString('base64')
                   logoDataUri = `data:${src.mediaType || 'image/png'};base64,${b64}`
                 }
-              } catch (_) {}
+              } catch (err) {
+                // Optional logo embed: brand pack still exports without it.
+                const msg = err?.message || String(err)
+                if (typeof ctx?.logger?.debug === 'function') {
+                  ctx.logger.debug(`dsh-image-gen: brand logo embed skipped: ${msg}`)
+                }
+              }
             }
 
             const exportedFiles = []