Total Nodes: 74
├─ Part 1 (Generation): 28 nodes
├─ Part 2 (Distribution): 46 nodes
└─ External APIs: 5 (Notion, Gemini, Perplexity, Twitter/LinkedIn, Google Drive)

Node Distribution:
├─ Content Extraction: 7 nodes
├─ AI Processing: 5 nodes
├─ Asset Management: 12 nodes
├─ Platform Publishing: 26 nodes
├─ Error Handling: 15 nodes
└─ Status Tracking: 9 nodes

Success Rate: 99.7% (997/1000 executions)
├─ Part 1 Success: 99.8%
├─ Part 2 Success: 99.7%
├─ Concurrent Execution: 100% (zero cross-contamination)
└─ Silent Failures: <0.1% (down from 15% in v3)

Error Distribution:
├─ API Timeouts: <0.1% (auto-retry successful)
├─ Token Expiration: <0.1% (n8n auto-refresh)
├─ Network Errors: <0.2% (graceful degradation)
└─ Content Validation: <0.1% (fail-fast on critical data)

End-to-End Processing Time: 65-111 seconds (avg: 88s)

Part 1 (Generation Pipeline):
├─ Notion Extraction: 2-3s
├─ Content Processing: 3-5s
├─ Perplexity Research: 8-12s
├─ LLM Generation (parallel): 35-60s
├─ Storage & Linking: 3-5s
└─ Subtotal: 48-80s (avg: 64s)

Part 2 (Distribution Pipeline):
├─ Content Retrieval: 2-3s
├─ Asset Organization: 2-3s
├─ Twitter Posting: 5-10s
├─ LinkedIn Posting: 5-10s
├─ Blog Publishing: 3-5s
├─ Status Tracking: 2-3s
└─ Subtotal: 17-31s (avg: 24s)

Monthly Operational Cost: $0

API Usage (Free Tier):
├─ Gemini 2.5 Pro: 20-30 requests/day (limit: 1000/day)
├─ Perplexity Sonar: 1-2 requests/day (limit: 5/day)
├─ Twitter API: 20-30 posts/month (limit: 450/month)
├─ LinkedIn API: 20-30 posts/month (unlimited organic)
├─ Google Drive: <1GB storage (limit: 1TB)
├─ Notion API: ~100 requests/day (unlimited)
└─ Sanity CMS: ~30 requests/month (limit: 100K/month)

Cost Comparison:
├─ Commercial Tools: $60-300/month (Buffer, Zapier, Make)
├─ Premium AI APIs: $50-200/month (GPT-4, Claude)
├─ This System: $0/month
└─ Savings: $110-500/month ($1,320-6,000/year)

Twitter Engagement:
├─ Before (v1): 60% engagement rate
├─ After (v4): 85% engagement rate
└─ Improvement: +42%

Blog Performance:
├─ Bounce Rate: 45% → 12% (-73%)
├─ Avg Time on Page: 1:00 min → 2:00 min (+100%)
├─ SEO Optimization: Applied (titles, meta, keywords)
└─ Readability: Hierarchical structure with code examples

LinkedIn Interactions:
├─ Status: Data collection in progress (30-day verification)
├─ Expected: 3-5x interaction rate vs. generic templates
└─ Target Metrics: Comments, shares, connection requests

┌──────────────────┐
│  Notion Database │ ← I write my ideas here
│  (Source)        │
└────────┬─────────┘
         │
         ▼
    ┌─────────────┐
    │  PART 1:    │ ← AI generates platform-specific content
    │ Generation  │    (28 nodes, 48-80 sec)
    │ Pipeline    │
    └──────┬──────┘
           │
           ▼
    ┌──────────────┐
    │ Google Drive │ ← Drafts stored for review
    │  (Drafts)    │
    └──────┬───────┘
           │
           ▼
    ┌─────────────┐
    │  PART 2:    │ ← Distributes to platforms
    │Distribution │    (46+ nodes, 17-31 sec)
    │ Pipeline    │
    └──────┬──────┘
           │
    ┌──────┴──────────────┬────────────┐
    ▼                     ▼            ▼
 Twitter/X           LinkedIn       Blog/Sanity

Notion: Get Ready Content
  ↓
Filter: Has Content?
  ↓
Code: Select Content & Build User Profile
  ↓
Notion: Update Status to "Generating"

Notion: Extract All Blocks (hierarchical)
  ↓
Code: Process & Structure Content
  ↓
Code: Personal Context Builder

Perplexity API: Automated Research
  ↓
Returns: Keywords, hashtags, optimal posting times

Code: Merge All Context
  ↓
Output: Master context object (personal + content + research)

Gemini 2.5 Pro: AI Content Strategist
  ↓
Gemini 2.5 Pro: Twitter Generation (280 char focus)
  ↓
Gemini 2.5 Pro: LinkedIn Generation (1500-2800 char)
  ↓
Gemini 2.5 Pro: Blog Generation (2500+ words, SEO)

Code: Rebuild Twitter (thread structure, 4 tweets)
Code: Rebuild LinkedIn (paragraph breaks, 1 image max)
Code: Rebuild Blog (Sanity CMS blocks, SEO metadata)

Extract: Image placeholders from drafts
  ↓
Generate: Image generation prompts

Google Drive: Create session folder
  ↓
Google Drive: Save all drafts (Twitter, LinkedIn, Blog, Image manifest)

Notion: Update with draft URLs, set status to "Pending Approval"

Notion: Get Approved Content
  ↓
Extract: Folder details & session ID
  ↓
Google Drive: List all files in session folder

Code: Robust Asset Organizer (regex-based file matching)
  ↓
Prepare: Image download queue

Download: Twitter draft
Download: LinkedIn draft
Download: Blog draft
Extract: All three to memory

Download: Image task manifest
  ↓
Parse: Image requirements

Code: Detect Images Needed vs. Available
  ↓
Output: Platform-specific image plan

Prepare: Downloads list
  ↓
Loop: Batch download images

Set: All Data Ready (drafts + images + metadata)

Parse: Blog content (markdown → Sanity blocks)
  ↓
Upload: Images to Sanity
  ↓
POST: Blog to Sanity API
  ↓
Extract: Blog URL

Parse: LinkedIn content (1 image max enforcement)
  ↓
POST: LinkedIn API (OAuth2)
  ↓
Extract: Post URL
  ↓
Error Recovery: Timeout/rate limit handling

Parse: Twitter thread (4 tweets)
  ↓
Loop: Post each tweet with reply-to logic
  ↓
Extract: Tweet IDs
  ↓
Build: Thread structure
  ↓
Error Recovery: Retry logic

Update: Notion with all platform links
  ↓
Set: Status to "Posted"

const sessionId = `session_${Date.now()}_${notionId.substring(0, 8)}`;
// Example: session_1731234567890_abc12345

Twitter:  twitter_draft_session_1731234567890_abc12345.md
LinkedIn: linkedin_draft_session_1731234567890_abc12345.md
Blog:     blog_draft_session_1731234567890_abc12345.md
Images:   asset-1-session_1731234567890_abc12345.png
          asset-2-session_1731234567890_abc12345.png

Social Content Queue (Database)
├─ Content Pages (relation to source content)
├─ Status (select: Ready to Generate, Generating, Pending Approval, Approved, Posted)
├─ SessionID (text)
├─ Priority (select: High, Medium, Low)
├─ Category (select: Technical, Learning, Project Update)
├─ Drive Folder Link (URL)
├─ Twitter Draft URL (URL)
├─ LinkedIn Draft URL (URL)
├─ Blog Draft URL (URL)
├─ Image Task List URL (URL)
├─ Twitter URL (URL - after posting)
├─ LinkedIn URL (URL - after posting)
├─ Blog URL (URL - after posting)
├─ Processing Started (date)
└─ Notes (text - for debugging)

<systemContext>
  <userProfile>
    <name>Aman Suryavanshi</name>
    <role>Fresh Graduate & AI/Automation Developer</role>
    <expertise>n8n, Next.js, AI/ML, Automation</expertise>
    <personality>Authentic, curious, growth-minded, detail-oriented</personality>
    <writingStyle platform="twitter">Casual, engaging, thread-friendly, question-driven</writingStyle>
    <writingStyle platform="linkedin">Professional, detailed, story-driven, insight-rich</writingStyle>
    <goals>
      <primary>Build technical credibility for AI PM roles</primary>
      <secondary>Help fellow developers learn</secondary>
    </goals>
    <audience>Tech community, AI enthusiasts, developers, PM aspirants</audience>
    <timezone>Asia/Kolkata</timezone>
  </userProfile>
  
  <contentContext>
    <title>{sourceTitle}</title>
    <category>{contentCategory}</category>
    <summary>{intelligentSummary}</summary>
    <sections>
      <section level="1">Introduction</section>
      <section level="2">Technical Details</section>
      <section level="2">Implementation</section>
    </sections>
    <complexity>high</complexity>
    <wordCount>1200</wordCount>
    <hasCode>true</hasCode>
  </contentContext>
  
  <researchContext>
    <authenticHashtags platform="twitter">#BuildInPublic, #n8n, #Automation</authenticHashtags>
    <optimalTiming platform="linkedin">10:00-12:00 IST</optimalTiming>
    <optimalTiming platform="twitter">18:00-20:00 IST</optimalTiming>
    <keyPainPoints>Integration complexity, vendor lock-in, cost optimization</keyPainPoints>
    <trendingTopics>AI automation, no-code tools, workflow optimization</trendingTopics>
  </researchContext>
  
  <task>
    <platform>Twitter</platform>
    <requirements>
      <format>4-tweet thread</format>
      <charLimit>280 per tweet</charLimit>
      <structure>Hook → Problem → Solution → CTA</structure>
      <tone>Casual, conversational, question-driven</tone>
      <elements>Relevant hashtags, engaging hook, clear CTA</elements>
    </requirements>
  </task>
</systemContext>

const twitterPrompt = `
${xmlContext}

PLATFORM: Twitter/X
OBJECTIVE: Generate a 4-tweet thread that hooks readers and drives engagement

REQUIREMENTS:
- Format: Exactly 4 tweets, each under 280 characters
- Structure: 
  * Tweet 1: Hook (problem statement or surprising insight)
  * Tweet 2: Context (why this matters, personal experience)
  * Tweet 3: Solution (specific, actionable insight)
  * Tweet 4: CTA (question to drive replies)
- Tone: ${userProfile.writingStyle.twitter}
- Elements: Use 2-3 relevant hashtags, mention @n8n_io if relevant
- Voice: ${userProfile.personality}

OUTPUT FORMAT:
Tweet 1/4
[Your hook here]

---

Tweet 2/4
[Your context here]

---

Tweet 3/4
[Your solution here]

---

Tweet 4/4
[Your CTA here]

Generate the thread now.
`;

const linkedinPrompt = `
${xmlContext}

PLATFORM: LinkedIn
OBJECTIVE: Generate a professional post that establishes thought leadership

REQUIREMENTS:
- Format: Single post, 1500-2800 characters
- Structure:
  * Personal hook (1-2 sentences, relatable)
  * Problem/insight (what you learned, why it matters)
  * Specific examples (technical details, real numbers)
  * Key takeaway (actionable insight)
  * CTA (question or call to connect)
- Tone: ${userProfile.writingStyle.linkedin}
- Elements: Use emojis for visual breaks, proper paragraphing
- Voice: ${userProfile.personality}
- Image Strategy: Prepare for 1 image embed (API limit)

OUTPUT FORMAT:
# LinkedIn Draft

[Personal hook]

[Problem/insight paragraph]

[Specific examples with details]

[Key takeaway]

[CTA]

Generate the post now.
`;

const blogPrompt = `
${xmlContext}

PLATFORM: Personal Blog (Sanity CMS)
OBJECTIVE: Generate a comprehensive technical blog post

REQUIREMENTS:
- Format: 2500-3500 words, hierarchical structure
- Structure:
  * H1: Title (60 chars, SEO-optimized)
  * Introduction (hook + what you'll learn)
  * 4-5 H2 sections (main content)
  * H3 subsections where needed
  * Code examples (with language tags)
  * Conclusion (key takeaways + CTA)
- Tone: Technical but accessible, conversational
- Elements: 
  * Code blocks with syntax highlighting
  * Numbered lists for steps
  * Bullet points for key insights
  * Image placeholders: <<IMAGE_1>>, <<IMAGE_2>>
- SEO: Include 3-5 long-tail keywords naturally
- Voice: ${userProfile.personality}

METADATA REQUIRED:
- SEO Title: 60 characters max
- Meta Description: 160 characters max
- Slug: lowercase-with-hyphens
- Keywords: 5 comma-separated keywords

OUTPUT FORMAT:
# [SEO Title]

[Introduction paragraph]

## [H2 Section 1]

[Content with code examples]

<<IMAGE_1>>

## [H2 Section 2]

[More content]

...

## Conclusion

[Key takeaways]

---
SEO_TITLE: [60 char title]
META_DESCRIPTION: [160 char description]
SLUG: [lowercase-slug]
KEYWORDS: keyword1, keyword2, keyword3, keyword4, keyword5

Generate the blog post now.
`;

// Node: "Code – Extract & Process Content"
function intelligentSummarize(sourceContent) {
  const { fullText, sections } = sourceContent;
  let summary = "";
  
  // Priority 1: Section headings (highest signal-to-noise)
  const sectionTitles = sections
    .filter(s => s.title && s.title.length > 3)
    .map(s => `• ${s.title}`)
    .slice(0, 12)
    .join('\n');
  
  if (sectionTitles) {
    summary += "**Key Sections:**\n" + sectionTitles + "\n\n";
  }
  
  // Priority 2: First substantive content
  const contentSection = sections.find(s => s.content && s.content.length > 50);
  if (contentSection) {
    summary += "**Core Content:**\n" 
      + contentSection.content.substring(0, 500) + "...\n";
  }
  
  // Enforce 2000 char limit
  return summary.substring(0, 2000);
}

Few-Shot Approach:
- Provide 3-5 example tweets
- 500-1000 tokens per example
- Total: 1500-5000 tokens just for examples
- Cost: Higher, slower

My Zero-Shot Approach:
- Provide complete user profile + content context
- 800-1200 tokens total
- Cost: Lower, faster
- Quality: Same or better (more context)

{
  "flow": "3-Legged OAuth2",
  "tier": "Free tier (450 posts/month)",
  "scopes": ["tweet.write", "tweet.read"],
  "rateLimit": "50 requests per 15 minutes",
  "implementation": "n8n OAuth node with automatic refresh"
}

{
  "flow": "3-Legged OAuth2",
  "tier": "Free tier (organic posts only)",
  "scopes": ["w_member_social"],
  "limitation": "1 image per post (API enforced)",
  "rateLimit": "100 requests per 24 hours"
}

{
  "authentication": "OAuth2",
  "quota": "1TB per user (free)",
  "rateLimit": "No limits on free tier"
}

// Run every 4 hours
async function preemptiveOAuthRefresh() {
  const tokens = {
    twitter: $credentials('Twitter OAuth2'),
    linkedin: $credentials('LinkedIn OAuth2'),
    googleDrive: $credentials('Google Drive OAuth2')
  };

  for (const [platform, token] of Object.entries(tokens)) {
    const expiresAt = new Date(token.expires_at);
    const timeUntilExpiry = expiresAt - Date.now();
    
    // Refresh 30 minutes BEFORE expiry
    if (timeUntilExpiry < 30 * 60 * 1000) {
      const newToken = await refreshToken(platform, token.refresh_token);
      await updateCredentials(platform, newToken);
    }
  }
}

// Node: "Code – Parse LinkedIn Content"
if (markersInThisBlock.length > 0) {
  // LinkedIn API limit: 1 image only
  imageNumbersToAttach = [markersInThisBlock[0]]; // Take first image
}

{
  "retryOnFail": true,
  "maxTries": 3,
  "waitBetweenTries": 2000 // 2 seconds
}

async function postWithBackoff(platform, content, maxRetries = 5) {
  for (let attempt = 0; attempt < maxRetries; attempt++) {
    try {
      return await post(platform, content);
    } catch (error) {
      if (error.status === 429) { // Rate limit
        const delay = Math.pow(2, attempt) * 1000; // 1s, 2s, 4s, 8s, 16s
        console.log(`Rate limited, waiting ${delay}ms`);
        await sleep(delay);
      } else {
        throw error;
      }
    }
  }
  throw new Error('Max retries exceeded');
}

// Node: "Detect Images Needed vs Present"
function determineImagePlan(platformMarkers, isSocialPlatform = false) {
  
  // TIER 1: Trust the AI-generated markers (highest priority)
  if (platformMarkers.length > 0) {
    return platformMarkers; // e.g., [1, 3, 5] for Blog
  }
  
  // TIER 2: Fallback to manifest or other drafts
  if (allDiscoveredMarkers.length > 0 || manifestHasImages) {
    if (isSocialPlatform) {
      return [1]; // LinkedIn/Twitter: Attach primary image only
    } else {
      return expectedImages || []; // Blog: Attach all
    }
  }
  
  // TIER 3: No images intended
  return [];
}

asset-1-session_1731234567890_abc123.png
asset-2-session_1731234567890_abc123.png

// Node: "Organize Assets"
const availableImages = files
  .map(item => {
    const name = item.name;
    
    // Must match pattern: asset-<number>-session_
    if (!name.match(/^asset-\d+-session_/)) return null;
    
    // Validate file extension
    const validExtensions = ['.jpeg', '.jpg', '.png', '.webp'];
    if (!validExtensions.some(ext => name.toLowerCase().endsWith(ext))) {
      return null;
    }
    
    // Extract asset number
    const assetMatch = name.match(/^asset-(\d+)-session_/);
    return {
      assetNumber: parseInt(assetMatch[1], 10),
      fileId: item.id,
      fileName: name
    };
  })
  .filter(img => img !== null)
  .sort((a, b) => a.assetNumber - b.assetNumber);

// Node: "Code – Parse & Attach Tweets"
const tweetBlocks = markdownText.match(
  /\d+\/\d+[\s\S]*?(?=\n\n---\n\nTweet \d+\/\d+|\n\n---\n\n$|$)/g
);

const tweets = tweetBlocks.map((block, index) => {
  // Find image placeholder
  const imageMatch = block.match(/<<IMAGE_(\d+)>>/);
  let imageBinary = null;
  
  if (imageMatch) {
    const imageNumber = parseInt(imageMatch[1]);
    const targetImage = allCachedImages.find(img => 
      img.json.fileName.includes(`asset-${imageNumber}-`)
    );
    
    if (!targetImage) {
      throw new Error(`Image asset-${imageNumber} required but not found`);
    }
    
    imageBinary = targetImage.binary.data;
  }
  
  // Clean text
  const cleanText = block
    .replace(/Tweet \d+\/\d+/, '')
    .replace(/<<IMAGE_\d+>>/, '')
    .replace(/\n\n---\n\n$/, '')
    .trim();
  
  return {
    json: {
      order: index + 1,
      text: cleanText,
      inReplyTo: index > 0, // Thread structure
      imageBinary: imageBinary
    }
  };
});

// Node: "Code – Parse LinkedIn Content"
const markersInThisBlock = Array.from(
  block.matchAll(/<<IMAGE_(\d+)>>/g), 
  m => parseInt(m[1])
);

let imageNumbersToAttach = [];

if (markersInThisBlock.length > 0) {
  // LinkedIn API limit: 1 image only
  imageNumbersToAttach = [markersInThisBlock[0]]; // Take first
}

const cleanText = block.replace(/<<IMAGE_\d+>>/g, '').trim();
const imageBinary = imageNumbersToAttach.length > 0 
  ? findImageBinary(imageNumbersToAttach[0]) 
  : null;

// Node: "Code – Parse Blog Content"
const blockPattern = /<<IMAGE_(\d+)>>/g;
let blocks = [];
let lastIdx = 0;

while ((match = blockPattern.exec(markdownText)) !== null) {
  // Text before image
  if (match.index > lastIdx) {
    blocks.push({ 
      type: 'text', 
      content: markdownText.slice(lastIdx, match.index) 
    });
  }
  
  // Image block
  blocks.push({ 
    type: 'image', 
    imageNumber: parseInt(match[1])
  });
  
  lastIdx = blockPattern.lastIndex;
}

// Attach binaries
outputBlocks = blocks.map(block => {
  if (block.type === 'image') {
    const targetImage = allCachedImages.find(
      img => img.json.fileName.includes(`asset-${block.imageNumber}`)
    );
    return { type: 'image', binary: targetImage.binary };
  }
  return block;
});

// Node: "Code – Select Content & Profile"
const sessionId = `session_${Date.now()}_${notionId.substring(0, 8)}`;
// Example: session_1731234567890_abc12345

// Timestamp ensures uniqueness
// Notion ID fragment enables traceability

// Node: "Create folder for title"
const folderName = `${sessionId}_${sanitizedTitle}`;
// Example: session_1731234567890_abc12345_Build-in-Public-Automation

const fileName = `twitter_draft_${sessionId}.md`;
const imageFileName = `asset-${assetNumber}-${sessionId}.png`;

// Node: "Notion – Create Drafts & Request Approval"
await updateNotionPage({
  pageId: item.id,
  properties: {
    SessionID: sessionId,
    DriveFolderLink: `https://drive.google.com/drive/folders/${folderId}`,
    TwitterDraftURL: `https://drive.google.com/file/d/${twitterFileId}`,
    // ... other URLs
  }
});

// Node: "Organize Assets"
const availableImages = files
  .map(item => {
    const name = item.name;
    
    // CRITICAL: Must match exact session ID
    if (!name.includes(sessionId)) {
      return null; // Ignore files from other sessions
    }
    
    // ... rest of matching logic
  })
  .filter(img => img !== null);

Page
├─ Heading 1: "Introduction"
│  ├─ Paragraph
│  └─ Bulleted List
│     └─ Nested List Item
├─ Toggle: "Technical Details"
│  ├─ Code Block
│  └─ Image
└─ Heading 2: "Conclusion"

// Node: "Code – Extract & Process Content"
const blockMap = new Map();
const topLevelBlocks = [];

// Create map
allBlocks.forEach(block => {
  blockMap.set(block.id, { ...block, children: [] });
});

// Build relationships
allBlocks.forEach(block => {
  if (block.parent?.type === 'page_id') {
    topLevelBlocks.push(blockMap.get(block.id));
  } else if (block.parent?.type === 'block_id') {
    const parent = blockMap.get(block.parent.block_id);
    if (parent) {
      parent.children.push(blockMap.get(block.id));
    }
  }
});

function renderBlock(block, level = 0) {
  const indent = '  '.repeat(level);
  const blockData = block[block.type] || {};
  let content = '';
  let sections = [];
  let images = [];
  
  const text = extractText(blockData?.rich_text || []);
  
  // Type-specific rendering
  switch (block.type) {
    case 'heading_1':
      content = `\n# ${text}\n\n`;
      sections.push({ level: 1, title: text });
      break;
    case 'heading_2':
      content = `\n## ${text}\n\n`;
      sections.push({ level: 2, title: text });
      break;
    case 'paragraph':
      content = `${text}\n\n`;
      break;
    case 'bulleted_list_item':
      content = `${indent}- ${text}\n`;
      break;
    case 'code':
      const language = blockData?.language || 'text';
      content = `\n\`\`\`${language}\n${text}\n\`\`\`\n\n`;
      break;
    case 'image':
      const imageUrl = blockData?.file?.url || blockData?.external?.url;
      images.push({ url: imageUrl, caption: text });
      content = `\n[📸 Image: ${text}]\n\n`;
      break;
    // ... 10+ more types
  }
  
  // CRITICAL: Recursively process children
  if (block.children?.length) {
    const childrenResult = block.children
      .map(child => renderBlock(child, level + 1))
      .reduce((acc, result) => {
        acc.text += result.text;
        acc.sections = acc.sections.concat(result.sections);
        acc.images = acc.images.concat(result.images);
        return acc;
      }, { text: '', sections: [], images: [] });
    
    content += childrenResult.text;
    sections = sections.concat(childrenResult.sections);
    images = images.concat(childrenResult.images);
  }
  
  return { text: content, sections, images };
}

{
  "name": "Download – Image Task list",
  "retryOnFail": true,
  "maxTries": 3,
  "waitBetweenTries": 2000,
  "alwaysOutputData": true,
  "onError": "continueRegularOutput"
}

// Node: "Parse Image Manifest"
try {
  const taskListText = $input.first()?.json?.data;
  
  // Scenario 1: No image task list = no images required (valid)
  if (!taskListText) {
    console.log('ℹ️ No image task list (content has no images)');
    return [{ json: { expectedImageNumbers: [] } }];
  }
  
  // Scenario 2: Parse expected images
  const imageNumbers = [];
  const assetMatches = taskListText.matchAll(/Asset (\d+)/g);
  for (const match of assetMatches) {
    imageNumbers.push(parseInt(match[1]));
  }
  
  return [{ json: { expectedImageNumbers: [...new Set(imageNumbers)] } }];
  
} catch (error) {
  // Scenario 3: Parsing error = log and assume no images
  console.error(`⚠️ Error parsing manifest: ${error.message}`);
  return [{ json: { error: true, expectedImageNumbers: [] } }];
}

// Node: "Extract Folder Details"
const driveFolderUrl = item.property_drive_folder_link;

if (!driveFolderUrl) {
  throw new Error('FATAL: Drive Folder Link missing from Notion');
}

const folderId = driveFolderUrl.match(/folders\/([a-zA-Z0-9_-]+)/)?.[1];

if (!folderId) {
  throw new Error(`FATAL: Could not extract Folder ID from ${driveFolderUrl}`);
}

// Node: "Organize Assets"
try {
  // ... processing logic ...
  
  console.log('[DEBUG] files:', files);
  console.log('[DEBUG] availableImages:', availableImages);
  
  return [{ json: { notionItem, sessionId, assets } }];
  
} catch (error) {
  console.error(`❌ Error in Organize Assets: ${error.message}`);
  console.error('Stack:', error.stack);
  console.error('Input:', $input.all());
  
  return [{
    json: {
      error: true,
      message: error.message,
      context: { sessionId, fileCount: $input.all().length }
    }
  }];
}

// Node: "Notion – Update Final Status"
const results = {
  twitter: {
    success: $('Twitter – Post Tweet').all().length > 0,
    url: $('Twitter – Post Tweet').first()?.json?.url || null
  },
  linkedin: {
    success: $('LinkedIn – Post').first()?.json?.id ? true : false,
    url: $('LinkedIn – Post').first()?.json?.url || null
  },
  blog: {
    success: $('POST Blog to Sanity').first()?.json?.body?.results ? true : false,
    url: $('POST Blog to Sanity').first()?.json?.url || null
  }
};

const successCount = Object.values(results).filter(r => r.success).length;
const status = successCount === 3 ? 'Posted' 
  : successCount > 0 ? 'Partially Posted' 
  : 'Failed';

await updateNotionPage({
  pageId: item.id,
  properties: {
    Status: status,
    TwitterURL: results.twitter.url,
    LinkedInURL: results.linkedin.url,
    BlogURL: results.blog.url,
    Errors: JSON.stringify(results)
  }
});

Tweet 1: "Just built something cool with APIs. Pretty excited about it 🚀"
Tweet 2: "Tech is amazing. Love working with automation tools."
Tweet 3: "If you're interested in coding, check out my blog!"
Tweet 4: "New tutorial coming soon on workflow automation"

Metrics: 60% engagement (generic reach)
Time to write: 20 minutes
Value: Low technical credibility

Tweet 1/4: "The N x M integration problem is a nightmare. Connecting 10 AI clients to 20 tools used to mean 200 custom builds. I've started using the Model Context Protocol (MCP), which is like a USB-C for AI. It turns N*M integrations into a manageable N+M. A huge time saver."

Tweet 2/4: "Here's how I'm using it with @n8n_io. I can expose my automation workflows as tools for an LLM. For instance, an AI agent can now take an unstructured Slack support message, understand it, and trigger my n8n workflow to create a structured ticket. No manual triage."

Tweet 3/4: "It's also changing how I code. My AI assistant in Cursor can now connect directly to our private GitHub codebase and search the latest library docs via an MCP server. This means code completions are based on *current* code, not old training data. Huge improvement."

Tweet 4/4: "MCP's real power is standardization. It stops us from building bespoke plumbing for every new AI tool and lets us focus on application logic. What's the first tool you would connect to your LLM with a standard protocol? #AI #LLM #DeveloperTools #Automation #n8n"

Metrics: 85% engagement (specific, discussion-driven)
Time to write: Automated (64 seconds)
Value: High technical credibility, actionable insights

System Uptime: 99.7%
├─ Part 1 Success Rate: 99.8%
├─ Part 2 Success Rate: 99.7%
├─ OAuth Token Management: 100% (n8n built-in + retry)
└─ Error Recovery: 95% (graceful degradation + partial success)

Error Categories:
├─ API Timeouts: <0.1% (auto-retry with retryOnFail)
├─ Token Expiration: <0.1% (n8n automatic refresh)
├─ Network Errors: <0.2% (continueRegularOutput on non-critical nodes)
├─ Missing Optional Data: 0% (graceful degradation)
└─ Content Validation: <0.1% (fail-fast on critical data)

Single Content Piece Timeline:

Part 1 (Generation):
├─ Notion extraction: 2-3 sec
├─ Content processing: 3-5 sec
├─ Perplexity research: 8-12 sec
├─ LLM generation (parallel): 35-60 sec
├─ Storage & linking: 3-5 sec
└─ SUBTOTAL: 48-80 sec (avg: 64 sec)

Part 2 (Distribution):
├─ Content retrieval: 2-3 sec
├─ Asset organization: 2-3 sec
├─ Twitter posting: 5-10 sec
├─ LinkedIn posting: 5-10 sec
├─ Blog publishing: 3-5 sec
├─ Status tracking: 2-3 sec
└─ SUBTOTAL: 17-31 sec (avg: 24 sec)

TOTAL END-TO-END: 65-111 seconds (avg: 88 seconds)