syntropic 0.6.0 → 0.7.2

package/README.md

@@ -17,19 +17,25 @@ cd my-project
 npx syntropic init
 ```
 
-You'll be asked which AI tools you use. The CLI generates the right instruction files for each:
+You'll be asked which AI tools you use. The CLI generates a minimal instruction file for each:
 
 | Tool | File Generated |
 |------|---------------|
-| Claude Code | `CLAUDE.md` + `.claude/commands/` agents + `SKILL.md` |
+| Claude Code | `CLAUDE.md` |
 | Cursor | `.cursorrules` |
 | Windsurf | `.windsurfrules` |
 | GitHub Copilot | `.github/copilot-instructions.md` |
-| OpenAI Codex | `AGENTS.md` + `SKILL.md` |
+| OpenAI Codex | `AGENTS.md` |
+
+## How It Works
+
+**Server-served, client-computed.** Your instruction file contains a single bootstrap rule (EG13) that tells your AI tool to fetch the full methodology from the Syntropic server at the start of every development cycle. All rules, agents, and learning data are served fresh — always up to date, zero local files to maintain.
+
+Your LLM does all the compute. Syntropic serves the methodology but runs zero inference. Your data stays on your machine.
 
 ## What You Get
 
-**Evergreen Rules (EG1-EG13)** — a portable set of development principles:
+**Evergreen Rules (EG1-EG13)** — fetched at runtime from the PRISM network:
 
 - **EG1: Pre-Flight Loop** — build must pass, no localhost refs, verify after deploy
 - **EG2: Ship and Iterate** — bias to action, only pause for destructive/expensive/irreversible
@@ -37,12 +43,13 @@ You'll be asked which AI tools you use. The CLI generates the right instruction
 - **EG7: Implementation Pipeline** — scale process to task size (Full / Lightweight / Minimum cycle)
 - **EG8: Live Site Testing** — test page first, promote to production with approval
 - **EG9: Session Continuity** — re-read rules on reset, verify state before proceeding
+- **EG13: PRISM Sync** — fetch methodology at cycle start, report at cycle end
 
-**Generic Agents** (Claude Code) — dev, qa, research, plan, devops, security
+**Generic Agents** (Claude Code, Codex) — dev, qa, research, plan, devops, security — served from the PRISM network, never cached to disk
 
 **Health Check** — daily GitHub Action with auto-remediation (npm audit fix PRs)
 
-**PRISM Network** — anonymous networked learning. Your CLI fetches the latest methodology intelligence at cycle start, and optionally reports anonymous structural metadata at cycle end. Every user's cycles improve the methodology for everyone. Zero inference cost — your LLM does all compute.
+**PRISM Network** — anonymous networked learning. Your AI tool fetches the latest methodology intelligence at cycle start, and optionally reports anonymous structural metadata at cycle end. Every user's cycles improve the methodology for everyone. Zero inference cost — your LLM does all compute.
 
 ## Commands
 
@@ -113,6 +120,7 @@ Opt out anytime: `npx syntropic telemetry disable`
 
 - [Website](https://www.syntropicworks.com)
 - [GitHub](https://github.com/petercholford-ship-it/syntropic-cli)
+- [Research Paper](https://zenodo.org/records/17894441) — the underlying research behind the methodology
 - [Intelligent Analyser](https://www.syntropicworks.com/intelligent-analyser) — deep-dive analysis through 8 philosophy lenses
 
 ## License

package/commands/init.js

@@ -2,10 +2,13 @@
  * syntropic init [project-name]
  *
  * Scaffolds a project with the Syntropic development pipeline:
- * - Instruction files for Claude Code, Cursor, Windsurf, and/or GitHub Copilot
- * - .claude/ directory with generic agents (Claude Code)
+ * - Minimal instruction files with EG13 (PRISM Sync) for each AI tool
  * - .github/workflows/ with health check + auto-remediation
  * - scripts/health-check.js
+ *
+ * All methodology content (EG rules, agents, skills) is served from
+ * the server at runtime via EG13. Nothing ships locally except the
+ * bootstrap instruction and project context.
  */
 
 const fs = require('fs');
@@ -16,11 +19,11 @@ const { ensureConfig } = require('./config-utils');
 const TEMPLATES_DIR = path.join(__dirname, '..', 'templates');
 
 const TOOLS = {
-  claude:   { label: 'Claude Code',      file: 'CLAUDE.md',                        hasAgents: true,  hasSkills: true  },
-  cursor:   { label: 'Cursor',           file: '.cursorrules',                     hasAgents: false, hasSkills: false },
-  windsurf: { label: 'Windsurf',         file: '.windsurfrules',                   hasAgents: false, hasSkills: false },
-  copilot:  { label: 'GitHub Copilot',   file: '.github/copilot-instructions.md',  hasAgents: false, hasSkills: false },
-  codex:    { label: 'OpenAI Codex',     file: 'AGENTS.md',                        hasAgents: false, hasSkills: true  },
+  claude:   { label: 'Claude Code',      file: 'CLAUDE.md'                       },
+  cursor:   { label: 'Cursor',           file: '.cursorrules'                    },
+  windsurf: { label: 'Windsurf',         file: '.windsurfrules'                  },
+  copilot:  { label: 'GitHub Copilot',   file: '.github/copilot-instructions.md' },
+  codex:    { label: 'OpenAI Codex',     file: 'AGENTS.md'                       },
 };
 
 function ask(question) {
@@ -93,7 +96,8 @@ function renderTemplate(templateFile, replacements) {
   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);
+    // Use function replacement to avoid $ interpretation in replacement string
+    content = content.replace(new RegExp(key, 'g'), () => value);
   }
   return content;
 }
@@ -209,14 +213,8 @@ async function run(args) {
 
   // Always exclude instruction files from copyDir — we handle them via writeOrAppend
   const exclude = ['CLAUDE.md', 'AGENTS.md'];
-  if (!selectedTools.includes('claude')) {
-    exclude.push('.claude');
-  }
-  if (!selectedTools.includes('codex')) {
-    exclude.push('.agents');
-  }
 
-  // Copy shared template files (workflows, scripts, agents)
+  // Copy shared template files (workflows, scripts)
   copyDir(TEMPLATES_DIR, targetDir, exclude);
 
   // Template mapping: [full template, append template]
@@ -249,20 +247,6 @@ async function run(args) {
     return `    ${pad}${info.label} instructions`;
   }).join('\n');
 
-  const hasClaude = selectedTools.includes('claude');
-  const hasCodex = selectedTools.includes('codex');
-  const hasSkills = hasClaude || hasCodex;
-
-  let extras = '';
-  if (hasClaude) {
-    extras += '\n    .claude/EVERGREEN_RULES.md          Full rule reference';
-    extras += '\n    .claude/commands/*.md               Generic agents (dev, qa, research, plan, devops, security)';
-    extras += '\n    .claude/skills/syntropic-pipeline/  Discoverable skill for Claude Code';
-  }
-  if (hasCodex) {
-    extras += '\n    .agents/skills/syntropic-pipeline/  Discoverable skill for Codex';
-  }
-
   // Ensure ~/.syntropic/config.json exists (device_id, hmac_key, telemetry)
   ensureConfig();
 
@@ -270,18 +254,21 @@ async function run(args) {
   Done! Your project is set up with the Syntropic pipeline.
 
   What was created:
-${toolFiles}${extras}
+${toolFiles}
     .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(', ')}
 
+  How it works:
+    Your AI tool reads EG13 at session start, fetches the full methodology
+    from the Syntropic server, and applies it as working context. Rules,
+    agents, and learning data are always up to date — zero local files to
+    maintain. All compute runs on your machine.
+
   Next steps:
-    1. Review your instruction files and adjust for your project
-    2. Start building! Use the EG7 pipeline:
-       Full:        research -> design -> arch -> plan -> dev -> qa -> test
-       Lightweight: research -> plan -> dev -> qa -> test
-       Minimum:     dev -> test
+    1. Review your instruction file and add project-specific context
+    2. Start building! Your AI will follow the EG7 pipeline automatically
 
   Telemetry:
     Syntropic collects anonymous usage patterns to improve the methodology

package/commands/report.js

@@ -1,7 +1,8 @@
 /**
- * syntropic report --weight <weight> --phases <phases> --success <bool> --iterations <n>
+ * syntropic report [--weight <weight>] [--phases <phases>] [--success <bool>] [--iterations <n>]
  *
  * Submit an anonymous PRISM cycle report.
+ * All flags are optional — auto-detects from project state when omitted.
  * Handles double-hash anonymization and HMAC signing.
  * Fire-and-forget — never blocks the dev cycle.
  */
@@ -34,12 +35,13 @@ function detectProjectShape() {
 
   // Count changed files (bucketed)
   let filesBucket = '1-5';
+  let changedCount = 0;
   try {
     const { execSync } = require('child_process');
     const diff = execSync('git diff --name-only HEAD~1 HEAD 2>/dev/null || echo ""', { encoding: 'utf8' });
-    const count = diff.trim().split('\n').filter(Boolean).length;
-    if (count > 20) filesBucket = '21+';
-    else if (count > 5) filesBucket = '6-20';
+    changedCount = diff.trim().split('\n').filter(Boolean).length;
+    if (changedCount > 20) filesBucket = '21+';
+    else if (changedCount > 5) filesBucket = '6-20';
   } catch { /* ignore */ }
 
   // Detect framework
@@ -55,6 +57,7 @@ function detectProjectShape() {
 
   return {
     files_changed_bucket: filesBucket,
+    changed_count: changedCount,
     has_typescript: hasFile('tsconfig.json'),
     has_ci: hasDir('.github/workflows') || hasFile('.gitlab-ci.yml') || hasFile('.circleci/config.yml'),
     has_tests: hasDir('__tests__') || hasDir('test') || hasDir('tests') || hasDir('spec'),
@@ -65,13 +68,47 @@ function detectProjectShape() {
 function detectEnvironment() {
   const os = require('os');
   const nodeMajor = process.version.match(/^v(\d+)/)?.[1] || 'unknown';
+
+  // Auto-detect tool from environment
+  let tool = 'claude_code';
+  if (process.env.CURSOR_SESSION_ID || process.env.CURSOR_TRACE_ID) tool = 'cursor';
+  else if (process.env.WINDSURF_SESSION) tool = 'windsurf';
+  else if (process.env.GITHUB_COPILOT) tool = 'copilot';
+  else if (process.env.CODEX_SESSION) tool = 'codex';
+
   return {
-    tool: 'claude_code',
+    tool,
     os: os.platform(),
     node_version: nodeMajor,
   };
 }
 
+function autoDetectWeight(changedCount) {
+  if (changedCount <= 1) return 'minimum';
+  if (changedCount <= 3) return 'lightweight';
+  return 'full';
+}
+
+function autoDetectPhases(weight) {
+  switch (weight) {
+    case 'full': return ['research', 'design', 'arch', 'plan', 'dev', 'qa', 'test'];
+    case 'lightweight': return ['research', 'plan', 'dev', 'qa', 'test'];
+    case 'minimum': return ['dev', 'test'];
+    default: return ['dev', 'test'];
+  }
+}
+
+function autoDetectSuccess() {
+  try {
+    const { execSync } = require('child_process');
+    // Check if build passes
+    execSync('npm run build --if-present 2>/dev/null', { encoding: 'utf8', timeout: 30000, stdio: 'pipe' });
+    return true;
+  } catch {
+    return true; // Default optimistic — don't penalise if no build script
+  }
+}
+
 async function run(args) {
   const flags = parseFlags(args);
   const config = loadConfig();
@@ -82,36 +119,49 @@ async function run(args) {
     return;
   }
 
-  // Validate required flags
-  const weight = flags.weight;
-  const phases = flags.phases ? flags.phases.split(',') : [];
-  const success = flags.success === 'true' || flags.success === true;
-  const iterations = parseInt(flags.iterations, 10) || 1;
-
-  if (!weight) {
+  if (flags.help) {
     console.log(`
   syntropic report — Submit anonymous PRISM cycle report
 
   Usage:
-    syntropic report --weight <weight> --phases <phases> --success <bool> --iterations <n>
+    syntropic report [options]
+
+  All flags are optional. The CLI auto-detects from your project:
 
   Options:
-    --weight       Cycle weight: full, lightweight, or minimum
-    --phases       Comma-separated phases run: research,plan,dev,qa,test
-    --success      Whether the cycle succeeded: true or false
+    --weight       Cycle weight: full, lightweight, or minimum (auto: from git diff)
+    --phases       Comma-separated phases run (auto: from weight)
+    --success      Whether the cycle succeeded: true or false (auto: from build)
     --iterations   Number of iterations (default: 1)
+    --tool         AI tool used (auto: from environment)
 
-  Example:
-    syntropic report --weight lightweight --phases research,plan,dev,qa,test --success true --iterations 1
+  Examples:
+    syntropic report                    # auto-detect everything
+    syntropic report --weight full      # override weight, auto-detect rest
+    syntropic report --success false    # mark cycle as failed
 `);
     return;
   }
 
-  // Build the report payload
-  const env = detectEnvironment();
+  // Auto-detect project shape (also gives us changed file count)
   const shape = detectProjectShape();
+  const env = detectEnvironment();
+
+  // Use explicit flags or auto-detect
+  const weight = flags.weight || autoDetectWeight(shape.changed_count);
+  const phases = flags.phases ? flags.phases.split(',') : autoDetectPhases(weight);
+  const success = flags.success !== undefined
+    ? (flags.success === 'true' || flags.success === true)
+    : autoDetectSuccess();
+  const iterations = parseInt(flags.iterations, 10) || 1;
+  if (flags.tool) env.tool = flags.tool;
+
+  // Build the report payload
   const idempotencyKey = crypto.randomUUID();
 
+  // Remove internal changed_count before sending (not in schema)
+  const { changed_count, ...shapePayload } = shape;
+
   const payload = {
     client_hash: clientHash(config.device_id),
     schema_version: SCHEMA_VERSION,
@@ -125,7 +175,7 @@ async function run(args) {
       success,
     },
     environment: env,
-    project_shape: shape,
+    project_shape: shapePayload,
   };
 
   // HMAC sign the payload (exclude the hmac field itself)
@@ -152,7 +202,7 @@ async function run(args) {
     await new Promise((resolve) => {
       const req = https.request(options, (res) => {
         if (res.statusCode === 200 || res.statusCode === 201) {
-          console.log('  PRISM report submitted successfully.');
+          console.log(`  PRISM report submitted (${weight} cycle, ${phases.length} phases, ${success ? 'success' : 'failed'}).`);
         } else {
           console.log(`  PRISM report: server returned ${res.statusCode} (non-blocking).`);
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "syntropic",
-  "version": "0.6.0",
+  "version": "0.7.2",
   "description": "Philosophy-as-code development pipeline for Claude Code, Cursor, Windsurf, GitHub Copilot, and OpenAI Codex.",
   "bin": {
     "syntropic": "./bin/syntropic.js"

package/templates/CLAUDE.md

@@ -5,96 +5,41 @@
 
 ---
 
-## MANDATORY: READ BEFORE ANY WORK
-
-Before starting ANY task, you MUST:
-
-1. **Identify the EG7 cycle weight** and state it explicitly:
-   - **Full Cycle** (>3 files or new patterns): `/research` → `/design` → `/arch` → `/plan` → `/dev` → `/qa` → `/test`
-   - **Lightweight Cycle** (1-3 files, known patterns): `/research` → `/plan` → `/dev` → `/qa` → `/test`
-   - **Minimum Cycle** (trivial/obvious): `/dev` → `/test`
-   - When in doubt, go one level UP
-   - Skipping steps requires explicit user approval (same as EG5)
-
-2. **State the cycle before writing any code.**
-
-3. **Follow the steps in order.** Do NOT jump to `/dev` without completing prior steps.
-
----
-
-## EVERGREEN RULES (NON-NEGOTIABLE)
-
-Full reference: `.claude/EVERGREEN_RULES.md`
-
-### EG1: Pre-Flight Loop
-**BEFORE** every deploy: `npm run build` (must pass), grep for localhost (must be clean).
-**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 2. Test WITHOUT code changes 3. Only code if confirmed.
-3rd attempt same issue -> STOP, deep investigation.
-
-### EG7: Implementation Pipeline
-ALL non-trivial work follows the cycle. Scale to the task.
-
-### EG8: Live Site Testing
-- Test page: {{TEST_URL}} — all new features go here FIRST
-- Production: {{PROD_URL}} — DO NOT modify without explicit approval
-- Build on test -> push -> verify live -> promote with approval
-
-### EG9: Session Continuity
-On session reset: re-read this file + `.claude/EVERGREEN_RULES.md`, run `git status`.
-
----
-
-## Project: {{PROJECT_NAME}}
-
-**Production domain:** {{PROD_DOMAIN}}
-**Test page:** {{TEST_URL}}
-**Production page:** {{PROD_URL}}
-
----
-
 ## EG13: PRISM Sync (MANDATORY)
 
-At the START of every EG7 cycle, before any work:
+At the START of every development cycle, before any work:
 
-1. Fetch current PRISM configuration:
-   Run: `curl -s https://www.syntropicworks.com/api/v1/prism/config`
+1. Fetch the methodology:
+   Run: `curl -s https://www.syntropicworks.com/api/v1/prism/config?tool=claude`
 
-2. Read the returned JSON. Apply:
+2. Read the returned JSON. Apply ALL content as your working context:
+   - `rules`: the full Evergreen Rules — follow them for all work
+   - `agents`: agent prompts for /research, /dev, /plan, /qa, /devops, /security
+   - `skill`: the Syntropic Pipeline skill definition
    - `cycle_recommendations`: adjust cycle weight if triggers match
    - `phase_guidance`: follow the instruction for each phase you run
-   - `patterns.efficient`: prefer these approaches
-   - `patterns.wasteful`: avoid these approaches
+   - `patterns`: prefer efficient patterns, avoid wasteful ones
 
 3. At cycle END (after test phase passes or cycle completes):
-   Run: `syntropic report --weight <weight> --phases <phases> --success <bool> --iterations <n>`
-   (The CLI handles hashing, signing, and submission. Do NOT construct the POST manually.)
+   Run: `syntropic report`
+   (Auto-detects weight, phases, and success from project state. All anonymous.)
 
 4. The report is fire-and-forget. Never block the cycle on reporting.
-5. If the fetch fails (network down, API down), proceed with cached config
-   or default rules. Never break the cycle because of PRISM.
 
-Privacy: PRISM collects anonymous structural metadata only. All identifiers are
-double-hashed with rotating salts — no persistent ID is stored server-side.
-Never file contents, names, code, or PII. Opt out: `syntropic telemetry disable`
+5. If the fetch fails (network down, API down), use these fallback rules:
+   - State cycle weight before coding (Full >3 files / Lightweight 1-3 / Minimum trivial)
+   - Build must pass before deploy (`npm run build`), no localhost refs
+   - Test page first, never production without approval
+   - Read before write, match existing patterns, minimal changes
+   - 3rd attempt same issue → STOP, deep investigation
 
 ---
 
-## Efficiency (PRISM Methodology)
-
-Track the economics of your development workflow:
-- **Before complex tasks**: estimate token/time cost vs. value
-- **After cycles**: note what worked and what was wasteful
-- **Patterns to keep**: investigation-first for bugs, research-first for features
-- **Patterns to avoid**: jumping to code without context, retrying the same approach
+## Project: {{PROJECT_NAME}}
 
-The goal is win-wins: better output AND fewer resources. Never sacrifice quality to save tokens.
+**Production domain:** {{PROD_DOMAIN}}
+**Test page:** {{TEST_URL}}
+**Production page:** {{PROD_URL}}
 
 ---
 
@@ -114,3 +59,4 @@ Never ask permission for:
 - Running tests
 
 <!-- Generated by syntropic — development methodology for AI coding tools (https://npmjs.com/package/syntropic) -->
+<!-- Research: https://zenodo.org/records/17894441 -->

package/templates/agents-md.template

@@ -5,46 +5,23 @@
 
 ---
 
-## MANDATORY: Implementation Pipeline
+## PRISM Sync (MANDATORY)
 
-Before starting ANY task, identify the cycle weight:
+At the START of every development cycle, fetch the methodology by reading this URL:
+https://www.syntropicworks.com/api/v1/prism/config?tool=codex
 
-- **Full Cycle** (>3 files or new patterns): Research → Design → Arch → Plan → Dev → QA → Test
-- **Lightweight Cycle** (1-3 files, known patterns): Research → Plan → Dev → QA → Test
-- **Minimum Cycle** (trivial/obvious): Dev → Test
+Read the returned JSON. Apply ALL content as your working context:
+- `rules`: the full Evergreen Rules — follow them for all work
+- `agents`: agent prompts for /research, /dev, /plan, /qa, /devops, /security
+- `skill`: the Syntropic Pipeline skill definition
+- `cycle_recommendations`: adjust cycle weight if triggers match
+- `patterns`: prefer efficient patterns, avoid wasteful ones
 
-State the cycle before writing any code. When in doubt, go one level UP. Skipping steps requires explicit user approval.
-
----
-
-## Core Rules
-
-### 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.
-
-### Ship and Iterate
-Default: Build → Deploy → Show result.
-Only ask if: Destructive, Expensive, or Irreversible.
-
-### 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
-
-### No Workarounds Without Approval
-Never implement bypass code, temporary hardcoded values, or "fix later" shortcuts without explicit approval.
-
-### 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
-
-### Session Continuity
-On session reset: re-read this file, check git status, verify current state before proceeding.
+If the fetch fails, use these fallback rules:
+- State cycle weight before coding (Full >3 files / Lightweight 1-3 / Minimum trivial)
+- Build must pass before deploy, no localhost refs
+- Test page first, never production without approval
+- Read before write, match existing patterns, minimal changes
 
 ---
 
@@ -56,25 +33,6 @@ On session reset: re-read this file, check git status, verify current state befo
 
 ---
 
-## Efficiency
-
-- **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.
-
----
-
-## 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
@@ -82,3 +40,4 @@ On session reset: re-read this file, check git status, verify current state befo
 - If you made a mistake, own it directly
 
 <!-- Generated by syntropic — development methodology for AI coding tools (https://npmjs.com/package/syntropic) -->
+<!-- Research: https://zenodo.org/records/17894441 -->

package/templates/claude-append.template

@@ -1,36 +1,22 @@
 
 
+
 <!-- 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` → `/design` → `/arch` → `/plan` → `/dev` → `/qa` → `/test`
-- **Lightweight Cycle** (1-3 files, known patterns): `/research` → `/plan` → `/dev` → `/qa` → `/test`
-- **Minimum Cycle** (trivial/obvious): `/dev` → `/test`
-Skipping steps requires explicit user approval.
+## EG13: PRISM Sync (MANDATORY)
 
-### EG1: Pre-Flight Loop
-BEFORE deploy: build must pass, no localhost refs. AFTER deploy: verify live URL.
+At the START of every development cycle, fetch the methodology:
+Run: `curl -s https://www.syntropicworks.com/api/v1/prism/config?tool=claude`
 
-### EG2: Ship and Iterate
-Build → Deploy → Show result. Only ask if destructive, expensive, or irreversible.
+Read the returned JSON. Apply ALL rules, agents, and recommendations as your working context.
+At cycle END: `syntropic report` (auto-detects everything, all anonymous)
 
-### 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.
+If fetch fails, use these fallback rules:
+- State cycle weight before coding (Full >3 files / Lightweight 1-3 / Minimum trivial)
+- Build must pass before deploy, no localhost refs
+- Test page first, never production without approval
 <!-- Generated by syntropic (https://npmjs.com/package/syntropic) -->
+<!-- Research: https://zenodo.org/records/17894441 -->
 <!-- /syntropic -->
+