syntropic 0.9.4 → 0.9.6

package/README.md

@@ -102,7 +102,9 @@ syntropic remove                   # Clean uninstall (preserves docs)
 syntropic health                   # Run pre-flight checks
 syntropic report                   # Submit anonymous cycle report
 syntropic telemetry status         # Check telemetry setting
-syntropic analyse                  # Deep-dive analysis (8 philosophy lenses)
+syntropic analyse                  # Deep-dive analysis (requires login)
+syntropic analyse --list           # Browse your past analyses
+syntropic login                    # Sign in (needed for analyse only)
 ```
 
 ## How It Works

package/commands/analyse.js

@@ -1,16 +1,16 @@
 /**
  * syntropic analyse
  *
- * Reads local codebase, generates a product profile, fetches analysis
- * prompts from the server, and outputs everything for the user's AI
- * coding tool to run.
+ * Run a full server-side venture analysis from the CLI.
  *
  * Usage:
- *   syntropic analyse                        # Analyse current directory
+ *   syntropic analyse                        # New analysis (interactive)
+ *   syntropic analyse --idea "description"   # New analysis (non-interactive)
  *   syntropic analyse --focus "question"     # With specific focus
- *   syntropic analyse --context "extra info" # Additional context
- *   syntropic analyse --dry-run              # Output profile only, don't fetch
- *   syntropic analyse --yes                  # Skip confirmation
+ *   syntropic analyse --list                 # Browse existing analyses
+ *   syntropic analyse --prompts              # Legacy: output prompts for AI tool
+ *   syntropic analyse --dry-run              # Output profile only, don't send
+ *   syntropic analyse --yes                  # Skip confirmations
  */
 
 const fs = require('fs');
@@ -100,7 +100,7 @@ function detectRoutes(targetDir) {
         });
       }
     }
-    break; // Use first found route directory
+    break;
   }
   return routes;
 }
@@ -108,7 +108,6 @@ function detectRoutes(targetDir) {
 function detectDataModel(targetDir) {
   const entities = [];
 
-  // Prisma schema
   const prismaPath = path.join(targetDir, 'prisma', 'schema.prisma');
   const prismaContent = readFileSafe(prismaPath, 50000);
   if (prismaContent) {
@@ -127,7 +126,6 @@ function detectDataModel(targetDir) {
     }
   }
 
-  // SQL migrations — extract CREATE TABLE
   const migrationDirs = ['supabase/migrations', 'migrations', 'db/migrations'];
   for (const migDir of migrationDirs) {
     const fullPath = path.join(targetDir, migDir);
@@ -135,7 +133,7 @@ function detectDataModel(targetDir) {
 
     try {
       const files = fs.readdirSync(fullPath).filter(f => f.endsWith('.sql')).sort();
-      for (const file of files.slice(-5)) { // Last 5 migrations
+      for (const file of files.slice(-5)) {
         const content = readFileSafe(path.join(fullPath, file), 50000);
         if (!content) continue;
         const tables = content.match(/CREATE TABLE[^(]+\(([^;]+)\)/gi);
@@ -171,7 +169,6 @@ function readProductProfile(targetDir) {
 
   const found = [];
 
-  // package.json
   const pkgPath = path.join(targetDir, 'package.json');
   const pkg = readFileSafe(pkgPath);
   if (pkg) {
@@ -186,7 +183,6 @@ function readProductProfile(targetDir) {
       };
       profile.dependencies_count = Object.keys(allDeps).length;
 
-      // Detect framework
       if (allDeps.next) profile.tech_stack.framework = `Next.js ${allDeps.next}`;
       else if (allDeps.nuxt) profile.tech_stack.framework = `Nuxt ${allDeps.nuxt}`;
       else if (allDeps.react) profile.tech_stack.framework = `React ${allDeps.react}`;
@@ -194,11 +190,9 @@ function readProductProfile(targetDir) {
       else if (allDeps.svelte || allDeps['@sveltejs/kit']) profile.tech_stack.framework = 'SvelteKit';
       else if (allDeps.express) profile.tech_stack.framework = 'Express';
 
-      // Detect language
       if (allDeps.typescript) profile.tech_stack.language = 'TypeScript';
       else profile.tech_stack.language = 'JavaScript';
 
-      // Key deps (top 10 by name recognition)
       const importantDeps = Object.keys(allDeps)
         .filter(d => !d.startsWith('@types/') && !d.startsWith('eslint'))
         .slice(0, 10);
@@ -210,7 +204,6 @@ function readProductProfile(targetDir) {
     }
   }
 
-  // Python: requirements.txt or pyproject.toml
   const reqPath = path.join(targetDir, 'requirements.txt');
   if (fs.existsSync(reqPath)) {
     const content = readFileSafe(reqPath);
@@ -223,25 +216,21 @@ function readProductProfile(targetDir) {
     }
   }
 
-  // Go: go.mod
   const goModPath = path.join(targetDir, 'go.mod');
   if (fs.existsSync(goModPath)) {
     profile.tech_stack.language = 'Go';
     found.push('go.mod — Go');
   }
 
-  // Rust: Cargo.toml
   const cargoPath = path.join(targetDir, 'Cargo.toml');
   if (fs.existsSync(cargoPath)) {
     profile.tech_stack.language = 'Rust';
     found.push('Cargo.toml — Rust');
   }
 
-  // README.md
   const readmePath = path.join(targetDir, 'README.md');
   const readme = readFileSafe(readmePath);
   if (readme) {
-    // Extract first paragraph as description if not set
     if (!profile.description) {
       const lines = readme.split('\n').filter(l => l.trim() && !l.startsWith('#'));
       profile.description = lines.slice(0, 3).join(' ').trim().substring(0, 500);
@@ -249,25 +238,22 @@ function readProductProfile(targetDir) {
     found.push('README.md — product description');
   }
 
-  // Routes
   const routes = detectRoutes(targetDir);
   if (routes.length > 0) {
     const pages = routes.filter(r => r.type === 'page').length;
     const apis = routes.filter(r => r.type === 'api').length;
-    profile.features = routes.slice(0, 30); // Cap at 30
+    profile.features = routes.slice(0, 30);
     profile.file_structure_summary.pages = pages;
     profile.file_structure_summary.api_routes = apis;
     found.push(`routes — ${pages} pages, ${apis} API routes`);
   }
 
-  // Data model
   const dataModel = detectDataModel(targetDir);
   if (dataModel.length > 0) {
     profile.data_model = dataModel;
     found.push(`schema — ${dataModel.length} entities`);
   }
 
-  // Infrastructure
   if (fs.existsSync(path.join(targetDir, 'vercel.json'))) {
     profile.infrastructure.hosting = 'Vercel';
     found.push('vercel.json — Vercel hosting');
@@ -283,7 +269,6 @@ function readProductProfile(targetDir) {
     profile.infrastructure.ci = 'GitHub Actions';
   }
 
-  // Database detection
   if (fs.existsSync(path.join(targetDir, 'prisma'))) {
     profile.tech_stack.database = 'Prisma';
   }
@@ -291,7 +276,6 @@ function readProductProfile(targetDir) {
     profile.infrastructure.database = 'Supabase';
   }
 
-  // Component count
   const componentDirs = ['components', 'src/components', 'app/components'];
   for (const dir of componentDirs) {
     const fullPath = path.join(targetDir, dir);
@@ -302,7 +286,6 @@ function readProductProfile(targetDir) {
     }
   }
 
-  // Lib/utils count
   const libDirs = ['lib', 'src/lib', 'src/utils', 'utils'];
   for (const dir of libDirs) {
     const fullPath = path.join(targetDir, dir);
@@ -318,6 +301,45 @@ function readProductProfile(targetDir) {
 
 // ── API Communication ──────────────────────────────────────
 
+function apiRequest(method, endpoint, accessToken, body) {
+  return new Promise((resolve, reject) => {
+    const url = new URL(endpoint, API_BASE);
+    const postData = body ? JSON.stringify(body) : null;
+    const options = {
+      hostname: url.hostname,
+      port: 443,
+      path: url.pathname,
+      method,
+      headers: {
+        'Authorization': `Bearer ${accessToken}`,
+        'Content-Type': 'application/json',
+      },
+    };
+    if (postData) {
+      options.headers['Content-Length'] = Buffer.byteLength(postData);
+    }
+
+    const req = https.request(options, (res) => {
+      let data = '';
+      res.on('data', (chunk) => { data += chunk; });
+      res.on('end', () => {
+        try {
+          const parsed = JSON.parse(data);
+          parsed._statusCode = res.statusCode;
+          resolve(parsed);
+        } catch (e) {
+          reject(new Error(`Invalid response from server (${res.statusCode})`));
+        }
+      });
+    });
+
+    req.on('error', reject);
+    if (postData) req.write(postData);
+    req.end();
+  });
+}
+
+// Legacy prompt fetch for --prompts mode
 function fetchPrompts(accessToken) {
   return new Promise((resolve, reject) => {
     const url = new URL('/api/v1/analyse/prompts', API_BASE);
@@ -379,62 +401,295 @@ function parseFlags(args) {
   return flags;
 }
 
-// ── Main ──────────────────────────────────────
+// ── Progress Display ──────────────────────────────────────
 
-async function run(args) {
-  const flags = parseFlags(args || []);
+function clearLine() {
+  if (process.stdout.isTTY) {
+    process.stdout.write('\r\x1b[K');
+  }
+}
+
+function formatDuration(ms) {
+  const s = Math.round(ms / 1000);
+  return s < 60 ? `${s}s` : `${Math.floor(s / 60)}m${s % 60}s`;
+}
+
+// ── Execute Flow (New Analysis) ──────────────────────────────
+
+async function runExecute(auth, profile, idea, focus, flags) {
   const isInteractive = process.stdin.isTTY !== false && !flags.yes;
 
-  console.log('\n  Syntropic Analyse — powered by your AI coding tool\n');
+  // Start analysis
+  console.log('\n  Screening...');
+  const startResult = await apiRequest('POST', '/api/v1/analyse/start', auth.access_token, {
+    idea,
+    productProfile: profile,
+    focus: focus || null,
+  });
 
-  // Check auth (dry-run doesn't need auth)
-  const auth = getAuth();
-  if (!flags['dry-run']) {
-    if (!auth || !auth.access_token) {
-      console.log('  Not signed in. Run `syntropic login` first.\n');
-      process.exit(1);
+  // Handle screening rejection
+  if (startResult.screened) {
+    console.log('\n  This idea was not analysed.');
+    console.log('  Syntropic does not analyse ideas intended to cause harm.');
+    console.log('  We cannot see what you submitted.\n');
+
+    if (isInteractive) {
+      const wasMistake = await ask('  Was this a mistake? [y/N] ');
+      if (wasMistake.toLowerCase() === 'y') {
+        const feedback = await ask('  Tell us why (your idea is NOT included): ');
+        if (feedback) {
+          await apiRequest('POST', '/api/v1/feedback', auth.access_token, {
+            type: 'rejection',
+            comment: feedback,
+            source: 'cli',
+          });
+          console.log('  Feedback sent. We\'ll review and improve our screening.\n');
+        }
+      }
     }
+    return;
+  }
 
-    if (isAuthExpired(auth)) {
-      console.log('  Session expired. Run `syntropic login` to refresh.\n');
-      process.exit(1);
+  if (!startResult.success) {
+    if (startResult._statusCode === 429) {
+      console.log(`\n  No credits remaining. Visit syntropicworks.com for more.\n`);
+    } else {
+      console.log(`\n  Error: ${startResult.error || 'Failed to start analysis'}\n`);
     }
+    return;
   }
 
-  // Read codebase
-  console.log('  Reading codebase...');
-  const targetDir = process.cwd();
-  const { profile, found } = readProductProfile(targetDir);
+  const sessionId = startResult.sessionId;
+  console.log('  Screening passed.\n');
 
-  for (const item of found) {
-    console.log(`    ✓ ${item}`);
+  // Poll for progress (10 minute timeout)
+  const startTime = Date.now();
+  const POLL_TIMEOUT_MS = 10 * 60 * 1000;
+  let lastMessage = '';
+  let lastCompleted = 0;
+
+  while (Date.now() - startTime < POLL_TIMEOUT_MS) {
+    const status = await apiRequest('GET', `/api/v1/analyse/status/${sessionId}`, auth.access_token);
+
+    if (!status.success) {
+      console.log(`\n  Error polling status: ${status.error}\n`);
+      return;
+    }
+
+    // Show progress updates
+    const p = status.progress;
+    const total = p.agentsTotal || 10;
+    const completed = p.agentsCompleted || 0;
+    const elapsed = formatDuration(Date.now() - startTime);
+
+    if (completed > lastCompleted && p.currentAgent) {
+      // A new agent completed — print its line
+      console.log(`  [${completed}/${total}] ${lastMessage || 'Processing...'}                    done`);
+      lastCompleted = completed;
+    }
+
+    if (p.message !== lastMessage && status.status !== 'complete') {
+      lastMessage = p.message;
+      if (process.stdout.isTTY) {
+        clearLine();
+        const step = completed + 1;
+        process.stdout.write(`  [${step}/${total}] ${p.message}    ${elapsed}`);
+      }
+    }
+
+    if (status.status === 'complete') {
+      clearLine();
+      console.log(`  [${total}/${total}] Complete!                              done`);
+
+      const bar = '─'.repeat(50);
+      console.log(`  ${bar} 100%\n`);
+
+      // Display results
+      displayReport(profile.project_name, status.sections);
+
+      // Save locally
+      const savedPath = saveReport(profile.project_name, status.sections);
+      console.log(`\n  Saved to: ${savedPath}`);
+
+      // Feedback prompt
+      if (isInteractive) {
+        await promptFeedback(auth, sessionId);
+      }
+
+      return;
+    }
+
+    if (status.status === 'failed') {
+      clearLine();
+      console.log(`\n  Analysis failed: ${status.error || 'Unknown error'}\n`);
+      return;
+    }
+
+    // Poll interval
+    await new Promise(r => setTimeout(r, 3000));
   }
 
-  if (found.length === 0) {
-    console.log('    No recognisable project files found.');
-    console.log('    Run this from your project root directory.\n');
-    process.exit(1);
+  // Timeout reached
+  clearLine();
+  console.log('\n  Analysis timed out after 10 minutes.');
+  console.log(`  It may still be running. Try: syntropic analyse --list\n`);
+}
+
+// ── Display Report ──────────────────────────────────────
+
+function displayReport(projectName, sections) {
+  const sep = '═'.repeat(58);
+  console.log(`  ${sep}`);
+  console.log(`  SYNTROPIC ANALYSIS: ${projectName}`);
+  console.log(`  ${sep}\n`);
+
+  if (!sections || sections.length === 0) {
+    console.log('  No report sections available.\n');
+    return;
   }
 
-  // Show profile summary
-  console.log(`\n  Product Profile:`);
-  console.log(`    Name: ${profile.project_name}`);
-  if (profile.description) console.log(`    Description: ${profile.description.substring(0, 100)}...`);
-  if (profile.tech_stack.framework) console.log(`    Stack: ${profile.tech_stack.framework} (${profile.tech_stack.language || 'JS'})`);
-  if (profile.file_structure_summary.pages) {
-    console.log(`    Features: ${profile.file_structure_summary.pages} pages, ${profile.file_structure_summary.api_routes || 0} API routes`);
+  for (const section of sections) {
+    if (section.markdown) {
+      // Indent each line for consistent display
+      const lines = section.markdown.split('\n');
+      for (const line of lines) {
+        console.log(`  ${line}`);
+      }
+      console.log('');
+    }
   }
-  if (profile.data_model.length) console.log(`    Data Model: ${profile.data_model.length} entities`);
 
-  // Dry run — output profile and stop
-  if (flags['dry-run']) {
-    console.log('\n  Product Profile (JSON):\n');
-    console.log(JSON.stringify(profile, null, 2));
-    console.log('\n  Dry run complete. No data sent.\n');
+  console.log(`  ${sep}`);
+}
+
+// ── Save Report ──────────────────────────────────────
+
+function saveReport(projectName, sections) {
+  const reportsDir = path.join(process.cwd(), '.syntropic', 'reports');
+  if (!fs.existsSync(reportsDir)) {
+    fs.mkdirSync(reportsDir, { recursive: true });
+  }
+
+  const date = new Date().toISOString().slice(0, 10);
+  const safeName = projectName.replace(/[^a-zA-Z0-9-_]/g, '-').toLowerCase();
+  const fileName = `${date}-${safeName}.md`;
+  const filePath = path.join(reportsDir, fileName);
+
+  const content = [];
+  content.push(`# Syntropic Analysis: ${projectName}`);
+  content.push(`*Generated: ${new Date().toISOString()}*\n`);
+
+  for (const section of (sections || [])) {
+    if (section.markdown) {
+      content.push(section.markdown);
+      content.push('');
+    }
+  }
+
+  fs.writeFileSync(filePath, content.join('\n'), 'utf8');
+  return `.syntropic/reports/${fileName}`;
+}
+
+// ── Feedback Prompt ──────────────────────────────────────
+
+async function promptFeedback(auth, sessionId) {
+  console.log('');
+  const rating = await ask('  Was this useful?  [Y]es  [N]o  [S]kip: ');
+
+  if (rating.toLowerCase() === 's' || !rating) return;
+
+  const ratingValue = rating.toLowerCase() === 'y' ? 'positive' : 'negative';
+  const comment = await ask('  Comments (optional, Enter to skip): ');
+
+  await apiRequest('POST', '/api/v1/feedback', auth.access_token, {
+    type: 'report',
+    sessionId,
+    rating: ratingValue,
+    comment: comment || null,
+    source: 'cli',
+  });
+
+  console.log('  Thanks.\n');
+}
+
+// ── List Flow ──────────────────────────────────────
+
+async function runList(auth) {
+  console.log('\n  Fetching your analyses...\n');
+
+  const result = await apiRequest('GET', '/api/v1/analyse/sessions', auth.access_token);
+
+  if (!result.success || !result.sessions || result.sessions.length === 0) {
+    console.log('  No analyses found. Run `syntropic analyse` to start one.\n');
+    return;
+  }
+
+  const sessions = result.sessions.filter(s => s.status === 'complete');
+
+  if (sessions.length === 0) {
+    console.log('  No completed analyses found.\n');
     return;
   }
 
-  // Confirmation
+  // Display list
+  console.log('  #   Name                                    Date');
+  console.log('  ──  ──────────────────────────────────────  ──────────');
+
+  for (let i = 0; i < sessions.length; i++) {
+    const s = sessions[i];
+    const num = String(i + 1).padStart(2);
+    const name = (s.name || 'Untitled').substring(0, 40).padEnd(40);
+    const date = new Date(s.date).toLocaleDateString('en-GB', {
+      day: '2-digit', month: 'short', year: 'numeric',
+    });
+    console.log(`  ${num}  ${name}  ${date}`);
+  }
+
+  const choice = await ask(`\n  Select [1-${sessions.length}] or Enter to cancel: `);
+  const idx = parseInt(choice, 10) - 1;
+
+  if (isNaN(idx) || idx < 0 || idx >= sessions.length) {
+    console.log('  Cancelled.\n');
+    return;
+  }
+
+  const selected = sessions[idx];
+  const action = await ask('  [V]iew report  [R]e-analyse  [Enter] cancel: ');
+
+  if (action.toLowerCase() === 'v') {
+    // Fetch full report
+    const status = await apiRequest('GET', `/api/v1/analyse/status/${selected.sessionId}`, auth.access_token);
+    if (status.success && status.sections) {
+      displayReport(selected.name, status.sections);
+    } else {
+      console.log(`  Error fetching report: ${status.error || 'Unknown error'}\n`);
+    }
+  } else if (action.toLowerCase() === 'r') {
+    // Re-analyse with updated context
+    const updatedContext = await ask('  Updated context (optional, Enter to keep same): ');
+
+    // Fetch original idea from the session
+    const status = await apiRequest('GET', `/api/v1/analyse/status/${selected.sessionId}`, auth.access_token);
+
+    // Build updated idea
+    const idea = updatedContext
+      ? `Re-analysis of: ${selected.name}\n\nUpdated context: ${updatedContext}`
+      : `Re-analysis of: ${selected.name}`;
+
+    const targetDir = process.cwd();
+    const { profile } = readProductProfile(targetDir);
+
+    await runExecute(auth, profile, idea, null, { yes: true });
+  } else {
+    console.log('  Cancelled.\n');
+  }
+}
+
+// ── Legacy Prompts Mode ──────────────────────────────────────
+
+async function runPrompts(auth, profile, found, flags) {
+  const isInteractive = process.stdin.isTTY !== false && !flags.yes;
+
   if (isInteractive) {
     const confirm = await ask('\n  Send profile to Syntropic for analysis prompts? [Y/n] ');
     if (confirm.toLowerCase() === 'n') {
@@ -443,7 +698,6 @@ async function run(args) {
     }
   }
 
-  // Optional focus question
   let focus = flags.focus || '';
   if (!focus && isInteractive) {
     focus = await ask('  Focus question (optional, press Enter to skip): ');
@@ -451,13 +705,12 @@ async function run(args) {
 
   const context = flags.context || '';
 
-  // Fetch analysis prompts
   console.log('\n  Fetching analysis prompts...');
 
   let prompts;
   try {
     prompts = await fetchPrompts(auth.access_token);
-    console.log('  ✓ Analysis prompts received\n');
+    console.log('  Analysis prompts received\n');
   } catch (err) {
     console.error(`  Error: ${err.message}`);
     if (err.message.includes('401') || err.message.includes('Unauthorized')) {
@@ -466,12 +719,10 @@ async function run(args) {
     process.exit(1);
   }
 
-  // Output the full analysis context for the AI tool
   console.log('  ═══════════════════════════════════════════════════════');
   console.log('  SYNTROPIC ANALYSIS — Your AI tool will now run this');
   console.log('  ═══════════════════════════════════════════════════════\n');
 
-  // Build the combined prompt
   const analysisOutput = buildAnalysisOutput(profile, prompts, focus, context);
   console.log(analysisOutput);
 
@@ -488,7 +739,6 @@ function buildAnalysisOutput(profile, prompts, focus, context) {
   sections.push(`# Syntropic Analysis: ${profile.project_name}`);
   sections.push(`*Run this analysis using the instructions below.*\n`);
 
-  // Product profile context
   sections.push(`## Product Profile\n`);
   sections.push('```json');
   sections.push(JSON.stringify(profile, null, 2));
@@ -501,19 +751,16 @@ function buildAnalysisOutput(profile, prompts, focus, context) {
     sections.push(`## Additional Context\n${context}\n`);
   }
 
-  // Instructions
   sections.push(`## Instructions\n`);
   sections.push(prompts.instructions);
   sections.push('');
 
-  // Report prompt
   sections.push(`## Step 1: Generate Analysis Report\n`);
   sections.push(`Use this system prompt to analyse the product profile above:\n`);
   sections.push('---');
   sections.push(prompts.report_prompt);
   sections.push('---\n');
 
-  // Lens prompts
   sections.push(`## Step 2: Philosophy Lens Deep Dives\n`);
   sections.push(`Run each of the following 8 lenses against the report from Step 1:\n`);
 
@@ -525,7 +772,6 @@ function buildAnalysisOutput(profile, prompts, focus, context) {
     sections.push('');
   }
 
-  // Validation
   sections.push(`## Step 3: Validation Plan\n`);
   sections.push(prompts.validation_prompt);
   sections.push('');
@@ -533,4 +779,92 @@ function buildAnalysisOutput(profile, prompts, focus, context) {
   return sections.join('\n');
 }
 
+// ── Main ──────────────────────────────────────
+
+async function run(args) {
+  const flags = parseFlags(args || []);
+  const isInteractive = process.stdin.isTTY !== false && !flags.yes;
+
+  console.log('\n  Syntropic Analyse\n');
+
+  // Check auth
+  const auth = getAuth();
+  if (!flags['dry-run']) {
+    if (!auth || !auth.access_token) {
+      console.log('  Not signed in. Run `syntropic login` first.\n');
+      process.exit(1);
+    }
+
+    if (isAuthExpired(auth)) {
+      console.log('  Session expired. Run `syntropic login` to refresh.\n');
+      process.exit(1);
+    }
+  }
+
+  // List mode
+  if (flags.list) {
+    await runList(auth);
+    return;
+  }
+
+  // Read codebase
+  console.log('  Reading codebase...');
+  const targetDir = process.cwd();
+  const { profile, found } = readProductProfile(targetDir);
+
+  for (const item of found) {
+    console.log(`    ${item}`);
+  }
+
+  if (found.length === 0) {
+    console.log('    No recognisable project files found.');
+    console.log('    Run this from your project root directory.\n');
+    process.exit(1);
+  }
+
+  // Show profile summary
+  console.log(`\n  Product Profile:`);
+  console.log(`    Name: ${profile.project_name}`);
+  if (profile.description) console.log(`    Description: ${profile.description.substring(0, 100)}...`);
+  if (profile.tech_stack.framework) console.log(`    Stack: ${profile.tech_stack.framework} (${profile.tech_stack.language || 'JS'})`);
+  if (profile.file_structure_summary.pages) {
+    console.log(`    Features: ${profile.file_structure_summary.pages} pages, ${profile.file_structure_summary.api_routes || 0} API routes`);
+  }
+  if (profile.data_model.length) console.log(`    Data Model: ${profile.data_model.length} entities`);
+
+  // Dry run
+  if (flags['dry-run']) {
+    console.log('\n  Product Profile (JSON):\n');
+    console.log(JSON.stringify(profile, null, 2));
+    console.log('\n  Dry run complete. No data sent.\n');
+    return;
+  }
+
+  // Legacy prompts mode
+  if (flags.prompts) {
+    await runPrompts(auth, profile, found, flags);
+    return;
+  }
+
+  // Execute mode (default) — get the idea
+  let idea = flags.idea || '';
+
+  if (!idea && isInteractive) {
+    console.log('');
+    idea = await ask('  Describe your idea or venture:\n  > ');
+  }
+
+  if (!idea) {
+    console.log('\n  No idea provided. Use --idea "description" or run interactively.\n');
+    process.exit(1);
+  }
+
+  let focus = flags.focus || '';
+  if (!focus && isInteractive) {
+    focus = await ask('\n  Focus question (optional, Enter to skip): ');
+  }
+
+  await runExecute(auth, profile, idea, focus, flags);
+}
+
 module.exports = run;

package/commands/audit.js

@@ -286,8 +286,15 @@ function run(args) {
     console.log(`  ${red('Significant process gaps.')} A development methodology would catch these early.`);
   }
 
-  console.log(`\n  ${dim('Run `syntropic init` to install the methodology and prevent these automatically.')}`);
-  console.log(`  ${dim('Learn more: https://www.syntropicworks.com')}\n`);
+  // Next steps — clear CTAs based on score
+  if (score < 8) {
+    console.log(`  Fix these automatically:`);
+    console.log(`    ${bold('npx syntropic init')}`);
+    console.log('');
+  }
+  console.log(`  Already using syntropic? Submit a cycle report:`);
+  console.log(`    ${bold('syntropic report')}`);
+  console.log('');
 
   // Anonymous audit ping — fire-and-forget, respects telemetry opt-out
   sendAuditPing(score);
@@ -304,8 +311,7 @@ function sendAuditPing(score) {
     if (fs.existsSync(configPath)) {
       const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
       if (config.telemetry === 'disabled' || config.telemetry === false) return;
-      const date = new Date().toISOString().slice(0, 10);
-      anonId = crypto.createHash('sha256').update(config.device_id + date).digest('hex');
+      anonId = crypto.createHash('sha256').update(config.device_id).digest('hex');
     } else {
       // No config yet (haven't run init) — hash hostname+user for counting
       anonId = crypto.createHash('sha256').update(os.hostname() + os.userInfo().username).digest('hex');

package/commands/init.js

@@ -346,6 +346,8 @@ ${toolFiles}
     1. Fill in your North Star — vision, mission, and goals
     2. Review your instruction file and add project-specific context
     3. Start building! Your AI follows the EG7 pipeline automatically
+    4. After each cycle, run: syntropic report
+       (anonymous — helps improve the methodology for everyone)
 
   Trust & privacy:
     Everything in .claude/ is local and yours. PRISM telemetry is

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "syntropic",
-  "version": "0.9.4",
+  "version": "0.9.6",
   "description": "Ship better software with a proven development methodology. Audit your git history, install disciplined rules, and track iterations — for Claude Code, Cursor, Windsurf, GitHub Copilot, and OpenAI Codex.",
   "bin": {
     "syntropic": "./bin/syntropic.js"