hanseol-dev 5.0.3-dev.9 → 5.0.4-dev.0

package/dist/agents/office/powerpoint-create-agent.js

@@ -4,7 +4,7 @@ import { powerpointClient } from '../../tools/office/powerpoint-client.js';
 import { getSubAgentPhaseLogger, getSubAgentToolCallLogger } from '../common/sub-agent.js';
 import { logger } from '../../utils/logger.js';
 import { getPlatform } from '../../utils/platform-utils.js';
-import { PPT_DESIGN_PROMPT, validateSlideHtml, extractLayoutHint, buildContentFillJsonPrompt, parseContentFillJson, buildContentSlideHtml, } from './powerpoint-create-prompts.js';
+import { PPT_DESIGN_PROMPT, validateSlideHtml, buildFreeHtmlPrompt, } from './powerpoint-create-prompts.js';
 const DEFAULT_DESIGN = {
     primary_color: '#1B2A4A',
     accent_color: '#00D4AA',
@@ -246,32 +246,6 @@ function injectEdgeSizing(html, backgroundColor) {
     }
     return result;
 }
-function injectTitleContrastFix(html, designTextColor) {
-    const safeColor = designTextColor.replace(/'/g, "\\'");
-    const script = `<script>(function(){` +
-        `var dc='${safeColor}';` +
-        `function lum(c){var m=c.match(/[\\d.]+/g);if(!m||m.length<3)return -1;` +
-        `var s=[m[0]/255,m[1]/255,m[2]/255].map(function(v){return v<=0.03928?v/12.92:Math.pow((v+0.055)/1.055,2.4)});` +
-        `return 0.2126*s[0]+0.7152*s[1]+0.0722*s[2]}` +
-        `function getBg(el){while(el){var s=getComputedStyle(el);var bg=s.backgroundColor;` +
-        `var m=bg.match(/[\\d.]+/g);if(m&&m.length>=3){if(m.length<4||parseFloat(m[3])>0.1)return bg}` +
-        `el=el.parentElement}return'rgb(255,255,255)'}` +
-        `var els=document.querySelectorAll('h1,h2');` +
-        `for(var i=0;i<els.length;i++){var el=els[i];var cs=getComputedStyle(el);` +
-        `var tfc=cs.webkitTextFillColor||'';` +
-        `if(tfc==='transparent'||tfc==='rgba(0, 0, 0, 0)'){` +
-        `el.style.setProperty('-webkit-text-fill-color','initial','important')}` +
-        `if(parseFloat(cs.opacity)<0.6){el.style.setProperty('opacity','1','important')}` +
-        `var fg=cs.color;var bg=getBg(el);var fl=lum(fg),bl=lum(bg);` +
-        `if(fl>=0&&bl>=0){var r=(Math.max(fl,bl)+0.05)/(Math.min(fl,bl)+0.05);` +
-        `if(r<3){el.style.setProperty('color',dc,'important');` +
-        `el.style.setProperty('-webkit-text-fill-color',dc,'important')}}}` +
-        `})()<\/script>`;
-    if (html.includes('</body>')) {
-        return html.replace('</body>', `${script}</body>`);
-    }
-    return html + script;
-}
 function escapeHtml(text) {
     return text.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;');
 }
@@ -429,139 +403,9 @@ body::after {
 </body>
 </html>`;
 }
-function isOverviewSlide(title, slideIndex) {
-    if (slideIndex !== 1)
-        return false;
-    return /개요|목차|overview|agenda|outline|순서|발표\s*구성|contents|목록/i.test(title);
-}
-function parseOverviewItems(contentDirection) {
-    const items = [];
-    const lines = contentDirection.split(/\n/).filter(l => l.trim());
-    for (const line of lines) {
-        const match = line.match(/^\d+[\.\)]\s*(.+?)(?:\s*[-–—:]\s*(.+))?$/);
-        if (match) {
-            items.push({ title: match[1].trim(), desc: match[2]?.trim() || '' });
-        }
-    }
-    if (items.length === 0) {
-        const parts = contentDirection.split(/[,;·•]/).map(s => s.trim()).filter(Boolean);
-        for (const part of parts) {
-            const sepMatch = part.match(/^(.+?)(?:\s*[-–—:]\s*(.+))?$/);
-            if (sepMatch) {
-                items.push({ title: sepMatch[1].trim(), desc: sepMatch[2]?.trim() || '' });
-            }
-        }
-    }
-    return items.slice(0, 5);
-}
-function buildOverviewSlideHtml(design, title, subtitle, items, slideNum) {
-    const badgeColors = [
-        design.primary_color, design.accent_color, design.gradient_end,
-        design.primary_color, design.accent_color,
-    ];
-    const itemCount = items.length;
-    const topRow = itemCount <= 3 ? items : items.slice(0, Math.ceil(itemCount / 2));
-    const bottomRow = itemCount <= 3 ? [] : items.slice(Math.ceil(itemCount / 2));
-    function renderCard(item, idx) {
-        const color = badgeColors[idx % badgeColors.length];
-        return `
-    <div class="card">
-      <div class="badge" style="background:${color}">${idx + 1}</div>
-      <div class="card-title">${escapeHtml(item.title)}</div>
-      ${item.desc ? `<div class="card-desc">${escapeHtml(item.desc)}</div>` : ''}
-    </div>`;
-    }
-    return `<!DOCTYPE html>
-<html lang="ko">
-<head>
-<meta charset="UTF-8">
-<style>
-* { margin: 0; padding: 0; box-sizing: border-box; }
-html, body { width: 1920px; height: 1080px; overflow: hidden; }
-body {
-  background: ${design.background_color};
-  font-family: "${design.font_body}", "${design.font_title}", "Segoe UI", "Malgun Gothic", sans-serif;
-  display: flex; flex-direction: column;
-  word-break: keep-all; overflow-wrap: break-word;
-}
-.header {
-  background: linear-gradient(135deg, ${design.primary_color}, ${design.gradient_end});
-  padding: 48px 80px 40px;
-  flex-shrink: 0;
-}
-.header-title {
-  font-size: 52px; font-weight: 800; color: #ffffff;
-  font-family: "${design.font_title}", "Segoe UI", sans-serif;
-  margin-bottom: 8px;
-}
-.header-subtitle {
-  font-size: 24px; font-weight: 400; color: rgba(255,255,255,0.75);
-}
-.content {
-  flex: 1; display: flex; flex-direction: column;
-  padding: 48px 80px 40px;
-  gap: 24px;
-  justify-content: center;
-}
-.row {
-  display: flex; gap: 24px;
-  justify-content: center;
-}
-.card {
-  flex: 1;
-  max-width: 340px;
-  background: #ffffff;
-  border-radius: 16px;
-  padding: 36px 32px;
-  box-shadow: 0 4px 20px rgba(0,0,0,0.06);
-  display: flex; flex-direction: column;
-  align-items: center; text-align: center;
-  gap: 12px;
-}
-.badge {
-  width: 44px; height: 44px;
-  border-radius: 50%;
-  color: #ffffff;
-  font-size: 20px; font-weight: 700;
-  display: flex; align-items: center; justify-content: center;
-  flex-shrink: 0;
-}
-.card-title {
-  font-size: 26px; font-weight: 700; color: ${design.text_color};
-  line-height: 1.3;
-}
-.card-desc {
-  font-size: 22px; font-weight: 400; color: ${design.text_color}aa;
-  line-height: 1.5;
-}
-.page-num {
-  position: absolute;
-  bottom: 24px; right: 44px;
-  font-size: 13px;
-  color: ${design.text_color}55;
-}
-</style>
-</head>
-<body>
-<div class="header">
-  <div class="header-title">${escapeHtml(title)}</div>
-  ${subtitle ? `<div class="header-subtitle">${escapeHtml(subtitle)}</div>` : ''}
-</div>
-<div class="content">
-  <div class="row">
-    ${topRow.map((item, idx) => renderCard(item, idx)).join('')}
-  </div>
-  ${bottomRow.length > 0 ? `<div class="row">
-    ${bottomRow.map((item, idx) => renderCard(item, topRow.length + idx)).join('')}
-  </div>` : ''}
-</div>
-<div class="page-num">${slideNum}</div>
-</body>
-</html>`;
-}
 function buildFallbackSlideHtml(design, title, contentDirection, slideNum) {
     const items = [];
-    const parts = contentDirection.split(/\(\d+\)\s*|•\s*|\n-\s*|\n\d+\.\s*/);
+    const parts = contentDirection.split(/\(\d+\)\s*|•\s*|\n-\s*|\n\d+[.)]\s*|Step\s*\d+[.:]\s*/i);
     for (const part of parts) {
         const cleaned = part.replace(/Layout:.*$/i, '').trim();
         if (cleaned.length > 5) {
@@ -569,8 +413,28 @@ function buildFallbackSlideHtml(design, title, contentDirection, slideNum) {
             items.push(sentence.slice(0, 80));
         }
     }
+    if (items.length < 3) {
+        const commaParts = contentDirection.split(/[,;，；]\s*/);
+        for (const part of commaParts) {
+            const cleaned = part.replace(/Layout:.*$/i, '').trim();
+            if (cleaned.length > 8 && !items.includes(cleaned.slice(0, 80))) {
+                items.push(cleaned.slice(0, 80));
+            }
+        }
+    }
+    if (items.length < 3) {
+        const sentences = contentDirection.split(/[.。!?]\s+/);
+        for (const s of sentences) {
+            const cleaned = s.replace(/Layout:.*$/i, '').trim();
+            if (cleaned.length > 10 && !items.some(i => i.startsWith(cleaned.slice(0, 20)))) {
+                items.push(cleaned.slice(0, 80));
+            }
+        }
+    }
     const bulletItems = items.slice(0, 6);
-    const bulletsHtml = bulletItems.map(item => `<div class="bullet"><span class="dot"></span><span>${escapeHtml(item)}</span></div>`).join('\n      ');
+    const useGrid = bulletItems.length >= 4;
+    const gridCols = useGrid ? 'grid-template-columns:1fr 1fr' : 'grid-template-columns:1fr';
+    const pointsHtml = bulletItems.map((item, i) => `<div class="point"><div class="point-num">${i + 1}</div><div class="point-text">${escapeHtml(item)}</div></div>`).join('\n      ');
     return `<!DOCTYPE html>
 <html lang="ko">
 <head>
@@ -589,9 +453,10 @@ body {
 .slide-num { font-size: 14px; color: ${design.accent_color}; font-weight: 600; letter-spacing: 2px; text-transform: uppercase; margin-bottom: 12px; }
 h1 { font-size: 52px; font-weight: 700; color: ${design.text_color}; font-family: "${design.font_title}", "Segoe UI", sans-serif; line-height: 1.2; }
 .accent-bar { width: 80px; height: 4px; background: ${design.accent_color}; margin-top: 20px; border-radius: 2px; }
-.content { flex: 1; display: flex; flex-direction: column; justify-content: center; gap: 20px; }
-.bullet { display: flex; align-items: flex-start; gap: 16px; font-size: 26px; color: ${design.text_color}; line-height: 1.5; }
-.dot { width: 10px; height: 10px; border-radius: 50%; background: ${design.accent_color}; flex-shrink: 0; margin-top: 10px; }
+.content { flex: 1; display: grid; ${gridCols}; gap: 24px; align-content: center; }
+.point { display: flex; align-items: flex-start; gap: 20px; padding: 28px 32px; background: #fff; border-radius: 16px; box-shadow: 0 4px 16px rgba(0,0,0,0.06); }
+.point-num { width: 48px; height: 48px; border-radius: 50%; background: ${design.accent_color}; color: #fff; display: flex; align-items: center; justify-content: center; font-size: 24px; font-weight: 700; flex-shrink: 0; }
+.point-text { font-size: 26px; line-height: 1.5; color: ${design.text_color}; flex: 1; }
 </style>
 </head>
 <body>
@@ -601,7 +466,7 @@ h1 { font-size: 52px; font-weight: 700; color: ${design.text_color}; font-family
   <div class="accent-bar"></div>
 </div>
 <div class="content">
-  ${bulletsHtml}
+  ${pointsHtml}
 </div>
 </body>
 </html>`;
@@ -700,43 +565,60 @@ async function runDesignPhase(llmClient, instruction, phaseLogger) {
     }
     return plan;
 }
-async function generateSingleSlideHtml(llmClient, slide, design, slideIndex, _totalSlides, language) {
-    const cleanedDirection = (slide.content_direction || '').replace(/\s*Layout\s*:\s*[^\n]*/gi, '').trim();
-    const layoutType = extractLayoutHint(slide.content_direction || '');
-    logger.info(`Slide ${slideIndex + 1}: Generating code template "${layoutType}"`);
-    const jsonPrompt = buildContentFillJsonPrompt(slide.title, cleanedDirection, layoutType, language);
+function extractHtmlFromResponse(raw) {
+    const trimmed = raw.trim();
+    if (/^<!DOCTYPE/i.test(trimmed) || /^<html/i.test(trimmed)) {
+        return trimmed;
+    }
+    const fenceMatch = trimmed.match(/```(?:html)?\s*\n?(<!DOCTYPE[\s\S]*?<\/html>)\s*\n?```/i);
+    if (fenceMatch)
+        return fenceMatch[1];
+    const htmlMatch = trimmed.match(/(<!DOCTYPE[\s\S]*<\/html>)/i);
+    if (htmlMatch)
+        return htmlMatch[1];
+    const htmlTagMatch = trimmed.match(/(<html[\s\S]*<\/html>)/i);
+    if (htmlTagMatch)
+        return '<!DOCTYPE html>\n' + htmlTagMatch[1];
+    return null;
+}
+async function generateSingleSlideHtml(llmClient, slide, design, slideIndex, totalSlides, language) {
+    const contentDirection = (slide.content_direction || '').trim();
+    logger.info(`Slide ${slideIndex + 1}: Generating free-form HTML for "${slide.title}"`);
+    const htmlPrompt = buildFreeHtmlPrompt(slide.title, contentDirection, design, slideIndex, totalSlides, language);
     try {
-        const jsonRes = await llmClient.chatCompletion({
+        const res = await llmClient.chatCompletion({
             messages: [
-                { role: 'system', content: jsonPrompt },
-                { role: 'user', content: 'Output the JSON now.' },
+                { role: 'system', content: htmlPrompt },
+                { role: 'user', content: 'Output the complete HTML now.' },
             ],
-            temperature: 0.3,
-            max_tokens: 2000,
+            temperature: 0.6,
+            max_tokens: 4000,
         });
-        const jsonMsg = jsonRes.choices[0]?.message;
-        const jsonRaw = jsonMsg ? extractContent(jsonMsg) : '';
-        let slideData = parseContentFillJson(jsonRaw, layoutType);
-        if (!slideData) {
-            const retryRes = await llmClient.chatCompletion({
-                messages: [
-                    { role: 'system', content: jsonPrompt },
-                    { role: 'user', content: 'Output ONLY valid JSON. No markdown fences, no explanation. Start with { and end with }.' },
-                ],
-                temperature: 0.2,
-                max_tokens: 2000,
-            });
-            const retryMsg = retryRes.choices[0]?.message;
-            const retryRaw = retryMsg ? extractContent(retryMsg) : '';
-            slideData = parseContentFillJson(retryRaw, layoutType);
+        const msg = res.choices[0]?.message;
+        const rawHtml = msg ? extractContent(msg) : '';
+        let html = extractHtmlFromResponse(rawHtml);
+        if (html && !hasPlaceholderText(html)) {
+            return { html, isCodeTemplate: false };
         }
-        if (slideData) {
-            const html = buildContentSlideHtml(design, slide.title, layoutType, slideData, slideIndex + 1, slideIndex);
-            return { html, isCodeTemplate: true };
+        logger.warn(`Slide ${slideIndex + 1}: First HTML attempt failed. Raw length: ${rawHtml.length}. Retrying...`);
+        const retryRes = await llmClient.chatCompletion({
+            messages: [
+                { role: 'system', content: htmlPrompt },
+                { role: 'user', content: 'Output ONLY the complete HTML document. Start with <!DOCTYPE html> and end with </html>. No explanation.' },
+            ],
+            temperature: 0.4,
+            max_tokens: 4000,
+        });
+        const retryMsg = retryRes.choices[0]?.message;
+        const retryRaw = retryMsg ? extractContent(retryMsg) : '';
+        html = extractHtmlFromResponse(retryRaw);
+        if (html && !hasPlaceholderText(html)) {
+            return { html, isCodeTemplate: false };
         }
+        logger.warn(`Slide ${slideIndex + 1}: Both HTML attempts failed.`);
     }
     catch (e) {
-        logger.warn(`Slide ${slideIndex + 1}: Code template fallback failed: ${e}`);
+        logger.warn(`Slide ${slideIndex + 1}: HTML generation error: ${e}`);
     }
     return null;
 }
@@ -759,18 +641,6 @@ async function generateAllHtml(llmClient, plan, companyName, titleSubtitle, kstD
                 isCodeTemplate: true,
             });
         }
-        else if (isOverviewSlide(slide.title, i)) {
-            const overviewItems = parseOverviewItems(slide.content_direction || '');
-            if (overviewItems.length >= 2) {
-                const firstLine = (slide.content_direction || '').split('\n')[0] || '';
-                const overviewSubtitle = /^\d/.test(firstLine.trim()) ? '' : firstLine.trim();
-                results.set(i, {
-                    index: i,
-                    html: buildOverviewSlideHtml(plan.design, slide.title, overviewSubtitle, overviewItems, i + 1),
-                    isCodeTemplate: true,
-                });
-            }
-        }
     }
     const contentIndices = plan.slides
         .map((s, i) => ({ slide: s, index: i }))
@@ -809,8 +679,7 @@ async function validateAndRegenerate(llmClient, htmlResults, plan, language, pha
         const slide = plan.slides[index];
         if (slide.type === 'title' || slide.type === 'closing')
             continue;
-        const layoutType = extractLayoutHint(slide.content_direction || '');
-        const validation = validateSlideHtml(result.html, layoutType);
+        const validation = validateSlideHtml(result.html);
         if (!validation.pass) {
             logger.info(`Slide ${index + 1}: Post-validation failed: ${validation.feedback}`);
             failedIndices.push(index);
@@ -852,23 +721,28 @@ async function validateAndRegenerate(llmClient, htmlResults, plan, language, pha
     }
     return htmlResults;
 }
-async function assemblePresentation(htmlResults, plan, timestamp, savePath, phaseLogger, toolCallLogger) {
+const MAX_SCREENSHOT_CONCURRENT = 4;
+async function assemblePresentation(htmlResults, plan, timestamp, savePath, companyName, language, phaseLogger, toolCallLogger) {
     const { writePath: tempWritePath, winPath: tempWinPath } = getTempDir();
     ensureTempDir(tempWritePath);
+    const totalSlides = htmlResults.size;
+    const sortedEntries = [...htmlResults.entries()].sort((a, b) => a[0] - b[0]);
     const builtSlides = [];
-    let failCount = 0;
     let totalToolCalls = 0;
     const tempFiles = [];
-    const sortedEntries = [...htmlResults.entries()].sort((a, b) => a[0] - b[0]);
+    const initCountRes = await powerpointClient.powerpointGetSlideCount();
+    const initSlideCount = initCountRes['slide_count'] || 1;
+    const slidesToAdd = Math.max(0, totalSlides - initSlideCount);
+    if (phaseLogger)
+        phaseLogger('powerpoint-create', 'assembly', `Pre-creating ${totalSlides} slides (existing: ${initSlideCount}, adding: ${slidesToAdd})...`);
+    for (let i = 0; i < slidesToAdd; i++) {
+        await powerpointClient.powerpointAddSlide(7);
+        totalToolCalls++;
+    }
+    const slideFiles = new Map();
+    let slideNum = 0;
     for (const [index, result] of sortedEntries) {
-        const slidePlan = plan.slides[index];
-        const slideNum = builtSlides.length + 1;
-        if (failCount >= 3) {
-            logger.warn('Too many slide failures, stopping');
-            break;
-        }
-        if (phaseLogger)
-            phaseLogger('powerpoint-create', 'assembly', `Rendering slide ${slideNum}: ${slidePlan.title}`);
+        slideNum++;
         const htmlFileName = `hanseol_slide_${slideNum}_${timestamp}.html`;
         const pngFileName = `hanseol_slide_${slideNum}_${timestamp}.png`;
         const htmlWritePath = path.join(tempWritePath, htmlFileName);
@@ -877,98 +751,200 @@ async function assemblePresentation(htmlResults, plan, timestamp, savePath, phas
         const pngWinPath = `${tempWinPath}\\${pngFileName}`;
         try {
             const viewportHtml = injectEdgeSizing(result.html, plan.design.background_color);
-            const processed = injectTitleContrastFix(viewportHtml, plan.design.text_color);
-            fs.writeFileSync(htmlWritePath, processed, 'utf-8');
+            fs.writeFileSync(htmlWritePath, viewportHtml, 'utf-8');
             tempFiles.push(htmlWritePath);
+            slideFiles.set(index, { slideNum, htmlWritePath, pngWritePath, htmlWinPath, pngWinPath });
         }
         catch (e) {
-            logger.warn(`Slide ${slideNum}: Failed to write HTML file: ${e}`);
-            failCount++;
-            continue;
-        }
-        let renderSuccess = false;
-        try {
-            const renderResult = await powerpointClient.renderHtmlToImage(htmlWinPath, pngWinPath);
-            totalToolCalls++;
-            renderSuccess = renderResult.success;
-            if (!renderSuccess) {
-                await new Promise(r => setTimeout(r, 2000));
-                const retryRender = await powerpointClient.renderHtmlToImage(htmlWinPath, pngWinPath);
-                totalToolCalls++;
-                renderSuccess = retryRender.success;
-            }
+            logger.warn(`Slide ${slideNum}: Failed to write HTML: ${e}`);
         }
-        catch (e) {
-            logger.warn(`Slide ${slideNum}: Edge screenshot failed: ${e}`);
+    }
+    if (phaseLogger)
+        phaseLogger('powerpoint-create', 'assembly', `Rendering ${slideFiles.size} screenshots in parallel (batch ${MAX_SCREENSHOT_CONCURRENT})...`);
+    const screenshotEntries = [...slideFiles.entries()].sort((a, b) => a[0] - b[0]);
+    const screenshotSuccess = new Set();
+    for (let batch = 0; batch < screenshotEntries.length; batch += MAX_SCREENSHOT_CONCURRENT) {
+        const chunk = screenshotEntries.slice(batch, batch + MAX_SCREENSHOT_CONCURRENT);
+        const batchResults = await Promise.all(chunk.map(async ([index, files]) => {
+            let success = false;
             try {
-                await new Promise(r => setTimeout(r, 2000));
-                const retryRender = await powerpointClient.renderHtmlToImage(htmlWinPath, pngWinPath);
+                const result = await powerpointClient.renderHtmlToImage(files.htmlWinPath, files.pngWinPath);
                 totalToolCalls++;
-                renderSuccess = retryRender.success;
+                success = result.success;
+                if (!success) {
+                    await new Promise(r => setTimeout(r, 1500));
+                    const retry = await powerpointClient.renderHtmlToImage(files.htmlWinPath, files.pngWinPath);
+                    totalToolCalls++;
+                    success = retry.success;
+                }
             }
             catch {
-                renderSuccess = false;
+                try {
+                    await new Promise(r => setTimeout(r, 1500));
+                    const retry = await powerpointClient.renderHtmlToImage(files.htmlWinPath, files.pngWinPath);
+                    totalToolCalls++;
+                    success = retry.success;
+                }
+                catch {
+                    success = false;
+                }
             }
+            try {
+                fs.unlinkSync(files.htmlWritePath);
+            }
+            catch { }
+            if (success) {
+                try {
+                    const stat = fs.statSync(files.pngWritePath);
+                    if (stat.size < 15000) {
+                        logger.warn(`Slide ${files.slideNum}: Screenshot too small (${stat.size} bytes)`);
+                        success = false;
+                        try {
+                            fs.unlinkSync(files.pngWritePath);
+                        }
+                        catch { }
+                    }
+                }
+                catch { }
+            }
+            if (success)
+                tempFiles.push(files.pngWritePath);
+            return { index, success };
+        }));
+        for (const { index, success } of batchResults) {
+            if (success)
+                screenshotSuccess.add(index);
         }
-        try {
-            fs.unlinkSync(htmlWritePath);
-        }
-        catch { }
-        if (!renderSuccess) {
-            logger.warn(`Slide ${slideNum}: Screenshot rendering failed, skipping`);
-            failCount++;
+        const done = Math.min(batch + MAX_SCREENSHOT_CONCURRENT, screenshotEntries.length);
+        if (phaseLogger)
+            phaseLogger('powerpoint-create', 'assembly', `Screenshots: ${done}/${screenshotEntries.length} done`);
+    }
+    if (phaseLogger)
+        phaseLogger('powerpoint-create', 'assembly', `Filling ${totalSlides} slides...`);
+    const unfilledSlideNums = [];
+    for (const [index] of sortedEntries) {
+        const files = slideFiles.get(index);
+        const slidePlan = plan.slides[index];
+        const htmlResult = htmlResults.get(index);
+        if (!files) {
+            const posInSorted = sortedEntries.findIndex(([idx]) => idx === index);
+            const inferredSlideNum = posInSorted >= 0 ? posInSorted + 1 : -1;
+            logger.warn(`Slide index ${index} (slideNum ${inferredSlideNum}): No file info, marking for deletion`);
+            if (inferredSlideNum > 0)
+                unfilledSlideNums.push(inferredSlideNum);
             continue;
         }
-        try {
-            const pngStats = fs.statSync(pngWritePath);
-            if (pngStats.size < 15000) {
-                logger.warn(`Slide ${slideNum}: Screenshot too small (${pngStats.size} bytes), likely blank — skipping`);
-                failCount++;
+        let filled = false;
+        if (screenshotSuccess.has(index)) {
+            const bgResult = await powerpointClient.powerpointAddFullSlideImage(files.slideNum, files.pngWinPath);
+            totalToolCalls++;
+            if (toolCallLogger)
+                toolCallLogger('powerpoint-create', 'addFullSlideImage', { slideNum: files.slideNum, imagePath: files.pngWinPath }, bgResult.success ? 'OK' : 'Failed', bgResult.success, files.slideNum, totalToolCalls);
+            filled = bgResult.success;
+        }
+        if (!filled) {
+            logger.info(`Slide ${files.slideNum}: Primary screenshot failed, trying fallback rendering...`);
+            const slide = plan.slides[index];
+            const fallbackHtml = buildFallbackSlideHtml(plan.design, slide.title, slide.content_direction || '', files.slideNum);
+            const fbHtmlName = `hanseol_fb_${files.slideNum}_${timestamp}.html`;
+            const fbPngName = `hanseol_fb_${files.slideNum}_${timestamp}.png`;
+            const fbHtmlWrite = path.join(tempWritePath, fbHtmlName);
+            const fbPngWrite = path.join(tempWritePath, fbPngName);
+            const fbHtmlWin = `${tempWinPath}\\${fbHtmlName}`;
+            const fbPngWin = `${tempWinPath}\\${fbPngName}`;
+            try {
+                const viewportHtml = injectEdgeSizing(fallbackHtml, plan.design.background_color);
+                fs.writeFileSync(fbHtmlWrite, viewportHtml, 'utf-8');
+                const fbResult = await powerpointClient.renderHtmlToImage(fbHtmlWin, fbPngWin);
+                totalToolCalls++;
                 try {
-                    fs.unlinkSync(pngWritePath);
+                    fs.unlinkSync(fbHtmlWrite);
+                }
+                catch { }
+                if (fbResult.success) {
+                    const bgResult = await powerpointClient.powerpointAddFullSlideImage(files.slideNum, fbPngWin);
+                    totalToolCalls++;
+                    filled = bgResult.success;
+                    try {
+                        fs.unlinkSync(fbPngWrite);
+                    }
+                    catch { }
+                }
+            }
+            catch (e) {
+                logger.warn(`Slide ${files.slideNum}: Fallback rendering also failed: ${e}`);
+                try {
+                    fs.unlinkSync(fbHtmlWrite);
                 }
                 catch { }
-                continue;
             }
         }
-        catch { }
-        tempFiles.push(pngWritePath);
-        const addResult = await powerpointClient.powerpointAddSlide(7);
-        totalToolCalls++;
-        if (!addResult.success) {
-            logger.warn(`Slide ${slideNum}: Failed to add blank slide`);
-            failCount++;
-            continue;
-        }
-        const bgResult = await powerpointClient.powerpointAddFullSlideImage(slideNum, pngWinPath);
-        totalToolCalls++;
-        if (toolCallLogger)
-            toolCallLogger('powerpoint-create', 'addFullSlideImage', { slideNum, imagePath: pngWinPath }, bgResult.success ? 'OK' : 'Failed', bgResult.success, slideNum, totalToolCalls);
-        if (bgResult.success) {
-            builtSlides.push(`Slide ${slideNum}: ${slidePlan.title} (${slidePlan.type})`);
+        if (filled) {
+            builtSlides.push(`Slide ${files.slideNum}: ${slidePlan.title} (${slidePlan.type})`);
             try {
-                await powerpointClient.powerpointAddNote(slideNum, result.html);
+                await powerpointClient.powerpointAddNote(files.slideNum, htmlResult.html);
             }
             catch { }
         }
         else {
-            logger.warn(`Slide ${slideNum}: Failed to set background: ${JSON.stringify(bgResult)}`);
-            failCount++;
+            logger.warn(`Slide ${files.slideNum}: All rendering attempts failed, marking for deletion`);
+            unfilledSlideNums.push(files.slideNum);
         }
     }
-    if (builtSlides.length > 0) {
+    if (unfilledSlideNums.length > 0) {
+        const sortedDesc = [...unfilledSlideNums].sort((a, b) => b - a);
+        for (const slideNum of sortedDesc) {
+            try {
+                await powerpointClient.powerpointDeleteSlide(slideNum);
+                totalToolCalls++;
+                logger.info(`Deleted unfilled slide ${slideNum}`);
+            }
+            catch (e) {
+                logger.warn(`Failed to delete unfilled slide ${slideNum}: ${e}`);
+            }
+        }
+    }
+    const hasClosingInPlan = plan.slides.some(s => s.type === 'closing');
+    const hasClosingBuilt = builtSlides.some(s => s.includes('(closing)'));
+    if (hasClosingInPlan && !hasClosingBuilt && builtSlides.length > 0) {
+        logger.info('Closing slide was lost during assembly — adding it now');
         try {
-            const slideCountResult = await powerpointClient.powerpointGetSlideCount();
-            const totalSlidesInPpt = slideCountResult['slide_count'] || 0;
-            if (totalSlidesInPpt > builtSlides.length) {
-                for (let d = totalSlidesInPpt; d > builtSlides.length; d--) {
-                    await powerpointClient.powerpointDeleteSlide(d);
-                    totalToolCalls++;
+            await powerpointClient.powerpointAddSlide(7);
+            totalToolCalls++;
+            const slideCountRes = await powerpointClient.powerpointGetSlideCount();
+            const newSlideNum = slideCountRes['slide_count'] || builtSlides.length + 1;
+            const closingPlan = plan.slides.find(s => s.type === 'closing');
+            const closingTagline = (closingPlan.content_direction || '').replace(/감사합니다|thank\s*you/gi, '').trim() || undefined;
+            const closingHtml = buildClosingSlideHtml(plan.design, companyName, newSlideNum, language, closingTagline);
+            const clHtmlName = `hanseol_closing_${timestamp}.html`;
+            const clPngName = `hanseol_closing_${timestamp}.png`;
+            const clHtmlWrite = path.join(tempWritePath, clHtmlName);
+            const clPngWrite = path.join(tempWritePath, clPngName);
+            const clHtmlWin = `${tempWinPath}\\${clHtmlName}`;
+            const clPngWin = `${tempWinPath}\\${clPngName}`;
+            const viewportHtml = injectEdgeSizing(closingHtml, plan.design.background_color);
+            fs.writeFileSync(clHtmlWrite, viewportHtml, 'utf-8');
+            const ssResult = await powerpointClient.renderHtmlToImage(clHtmlWin, clPngWin);
+            totalToolCalls++;
+            try {
+                fs.unlinkSync(clHtmlWrite);
+            }
+            catch { }
+            if (ssResult.success) {
+                const bgResult = await powerpointClient.powerpointAddFullSlideImage(newSlideNum, clPngWin);
+                totalToolCalls++;
+                if (bgResult.success) {
+                    builtSlides.push(`Slide ${newSlideNum}: ${closingPlan.title} (closing)`);
+                    logger.info('Closing slide added successfully');
+                }
+                try {
+                    fs.unlinkSync(clPngWrite);
                 }
+                catch { }
             }
         }
         catch (e) {
-            logger.warn(`Failed to clean up trailing slides: ${e}`);
+            logger.warn(`Failed to add closing slide: ${e}`);
         }
     }
     if (builtSlides.length > 0) {
@@ -1102,7 +1078,7 @@ async function runStructured(llmClient, instruction, explicitSavePath) {
     const validatedResults = await validateAndRegenerate(llmClient, htmlResults, plan, language, phaseLogger);
     if (phaseLogger)
         phaseLogger('powerpoint-create', 'assembly', `Assembling ${validatedResults.size} slides into PowerPoint...`);
-    const { builtSlides, totalToolCalls } = await assemblePresentation(validatedResults, plan, timestamp, savePath, phaseLogger, toolCallLogger);
+    const { builtSlides, totalToolCalls } = await assemblePresentation(validatedResults, plan, timestamp, savePath, companyName, language, phaseLogger, toolCallLogger);
     const duration = Date.now() - startTime;
     const slideList = builtSlides.join('\n');
     const summary = `Presentation COMPLETE — ${builtSlides.length} slides created and saved successfully.\nAll requested topics are covered across these slides. Do NOT add more slides or call powerpoint_modify_agent.\n\nSlides:\n${slideList}`;