hanseol-dev 5.0.2-dev.13 → 5.0.2-dev.131

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

@@ -0,0 +1,1295 @@
+import * as fs from 'fs';
+import * as path from 'path';
+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_CREATE_ENHANCEMENT_PROMPT, PPT_STRUCTURED_PLANNING_PROMPT, buildSlideHtmlPrompt, } from './powerpoint-create-prompts.js';
+const DEFAULT_DESIGN = {
+    primary_color: '#1B2A4A',
+    accent_color: '#00D4AA',
+    background_color: '#FFFFFF',
+    text_color: '#1A1A2E',
+    accent_light: '#E8F5F0',
+    gradient_end: '#2D5F8A',
+    font_title: 'Segoe UI',
+    font_body: 'Malgun Gothic',
+    mood: 'modern-minimal',
+    design_notes: 'Clean gradients, card-based layouts',
+};
+function extractContent(msg) {
+    const content = msg['content'];
+    if (content && content.trim())
+        return content;
+    const reasoning = msg['reasoning_content'];
+    if (reasoning && reasoning.trim())
+        return reasoning;
+    return '';
+}
+function validateAndFixPlan(plan) {
+    if (!plan.design)
+        return 'Missing design object';
+    if (!plan.design.primary_color || !plan.design.accent_color) {
+        return 'Missing design colors (primary_color, accent_color)';
+    }
+    if (!Array.isArray(plan.slides) || plan.slides.length < 3) {
+        return 'slides array must have at least 3 entries';
+    }
+    if (plan.slides.length < 10) {
+        return `Only ${plan.slides.length} slides — minimum 10 required (aim for 12-15). Add more content slides with specific data.`;
+    }
+    if (plan.slides[0]?.type !== 'title') {
+        logger.info('Auto-fixing: first slide type changed to "title"');
+        plan.slides[0].type = 'title';
+    }
+    const lastSlide = plan.slides[plan.slides.length - 1];
+    if (lastSlide.type !== 'closing') {
+        logger.info('Auto-fixing: last slide type changed to "closing"');
+        lastSlide.type = 'closing';
+    }
+    for (let i = 0; i < plan.slides.length; i++) {
+        if (!plan.slides[i].title) {
+            plan.slides[i].title = `Slide ${i + 1}`;
+            logger.info(`Auto-fixing: slide ${i + 1} missing title, set placeholder`);
+        }
+    }
+    const layoutOnlyPatterns = [
+        /^(?:전체\s*배경|왼쪽에|오른쪽에|중앙에|상단에|하단에)/,
+        /#[0-9a-fA-F]{3,8}에서.*그라데이션/,
+        /(?:accent_light|primary|gradient_end)\s*(?:배경|글씨|색상)/,
+        /^(?:CSS|flexbox|grid|conic-gradient|linear-gradient)/i,
+    ];
+    for (let i = 0; i < plan.slides.length; i++) {
+        const slide = plan.slides[i];
+        if (slide.type === 'title' || slide.type === 'closing')
+            continue;
+        const cd = slide.content_direction || '';
+        const hasNumbers = /\d/.test(cd);
+        const isLayoutOnly = layoutOnlyPatterns.some(p => p.test(cd));
+        if (isLayoutOnly && !hasNumbers) {
+            return `Slide ${i + 1} "${slide.title}" content_direction contains layout instructions instead of actual data. content_direction must include REAL text/numbers to display.`;
+        }
+    }
+    return null;
+}
+function repairLlmJson(raw) {
+    let result = '';
+    let inString = false;
+    let i = 0;
+    while (i < raw.length) {
+        const ch = raw[i];
+        if (!inString) {
+            if (ch === ',') {
+                let j = i + 1;
+                while (j < raw.length && /\s/.test(raw[j]))
+                    j++;
+                if (j < raw.length && (raw[j] === '}' || raw[j] === ']')) {
+                    i++;
+                    continue;
+                }
+            }
+            result += ch;
+            if (ch === '"')
+                inString = true;
+            i++;
+            continue;
+        }
+        if (ch === '\\') {
+            result += ch;
+            if (i + 1 < raw.length) {
+                result += raw[i + 1];
+                i += 2;
+            }
+            else {
+                i++;
+            }
+            continue;
+        }
+        if (ch === '"') {
+            let j = i + 1;
+            while (j < raw.length && /[ \t\r\n]/.test(raw[j]))
+                j++;
+            const next = j < raw.length ? raw[j] : '';
+            if (next === '' || /[,:}\]]/.test(next)) {
+                result += '"';
+                inString = false;
+            }
+            else {
+                result += '\\"';
+            }
+            i++;
+            continue;
+        }
+        if (ch === '\n') {
+            result += '\\n';
+            i++;
+            continue;
+        }
+        if (ch === '\r') {
+            result += '\\n';
+            i += (i + 1 < raw.length && raw[i + 1] === '\n') ? 2 : 1;
+            continue;
+        }
+        if (ch === '\t') {
+            result += '\\t';
+            i++;
+            continue;
+        }
+        if (ch.charCodeAt(0) < 0x20) {
+            i++;
+            continue;
+        }
+        result += ch;
+        i++;
+    }
+    return result;
+}
+function parseJsonPlan(raw) {
+    let cleaned = raw.trim();
+    if (cleaned.startsWith('```')) {
+        cleaned = cleaned.replace(/^```(?:json|JSON)?\s*\n?/, '').replace(/\n?```\s*$/, '');
+    }
+    const firstBrace = cleaned.indexOf('{');
+    if (firstBrace > 0) {
+        cleaned = cleaned.slice(firstBrace);
+    }
+    const lastBrace = cleaned.lastIndexOf('}');
+    if (lastBrace >= 0 && lastBrace < cleaned.length - 1) {
+        cleaned = cleaned.slice(0, lastBrace + 1);
+    }
+    try {
+        return JSON.parse(cleaned);
+    }
+    catch (e) {
+        logger.debug('parseJsonPlan: direct parse failed', { error: String(e), length: cleaned.length });
+    }
+    const match = cleaned.match(/\{[\s\S]*\}/);
+    if (!match)
+        return null;
+    try {
+        return JSON.parse(match[0]);
+    }
+    catch { }
+    const repaired = repairLlmJson(match[0]);
+    try {
+        return JSON.parse(repaired);
+    }
+    catch (e) {
+        logger.debug('parseJsonPlan: repaired parse failed', { error: String(e) });
+    }
+    try {
+        let final = repaired;
+        let braces = 0, brackets = 0;
+        let inStr = false, esc = false;
+        for (const ch of final) {
+            if (esc) {
+                esc = false;
+                continue;
+            }
+            if (ch === '\\') {
+                esc = true;
+                continue;
+            }
+            if (ch === '"') {
+                inStr = !inStr;
+                continue;
+            }
+            if (inStr)
+                continue;
+            if (ch === '{')
+                braces++;
+            else if (ch === '}')
+                braces--;
+            else if (ch === '[')
+                brackets++;
+            else if (ch === ']')
+                brackets--;
+        }
+        if (inStr)
+            final += '"';
+        for (let i = 0; i < brackets; i++)
+            final += ']';
+        for (let i = 0; i < braces; i++)
+            final += '}';
+        return JSON.parse(final);
+    }
+    catch {
+        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 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>`;
+    const injection = overrideCss;
+    if (result.includes('</head>')) {
+        result = result.replace('</head>', `${injection}</head>`);
+    }
+    else if (result.includes('<head>')) {
+        result = result.replace('<head>', `<head>${injection}`);
+    }
+    else if (result.includes('<html')) {
+        result = result.replace(/<html[^>]*>/, (match) => `${match}<head>${injection}</head>`);
+    }
+    else {
+        result = injection + result;
+    }
+    return result;
+}
+function enforceMinFontSize(html) {
+    const MIN_PX = 26;
+    let result = html.replace(/font-size:\s*(\d+(?:\.\d+)?)px/g, (_match, size) => {
+        const px = parseFloat(size);
+        return (px > 12 && px < MIN_PX) ? `font-size:${MIN_PX}px` : _match;
+    });
+    result = result.replace(/font-size:\s*(\d+(?:\.\d+)?)pt/g, (_match, size) => {
+        const pt = parseFloat(size);
+        const px = pt * 1.333;
+        return (px > 12 && px < MIN_PX) ? `font-size:${MIN_PX}px` : _match;
+    });
+    result = result.replace(/font-size:\s*(\d+(?:\.\d+)?)r?em/g, (_match, size) => {
+        const em = parseFloat(size);
+        const px = em * 16;
+        return (px > 12 && px < MIN_PX) ? `font-size:${MIN_PX}px` : _match;
+    });
+    result = result.replace(/font-size:\s*(\d+(?:\.\d+)?)%/g, (_match, size) => {
+        const pct = parseFloat(size);
+        const px = pct / 100 * 16;
+        return (px > 12 && px < MIN_PX) ? `font-size:${MIN_PX}px` : _match;
+    });
+    return result;
+}
+function ensureSafeBodyPadding(html) {
+    const safeStyle = `<style>body{padding-top:20px!important;padding-bottom:40px!important;min-height:auto!important}body>div:last-child,body>section:last-child{margin-bottom:0!important;padding-bottom:0!important}</style>`;
+    if (html.includes('</head>')) {
+        return html.replace('</head>', `${safeStyle}</head>`);
+    }
+    return html;
+}
+function stripGradientTextEffects(html) {
+    let result = html.replace(/-webkit-text-fill-color:\s*transparent/gi, '-webkit-text-fill-color:initial');
+    result = result.replace(/background-clip:\s*text/gi, 'background-clip:initial');
+    result = result.replace(/-webkit-background-clip:\s*text/gi, '-webkit-background-clip:initial');
+    return result;
+}
+function removeAbsolutePositioning(html) {
+    let result = html.replace(/style="([^"]*)position:\s*absolute([^"]*)"/gi, (match, before, after) => {
+        if (/(?:width|height):\s*[1-5]?\dpx/i.test(before + after) || /opacity:\s*0\.[0-4]/i.test(before + after)) {
+            return match;
+        }
+        let cleaned = `${before}position:static${after}`;
+        cleaned = cleaned.replace(/(?:^|;)\s*(?:top|left|right|bottom):\s*[^;]+/gi, '');
+        return `style="${cleaned}"`;
+    });
+    result = result.replace(/(<style[^>]*>)([\s\S]*?)(<\/style>)/gi, (_m, open, css, close) => {
+        let fixed = css.replace(/position:\s*absolute/gi, 'position:static');
+        fixed = fixed.replace(/position:\s*static([^}]*)/gi, (ruleMatch) => {
+            return ruleMatch.replace(/(?:^|;)\s*(?:top|left|right|bottom):\s*[^;{}]+/gi, '');
+        });
+        return open + fixed + close;
+    });
+    result = result.replace(/transform:\s*translate[^;)]*\)/gi, 'transform:none');
+    result = result.replace(/transform:\s*scale\(\s*0\.\d+\s*\)/gi, 'transform:none');
+    result = result.replace(/transform:\s*scale\(\s*0\.\d+\s*,\s*0\.\d+\s*\)/gi, 'transform:none');
+    result = result.replace(/zoom:\s*0\.\d+/gi, 'zoom:1');
+    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 injectMeasureCss(html) {
+    let result = html.replace(/<meta\s+name=["']viewport["'][^>]*>/gi, '');
+    const measureCss = `<style>*{box-sizing:border-box;word-break:keep-all;overflow-wrap:break-word;overflow:visible!important;max-height:none!important}html{width:2040px!important;height:auto!important;min-height:auto!important;margin:0!important}body{width:1920px!important;min-width:1920px!important;height:auto!important;min-height:auto!important;overflow:visible!important;margin:0!important}</style>`;
+    const injection = measureCss;
+    if (result.includes('</head>')) {
+        result = result.replace('</head>', `${injection}</head>`);
+    }
+    else if (result.includes('<head>')) {
+        result = result.replace('<head>', `<head>${injection}`);
+    }
+    else if (result.includes('<html')) {
+        result = result.replace(/<html[^>]*>/, (match) => `${match}<head>${injection}</head>`);
+    }
+    else {
+        result = injection + result;
+    }
+    const measureScript = `<script>document.title='SH:'+document.documentElement.scrollHeight</script>`;
+    if (result.includes('</body>')) {
+        result = result.replace('</body>', `${measureScript}</body>`);
+    }
+    else {
+        result += measureScript;
+    }
+    return result;
+}
+function injectFillMeasureCss(html) {
+    let result = html.replace(/<meta\s+name=["']viewport["'][^>]*>/gi, '');
+    const fillCss = `<style>*{box-sizing:border-box;word-break:keep-all;overflow-wrap:break-word;min-height:auto!important;height:auto!important}html{width:2040px!important;margin:0!important;height:auto!important}body{width:1920px!important;min-width:1920px!important;margin:0!important;display:block!important;height:auto!important;min-height:auto!important;overflow:visible!important}body>*{flex:none!important}body *{flex-grow:0!important;flex-shrink:1!important;flex-basis:auto!important}</style>`;
+    const measureScript = `<script>document.title='SH:'+document.documentElement.scrollHeight</script>`;
+    if (result.includes('</head>')) {
+        result = result.replace('</head>', `${fillCss}</head>`);
+    }
+    else if (result.includes('<head>')) {
+        result = result.replace('<head>', `<head>${fillCss}`);
+    }
+    else if (result.includes('<html')) {
+        result = result.replace(/<html[^>]*>/, (match) => `${match}<head>${fillCss}</head>`);
+    }
+    else {
+        result = fillCss + result;
+    }
+    if (result.includes('</body>')) {
+        result = result.replace('</body>', `${measureScript}</body>`);
+    }
+    else {
+        result += measureScript;
+    }
+    return result;
+}
+function escapeHtml(text) {
+    return text
+        .replace(/&/g, '&amp;')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;');
+}
+function buildTitleSlideHtml(design, mainTitle, subtitle, date, _slideNum) {
+    return `<!DOCTYPE html>
+<html lang="ko">
+<head>
+<meta charset="UTF-8">
+<style>
+* { margin: 0; padding: 0; box-sizing: border-box; }
+html { background-color: ${design.primary_color}; }
+html, body { width: 1920px; height: 1080px; overflow: hidden; }
+body {
+  background: linear-gradient(135deg, ${design.primary_color} 0%, ${design.gradient_end} 60%, ${design.primary_color} 100%);
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  justify-content: center;
+  font-family: "${design.font_title}", "Segoe UI", sans-serif;
+}
+body::before {
+  content: '';
+  display: block;
+  width: 100%;
+  height: 6px;
+  background: linear-gradient(90deg, transparent, ${design.accent_color}, transparent);
+  flex-shrink: 0;
+}
+.slide-content {
+  text-align: center;
+  max-width: 1400px;
+  padding: 0 60px;
+}
+.main-title {
+  font-size: 96px;
+  font-weight: 800;
+  color: #ffffff;
+  letter-spacing: -2px;
+  text-shadow: 0 6px 40px rgba(0,0,0,0.25);
+  line-height: 1.1;
+  margin-bottom: 32px;
+}
+.accent-bar {
+  width: 120px; height: 5px;
+  background: ${design.accent_color};
+  margin: 0 auto 32px;
+  border-radius: 3px;
+  box-shadow: 0 0 20px ${design.accent_color}40;
+}
+.subtitle {
+  font-size: 32px;
+  font-weight: 400;
+  color: rgba(255,255,255,0.88);
+  font-family: "${design.font_body}", "Malgun Gothic", sans-serif;
+  line-height: 1.5;
+  margin-bottom: 16px;
+}
+.date-text {
+  font-size: 22px;
+  font-weight: 300;
+  color: rgba(255,255,255,0.55);
+  font-family: "${design.font_body}", "Malgun Gothic", sans-serif;
+}
+</style>
+</head>
+<body>
+<div class="slide-content">
+  <div class="main-title">${escapeHtml(mainTitle)}</div>
+  <div class="accent-bar"></div>
+  ${subtitle ? `<div class="subtitle">${escapeHtml(subtitle)}</div>` : ''}
+  <div class="date-text">${escapeHtml(date)}</div>
+</div>
+<style>body{align-items:center!important;justify-content:center!important}.slide-content{flex:unset!important;min-height:unset!important;display:flex!important;flex-direction:column!important;align-items:center!important;justify-content:center!important}.slide-content>*{flex:unset!important;min-height:unset!important}</style>
+</body>
+</html>`;
+}
+function buildClosingSlideHtml(design, companyName, _slideNum, language) {
+    const thankYou = language === 'ko' ? '감사합니다' : 'Thank You';
+    return `<!DOCTYPE html>
+<html lang="${language}">
+<head>
+<meta charset="UTF-8">
+<style>
+* { margin: 0; padding: 0; box-sizing: border-box; }
+html { background-color: ${design.primary_color}; }
+html, body { width: 1920px; height: 1080px; overflow: hidden; }
+body {
+  background: linear-gradient(135deg, ${design.primary_color} 0%, ${design.gradient_end} 60%, ${design.primary_color} 100%);
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  justify-content: center;
+  font-family: "${design.font_title}", "Segoe UI", sans-serif;
+}
+body::after {
+  content: '';
+  display: block;
+  width: 100%;
+  height: 6px;
+  background: linear-gradient(90deg, transparent, ${design.accent_color}, transparent);
+  flex-shrink: 0;
+}
+.slide-content {
+  text-align: center;
+}
+.thank-you {
+  font-size: 96px;
+  font-weight: 800;
+  color: #ffffff;
+  letter-spacing: -1px;
+  text-shadow: 0 6px 40px rgba(0,0,0,0.25);
+  margin-bottom: 32px;
+}
+.accent-bar {
+  width: 100px; height: 5px;
+  background: ${design.accent_color};
+  margin: 0 auto 32px;
+  border-radius: 3px;
+  box-shadow: 0 0 20px ${design.accent_color}40;
+}
+.company {
+  font-size: 36px;
+  font-weight: 500;
+  color: rgba(255,255,255,0.80);
+  font-family: "${design.font_body}", "Malgun Gothic", sans-serif;
+}
+</style>
+</head>
+<body>
+<div class="slide-content">
+  <div class="thank-you">${escapeHtml(thankYou)}</div>
+  <div class="accent-bar"></div>
+  <div class="company">${escapeHtml(companyName)}</div>
+</div>
+<style>body{align-items:center!important;justify-content:center!important}.slide-content{flex:unset!important;min-height:unset!important;display:flex!important;flex-direction:column!important;align-items:center!important;justify-content:center!important}.slide-content>*{flex:unset!important;min-height:unset!important}</style>
+</body>
+</html>`;
+}
+function isOverviewSlide(title, slideIndex) {
+    if (slideIndex !== 1)
+        return false;
+    const overviewKeywords = /개요|목차|overview|agenda|outline|순서|발표\s*구성|contents|목록/i;
+    return overviewKeywords.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;
+  transition: none;
+}
+.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 getTempDir() {
+    const platform = getPlatform();
+    if (platform === 'wsl') {
+        return { writePath: '/mnt/c/temp', winPath: 'C:\\temp' };
+    }
+    return { writePath: 'C:\\temp', winPath: 'C:\\temp' };
+}
+function ensureTempDir(writePath) {
+    if (!fs.existsSync(writePath)) {
+        fs.mkdirSync(writePath, { recursive: true });
+    }
+}
+function normalizeDesign(raw) {
+    return {
+        primary_color: raw['primary_color'] || DEFAULT_DESIGN.primary_color,
+        accent_color: raw['accent_color'] || DEFAULT_DESIGN.accent_color,
+        background_color: raw['background_color'] || DEFAULT_DESIGN.background_color,
+        text_color: raw['text_color'] || DEFAULT_DESIGN.text_color,
+        accent_light: raw['accent_light'] || DEFAULT_DESIGN.accent_light,
+        gradient_end: raw['gradient_end'] || DEFAULT_DESIGN.gradient_end,
+        font_title: raw['font_title'] || DEFAULT_DESIGN.font_title,
+        font_body: raw['font_body'] || DEFAULT_DESIGN.font_body,
+        mood: raw['mood'] || DEFAULT_DESIGN.mood,
+        design_notes: raw['design_notes'] || DEFAULT_DESIGN.design_notes,
+    };
+}
+async function runStructured(llmClient, instruction, explicitSavePath) {
+    const startTime = Date.now();
+    const phaseLogger = getSubAgentPhaseLogger();
+    const toolCallLogger = getSubAgentToolCallLogger();
+    let totalToolCalls = 0;
+    const timestamp = Date.now();
+    logger.enter('PPT-Create.runStructured');
+    const hasKorean = /[\uac00-\ud7af\u1100-\u11ff]/.test(instruction);
+    const language = hasKorean ? 'ko' : 'en';
+    if (phaseLogger)
+        phaseLogger('powerpoint-create', 'enhancement', 'Generating creative guidance...');
+    let guidance = '';
+    try {
+        const enhRes = await llmClient.chatCompletion({
+            messages: [
+                { role: 'system', content: PPT_CREATE_ENHANCEMENT_PROMPT },
+                { role: 'user', content: instruction },
+            ],
+            temperature: 0.7,
+            max_tokens: 2000,
+        });
+        const enhMsg = enhRes.choices[0]?.message;
+        guidance = enhMsg ? extractContent(enhMsg) : '';
+        if (guidance.length < 1500) {
+            logger.warn('PPT enhancement too short, retrying', { length: guidance.length });
+            const retryEnhRes = await llmClient.chatCompletion({
+                messages: [
+                    { role: 'system', content: PPT_CREATE_ENHANCEMENT_PROMPT },
+                    { role: 'user', content: `${instruction}\n\nIMPORTANT: Produce a COMPLETE, DETAILED design system and content plan. Include ALL 7 sections: DOCUMENT_TYPE, AUDIENCE, MOOD, COLOR PALETTE (6 hex values), FONTS, SLIDE PLAN (10-15 slides), DESIGN NOTES. Do NOT stop early.` },
+                ],
+                temperature: 0.7,
+                max_tokens: 2000,
+            });
+            const retryMsg = retryEnhRes.choices[0]?.message;
+            const retryGuidance = retryMsg ? extractContent(retryMsg) : '';
+            if (retryGuidance.length > guidance.length) {
+                guidance = retryGuidance;
+            }
+        }
+        if (phaseLogger)
+            phaseLogger('powerpoint-create', 'enhancement', `Done (${guidance.length} chars)`);
+    }
+    catch (e) {
+        logger.warn('PPT enhancement failed, proceeding without', { error: String(e) });
+    }
+    const enhancedInstruction = guidance
+        ? `${instruction}\n\n═══ CREATIVE GUIDANCE ═══\n${guidance}\n═══ END GUIDANCE ═══`
+        : instruction;
+    if (phaseLogger)
+        phaseLogger('powerpoint-create', 'planning', 'Generating JSON plan...');
+    let plan = null;
+    try {
+        const planRes = await llmClient.chatCompletion({
+            messages: [
+                { role: 'system', content: PPT_STRUCTURED_PLANNING_PROMPT },
+                { role: 'user', content: enhancedInstruction },
+            ],
+            temperature: 0.4,
+            max_tokens: 8000,
+        });
+        const planMsg = planRes.choices[0]?.message;
+        const finishReason = planRes.choices[0]?.finish_reason;
+        const rawPlan = planMsg ? extractContent(planMsg) : '';
+        if (finishReason === 'length') {
+            logger.warn('PPT planning response was truncated (finish_reason=length)');
+        }
+        logger.debug('PPT planning raw response', { length: rawPlan.length, finishReason, first200: rawPlan.slice(0, 200) });
+        plan = rawPlan ? parseJsonPlan(rawPlan) : null;
+        if (plan) {
+            plan.design = normalizeDesign(plan.design);
+            const validationError = validateAndFixPlan(plan);
+            if (validationError) {
+                logger.warn('PPT plan validation failed', { error: validationError });
+                if (phaseLogger)
+                    phaseLogger('powerpoint-create', 'planning', `Validation failed: ${validationError}. Retrying...`);
+                const retryRes = await llmClient.chatCompletion({
+                    messages: [
+                        { role: 'system', content: PPT_STRUCTURED_PLANNING_PROMPT },
+                        { role: 'user', content: enhancedInstruction },
+                        { role: 'assistant', content: rawPlan },
+                        { role: 'user', content: `ERROR: ${validationError}\n\nFix the issues and output the corrected JSON. Remember: aim for 10-12 slides with REAL content data in each content_direction.` },
+                    ],
+                    temperature: 0.2,
+                    max_tokens: 8000,
+                });
+                const retryMsg = retryRes.choices[0]?.message;
+                const retryRaw = retryMsg ? extractContent(retryMsg) : '';
+                const retryPlan = retryRaw ? parseJsonPlan(retryRaw) : null;
+                if (retryPlan) {
+                    retryPlan.design = normalizeDesign(retryPlan.design);
+                    const retryError = validateAndFixPlan(retryPlan);
+                    if (!retryError) {
+                        plan = retryPlan;
+                        if (phaseLogger)
+                            phaseLogger('powerpoint-create', 'planning', `Retry succeeded (${plan.slides.length} slides)`);
+                    }
+                    else {
+                        plan = null;
+                    }
+                }
+                else {
+                    plan = null;
+                }
+            }
+            else {
+                if (phaseLogger)
+                    phaseLogger('powerpoint-create', 'planning', `Done (${plan.slides.length} slides)`);
+            }
+        }
+        else {
+            logger.warn('PPT JSON plan parsing failed');
+            if (phaseLogger)
+                phaseLogger('powerpoint-create', 'planning', 'JSON parsing failed. Falling back.');
+        }
+    }
+    catch (e) {
+        logger.warn('PPT planning failed', { error: String(e) });
+        if (phaseLogger)
+            phaseLogger('powerpoint-create', 'planning', 'Planning error. Falling back.');
+    }
+    if (!plan) {
+        logger.error('PPT planning failed after retries — cannot create presentation');
+        return {
+            success: false,
+            error: 'Failed to generate presentation plan. Please try again.',
+        };
+    }
+    if (plan.slides.length > 15) {
+        logger.warn(`PPT plan has ${plan.slides.length} slides, capping to 15`);
+        const firstSlide = plan.slides[0];
+        const lastSlide = plan.slides[plan.slides.length - 1];
+        const contentSlides = plan.slides.slice(1, -1).slice(0, 13);
+        plan.slides = [firstSlide, ...contentSlides, lastSlide];
+        if (phaseLogger)
+            phaseLogger('powerpoint-create', 'planning', `Capped to ${plan.slides.length} slides`);
+    }
+    const userYearMatch = instruction.match(/(\d{4})년/);
+    if (userYearMatch) {
+        const userYear = userYearMatch[1];
+        for (const slide of plan.slides) {
+            if (slide.type === 'content' && slide.content_direction) {
+                if (!slide.content_direction.includes(`${userYear}년`)) {
+                    slide.content_direction += ` (Note: This report covers ${userYear}년 data.)`;
+                }
+            }
+        }
+    }
+    const companyMatch = instruction.match(/회사명\s*[:：]\s*([^\s,，、]+)/);
+    if (companyMatch && companyMatch[1]) {
+        const companyName_ = companyMatch[1];
+        const titleSlide = plan.slides.find(s => s.type === 'title');
+        if (titleSlide) {
+            if (titleSlide.title.trim() !== companyName_) {
+                const originalTitle = titleSlide.title;
+                titleSlide.title = companyName_;
+                if (!titleSlide.content_direction?.includes(originalTitle)) {
+                    const stripped = originalTitle.replace(companyName_, '').replace(/^\s*[-–—:|\s]+/, '').trim();
+                    const subtitle = stripped || originalTitle;
+                    titleSlide.content_direction = subtitle + (titleSlide.content_direction ? '\n' + titleSlide.content_direction : '');
+                }
+            }
+        }
+    }
+    if (phaseLogger)
+        phaseLogger('powerpoint-create', 'execution', 'Starting HTML rendering pipeline...');
+    const { writePath: tempWritePath, winPath: tempWinPath } = getTempDir();
+    ensureTempDir(tempWritePath);
+    let savePath = explicitSavePath;
+    if (!savePath) {
+        const fullPathMatch = instruction.match(/([A-Za-z]:\\[^\s,]+\.pptx|\/[^\s,]+\.pptx)/i);
+        if (fullPathMatch) {
+            savePath = fullPathMatch[1];
+        }
+        else {
+            const nameMatch = instruction.match(/([\w][\w\-_.]*\.pptx)/i);
+            if (nameMatch) {
+                savePath = `C:\\temp\\${nameMatch[1]}`;
+            }
+        }
+    }
+    const titleSlidePlanForDate = plan.slides.find(s => s.type === 'title');
+    const dateSearchTexts = [
+        instruction,
+        titleSlidePlanForDate?.title || '',
+        titleSlidePlanForDate?.content_direction || '',
+    ];
+    let kstDate = '';
+    for (const text of dateSearchTexts) {
+        const dateMatch = text.match(/(\d{4})년\s*(\d{1,2})\s*(월|분기)/);
+        if (dateMatch) {
+            kstDate = `${dateMatch[1]}년 ${dateMatch[2]}${dateMatch[3]}`;
+            break;
+        }
+    }
+    if (!kstDate) {
+        const kstNow = new Date(Date.now() + 9 * 60 * 60 * 1000);
+        kstDate = `${kstNow.getUTCFullYear()}년 ${kstNow.getUTCMonth() + 1}월`;
+    }
+    const titleSlidePlan = plan.slides.find(s => s.type === 'title');
+    const rawTitleText = titleSlidePlan?.title || '';
+    const titleSeps = [' - ', ' – ', ' — ', ': ', ' | '];
+    let companyName = rawTitleText;
+    let titleSubtitle = '';
+    for (const sep of titleSeps) {
+        const idx = rawTitleText.indexOf(sep);
+        if (idx > 0) {
+            companyName = rawTitleText.slice(0, idx).trim();
+            titleSubtitle = rawTitleText.slice(idx + sep.length).trim();
+            break;
+        }
+    }
+    if (!titleSubtitle && titleSlidePlan) {
+        titleSubtitle = ((titleSlidePlan.content_direction || '').split('\n')[0] || '').trim().slice(0, 120);
+    }
+    if (/로고|슬로건|연락처|contact|logo|placeholder/i.test(titleSubtitle)) {
+        titleSubtitle = '';
+    }
+    const createResult = await powerpointClient.powerpointCreate();
+    totalToolCalls++;
+    if (toolCallLogger)
+        toolCallLogger('powerpoint-create', 'powerpoint_create', {}, createResult.success ? 'Created' : createResult['error'] || '', createResult.success, 0, totalToolCalls);
+    if (!createResult.success) {
+        return { success: false, error: `Failed to create presentation: ${createResult['error']}` };
+    }
+    const builtSlides = [];
+    let failCount = 0;
+    const tempFiles = [];
+    for (let i = 0; i < plan.slides.length; i++) {
+        const slidePlan = plan.slides[i];
+        const slideNum = i + 1;
+        if (failCount >= 3) {
+            logger.warn('Too many slide failures, stopping');
+            break;
+        }
+        if (phaseLogger)
+            phaseLogger('powerpoint-create', 'execution', `Rendering slide ${slideNum}/${plan.slides.length}: ${slidePlan.title}`);
+        let html = null;
+        let htmlPrompt = null;
+        if (slidePlan.type === 'title') {
+            html = buildTitleSlideHtml(plan.design, companyName, titleSubtitle, kstDate, slideNum);
+        }
+        else if (slidePlan.type === 'closing') {
+            html = buildClosingSlideHtml(plan.design, companyName, slideNum, language);
+        }
+        else if (isOverviewSlide(slidePlan.title, i)) {
+            const overviewItems = parseOverviewItems(slidePlan.content_direction || '');
+            if (overviewItems.length >= 2) {
+                const firstLine = (slidePlan.content_direction || '').split('\n')[0] || '';
+                const overviewSubtitle = /^\d/.test(firstLine.trim()) ? '' : firstLine.trim();
+                html = buildOverviewSlideHtml(plan.design, slidePlan.title, overviewSubtitle, overviewItems, slideNum);
+                logger.info(`Slide ${slideNum}: Using code-generated overview template (${overviewItems.length} items)`);
+            }
+        }
+        if (!html && slidePlan.type !== 'title' && slidePlan.type !== 'closing') {
+            const cleanedDirection = (slidePlan.content_direction || '')
+                .replace(/\s*Layout\s*:\s*[^\n]*/gi, '')
+                .trim();
+            htmlPrompt = buildSlideHtmlPrompt(slidePlan.title, cleanedDirection, plan.design, i, plan.slides.length, language);
+            try {
+                const htmlRes = await llmClient.chatCompletion({
+                    messages: [
+                        { role: 'system', content: htmlPrompt },
+                        { role: 'user', content: 'Generate the HTML slide now.' },
+                    ],
+                    temperature: 0.3,
+                    max_tokens: 8000,
+                });
+                const htmlMsg = htmlRes.choices[0]?.message;
+                const rawHtml = htmlMsg ? extractContent(htmlMsg) : '';
+                html = extractHtml(rawHtml);
+                if (!html && rawHtml.length > 100) {
+                    logger.warn(`Slide ${slideNum}: HTML extraction failed, retrying`);
+                    const retryRes = await llmClient.chatCompletion({
+                        messages: [
+                            { role: 'system', content: htmlPrompt },
+                            { role: 'user', content: 'Generate the complete HTML document. Start with <!DOCTYPE html> and end with </html>. No markdown fences.' },
+                        ],
+                        temperature: 0.2,
+                        max_tokens: 4000,
+                    });
+                    const retryMsg = retryRes.choices[0]?.message;
+                    const retryRaw = retryMsg ? extractContent(retryMsg) : '';
+                    html = extractHtml(retryRaw);
+                }
+            }
+            catch (e) {
+                logger.warn(`Slide ${slideNum}: LLM call failed: ${e}`);
+            }
+        }
+        if (!html) {
+            logger.warn(`Slide ${slideNum}: Failed to generate HTML, skipping`);
+            failCount++;
+            continue;
+        }
+        const OVERFLOW_THRESHOLD = 1000;
+        if (htmlPrompt) {
+            const MAX_REGEN_ATTEMPTS = 5;
+            for (let attempt = 0; attempt < MAX_REGEN_ATTEMPTS; attempt++) {
+                const measureFileName = `hanseol_measure_${slideNum}_${timestamp}_${attempt}.html`;
+                const measureWritePath = path.join(tempWritePath, measureFileName);
+                const measureWinPath = `${tempWinPath}\\${measureFileName}`;
+                try {
+                    fs.writeFileSync(measureWritePath, injectMeasureCss(html), 'utf-8');
+                    const contentHeight = await powerpointClient.measureHtmlHeight(measureWinPath);
+                    try {
+                        fs.unlinkSync(measureWritePath);
+                    }
+                    catch { }
+                    if (contentHeight <= OVERFLOW_THRESHOLD) {
+                        if (attempt > 0)
+                            logger.info(`Slide ${slideNum}: Fits after ${attempt} regeneration(s) (${contentHeight}px)`);
+                        break;
+                    }
+                    logger.warn(`Slide ${slideNum}: Content overflows (${contentHeight}px > ${OVERFLOW_THRESHOLD}), attempt ${attempt + 1}/${MAX_REGEN_ATTEMPTS}`);
+                    if (phaseLogger)
+                        phaseLogger('powerpoint-create', 'execution', `Slide ${slideNum}: overflow (${contentHeight}px), regen ${attempt + 1}/${MAX_REGEN_ATTEMPTS}...`);
+                    try {
+                        const regenRes = await llmClient.chatCompletion({
+                            messages: [
+                                { role: 'system', content: htmlPrompt },
+                                { role: 'user', content: `Generate the HTML slide now. CRITICAL: Your previous version was ${contentHeight}px tall but the viewport is only 1080px (with ~60px padding = ~1020px usable). Content was CLIPPED at the bottom by ${contentHeight - 1000}px.\n\nFix by COMPACTING — do NOT remove content:\n- Reduce title font to 36px max, body text to 20-22px\n- Reduce card padding to 20px, gaps to 12-16px\n- Reduce margins between sections to 12px\n- Keep ALL data items — just make them more compact\n- If using a header strip, keep it under 80px\n${attempt >= 2 ? '- LAST CHANCE: Use minimal padding (12px), small fonts (18px body), tight gaps (8px). Keep all content.' : ''}\n\nThis is attempt ${attempt + 1}.` },
+                            ],
+                            temperature: 0.2,
+                            max_tokens: 8000,
+                        });
+                        const regenMsg = regenRes.choices[0]?.message;
+                        const regenRaw = regenMsg ? extractContent(regenMsg) : '';
+                        const regenHtml = extractHtml(regenRaw);
+                        if (regenHtml) {
+                            html = regenHtml;
+                            logger.info(`Slide ${slideNum}: Regenerated HTML (attempt ${attempt + 1})`);
+                        }
+                        else {
+                            break;
+                        }
+                    }
+                    catch (e) {
+                        logger.warn(`Slide ${slideNum}: Overflow regeneration attempt ${attempt + 1} failed: ${e}`);
+                        break;
+                    }
+                }
+                catch {
+                    break;
+                }
+            }
+        }
+        const MIN_FILL_HEIGHT = 600;
+        const MAX_FILL_ATTEMPTS = 1;
+        if (htmlPrompt && slidePlan.type === 'content') {
+            if (phaseLogger)
+                phaseLogger('powerpoint-create', 'execution', `Slide ${slideNum}: starting fill measurement...`);
+            for (let fillAttempt = 0; fillAttempt < MAX_FILL_ATTEMPTS; fillAttempt++) {
+                const fillFileName = `hanseol_fill_${slideNum}_${timestamp}_${fillAttempt}.html`;
+                const fillWritePath = path.join(tempWritePath, fillFileName);
+                const fillWinPath = `${tempWinPath}\\${fillFileName}`;
+                try {
+                    fs.writeFileSync(fillWritePath, injectFillMeasureCss(html), 'utf-8');
+                    const naturalHeight = await powerpointClient.measureHtmlHeight(fillWinPath);
+                    if (naturalHeight > 0) {
+                        try {
+                            fs.unlinkSync(fillWritePath);
+                        }
+                        catch { }
+                    }
+                    if (phaseLogger)
+                        phaseLogger('powerpoint-create', 'execution', `Slide ${slideNum}: fill=${naturalHeight}px (${Math.round(naturalHeight / 1080 * 100)}%), threshold=${MIN_FILL_HEIGHT}px`);
+                    if (naturalHeight > 0 && naturalHeight < MIN_FILL_HEIGHT) {
+                        const fillPct = Math.round(naturalHeight / 1080 * 100);
+                        logger.warn(`Slide ${slideNum}: Underfill — natural height ${naturalHeight}px (${fillPct}%). Attempt ${fillAttempt + 1}/${MAX_FILL_ATTEMPTS}...`);
+                        if (phaseLogger)
+                            phaseLogger('powerpoint-create', 'execution', `Slide ${slideNum}: underfill (${fillPct}%), regen attempt ${fillAttempt + 1}...`);
+                        try {
+                            const fillRes = await llmClient.chatCompletion({
+                                messages: [
+                                    { role: 'system', content: htmlPrompt },
+                                    { role: 'user', content: `Generate the HTML slide now.\n\nCRITICAL FEEDBACK: Your previous version only fills ${fillPct}% of the slide vertically (natural content height: ${naturalHeight}px, slide: 1080px). The slide looks EMPTY with huge blank areas at the bottom.\n\nYou MUST add MORE ACTUAL CONTENT to fill the slide. Target: 85-95% fill. DO NOT exceed 1080px.\n\nADD MORE CONTENT:\n- Each card/section needs 4-6 bullet points (not 2-3)\n- Add a 2-3 sentence descriptive paragraph under each heading\n- Include specific numbers, percentages, and comparisons in every bullet\n- Add a summary/insight box at the bottom of each card\n- Use larger font sizes: titles 36-40px, body 26-28px, metrics 48-56px\n- Use generous padding: 48px 40px inside cards, 24px between items\n- Add a footer bar with additional context or page numbers\n\nDo NOT use CSS tricks (flex:1, min-height) to stretch empty space — add real text content instead.` },
+                                ],
+                                temperature: 0.3,
+                                max_tokens: 8000,
+                            });
+                            const fillMsg = fillRes.choices[0]?.message;
+                            const fillRaw = fillMsg ? extractContent(fillMsg) : '';
+                            const fillHtml = extractHtml(fillRaw);
+                            if (fillHtml) {
+                                const overflowCheckFile = `hanseol_ocheck_${slideNum}_${timestamp}_${fillAttempt}.html`;
+                                const overflowCheckPath = path.join(tempWritePath, overflowCheckFile);
+                                const overflowCheckWin = `${tempWinPath}\\${overflowCheckFile}`;
+                                let overflowOk = true;
+                                try {
+                                    fs.writeFileSync(overflowCheckPath, injectMeasureCss(fillHtml), 'utf-8');
+                                    const regenHeight = await powerpointClient.measureHtmlHeight(overflowCheckWin);
+                                    try {
+                                        fs.unlinkSync(overflowCheckPath);
+                                    }
+                                    catch { }
+                                    if (regenHeight > OVERFLOW_THRESHOLD) {
+                                        logger.warn(`Slide ${slideNum}: Fill regen overflows (${regenHeight}px), keeping original`);
+                                        overflowOk = false;
+                                    }
+                                }
+                                catch {
+                                    try {
+                                        fs.unlinkSync(overflowCheckPath);
+                                    }
+                                    catch { }
+                                }
+                                if (!overflowOk)
+                                    break;
+                                html = fillHtml;
+                                logger.info(`Slide ${slideNum}: Regenerated with more content (was ${fillPct}% fill, attempt ${fillAttempt + 1})`);
+                                continue;
+                            }
+                        }
+                        catch (e) {
+                            logger.warn(`Slide ${slideNum}: Fill regeneration failed: ${e}`);
+                        }
+                        break;
+                    }
+                    else if (naturalHeight > 0) {
+                        const fillPct = Math.round(naturalHeight / 1080 * 100);
+                        logger.info(`Slide ${slideNum}: Fill OK — ${naturalHeight}px (${fillPct}%)`);
+                        break;
+                    }
+                    else {
+                        if (phaseLogger)
+                            phaseLogger('powerpoint-create', 'execution', `Slide ${slideNum}: fill measure returned 0, skipping`);
+                        break;
+                    }
+                }
+                catch (fillErr) {
+                    if (phaseLogger)
+                        phaseLogger('powerpoint-create', 'execution', `Slide ${slideNum}: fill measure FAILED: ${fillErr}`);
+                    break;
+                }
+            }
+        }
+        const htmlFileName = `hanseol_slide_${slideNum}_${timestamp}.html`;
+        const pngFileName = `hanseol_slide_${slideNum}_${timestamp}.png`;
+        const htmlWritePath = path.join(tempWritePath, htmlFileName);
+        const pngWritePath = path.join(tempWritePath, pngFileName);
+        const htmlWinPath = `${tempWinPath}\\${htmlFileName}`;
+        const pngWinPath = `${tempWinPath}\\${pngFileName}`;
+        try {
+            const processed = injectTitleContrastFix(ensureSafeBodyPadding(removeAbsolutePositioning(stripGradientTextEffects(enforceMinFontSize(injectViewportCss(html, plan.design.background_color))))), plan.design.text_color);
+            fs.writeFileSync(htmlWritePath, processed, 'utf-8');
+            tempFiles.push(htmlWritePath);
+        }
+        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;
+            }
+        }
+        catch (e) {
+            logger.warn(`Slide ${slideNum}: Edge screenshot failed: ${e}`);
+            try {
+                await new Promise(r => setTimeout(r, 2000));
+                const retryRender = await powerpointClient.renderHtmlToImage(htmlWinPath, pngWinPath);
+                totalToolCalls++;
+                renderSuccess = retryRender.success;
+            }
+            catch {
+                renderSuccess = false;
+            }
+        }
+        try {
+            fs.unlinkSync(htmlWritePath);
+        }
+        catch { }
+        if (!renderSuccess) {
+            logger.warn(`Slide ${slideNum}: Screenshot rendering failed, skipping`);
+            failCount++;
+            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++;
+                try {
+                    fs.unlinkSync(pngWritePath);
+                }
+                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})`);
+            try {
+                await powerpointClient.powerpointAddNote(slideNum, html);
+            }
+            catch { }
+        }
+        else {
+            logger.warn(`Slide ${slideNum}: Failed to set background: ${JSON.stringify(bgResult)}`);
+            failCount++;
+        }
+    }
+    if (builtSlides.length > 0) {
+        try {
+            const slideCountResult = await powerpointClient.powerpointGetSlideCount();
+            const totalSlidesInPpt = slideCountResult['slide_count'] || 0;
+            if (totalSlidesInPpt > builtSlides.length) {
+                logger.warn(`PPT has ${totalSlidesInPpt} slides but only ${builtSlides.length} were rendered — deleting ${totalSlidesInPpt - builtSlides.length} trailing blanks`);
+                for (let d = totalSlidesInPpt; d > builtSlides.length; d--) {
+                    await powerpointClient.powerpointDeleteSlide(d);
+                    totalToolCalls++;
+                }
+            }
+        }
+        catch (e) {
+            logger.warn(`Failed to clean up trailing slides: ${e}`);
+        }
+    }
+    if (builtSlides.length > 0) {
+        if (savePath) {
+            const wslSavePath = savePath.replace(/\\/g, '/').replace(/^([A-Za-z]):/, (_m, d) => `/mnt/${d.toLowerCase()}`);
+            try {
+                fs.unlinkSync(wslSavePath);
+            }
+            catch { }
+        }
+        let saveResult = await powerpointClient.powerpointSave(savePath);
+        totalToolCalls++;
+        if (toolCallLogger)
+            toolCallLogger('powerpoint-create', 'powerpoint_save', { path: savePath }, saveResult.success ? (saveResult['path'] || 'OK') : (saveResult.error || 'Failed'), saveResult.success, 0, totalToolCalls);
+        if (!saveResult.success && savePath) {
+            const fallbackPath = 'C:\\temp\\presentation.pptx';
+            saveResult = await powerpointClient.powerpointSave(fallbackPath);
+            totalToolCalls++;
+            if (toolCallLogger)
+                toolCallLogger('powerpoint-create', 'powerpoint_save', { path: fallbackPath }, saveResult.success ? (saveResult['path'] || 'OK') : (saveResult.error || 'Failed'), saveResult.success, 0, totalToolCalls);
+        }
+    }
+    for (const tempFile of tempFiles) {
+        try {
+            fs.unlinkSync(tempFile);
+        }
+        catch { }
+    }
+    const duration = Date.now() - startTime;
+    const summary = `Presentation created with ${builtSlides.length} slides (HTML rendering, ${plan.design.mood}):\n${builtSlides.join('\n')}`;
+    logger.exit('PPT-Create.runStructured', { slideCount: builtSlides.length, totalToolCalls, duration });
+    return {
+        success: builtSlides.length > 0,
+        result: summary,
+        metadata: { iterations: plan.slides.length, toolCalls: totalToolCalls, duration },
+    };
+}
+export function createPowerPointCreateRequestTool() {
+    return {
+        definition: {
+            type: 'function',
+            function: {
+                name: 'powerpoint_create_agent',
+                description: 'Autonomous PowerPoint CREATION agent. Creates NEW presentations from scratch with professional slide designs, color schemes, and visual hierarchy. Uses HTML rendering pipeline for maximum design quality — each slide is rendered as a beautiful HTML page and captured as a high-quality image. Give it a topic or outline and it produces a polished, enterprise-grade presentation. For EDITING existing .pptx files, use powerpoint_modify_agent instead.',
+                parameters: {
+                    type: 'object',
+                    properties: {
+                        instruction: {
+                            type: 'string',
+                            description: 'Detailed instruction for creating a new presentation. Include: topic/title, desired content, and design preferences. The agent autonomously creates a professional presentation with title, content, and closing slides.',
+                        },
+                        save_path: {
+                            type: 'string',
+                            description: 'Windows file path to save the presentation (e.g., "C:\\\\temp\\\\pitch.pptx"). MUST be provided if the user specified a save path.',
+                        },
+                    },
+                    required: ['instruction'],
+                },
+            },
+        },
+        execute: async (args, llmClient) => {
+            const instruction = args['instruction'];
+            const explicitSavePath = args['save_path'];
+            return runStructured(llmClient, instruction, explicitSavePath);
+        },
+        categories: ['llm-agent'],
+        requiresSubLLM: true,
+    };
+}
+//# sourceMappingURL=powerpoint-create-agent.js.map