wtf-p 0.2.0 → 0.3.0

package/bin/lib/manifest.js

@@ -0,0 +1,41 @@
+const path = require('path');
+
+const ROOT = path.resolve(__dirname, '../..');
+
+const MANIFEST = {
+  claude: {
+    name: 'Claude Code',
+    configDirEnv: 'CLAUDE_CONFIG_DIR',
+    defaultDir: '.claude',
+    components: [
+      {
+        id: 'workflows',
+        src: path.join(ROOT, 'core', 'write-the-f-paper'),
+        dest: 'write-the-f-paper',
+        type: 'dir'
+      },
+      {
+        id: 'commands',
+        src: path.join(ROOT, 'vendors', 'claude', 'commands', 'wtfp'),
+        dest: 'commands/wtfp',
+        type: 'dir'
+      },
+      {
+        id: 'skills',
+        src: path.join(ROOT, 'vendors', 'claude', 'skills', 'wtfp'),
+        dest: 'skills/wtfp',
+        type: 'dir'
+      },
+      {
+        id: 'plugin',
+        src: path.join(ROOT, 'vendors', 'claude', '.claude-plugin'),
+        dest: '.claude-plugin',
+        type: 'dir'
+      }
+    ]
+  },
+  // Future:
+  // gemini: { ... }
+};
+
+module.exports = MANIFEST;

package/bin/lib/utils.js

@@ -62,17 +62,25 @@ function isValidPath(inputPath) {
 }
 
 /**
- * Get the Claude config directory (respects CLAUDE_CONFIG_DIR env var)
+ * Get the configuration directory for a specific vendor
  */
-function getClaudeDir(explicitConfigDir, isGlobal = true) {
+function getVendorDir(vendor, explicitConfigDir, isGlobal = true) {
   if (!isGlobal) {
-    return path.join(process.cwd(), '.claude');
+    return path.join(process.cwd(), `.${vendor}`);
   }
 
+  const envVar = `${vendor.toUpperCase()}_CONFIG_DIR`;
   const configDir = normalizePath(explicitConfigDir) ||
-                   normalizePath(process.env.CLAUDE_CONFIG_DIR);
+                   normalizePath(process.env[envVar]);
 
-  return configDir || path.join(os.homedir(), '.claude');
+  return configDir || path.join(os.homedir(), `.${vendor}`);
+}
+
+/**
+ * Get the Claude config directory (respects CLAUDE_CONFIG_DIR env var)
+ */
+function getClaudeDir(explicitConfigDir, isGlobal = true) {
+  return getVendorDir('claude', explicitConfigDir, isGlobal);
 }
 
 /**
@@ -109,6 +117,9 @@ function readInstalledVersion(claudeDir) {
  * Write version tracking file
  */
 function writeVersionFile(claudeDir, version, installedFiles) {
+  if (!fs.existsSync(claudeDir)) {
+    fs.mkdirSync(claudeDir, { recursive: true });
+  }
   const versionFile = path.join(claudeDir, VERSION_FILE);
   const data = {
     version,
@@ -144,47 +155,56 @@ function simpleChecksum(filePath) {
 /**
  * Detect installation state
  */
-function detectInstallation(claudeDir) {
+function detectInstallation(vendorDir) {
   const result = {
     hasCommands: false,
-    hasSkill: false,
+    hasWorkflows: false,
+    hasSkills: false,
     version: null,
     partial: false,
     corrupt: false,
     commandFiles: [],
+    workflowFiles: [],
     skillFiles: []
   };
 
-  const commandsDir = path.join(claudeDir, 'commands', 'wtfp');
-  const skillDir = path.join(claudeDir, 'write-the-f-paper');
+  const commandsDir = path.join(vendorDir, 'commands', 'wtfp');
+  const workflowsDir = path.join(vendorDir, 'write-the-f-paper');
+  const skillsDir = path.join(vendorDir, 'skills', 'wtfp');
 
   result.hasCommands = fs.existsSync(commandsDir);
-  result.hasSkill = fs.existsSync(skillDir);
+  result.hasWorkflows = fs.existsSync(workflowsDir);
+  result.hasSkills = fs.existsSync(skillsDir);
 
   if (result.hasCommands) {
     result.commandFiles = collectFiles(commandsDir);
   }
-  if (result.hasSkill) {
-    result.skillFiles = collectFiles(skillDir);
+  if (result.hasWorkflows) {
+    result.workflowFiles = collectFiles(workflowsDir);
+  }
+  if (result.hasSkills) {
+    result.skillFiles = collectFiles(skillsDir);
   }
 
   // Read version info
-  const versionData = readInstalledVersion(claudeDir);
+  const versionData = readInstalledVersion(vendorDir);
   if (versionData) {
     result.version = versionData.version;
     result.corrupt = versionData.corrupt || false;
 
-    // Check for partial install (version file exists but missing dirs)
+    // Check for partial install
     if (!versionData.corrupt) {
       const expectedHasCommands = versionData.manifest?.some(f => f.path.includes('commands/wtfp'));
-      const expectedHasSkill = versionData.manifest?.some(f => f.path.includes('write-the-f-paper'));
+      const expectedHasWorkflows = versionData.manifest?.some(f => f.path.includes('write-the-f-paper'));
+      const expectedHasSkills = versionData.manifest?.some(f => f.path.includes('skills/wtfp'));
 
       if ((expectedHasCommands && !result.hasCommands) ||
-          (expectedHasSkill && !result.hasSkill)) {
+          (expectedHasWorkflows && !result.hasWorkflows) ||
+          (expectedHasSkills && !result.hasSkills)) {
         result.partial = true;
       }
     }
-  } else if (result.hasCommands || result.hasSkill) {
+  } else if (result.hasCommands || result.hasWorkflows || result.hasSkills) {
     // Files exist but no version file - legacy install
     result.version = 'legacy';
   }

package/bin/lib/wcn-compiler.js

@@ -0,0 +1,226 @@
+/**
+ * WCN Compiler (Workflow Compression Notation)
+ * A robust, state-machine based compiler for converting Verbose Markdown to Compressed WCN.
+ */
+
+const FLUFF_PATTERNS = [
+  /This ensures[^.]*\./g,
+  /This is important[^.]*\./g,
+  /Note that[^.]*\./g,
+  /Keep in mind[^.]*\./g,
+  /Remember that[^.]*\./g,
+  /As mentioned[^.]*\./g,
+  /It is important to[^.]*\./g,
+];
+
+class WCNCompiler {
+  constructor() {
+    this.lines = [];
+    this.output = [];
+    this.state = 'ROOT'; // ROOT, STEP, BASH
+    this.context = {};
+  }
+
+  compile(markdown) {
+    // 1. Pre-process: Remove fluff and normalize
+    let cleanMd = markdown;
+    FLUFF_PATTERNS.forEach(p => cleanMd = cleanMd.replace(p, ''));
+    
+    this.lines = cleanMd.split('\n');
+    this.output = [];
+    this.state = 'ROOT';
+    
+    // 2. Parse Line by Line
+    for (let i = 0; i < this.lines.length; i++) {
+      const line = this.lines[i].trim();
+      this.processLine(line, i);
+    }
+
+    // 3. Post-process: Clean up excessive newlines
+    return this.output.join('\n').replace(/\n{3,}/g, '\n\n').trim();
+  }
+
+  processLine(line, index) {
+    // Handle State Transitions
+    if (this.state === 'ROOT') {
+      if (line.startsWith('<step')) {
+        this.enterStep(line);
+      } else if (line.startsWith('<context>')) {
+        this.enterContext();
+      } else if (line.startsWith('**If') && line.endsWith(':**')) {
+        // Handle standalone conditionals (outside steps, rare but possible)
+        this.parseConditional(line, index);
+      } else if (line.startsWith('**Route')) {
+        this.parseRoute(line, index);
+      } else if (!line.startsWith('</')) {
+        // Pass through other content, but minimal
+        // We generally skip prose outside steps in WCN unless it's structural
+        if (line.startsWith('#') || line.startsWith('---')) {
+          this.output.push(line);
+        }
+      }
+    } else if (this.state === 'STEP') {
+      if (line.startsWith('</step>')) {
+        this.exitStep();
+      } else if (line.startsWith('```bash')) {
+        this.state = 'BASH';
+      } else if (line.startsWith('**If') && line.endsWith(':**')) {
+        this.parseConditional(line, index);
+      } else if (line.toLowerCase().startsWith('parse and internalize:')) {
+        this.parseParseBlock(index);
+      } else if (line.trim().startsWith('- ') || line.trim().startsWith('* ')) {
+        // Capture bullet points as instructions
+        this.output.push(line.trim());
+      } else if (line.trim().startsWith('**') && !line.includes('If')) {
+        // Capture bold instructions
+        this.output.push(line.trim());
+      }
+    } else if (this.state === 'BASH') {
+      if (line.startsWith('```')) {
+        this.state = 'STEP';
+      } else {
+        // Capture bash command (first line usually sufficient for WCN)
+        if (line && !line.startsWith('#')) {
+          this.output.push(`RUN: ${line}`);
+          // Skip rest of bash block for WCN brevity? 
+          // Current logic captures all commands. Let's capture all.
+        }
+      }
+    }
+  }
+
+  enterStep(line) {
+    this.state = 'STEP';
+    // Parse attributes: name="foo" priority="bar"
+    const nameMatch = line.match(/name="([^"]+)"/);
+    const priorityMatch = line.match(/priority="([^"]+)"/);
+    
+    const name = nameMatch ? nameMatch[1] : 'unknown';
+    const pAttr = priorityMatch ? ` p=${priorityMatch[1] === 'first' ? '1' : priorityMatch[1]}` : '';
+    
+    this.output.push(`[step:${name}${pAttr}]`);
+  }
+
+  exitStep() {
+    this.output.push('[/step]');
+    this.state = 'ROOT';
+  }
+
+  enterContext() {
+    // Context is usually multiline, handled by looking ahead or buffering
+    // For simplicity, we'll scan ahead here since we have full lines access
+    // But sticking to line-by-line:
+    // Actually, Regex is better for Context blocks as they are simple <context>...</context>
+    // Let's defer this to a specialized Regex pass *before* line processing?
+    // Or just look ahead now.
+    // Let's skip for now and rely on a pre-pass replacement for Context, similar to current tool.
+    // Why? Because Context is global metadata, usually at top.
+  }
+
+  parseConditional(line, index) {
+    // **If mode="yolo":**
+    const condition = line.replace(/\*\*If\s+/, '').replace(/:\*\*/, '').trim().replace(/["']/g, '');
+    
+    // Look ahead for the action
+    // Usually the next line or the line after
+    let action = '';
+    for (let i = 1; i < 5; i++) {
+      const next = this.lines[index + i];
+      if (next && next.trim()) {
+        action = next.trim();
+        break;
+      }
+    }
+
+    if (action) {
+      // Simplify action text
+      if (action.length > 50) action = action.substring(0, 47) + '...';
+      this.output.push(`IF ${condition} → ${action}`);
+    }
+  }
+
+  parseParseBlock(index) {
+    // Parse and internalize:
+    // - Item 1
+    // - Item 2
+    const fields = [];
+    for (let i = 1; i < 10; i++) {
+      const next = this.lines[index + i];
+      if (!next || (!next.trim().startsWith('-') && !next.trim().startsWith('*'))) break;
+      
+      const field = next.replace(/^[-*]\s+/, '').trim().split(' ')[0].toLowerCase().replace(/\s+/g, '_');
+      fields.push(field);
+    }
+    
+    if (fields.length > 0) {
+      this.output.push(`PARSE: ${fields.join(', ')}`);
+    }
+  }
+
+  parseRoute(line, index) {
+    // **Route A: Title**
+    const match = line.match(/\*\*Route\s+([A-Z]):\s*([^*]+)\*\*/);
+    if (!match) return;
+
+    // We need to buffer the route table
+    // This is hard to do line-by-line without buffering.
+    // Let's assume we handle Routes via Regex pre-pass like the original, 
+    // OR we detect the start of a route block and switch state.
+    // Given the complexity, let's stick to the Regex for Routes/Modes/Context
+    // and use State Machine for the detailed STEP logic which is where the fragility usually is.
+  }
+}
+
+/**
+ * Hybrid Compiler:
+ * 1. Uses Regex for high-level blocks (Context, Routes, Modes)
+ * 2. Uses State Machine for Steps (the most complex part)
+ */
+function compile(markdown) {
+  let result = markdown;
+
+  // 1. Remove fluff
+  FLUFF_PATTERNS.forEach(p => result = result.replace(p, ''));
+
+  // 2. Compress Context (Regex is fine here)
+  result = result.replace(/<context>\s*([\s\S]*?)<\/context>/g, (match, content) => {
+    const files = content.match(/@[^\s\n]+/g) || [];
+    if (files.length === 0) return '';
+    const simplified = files.map(f => f.replace('@.planning/', ''));
+    return `@context{${simplified.join(',')}}`;
+  });
+
+  // 3. Compress Routes (Regex is fine here)
+  const routes = [];
+  result = result.replace(/\*\*Route\s+([A-Z]):\s*([^*]+)\*\*\s*([\s\S]*?)(?=\*\*Route|<step|$)/g, (match, id, title, content) => {
+    // Extract next step logic
+    const nextMatch = content.match(/\`\/wtfp:([^`]+)\`/);
+    const next = nextMatch ? `/wtfp:${nextMatch[1]}` : 'continue';
+    routes.push(`  ${title.trim().toLowerCase().replace(/\s+/g, '_')} → "${title.trim()}" → ${next}`);
+    return '';
+  });
+  if (routes.length > 0) {
+    result = result + '\n\nROUTE{condition → output → next}:\n' + routes.join('\n');
+  }
+
+  // 4. Compress Modes (Regex is fine here)
+  const modes = [];
+  result = result.replace(/\*\*If\s+mode="([^"]+)":\*\*\s*\n((?:[-*]\s+[^\n]+\n?)+)/g, (match, mode, items) => {
+    const itemList = items.split('\n').filter(l => l.trim()).map(l => l.replace(/^[-*]\s+/, '').trim());
+    modes.push(`  ${mode} | ${itemList[0] || ''}`);
+    return '';
+  });
+  if (modes.length > 0) {
+    result = 'MODE{name,action}:\n' + modes.join('\n') + '\n\n' + result;
+  }
+
+  // 5. Compress Steps using State Machine (The Core Logic)
+  const compiler = new WCNCompiler();
+  // We only run the compiler on the text that remains (which should be mostly steps)
+  // But wait, the compiler expects full text to find steps.
+  // Let's pass the text to the compiler, but the compiler only outputs Step blocks and structural elements.
+  
+  return compiler.compile(result);
+}
+
+module.exports = { compile, WCNCompiler };

package/bin/uninstall.js

@@ -102,7 +102,9 @@ if (hasHelp) {
 
   ${c.yellow('What gets removed:')}
     ${c.dim('commands/wtfp/')}         - WTF-P slash commands
-    ${c.dim('write-the-f-paper/')}     - WTF-P skill and workflows
+    ${c.dim('write-the-f-paper/')}     - WTF-P workflows
+    ${c.dim('skills/wtfp/')}           - WTF-P skills
+    ${c.dim('.claude-plugin/')}        - Plugin manifest
     ${c.dim('.wtfp-version')}          - Version tracking file
 
   ${c.yellow('What stays intact:')}
@@ -200,9 +202,9 @@ async function uninstall(isGlobal) {
 
   // Detect installation
   const installed = detectInstallation(claudeDir);
-  const totalFiles = installed.commandFiles.length + installed.skillFiles.length;
+  const totalFiles = installed.commandFiles.length + installed.workflowFiles.length + installed.skillFiles.length;
 
-  if (!installed.hasCommands && !installed.hasSkill) {
+  if (!installed.hasCommands && !installed.hasWorkflows && !installed.hasSkills) {
     out.log(`  ${c.yellow('No WTF-P installation found in ' + locationLabel)}\n`);
 
     // Check for backups if requested
@@ -252,13 +254,21 @@ async function uninstall(isGlobal) {
   out.log(`  ${c.yellow('Found WTF-P installation:')}\n`);
 
   const commandsDir = path.join(claudeDir, 'commands', 'wtfp');
-  const skillDir = path.join(claudeDir, 'write-the-f-paper');
+  const workflowsDir = path.join(claudeDir, 'write-the-f-paper');
+  const skillsDir = path.join(claudeDir, 'skills', 'wtfp');
+  const pluginDir = path.join(claudeDir, '.claude-plugin');
 
   if (installed.hasCommands) {
     out.log(`    ${c.cyan('commands/wtfp/')} (${installed.commandFiles.length} files)`);
   }
-  if (installed.hasSkill) {
-    out.log(`    ${c.cyan('write-the-f-paper/')} (${installed.skillFiles.length} files)`);
+  if (installed.hasWorkflows) {
+    out.log(`    ${c.cyan('write-the-f-paper/')} (${installed.workflowFiles.length} files)`);
+  }
+  if (installed.hasSkills) {
+    out.log(`    ${c.cyan('skills/wtfp/')} (${installed.skillFiles.length} files)`);
+  }
+  if (fs.existsSync(pluginDir)) {
+    out.log(`    ${c.cyan('.claude-plugin/')} (manifest)`);
   }
   if (installed.version) {
     out.log(`    ${c.cyan(VERSION_FILE)} (version tracking)`);
@@ -304,12 +314,16 @@ async function uninstall(isGlobal) {
     fs.mkdirSync(backupDir, { recursive: true });
 
     if (installed.hasCommands) {
-      const dest = path.join(backupDir, 'commands', 'wtfp');
-      copyDir(commandsDir, dest);
+      copyDir(commandsDir, path.join(backupDir, 'commands', 'wtfp'));
+    }
+    if (installed.hasWorkflows) {
+      copyDir(workflowsDir, path.join(backupDir, 'write-the-f-paper'));
     }
-    if (installed.hasSkill) {
-      const dest = path.join(backupDir, 'write-the-f-paper');
-      copyDir(skillDir, dest);
+    if (installed.hasSkills) {
+      copyDir(skillsDir, path.join(backupDir, 'skills', 'wtfp'));
+    }
+    if (fs.existsSync(pluginDir)) {
+      copyDir(pluginDir, path.join(backupDir, '.claude-plugin'));
     }
 
     const backupLabel = backupDir.replace(os.homedir(), '~').replace(process.cwd(), '.');
@@ -332,11 +346,31 @@ async function uninstall(isGlobal) {
     }
   }
 
-  if (installed.hasSkill) {
-    removeDir(skillDir);
+  if (installed.hasWorkflows) {
+    removeDir(workflowsDir);
     out.log(`  ${c.red('-')} ${c.dim('write-the-f-paper/')}`);
   }
 
+  if (installed.hasSkills) {
+    removeDir(skillsDir);
+    out.log(`  ${c.red('-')} ${c.dim('skills/wtfp/')}`);
+    
+    // Clean up empty skills dir
+    const parentSkillsDir = path.join(claudeDir, 'skills');
+    if (fs.existsSync(parentSkillsDir)) {
+      const remaining = fs.readdirSync(parentSkillsDir);
+      if (remaining.length === 0) {
+        fs.rmdirSync(parentSkillsDir);
+        out.log(`  ${c.red('-')} ${c.dim('skills/')} ${c.dim('(empty)')}`);
+      }
+    }
+  }
+
+  if (fs.existsSync(pluginDir)) {
+    removeDir(pluginDir);
+    out.log(`  ${c.red('-')} ${c.dim('.claude-plugin/')}`);
+  }
+
   // Remove version file
   const versionFile = path.join(claudeDir, VERSION_FILE);
   if (fs.existsSync(versionFile)) {
@@ -379,8 +413,8 @@ async function promptLocation() {
   const globalInstalled = detectInstallation(globalPath);
   const localInstalled = detectInstallation(localPath);
 
-  const hasGlobalInstall = globalInstalled.hasCommands || globalInstalled.hasSkill;
-  const hasLocalInstall = localInstalled.hasCommands || localInstalled.hasSkill;
+  const hasGlobalInstall = globalInstalled.hasCommands || globalInstalled.hasWorkflows || globalInstalled.hasSkills;
+  const hasLocalInstall = localInstalled.hasCommands || localInstalled.hasWorkflows || localInstalled.hasSkills;
 
   if (!hasGlobalInstall && !hasLocalInstall) {
     out.log(`  ${c.yellow('No WTF-P installation found.')}\n`);
@@ -394,14 +428,14 @@ async function promptLocation() {
   out.log(`  ${c.yellow('Where would you like to uninstall from?')}\n`);
 
   if (hasGlobalInstall) {
-    const count = globalInstalled.commandFiles.length + globalInstalled.skillFiles.length;
+    const count = globalInstalled.commandFiles.length + globalInstalled.workflowFiles.length + globalInstalled.skillFiles.length;
     out.log(`  ${c.cyan('1)')} Global ${c.dim('(' + globalLabel + ')')} - ${count} files`);
   } else {
     out.log(`  ${c.dim('1) Global (' + globalLabel + ') - not installed')}`);
   }
 
   if (hasLocalInstall) {
-    const count = localInstalled.commandFiles.length + localInstalled.skillFiles.length;
+    const count = localInstalled.commandFiles.length + localInstalled.workflowFiles.length + localInstalled.skillFiles.length;
     out.log(`  ${c.cyan('2)')} Local  ${c.dim('(./.claude)')} - ${count} files`);
   } else {
     out.log(`  ${c.dim('2) Local (./.claude) - not installed')}`);

package/core/write-the-f-paper/templates/posters/basic.md

@@ -0,0 +1,34 @@
+---
+marp: true
+theme: uncover
+size: 4:3
+---
+
+# [Poster Title]
+
+## Authors
+Author 1, Author 2
+
+---
+
+## Introduction
+- Problem statement
+- Importance
+
+---
+
+## Methodology
+- Approach
+- Implementation details
+
+---
+
+## Results
+- Key findings
+- Charts (use ECharts!)
+
+---
+
+## Conclusion
+- Summary
+- Future work

package/core/write-the-f-paper/templates/slides/basic.md

@@ -0,0 +1,31 @@
+---
+marp: true
+theme: gaia
+_class: lead
+---
+
+# [Presentation Title]
+## [Subtitle]
+
+Author Name
+
+---
+
+# Agenda
+1. Introduction
+2. Problem Statement
+3. Methodology
+4. Results
+5. Conclusion
+
+---
+
+# Introduction
+- Context
+- High-level overview
+
+---
+
+# Conclusion
+- Final thoughts
+- Q&A

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wtf-p",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "The G.O.A.T. meta-prompting system for 10x researchers who need to submit papers and projects and proposals YESTERDAY.",
   "bin": {
     "wtfp": "bin/install.js",
@@ -8,7 +8,7 @@
     "wtf-p-uninstall": "bin/uninstall.js"
   },
   "scripts": {
-    "test": "node test/sanity.js && node test/paths.js",
+    "test": "node test/sanity.js && node test/paths.js && node test/linter.js",
     "test:integration": "node test/integration.js",
     "test:all": "npm test && npm run test:integration",
     "preflight": "node scripts/preflight.js",
@@ -16,9 +16,17 @@
   },
   "files": [
     "bin",
-    "commands",
-    "write-the-f-paper"
+    "core",
+    "vendors"
   ],
+  "peerDependencies": {
+    "@marp-team/marp-cli": ">=3.0.0"
+  },
+  "peerDependenciesMeta": {
+    "@marp-team/marp-cli": {
+      "optional": true
+    }
+  },
   "keywords": [
     "claude",
     "claude-code",

package/vendors/claude/.claude-plugin/plugin.json

@@ -0,0 +1,12 @@
+{
+  "name": "wtf-p",
+  "description": "Academic writing toolkit - Paper, Proposal, Presentation, Poster",
+  "version": "0.3.0",
+  "author": {
+    "name": "akougkas",
+    "url": "https://github.com/akougkas"
+  },
+  "homepage": "https://github.com/akougkas/wtf-p",
+  "repository": "https://github.com/akougkas/wtf-p",
+  "license": "MIT"
+}

package/vendors/claude/commands/wtfp/create-poster.md

@@ -0,0 +1,42 @@
+---
+name: wtfp:create-poster
+description: Full workflow for creating an academic poster from project content
+allowed-tools:
+  - Read
+  - Write
+  - Bash
+  - AskUserQuestion
+---
+
+<objective>
+Generate an academic poster based on the current project's PROJECT.md and findings.
+Uses the wtfp-marp skill to compile to HTML.
+</objective>
+
+<context>
+@~/.claude/write-the-f-paper/references/principles.md
+@~/.claude/write-the-f-paper/templates/posters/basic.md
+</context>
+
+<process>
+## Step 1: Content Synthesis
+- Read `.planning/PROJECT.md` and any drafted sections.
+- Identify key findings, methodology, and conclusion.
+
+## Step 2: User Interview
+AskUserQuestion to determine:
+- Poster title (default to project title)
+- Authors
+- Key visuals/charts needed
+- Target audience
+
+## Step 3: Markdown Generation
+- Create `poster.md` using Marp format.
+- Integrate synthesized content.
+
+## Step 4: Compilation
+- Use `wtfp-marp` skill: `npx @marp-team/marp-cli poster.md -o poster.html`
+
+## Step 5: Review
+- Present the generated poster.html path to the user.
+</process>