hanseol-dev 5.0.3-dev.2 → 5.0.3-dev.20

package/dist/agents/office/powerpoint-create-agent.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"powerpoint-create-agent.d.ts","sourceRoot":"","sources":["../../../src/agents/office/powerpoint-create-agent.ts"],"names":[],"mappings":"AAcA,OAAO,EAAE,YAAY,EAAc,MAAM,sBAAsB,CAAC;AAkzChE,wBAAgB,iCAAiC,IAAI,YAAY,CAkChE"}
+{"version":3,"file":"powerpoint-create-agent.d.ts","sourceRoot":"","sources":["../../../src/agents/office/powerpoint-create-agent.ts"],"names":[],"mappings":"AAcA,OAAO,EAAE,YAAY,EAAc,MAAM,sBAAsB,CAAC;AAmgDhE,wBAAgB,iCAAiC,IAAI,YAAY,CAkChE"}

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, buildDirectHtmlPrompt, validateSlideHtml, extractLayoutHint, buildContentFillJsonPrompt, parseContentFillJson, buildContentSlideHtml, } from './powerpoint-create-prompts.js';
+import { PPT_DESIGN_PROMPT, validateSlideHtml, extractLayoutHint, buildContentFillJsonPrompt, parseContentFillJson, buildContentSlideHtml, } from './powerpoint-create-prompts.js';
 const DEFAULT_DESIGN = {
     primary_color: '#1B2A4A',
     accent_color: '#00D4AA',
@@ -17,7 +17,7 @@ const DEFAULT_DESIGN = {
     mood: 'modern-minimal',
     design_notes: 'Clean gradients, card-based layouts',
 };
-const MAX_CONCURRENT = 3;
+const MAX_CONCURRENT = 5;
 function extractContent(msg) {
     const content = msg['content'];
     if (content && content.trim())
@@ -228,18 +228,6 @@ function parseJsonPlan(raw) {
         return null;
     }
 }
-function extractHtml(raw) {
-    const trimmed = raw.trim();
-    if (trimmed.startsWith('<!DOCTYPE') || trimmed.startsWith('<html'))
-        return trimmed;
-    const fenceMatch = trimmed.match(/```(?:html)?\s*\n([\s\S]*?)\n```/);
-    if (fenceMatch?.[1])
-        return fenceMatch[1].trim();
-    const docMatch = trimmed.match(/(<!DOCTYPE[\s\S]*<\/html>)/i);
-    if (docMatch?.[1])
-        return docMatch[1].trim();
-    return null;
-}
 function injectEdgeSizing(html, backgroundColor) {
     let result = html.replace(/<meta\s+name=["']viewport["'][^>]*>/gi, '');
     const bgColor = backgroundColor || '#000000';
@@ -258,24 +246,6 @@ function injectEdgeSizing(html, backgroundColor) {
     }
     return result;
 }
-function injectViewportCss(html, backgroundColor) {
-    let result = html.replace(/<meta\s+name=["']viewport["'][^>]*>/gi, '');
-    const bgColor = backgroundColor || '#000000';
-    const overrideCss = `<style>*{box-sizing:border-box;word-break:keep-all;overflow-wrap:break-word}html{width:2040px!important;height:1200px!important;overflow:hidden!important;margin:0!important;background-color:${bgColor}!important;zoom:1!important}body{width:1920px!important;height:1080px!important;min-width:1920px!important;min-height:1080px!important;overflow:hidden!important;margin:0!important;display:flex!important;flex-direction:column!important;zoom:1!important;font-size:26px!important}body>div,body>main,body>section,body>article,body>header,body>footer{max-width:none!important;zoom:1!important}body>*>div,body>*>main,body>*>section,body>*>article{max-width:none!important;zoom:1!important}body>*:only-child{display:flex!important;flex-direction:column!important;flex:1!important;min-height:1080px!important}body>*:only-child>*:nth-child(2),body>*:only-child>*:nth-child(3),body>*:only-child>*:last-child:not(:first-child){flex:1!important;display:flex!important;align-items:stretch!important}body>.content,body>*:nth-child(2),body>*:nth-child(3),body *>.content,body [class*=content]{flex:1!important;align-items:stretch!important;align-content:stretch!important;grid-auto-rows:1fr!important}[class*=card],[class*=item],[class*=step],[class*=milestone],[class*=feature]{justify-content:flex-start!important;gap:20px!important}</style>`;
-    if (result.includes('</head>')) {
-        result = result.replace('</head>', `${overrideCss}</head>`);
-    }
-    else if (result.includes('<head>')) {
-        result = result.replace('<head>', `<head>${overrideCss}`);
-    }
-    else if (result.includes('<html')) {
-        result = result.replace(/<html[^>]*>/, (m) => `${m}<head>${overrideCss}</head>`);
-    }
-    else {
-        result = overrideCss + result;
-    }
-    return result;
-}
 function injectTitleContrastFix(html, designTextColor) {
     const safeColor = designTextColor.replace(/'/g, "\\'");
     const script = `<script>(function(){` +
@@ -589,6 +559,71 @@ body {
 </body>
 </html>`;
 }
+function buildFallbackSlideHtml(design, title, contentDirection, slideNum) {
+    const items = [];
+    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) {
+            const sentence = cleaned.split(/[.。!]\s/)[0] || cleaned;
+            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      ');
+    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}", "Malgun Gothic", sans-serif;
+  padding: 80px 100px;
+  display: flex;
+  flex-direction: column;
+}
+.header { margin-bottom: 48px; }
+.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; }
+</style>
+</head>
+<body>
+<div class="header">
+  <div class="slide-num">SLIDE ${slideNum}</div>
+  <h1>${escapeHtml(title)}</h1>
+  <div class="accent-bar"></div>
+</div>
+<div class="content">
+  ${bulletsHtml}
+</div>
+</body>
+</html>`;
+}
 function getTempDir() {
     const platform = getPlatform();
     if (platform === 'wsl') {
@@ -683,34 +718,64 @@ 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 || '');
-    const directPrompt = buildDirectHtmlPrompt(slide.title, cleanedDirection, design, slideIndex, totalSlides, language, layoutType);
-    try {
-        const res = await llmClient.chatCompletion({
-            messages: [
-                { role: 'system', content: directPrompt },
-                { role: 'user', content: 'Generate the HTML slide now.' },
-            ],
-            temperature: 0.4,
-            max_tokens: 6000,
-        });
-        const msg = res.choices[0]?.message;
-        const rawHtml = msg ? extractContent(msg) : '';
-        const html = extractHtml(rawHtml);
-        if (html) {
-            const validation = validateSlideHtml(html, layoutType);
-            if (validation.pass) {
-                return { html, isCodeTemplate: false };
+const LAYOUT_ALTERNATIVES = {
+    cards: ['progress_bars', 'hero_stat', 'donut_chart', 'two_col_split', 'process_flow', 'timeline'],
+};
+const CARDS_KEEP_KEYWORDS = /team|팀|case|사례|success|성과|partner|파트너|고객|customer|member|멤버/i;
+function rebalanceLayouts(plan) {
+    const contentSlides = plan.slides.filter(s => s.type === 'content');
+    const counts = new Map();
+    const slidesByLayout = new Map();
+    for (const slide of contentSlides) {
+        const layout = extractLayoutHint(slide.content_direction || '');
+        counts.set(layout, (counts.get(layout) || 0) + 1);
+        if (!slidesByLayout.has(layout))
+            slidesByLayout.set(layout, []);
+        slidesByLayout.get(layout).push(slide);
+    }
+    for (const [layout, count] of counts) {
+        if (count <= 2)
+            continue;
+        const slides = slidesByLayout.get(layout);
+        const keepSlides = slides.filter(s => CARDS_KEEP_KEYWORDS.test(s.title));
+        const reassignCandidates = slides.filter(s => !CARDS_KEEP_KEYWORDS.test(s.title));
+        const keepCount = Math.max(2, keepSlides.length);
+        const excess = reassignCandidates.slice(Math.max(0, keepCount - keepSlides.length));
+        if (excess.length === 0)
+            continue;
+        const alternatives = LAYOUT_ALTERNATIVES[layout] || ['progress_bars', 'hero_stat', 'donut_chart', 'two_col_split'];
+        const usedAlts = new Set();
+        for (const slide of excess) {
+            let chosen = null;
+            for (const alt of alternatives) {
+                const altCount = (counts.get(alt) || 0) + (usedAlts.has(alt) ? 1 : 0);
+                if (altCount < 2) {
+                    chosen = alt;
+                    usedAlts.add(alt);
+                    break;
+                }
             }
-            logger.info(`Slide ${slideIndex + 1}: Direct HTML failed validation: ${validation.feedback}`);
+            if (!chosen)
+                chosen = alternatives[0];
+            const cd = slide.content_direction || '';
+            const hasLayoutHint = /Layout:\s*.+$/im.test(cd);
+            const layoutName = chosen.replace(/_/g, ' ');
+            if (hasLayoutHint) {
+                slide.content_direction = cd.replace(/Layout:\s*.+$/im, `Layout: ${layoutName}`);
+            }
+            else {
+                slide.content_direction = cd + `\nLayout: ${layoutName}`;
+            }
+            counts.set(chosen, (counts.get(chosen) || 0) + 1);
+            counts.set(layout, counts.get(layout) - 1);
+            logger.info(`Rebalance: "${slide.title}" layout changed from ${layout} → ${chosen}`);
         }
     }
-    catch (e) {
-        logger.warn(`Slide ${slideIndex + 1}: Direct HTML LLM call failed: ${e}`);
-    }
-    logger.info(`Slide ${slideIndex + 1}: Falling back to code template "${layoutType}"`);
+}
+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);
     try {
         const jsonRes = await llmClient.chatCompletion({
@@ -725,6 +790,7 @@ async function generateSingleSlideHtml(llmClient, slide, design, slideIndex, tot
         const jsonRaw = jsonMsg ? extractContent(jsonMsg) : '';
         let slideData = parseContentFillJson(jsonRaw, layoutType);
         if (!slideData) {
+            logger.warn(`Slide ${slideIndex + 1}: JSON fill parse failed (attempt 1). Layout: ${layoutType}. Raw length: ${jsonRaw.length}. First 200 chars: ${jsonRaw.slice(0, 200)}`);
             const retryRes = await llmClient.chatCompletion({
                 messages: [
                     { role: 'system', content: jsonPrompt },
@@ -736,6 +802,9 @@ async function generateSingleSlideHtml(llmClient, slide, design, slideIndex, tot
             const retryMsg = retryRes.choices[0]?.message;
             const retryRaw = retryMsg ? extractContent(retryMsg) : '';
             slideData = parseContentFillJson(retryRaw, layoutType);
+            if (!slideData) {
+                logger.warn(`Slide ${slideIndex + 1}: JSON fill parse failed (attempt 2). Raw length: ${retryRaw.length}. First 200 chars: ${retryRaw.slice(0, 200)}`);
+            }
         }
         if (slideData) {
             const html = buildContentSlideHtml(design, slide.title, layoutType, slideData, slideIndex + 1, slideIndex);
@@ -797,6 +866,12 @@ async function generateAllHtml(llmClient, plan, companyName, titleSubtitle, kstD
             if (result) {
                 results.set(index, { index, html: result.html, isCodeTemplate: result.isCodeTemplate });
             }
+            else {
+                const slide = plan.slides[index];
+                const fallbackHtml = buildFallbackSlideHtml(plan.design, slide.title, slide.content_direction || '', index + 1);
+                results.set(index, { index, html: fallbackHtml, isCodeTemplate: true });
+                logger.warn(`Slide ${index + 1}: Using fallback HTML for "${slide.title}"`);
+            }
         }
         const done = Math.min(batch + MAX_CONCURRENT, contentIndices.length);
         if (phaseLogger)
@@ -823,38 +898,55 @@ async function validateAndRegenerate(llmClient, htmlResults, plan, language, pha
         return htmlResults;
     }
     if (phaseLogger)
-        phaseLogger('powerpoint-create', 'validation', `${failedIndices.length} slides failed validation, regenerating...`);
-    for (const index of failedIndices) {
-        const slide = plan.slides[index];
-        const original = htmlResults.get(index);
-        const result = await generateSingleSlideHtml(llmClient, slide, plan.design, index, plan.slides.length, language);
-        if (result) {
-            const regenHasPlaceholder = hasPlaceholderText(result.html);
-            const origHasPlaceholder = hasPlaceholderText(original.html);
-            if (!regenHasPlaceholder || origHasPlaceholder) {
-                htmlResults.set(index, { index, html: result.html, isCodeTemplate: result.isCodeTemplate });
+        phaseLogger('powerpoint-create', 'validation', `${failedIndices.length} slides failed validation, regenerating in parallel...`);
+    for (let batch = 0; batch < failedIndices.length; batch += MAX_CONCURRENT) {
+        const chunk = failedIndices.slice(batch, batch + MAX_CONCURRENT);
+        const promises = chunk.map(async (index) => {
+            const slide = plan.slides[index];
+            const original = htmlResults.get(index);
+            try {
+                const result = await generateSingleSlideHtml(llmClient, slide, plan.design, index, plan.slides.length, language);
+                if (result) {
+                    const regenHasPlaceholder = hasPlaceholderText(result.html);
+                    const origHasPlaceholder = hasPlaceholderText(original.html);
+                    if (!regenHasPlaceholder || origHasPlaceholder) {
+                        return { index, result: { index, html: result.html, isCodeTemplate: result.isCodeTemplate } };
+                    }
+                }
+            }
+            catch (e) {
+                logger.warn(`Slide ${index + 1}: Regen error: ${e}`);
+            }
+            return { index, result: null };
+        });
+        const chunkResults = await Promise.all(promises);
+        for (const { index, result } of chunkResults) {
+            if (result) {
+                htmlResults.set(index, result);
             }
         }
     }
     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]);
+    if (phaseLogger)
+        phaseLogger('powerpoint-create', 'assembly', `Pre-creating ${totalSlides} slides...`);
+    for (let i = 1; i < totalSlides; 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);
@@ -862,101 +954,202 @@ async function assemblePresentation(htmlResults, plan, timestamp, savePath, phas
         const htmlWinPath = `${tempWinPath}\\${htmlFileName}`;
         const pngWinPath = `${tempWinPath}\\${pngFileName}`;
         try {
-            const viewportHtml = result.isCodeTemplate
-                ? injectEdgeSizing(result.html, plan.design.background_color)
-                : injectViewportCss(result.html, plan.design.background_color);
+            const viewportHtml = injectEdgeSizing(result.html, plan.design.background_color);
             const processed = injectTitleContrastFix(viewportHtml, plan.design.text_color);
             fs.writeFileSync(htmlWritePath, processed, '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) {
@@ -1069,7 +1262,8 @@ async function runStructured(llmClient, instruction, explicitSavePath) {
     if (/로고|슬로건|연락처|contact|logo|placeholder/i.test(titleSubtitle)) {
         titleSubtitle = '';
     }
-    const companyMatch = instruction.match(/회사명\s*[:：]\s*([^\s,，、]+)/);
+    const cleanInstruction = instruction.replace(/\*\*/g, '');
+    const companyMatch = cleanInstruction.match(/회사명\s*[:：]?\s*([^\s,，、]+)/);
     if (companyMatch && companyMatch[1]) {
         const companyName_ = companyMatch[1];
         if (titleSlidePlan && titleSlidePlan.title.trim() !== companyName_) {
@@ -1083,13 +1277,14 @@ async function runStructured(llmClient, instruction, explicitSavePath) {
             }
         }
     }
+    rebalanceLayouts(plan);
     if (phaseLogger)
         phaseLogger('powerpoint-create', 'html-generation', 'Starting parallel HTML generation...');
     const htmlResults = await generateAllHtml(llmClient, plan, companyName, titleSubtitle, kstDate, language, phaseLogger);
     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}`;