syntropic 0.1.0 → 0.3.1

package/bin/syntropic.js

@@ -15,6 +15,7 @@ const command = args[0];
 
 const COMMANDS = {
   init: () => require('../commands/init'),
+  add: () => require('../commands/add'),
   health: () => require('../commands/health'),
 };
 
@@ -32,16 +33,26 @@ if (!command || args.includes('--help') || args.includes('-h')) {
 
   Usage:
     syntropic init [project-name]   Scaffold a new project with the Syntropic pipeline
+    syntropic add <tool> [tool...]  Add support for another AI tool (cursor, windsurf, copilot, claude)
     syntropic health                Run a local health check
     syntropic --version             Show version
     syntropic --help                Show this help
 
   What you get:
-    - CLAUDE.md with Evergreen Rules (EG1-EG9) — a disciplined dev pipeline
-    - Generic agents: dev, qa, research, plan, devops, security
+    - Instruction files for Claude Code, Cursor, Windsurf, and/or GitHub Copilot
+    - Evergreen Rules (EG1-EG9) — a disciplined dev pipeline
+    - Generic agents: dev, qa, research, plan, devops, security (Claude Code)
     - Daily health check workflow with auto-remediation
     - PRISM efficiency tracking methodology
 
+  Flags (init):
+    --tools claude,cursor,windsurf,copilot   Select AI tools (default: all)
+    --name "My Project"                      Project name
+    --domain example.com                     Production domain
+    --test-url /test                         Test page path
+    --prod-url /                             Production page path
+    --yes                                    Skip interactive prompts
+
   Learn more: https://www.syntropicworks.com
 `);
   process.exit(0);

package/commands/add.js

@@ -0,0 +1,195 @@
+/**
+ * syntropic add <tool> [tool...]
+ *
+ * Adds Syntropic pipeline support for additional AI coding tools
+ * to an existing project. Creates new instruction files or appends
+ * rules to existing ones.
+ *
+ * Examples:
+ *   syntropic add cursor
+ *   syntropic add cursor windsurf copilot
+ */
+
+const fs = require('fs');
+const path = require('path');
+const readline = require('readline');
+
+const TEMPLATES_DIR = path.join(__dirname, '..', 'templates');
+
+const TOOLS = {
+  claude:   { label: 'Claude Code',      file: 'CLAUDE.md',                        hasAgents: true },
+  cursor:   { label: 'Cursor',           file: '.cursorrules',                     hasAgents: false },
+  windsurf: { label: 'Windsurf',         file: '.windsurfrules',                   hasAgents: false },
+  copilot:  { label: 'GitHub Copilot',   file: '.github/copilot-instructions.md',  hasAgents: false },
+};
+
+const TEMPLATE_MAP = {
+  claude:   ['CLAUDE.md',                     'claude-append.template'],
+  cursor:   ['cursorrules.template',          'tool-append.template'],
+  windsurf: ['windsurfrules.template',        'tool-append.template'],
+  copilot:  ['copilot-instructions.template', 'tool-append.template'],
+};
+
+function ask(question) {
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer.trim());
+    });
+  });
+}
+
+function hasSyntropicMarker(filePath) {
+  if (!fs.existsSync(filePath)) return false;
+  return fs.readFileSync(filePath, 'utf8').includes('<!-- syntropic -->');
+}
+
+function renderTemplate(templateFile, replacements) {
+  const templatePath = path.join(TEMPLATES_DIR, templateFile);
+  if (!fs.existsSync(templatePath)) return null;
+  let content = fs.readFileSync(templatePath, 'utf8');
+  for (const [key, value] of Object.entries(replacements)) {
+    content = content.replace(new RegExp(key, 'g'), value);
+  }
+  return content;
+}
+
+function writeOrAppend(fullTemplate, appendTemplate, destPath, replacements) {
+  const relPath = path.relative(process.cwd(), destPath);
+  const destDir = path.dirname(destPath);
+  if (!fs.existsSync(destDir)) fs.mkdirSync(destDir, { recursive: true });
+
+  if (!fs.existsSync(destPath)) {
+    const content = renderTemplate(fullTemplate, replacements);
+    if (content) fs.writeFileSync(destPath, content, 'utf8');
+    console.log(`  create  ${relPath}`);
+    return 'created';
+  } else if (hasSyntropicMarker(destPath)) {
+    console.log(`  skip  ${relPath} (Syntropic rules already present)`);
+    return 'skipped';
+  } else {
+    const appendContent = renderTemplate(appendTemplate, replacements);
+    if (appendContent) fs.appendFileSync(destPath, appendContent, 'utf8');
+    console.log(`  append  ${relPath} (added Syntropic pipeline rules)`);
+    return 'appended';
+  }
+}
+
+function detectExistingConfig(targetDir) {
+  // Try to read project config from existing Syntropic instruction files
+  for (const tool of Object.values(TOOLS)) {
+    const filePath = path.join(targetDir, tool.file);
+    if (fs.existsSync(filePath)) {
+      const content = fs.readFileSync(filePath, 'utf8');
+      const config = {};
+
+      // Extract test URL
+      const testMatch = content.match(/Test page:\s*(\S+)/);
+      if (testMatch) config.testUrl = testMatch[1];
+
+      // Extract prod URL
+      const prodMatch = content.match(/Production:\s*(\S+)/);
+      if (prodMatch) config.prodUrl = prodMatch[1];
+
+      // Extract domain
+      const domainMatch = content.match(/Production domain:\*?\*?\s*(\S+)/);
+      if (domainMatch) config.prodDomain = domainMatch[1];
+
+      // Extract project name
+      const nameMatch = content.match(/## Project:\s*(.+)/);
+      if (nameMatch) config.projectName = nameMatch[1].trim();
+
+      if (Object.keys(config).length > 0) return config;
+    }
+  }
+  return null;
+}
+
+async function run(args) {
+  const validTools = Object.keys(TOOLS);
+  const requestedTools = args.map(a => a.toLowerCase()).filter(a => validTools.includes(a));
+
+  if (requestedTools.length === 0) {
+    console.log(`
+  syntropic add — Add AI tool support to an existing project
+
+  Usage:
+    syntropic add cursor                Add Cursor support
+    syntropic add windsurf copilot      Add multiple tools
+    syntropic add claude                Add Claude Code support
+
+  Available tools: ${validTools.join(', ')}
+`);
+    process.exit(0);
+  }
+
+  const targetDir = process.cwd();
+  console.log(`\n  syntropic add — Adding ${requestedTools.map(t => TOOLS[t].label).join(', ')}\n`);
+
+  // Try to detect project config from existing instruction files
+  const existing = detectExistingConfig(targetDir);
+  const isInteractive = process.stdin.isTTY !== false;
+
+  const dirName = path.basename(targetDir);
+  const projectName = existing?.projectName || (isInteractive ? await ask(`  Project name (${dirName}): `) : '') || dirName;
+  const testUrl = existing?.testUrl || (isInteractive ? await ask('  Test page URL path (e.g. /test): ') : '') || '/test';
+  const prodUrl = existing?.prodUrl || (isInteractive ? await ask('  Production URL path (e.g. /): ') : '') || '/';
+  const prodDomain = existing?.prodDomain || (isInteractive ? await ask('  Production domain (e.g. example.com): ') : '') || 'example.com';
+
+  if (existing) {
+    console.log(`  Detected config: ${projectName} (${prodDomain})\n`);
+  }
+
+  const replacements = {
+    '\\{\\{PROJECT_NAME\\}\\}': projectName,
+    '\\{\\{TEST_URL\\}\\}': testUrl,
+    '\\{\\{PROD_URL\\}\\}': prodUrl,
+    '\\{\\{PROD_DOMAIN\\}\\}': prodDomain,
+  };
+
+  for (const tool of requestedTools) {
+    const [fullTpl, appendTpl] = TEMPLATE_MAP[tool];
+    const destPath = path.join(targetDir, TOOLS[tool].file);
+    writeOrAppend(fullTpl, appendTpl, destPath, replacements);
+  }
+
+  // If adding Claude, also copy agents
+  if (requestedTools.includes('claude')) {
+    const claudeDir = path.join(targetDir, '.claude');
+    const templateClaudeDir = path.join(TEMPLATES_DIR, '.claude');
+    if (fs.existsSync(templateClaudeDir)) {
+      const { copyDir } = require('./init');
+      if (typeof copyDir === 'function') {
+        copyDir(templateClaudeDir, claudeDir);
+      } else {
+        // Inline copy for agents
+        const commandsDir = path.join(templateClaudeDir, 'commands');
+        const destCommandsDir = path.join(claudeDir, 'commands');
+        if (fs.existsSync(commandsDir)) {
+          if (!fs.existsSync(destCommandsDir)) fs.mkdirSync(destCommandsDir, { recursive: true });
+          for (const file of fs.readdirSync(commandsDir)) {
+            const dest = path.join(destCommandsDir, file);
+            if (!fs.existsSync(dest)) {
+              fs.copyFileSync(path.join(commandsDir, file), dest);
+              console.log(`  create  ${path.relative(process.cwd(), dest)}`);
+            }
+          }
+        }
+        // Copy EVERGREEN_RULES.md
+        const egSrc = path.join(templateClaudeDir, 'EVERGREEN_RULES.md');
+        const egDest = path.join(claudeDir, 'EVERGREEN_RULES.md');
+        if (fs.existsSync(egSrc) && !fs.existsSync(egDest)) {
+          fs.copyFileSync(egSrc, egDest);
+          console.log(`  create  ${path.relative(process.cwd(), egDest)}`);
+        }
+      }
+    }
+  }
+
+  console.log(`
+  Done! Added: ${requestedTools.map(t => TOOLS[t].label).join(', ')}
+`);
+}
+
+module.exports = run;

package/commands/health.js

@@ -15,22 +15,35 @@ function run() {
   const checks = [];
   let hasErrors = false;
 
-  // 1. Check CLAUDE.md exists
-  const claudeMd = path.join(process.cwd(), 'CLAUDE.md');
-  if (fs.existsSync(claudeMd)) {
-    checks.push({ name: 'CLAUDE.md', status: 'pass', detail: 'Found' });
+  // 1. Check instruction files
+  const instructionFiles = [
+    { name: 'Claude Code',     path: 'CLAUDE.md' },
+    { name: 'Cursor',          path: '.cursorrules' },
+    { name: 'Windsurf',        path: '.windsurfrules' },
+    { name: 'GitHub Copilot',  path: path.join('.github', 'copilot-instructions.md') },
+  ];
+
+  const foundTools = [];
+  for (const tool of instructionFiles) {
+    if (fs.existsSync(path.join(process.cwd(), tool.path))) {
+      foundTools.push(tool.name);
+    }
+  }
+
+  if (foundTools.length > 0) {
+    checks.push({ name: 'Instructions', status: 'pass', detail: `Found: ${foundTools.join(', ')}` });
   } else {
-    checks.push({ name: 'CLAUDE.md', status: 'fail', detail: 'Missing — run "syntropic init"' });
+    checks.push({ name: 'Instructions', status: 'fail', detail: 'No instruction files — run "syntropic init"' });
     hasErrors = true;
   }
 
-  // 2. Check .claude directory
+  // 2. Check .claude directory (Claude Code agents)
   const claudeDir = path.join(process.cwd(), '.claude');
-  if (fs.existsSync(claudeDir)) {
+  if (fs.existsSync(claudeDir) && fs.existsSync(path.join(claudeDir, 'commands'))) {
     const agents = fs.readdirSync(path.join(claudeDir, 'commands')).filter(f => f.endsWith('.md') && f !== 'README.md');
     checks.push({ name: 'Agents', status: 'pass', detail: `${agents.length} agents found` });
-  } else {
-    checks.push({ name: 'Agents', status: 'warn', detail: 'No .claude directory' });
+  } else if (foundTools.includes('Claude Code')) {
+    checks.push({ name: 'Agents', status: 'warn', detail: 'No .claude/commands directory' });
   }
 
   // 3. npm build check

package/commands/init.js

@@ -2,8 +2,8 @@
  * syntropic init [project-name]
  *
  * Scaffolds a project with the Syntropic development pipeline:
- * - CLAUDE.md with Evergreen Rules
- * - .claude/ directory with generic agents
+ * - Instruction files for Claude Code, Cursor, Windsurf, and/or GitHub Copilot
+ * - .claude/ directory with generic agents (Claude Code)
  * - .github/workflows/ with health check + auto-remediation
  * - scripts/health-check.js
  */
@@ -14,6 +14,13 @@ const readline = require('readline');
 
 const TEMPLATES_DIR = path.join(__dirname, '..', 'templates');
 
+const TOOLS = {
+  claude:   { label: 'Claude Code',      file: 'CLAUDE.md',                        hasAgents: true },
+  cursor:   { label: 'Cursor',           file: '.cursorrules',                     hasAgents: false },
+  windsurf: { label: 'Windsurf',         file: '.windsurfrules',                   hasAgents: false },
+  copilot:  { label: 'GitHub Copilot',   file: '.github/copilot-instructions.md',  hasAgents: false },
+};
+
 function ask(question) {
   const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
   return new Promise((resolve) => {
@@ -24,15 +31,36 @@ function ask(question) {
   });
 }
 
-function copyDir(src, dest) {
+async function askMultiSelect(question, options) {
+  console.log(question);
+  options.forEach((opt, i) => {
+    console.log(`    ${i + 1}. ${opt.label}`);
+  });
+  const answer = await ask('  Enter numbers separated by commas (e.g. 1,2,3) or "all": ');
+
+  if (answer.toLowerCase() === 'all' || answer === '') {
+    return options.map(o => o.key);
+  }
+
+  const indices = answer.split(',').map(s => parseInt(s.trim(), 10) - 1);
+  return indices
+    .filter(i => i >= 0 && i < options.length)
+    .map(i => options[i].key);
+}
+
+function copyDir(src, dest, exclude) {
   if (!fs.existsSync(dest)) fs.mkdirSync(dest, { recursive: true });
 
   for (const entry of fs.readdirSync(src, { withFileTypes: true })) {
     const srcPath = path.join(src, entry.name);
     const destPath = path.join(dest, entry.name);
 
+    // Skip template files (handled separately) and excluded patterns
+    if (entry.name.endsWith('.template')) continue;
+    if (exclude && exclude.some(e => srcPath.includes(e))) continue;
+
     if (entry.isDirectory()) {
-      copyDir(srcPath, destPath);
+      copyDir(srcPath, destPath, exclude);
     } else {
       // Don't overwrite existing files
       if (fs.existsSync(destPath)) {
@@ -53,6 +81,44 @@ function replaceInFile(filePath, replacements) {
   fs.writeFileSync(filePath, content, 'utf8');
 }
 
+function hasSyntropicMarker(filePath) {
+  if (!fs.existsSync(filePath)) return false;
+  return fs.readFileSync(filePath, 'utf8').includes('<!-- syntropic -->');
+}
+
+function renderTemplate(templateFile, replacements) {
+  const templatePath = path.join(TEMPLATES_DIR, templateFile);
+  if (!fs.existsSync(templatePath)) return null;
+  let content = fs.readFileSync(templatePath, 'utf8');
+  for (const [key, value] of Object.entries(replacements)) {
+    content = content.replace(new RegExp(key, 'g'), value);
+  }
+  return content;
+}
+
+function writeOrAppend(fullTemplate, appendTemplate, destPath, replacements) {
+  const relPath = path.relative(process.cwd(), destPath);
+  const destDir = path.dirname(destPath);
+  if (!fs.existsSync(destDir)) fs.mkdirSync(destDir, { recursive: true });
+
+  if (!fs.existsSync(destPath)) {
+    // New file — write full template
+    const content = renderTemplate(fullTemplate, replacements);
+    if (content) fs.writeFileSync(destPath, content, 'utf8');
+    console.log(`  create  ${relPath}`);
+    return 'created';
+  } else if (hasSyntropicMarker(destPath)) {
+    console.log(`  skip  ${relPath} (Syntropic rules already present)`);
+    return 'skipped';
+  } else {
+    // Existing file without Syntropic — append methodology
+    const appendContent = renderTemplate(appendTemplate, replacements);
+    if (appendContent) fs.appendFileSync(destPath, appendContent, 'utf8');
+    console.log(`  append  ${relPath} (added Syntropic pipeline rules)`);
+    return 'appended';
+  }
+}
+
 function parseFlags(args) {
   const flags = {};
   const positional = [];
@@ -67,6 +133,23 @@ function parseFlags(args) {
   return { flags, positional };
 }
 
+function detectTools(targetDir) {
+  const detected = [];
+  if (fs.existsSync(path.join(targetDir, 'CLAUDE.md')) || fs.existsSync(path.join(targetDir, '.claude'))) {
+    detected.push('claude');
+  }
+  if (fs.existsSync(path.join(targetDir, '.cursorrules'))) {
+    detected.push('cursor');
+  }
+  if (fs.existsSync(path.join(targetDir, '.windsurfrules'))) {
+    detected.push('windsurf');
+  }
+  if (fs.existsSync(path.join(targetDir, '.github', 'copilot-instructions.md'))) {
+    detected.push('copilot');
+  }
+  return detected;
+}
+
 async function run(args) {
   console.log('\n  syntropic init — Philosophy-as-code development pipeline\n');
 
@@ -95,20 +178,53 @@ async function run(args) {
   const prodUrl = flags['prod-url'] || (isInteractive ? await ask('  Production URL path (e.g. /): ') : '') || '/';
   const prodDomain = flags.domain || (isInteractive ? await ask('  Production domain (e.g. example.com): ') : '') || 'example.com';
 
+  // Select AI tools
+  let selectedTools;
+
+  if (flags.tools) {
+    // --tools claude,cursor,windsurf,copilot
+    selectedTools = flags.tools.split(',').map(t => t.trim().toLowerCase());
+  } else if (isInteractive) {
+    const toolOptions = Object.entries(TOOLS).map(([key, val]) => ({ key, label: val.label }));
+    selectedTools = await askMultiSelect('\n  Which AI coding tools do you use?', toolOptions);
+    if (selectedTools.length === 0) selectedTools = ['claude'];
+  } else {
+    // Non-interactive default: all tools
+    selectedTools = Object.keys(TOOLS);
+  }
+
+  const replacements = {
+    '\\{\\{PROJECT_NAME\\}\\}': projectName,
+    '\\{\\{TEST_URL\\}\\}': testUrl,
+    '\\{\\{PROD_URL\\}\\}': prodUrl,
+    '\\{\\{PROD_DOMAIN\\}\\}': prodDomain,
+  };
+
   console.log('\n  Scaffolding...\n');
 
-  // Copy all template files
-  copyDir(TEMPLATES_DIR, targetDir);
-
-  // Replace placeholders in CLAUDE.md
-  const claudeMdPath = path.join(targetDir, 'CLAUDE.md');
-  if (fs.existsSync(claudeMdPath)) {
-    replaceInFile(claudeMdPath, {
-      '{{PROJECT_NAME}}': projectName,
-      '{{TEST_URL}}': testUrl,
-      '{{PROD_URL}}': prodUrl,
-      '{{PROD_DOMAIN}}': prodDomain,
-    });
+  // Always exclude CLAUDE.md from copyDir — we handle all instruction files via writeOrAppend
+  const exclude = ['CLAUDE.md'];
+  if (!selectedTools.includes('claude')) {
+    exclude.push('.claude');
+  }
+
+  // Copy shared template files (workflows, scripts, agents)
+  copyDir(TEMPLATES_DIR, targetDir, exclude);
+
+  // Template mapping: [full template, append template]
+  const templateMap = {
+    claude:   ['CLAUDE.md',                     'claude-append.template'],
+    cursor:   ['cursorrules.template',          'tool-append.template'],
+    windsurf: ['windsurfrules.template',        'tool-append.template'],
+    copilot:  ['copilot-instructions.template', 'tool-append.template'],
+  };
+
+  // Generate instruction files — create new or append to existing
+  const actions = {};
+  for (const tool of selectedTools) {
+    const [fullTpl, appendTpl] = templateMap[tool];
+    const destPath = path.join(targetDir, TOOLS[tool].file);
+    actions[tool] = writeOrAppend(fullTpl, appendTpl, destPath, replacements);
   }
 
   // Make health check executable
@@ -117,25 +233,30 @@ async function run(args) {
     fs.chmodSync(healthScript, '755');
   }
 
-  // Summary
+  // Build summary
+  const toolFiles = selectedTools.map(t => {
+    const info = TOOLS[t];
+    const pad = info.file.padEnd(36);
+    return `    ${pad}${info.label} instructions`;
+  }).join('\n');
+
+  const hasAgents = selectedTools.includes('claude');
+
   console.log(`
   Done! Your project is set up with the Syntropic pipeline.
 
   What was created:
-    CLAUDE.md                           Evergreen Rules (EG1-EG9) + project config
-    .claude/EVERGREEN_RULES.md          Full rule reference
-    .claude/commands/*.md               Generic agents (dev, qa, research, plan, devops, security)
+${toolFiles}${hasAgents ? '\n    .claude/EVERGREEN_RULES.md          Full rule reference\n    .claude/commands/*.md               Generic agents (dev, qa, research, plan, devops, security)' : ''}
     .github/workflows/                  Daily health check with auto-remediation
     scripts/health-check.js             Local health check script
 
+  Tools configured: ${selectedTools.map(t => TOOLS[t].label).join(', ')}
+
   Next steps:
-    1. Review CLAUDE.md and adjust for your project
-    2. If using Supabase, add secrets to GitHub repo settings:
-       - NEXT_PUBLIC_SUPABASE_URL
-       - SUPABASE_SERVICE_ROLE_KEY
-    3. Start building! Use the EG7 pipeline:
-       Full:        research -> design -> arch -> plan -> dev -> qa -> test
-       Lightweight: research -> plan -> dev -> qa -> test
+    1. Review your instruction files and adjust for your project
+    2. Start building! Use the EG7 pipeline:
+       Full:        research -> plan -> dev -> qa -> test
+       Lightweight: plan -> dev -> qa -> test
        Minimum:     dev -> test
 
   The methodology is your superpower. Ship and iterate.

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "syntropic",
-  "version": "0.1.0",
-  "description": "Philosophy-as-code development pipeline. Ship better products with outcome-thinking.",
+  "version": "0.3.1",
+  "description": "Philosophy-as-code development pipeline for Claude Code, Cursor, Windsurf, and GitHub Copilot.",
   "bin": {
     "syntropic": "./bin/syntropic.js"
   },
@@ -11,6 +11,9 @@
     "philosophy-as-code",
     "outcome-thinking",
     "claude-code",
+    "cursor",
+    "windsurf",
+    "github-copilot",
     "ai-development",
     "dev-pipeline",
     "syntropic"

package/templates/CLAUDE.md

@@ -1,3 +1,4 @@
+<!-- syntropic -->
 # CLAUDE.md — {{PROJECT_NAME}}
 
 **This file is loaded automatically at session start. It is the primary authority.**

package/templates/claude-append.template

@@ -0,0 +1,34 @@
+
+
+<!-- syntropic -->
+---
+
+## Syntropic Development Pipeline
+
+Full reference: `.claude/EVERGREEN_RULES.md`
+
+### EG7: Implementation Pipeline (MANDATORY)
+Before starting ANY task, state the cycle weight:
+- **Full Cycle** (>3 files or new patterns): `/research` → `/plan` → `/dev` → `/qa`
+- **Lightweight Cycle** (1-3 files, known patterns): `/plan` → `/dev` → `/qa`
+- **Minimum Cycle** (trivial/obvious): `/dev` → verify
+
+### EG1: Pre-Flight Loop
+BEFORE deploy: build must pass, no localhost refs. AFTER deploy: verify live URL.
+
+### EG2: Ship and Iterate
+Build → Deploy → Show result. Only ask if destructive, expensive, or irreversible.
+
+### EG3: Hypothesis-Driven Debugging
+1. State hypothesis 2. Test WITHOUT code changes 3. Only code if confirmed.
+3rd attempt → STOP, deep investigation.
+
+### EG8: Live Site Testing
+- Test page: {{TEST_URL}} — all new features go here FIRST
+- Production: {{PROD_URL}} — DO NOT modify without explicit approval
+
+### Efficiency (PRISM Methodology)
+- Before complex tasks: estimate cost vs. value
+- After cycles: note what worked and what was wasteful
+- Better output AND fewer resources. Never sacrifice quality to save tokens.
+<!-- /syntropic -->

package/templates/copilot-instructions.template

@@ -0,0 +1,68 @@
+<!-- syntropic -->
+# {{PROJECT_NAME}} — Development Instructions
+
+These instructions are loaded automatically by GitHub Copilot. Follow them for all work in this project.
+
+## Implementation Pipeline (EG7) — MANDATORY
+
+Before starting ANY task, identify the cycle weight:
+
+- **Full Cycle** (>3 files or new patterns): Research → Plan → Implement → Review
+- **Lightweight Cycle** (1-3 files, known patterns): Plan → Implement → Review
+- **Minimum Cycle** (trivial/obvious): Implement → Verify
+
+State the cycle before writing any code. When in doubt, go one level UP.
+
+## Core Rules
+
+### EG1: Pre-Flight Loop
+BEFORE every deploy: build must pass, no localhost references in source.
+AFTER every deploy: verify the live URL works.
+
+### EG2: Ship and Iterate
+Default: Build → Deploy → Show result.
+Only ask if: Destructive, Expensive, or Irreversible.
+
+### EG3: Hypothesis-Driven Debugging
+1. State hypothesis ("X because Y")
+2. Test WITHOUT code changes
+3. Only code if confirmed
+4. 3rd attempt same issue → STOP, deep investigation
+
+### EG5: No Workarounds Without Approval
+Never implement bypass code, temporary hardcoded values, or "fix later" shortcuts without explicit approval.
+
+### EG8: Live Site Testing
+- Test page: {{TEST_URL}} — all new features go here FIRST
+- Production: {{PROD_URL}} — DO NOT modify without explicit approval
+
+### EG9: Session Continuity
+On reset: re-read this file, check git status, verify state before proceeding.
+
+## Project Details
+
+- **Production domain:** {{PROD_DOMAIN}}
+- **Test page:** {{TEST_URL}}
+- **Production page:** {{PROD_URL}}
+
+## Efficiency (PRISM Methodology)
+
+- Before complex tasks: estimate cost vs. value
+- After cycles: note what worked and what was wasteful
+- Keep: investigation-first for bugs, research-first for features
+- Avoid: jumping to code without context, retrying the same approach
+
+## Implementation Standards
+
+1. Read before write — always read existing code before modifying
+2. Match existing patterns — follow codebase conventions
+3. Minimal changes — only change what's needed
+4. No over-engineering — solve the current problem only
+5. Security first — no injection vulnerabilities, no hardcoded secrets
+6. Test what you build — verify before marking done
+
+## Communication
+
+- Be direct and concise
+- Recommend the objectively best solution
+- Own mistakes directly

package/templates/cursorrules.template

@@ -0,0 +1,85 @@
+<!-- syntropic -->
+# {{PROJECT_NAME}} — Development Rules
+
+**These rules are loaded automatically by Cursor. Follow them for all work in this project.**
+
+---
+
+## MANDATORY: Implementation Pipeline (EG7)
+
+Before starting ANY task, identify the cycle weight:
+
+- **Full Cycle** (>3 files or new patterns): Research → Plan → Implement → Review
+- **Lightweight Cycle** (1-3 files, known patterns): Plan → Implement → Review
+- **Minimum Cycle** (trivial/obvious): Implement → Verify
+
+State the cycle before writing any code. When in doubt, go one level UP.
+
+---
+
+## Core Rules
+
+### EG1: Pre-Flight Loop
+**BEFORE** every deploy:
+- Build must pass (`npm run build` or equivalent)
+- No localhost/127.0.0.1 references in source
+**AFTER** every deploy: verify the live URL works.
+
+### EG2: Ship and Iterate
+Default: Build → Deploy → Show result.
+Only ask if: Destructive, Expensive, or Irreversible.
+
+### EG3: Hypothesis-Driven Debugging
+1. State hypothesis ("X because Y")
+2. Test WITHOUT code changes (logs, DB, API)
+3. Only code if confirmed
+4. 3rd attempt same issue → STOP, deep investigation
+
+### EG5: No Workarounds Without Approval
+Never implement bypass code, temporary hardcoded values, or "fix later" shortcuts without explicit approval.
+
+### EG8: Live Site Testing
+- Test page: {{TEST_URL}} — all new features go here FIRST
+- Production: {{PROD_URL}} — DO NOT modify without explicit approval
+- Workflow: Build on test → push → verify live → promote with approval
+
+### EG9: Session Continuity
+On session reset: re-read this file, check git status, verify current state before proceeding.
+
+---
+
+## Project: {{PROJECT_NAME}}
+
+**Production domain:** {{PROD_DOMAIN}}
+**Test page:** {{TEST_URL}}
+**Production page:** {{PROD_URL}}
+
+---
+
+## Efficiency (PRISM Methodology)
+
+- **Before complex tasks**: estimate cost vs. value
+- **After cycles**: note what worked and what was wasteful
+- **Keep**: investigation-first for bugs, research-first for features
+- **Avoid**: jumping to code without context, retrying the same approach
+
+Better output AND fewer resources. Never sacrifice quality to save tokens.
+
+---
+
+## Implementation Standards
+
+1. **Read before write** — always read existing code before modifying
+2. **Match existing patterns** — follow codebase conventions
+3. **Minimal changes** — only change what's needed
+4. **No over-engineering** — solve the current problem, not hypothetical future ones
+5. **Security first** — no injection vulnerabilities, no hardcoded secrets
+6. **Test what you build** — verify it works before marking done
+
+---
+
+## Communication
+
+- Be direct and concise
+- Recommend the objectively best solution
+- If you made a mistake, own it directly

package/templates/tool-append.template

@@ -0,0 +1,32 @@
+
+
+<!-- syntropic -->
+---
+
+## Syntropic Development Pipeline
+
+### Implementation Pipeline (MANDATORY)
+Before starting ANY task, state the cycle weight:
+- **Full Cycle** (>3 files or new patterns): Research → Plan → Implement → Review
+- **Lightweight Cycle** (1-3 files, known patterns): Plan → Implement → Review
+- **Minimum Cycle** (trivial/obvious): Implement → Verify
+
+### Pre-Flight Loop
+BEFORE deploy: build must pass, no localhost refs. AFTER deploy: verify live URL.
+
+### Ship and Iterate
+Build → Deploy → Show result. Only ask if destructive, expensive, or irreversible.
+
+### Hypothesis-Driven Debugging
+1. State hypothesis 2. Test WITHOUT code changes 3. Only code if confirmed.
+3rd attempt → STOP, deep investigation.
+
+### Live Site Testing
+- Test page: {{TEST_URL}} — all new features go here FIRST
+- Production: {{PROD_URL}} — DO NOT modify without explicit approval
+
+### Efficiency (PRISM Methodology)
+- Before complex tasks: estimate cost vs. value
+- After cycles: note what worked and what was wasteful
+- Better output AND fewer resources. Never sacrifice quality to save tokens.
+<!-- /syntropic -->

package/templates/windsurfrules.template

@@ -0,0 +1,85 @@
+<!-- syntropic -->
+# {{PROJECT_NAME}} — Development Rules
+
+**These rules are loaded automatically by Windsurf. Follow them for all work in this project.**
+
+---
+
+## MANDATORY: Implementation Pipeline (EG7)
+
+Before starting ANY task, identify the cycle weight:
+
+- **Full Cycle** (>3 files or new patterns): Research → Plan → Implement → Review
+- **Lightweight Cycle** (1-3 files, known patterns): Plan → Implement → Review
+- **Minimum Cycle** (trivial/obvious): Implement → Verify
+
+State the cycle before writing any code. When in doubt, go one level UP.
+
+---
+
+## Core Rules
+
+### EG1: Pre-Flight Loop
+**BEFORE** every deploy:
+- Build must pass (`npm run build` or equivalent)
+- No localhost/127.0.0.1 references in source
+**AFTER** every deploy: verify the live URL works.
+
+### EG2: Ship and Iterate
+Default: Build → Deploy → Show result.
+Only ask if: Destructive, Expensive, or Irreversible.
+
+### EG3: Hypothesis-Driven Debugging
+1. State hypothesis ("X because Y")
+2. Test WITHOUT code changes (logs, DB, API)
+3. Only code if confirmed
+4. 3rd attempt same issue → STOP, deep investigation
+
+### EG5: No Workarounds Without Approval
+Never implement bypass code, temporary hardcoded values, or "fix later" shortcuts without explicit approval.
+
+### EG8: Live Site Testing
+- Test page: {{TEST_URL}} — all new features go here FIRST
+- Production: {{PROD_URL}} — DO NOT modify without explicit approval
+- Workflow: Build on test → push → verify live → promote with approval
+
+### EG9: Session Continuity
+On session reset: re-read this file, check git status, verify current state before proceeding.
+
+---
+
+## Project: {{PROJECT_NAME}}
+
+**Production domain:** {{PROD_DOMAIN}}
+**Test page:** {{TEST_URL}}
+**Production page:** {{PROD_URL}}
+
+---
+
+## Efficiency (PRISM Methodology)
+
+- **Before complex tasks**: estimate cost vs. value
+- **After cycles**: note what worked and what was wasteful
+- **Keep**: investigation-first for bugs, research-first for features
+- **Avoid**: jumping to code without context, retrying the same approach
+
+Better output AND fewer resources. Never sacrifice quality to save tokens.
+
+---
+
+## Implementation Standards
+
+1. **Read before write** — always read existing code before modifying
+2. **Match existing patterns** — follow codebase conventions
+3. **Minimal changes** — only change what's needed
+4. **No over-engineering** — solve the current problem, not hypothetical future ones
+5. **Security first** — no injection vulnerabilities, no hardcoded secrets
+6. **Test what you build** — verify it works before marking done
+
+---
+
+## Communication
+
+- Be direct and concise
+- Recommend the objectively best solution
+- If you made a mistake, own it directly