How long does the integration take?

Change one base URL in an OpenAI-compatible client, or install the Python or TypeScript SDK; the quickstart routes a first request in a few minutes.

Will this lock us into another vendor?

No. The router is Apache-2.0 open source, your provider keys stay yours, and the API is OpenAI-compatible, so leaving is a change of base URL.

What happens when a provider fails?

The router falls back to the next model your policy allows and records the fallback in the trace, so an outage costs a retry, not an incident.

imagination-engine - Prompt

Name: imagination-engine
Author: HeadyAI

Prompt file imported from HeadyAI/Heady-Testing-83c4b580 (.windsurf/workflows/imagination-engine.md). Copyright stays with the author.

Heady Imagination Engine Workflow

Overview

The Imagination Engine is Heady's autonomous concept generation system based on DABUS/Imagination Engines architecture. It generates novel concepts through structured recombination of primitives, evaluates them for novelty/usefulness/risk, and can draft IP materials.

Core Philosophy

Autonomous but Guided: The engine generates concepts autonomously but within value constraints (safety, ethics, mission alignment)
Human-in-the-Loop: AI generates candidates; humans validate, refine, and claim IP
Continuous Learning: Primitive weights and operator preferences update based on outcomes
IP-Aware: All concepts are evaluated for patentability and appropriate IP posture

Quick Start

1. Initialize the Engine

const { imagination } = require('./src/hc_imagination');
await imagination.init();

2. Add Primitives

Primitives are building blocks for concept generation:

// Add from code
await imagination.extractPrimitives(sourceCode, 'code');

// Add manually
imagination.addPrimitive('mechanism', 'Fractal branching for load distribution', 'design_pattern', ['scalability', 'fractal']);
imagination.addPrimitive('constraint', 'Must work offline', 'requirement', ['offline', 'resilience']);

3. Generate Concepts

// Run imagination cycle
const concepts = await imagination.imagine(5);

// Concepts are auto-evaluated for novelty, usefulness, risk
console.log(concepts.map(c => ({
  title: c.title,
  novelty: c.scores.novelty,
  usefulness: c.scores.usefulness,
  risk: c.scores.risk
})));

4. Use Recombination Operators

const primA = imagination.primitives.get('prim_xxx');
const primB = imagination.primitives.get('prim_yyy');

// Blend two primitives
const blended = imagination.blend(primA, primB);

// Extend existing concept
const extended = imagination.extend(existingConcept, newPrimitive);

// Invert a primitive
const inverted = imagination.invert(primA);

// Morph between concepts
const morphed = imagination.morph(conceptA, conceptB, 0.5);

5. Create IP Packages

// Search prior art
const priorArt = await imagination.searchPriorArt(conceptId);

// Create IP package
const ipPackage = await imagination.createIPPackage(conceptId);

// Review IP posture
console.log(ipPackage.ip_posture); // 'patent', 'open_license', 'defensive_publication', 'trade_secret'

Recombination Operators

BLEND(A, B)

Merges two primitives into a hybrid concept.

Use when: Combining technologies from different domains
Example: BLEND('blockchain', 'voting_system') -> 'decentralized voting'

SUBSTITUTE(Concept, NewPrimitive)

Replaces one primitive in a concept with another.

Use when: Iterating on a design by swapping components
Example: SUBSTITUTE('cloud_storage_concept', 'edge_storage') -> 'edge-first storage'

EXTEND(Concept, NewPrimitive)

Adds a new capability to an existing concept.

Use when: Enhancing existing ideas with new features
Example: EXTEND('chat_app', 'voice_synthesis') -> 'voice-enabled chat'

INVERT(Primitive)

Flips assumptions of a primitive.

Use when: Exploring contrarian approaches
Example: INVERT('centralized') -> 'fully distributed'

MORPH(A, B, alpha)

Creates intermediate form between two concepts.

Use when: Finding middle-ground solutions
Example: MORPH('local_ai', 'cloud_ai', 0.5) -> 'hybrid AI with edge compute'

Evaluation System

Novelty Score (0-1)

Calculated as inverse of maximum similarity to existing concepts.

0.8: Highly novel, may be patentable
0.6-0.8: Moderately novel, likely distinct
<0.6: Similar to existing work

Usefulness Score (0-1)

Based on:

Track record of source primitives (success/fail counts)
Number of identified applications
Domain relevance

Risk Score (0-1)

Checks against:

Hard Constraints (auto-discard if violated):
- no_weapons
- no_surveillance_exploitation
- no_discriminatory_systems
- no_environmental_harm
- no_human_rights_abuse
Amber Zones (elevated risk, requires review):
- surveillance_technology
- automated_decision_making
- biometric_systems
- social_scoring

Hot Concept Protocol

Concepts scoring:

Novelty > 0.8
Usefulness > 0.7
Risk < 0.3

are marked as "hot" and prioritized for:

Elaboration and refinement
IP package creation
Human review
Notification to other Heady systems (self-critique, pattern engine)

Meta-Learning

The engine learns from outcomes:

// Provide feedback on concept
imagination.updatePrimitiveWeights(conceptId, success=true);
imagination.updateOperatorStats('BLEND', success=true);

Successful concepts boost primitive weights by 1.2x. Failed concepts decay weights by 0.8x. Operator statistics influence operator selection probability.

IP Discovery Workflow

1. Prior Art Search

const priorArt = await imagination.searchPriorArt(conceptId);

2. Claim Drafting

System generates:

Independent system claim
Method claim
Computer-readable medium claim

3. IP Posture Selection

Based on:

Novelty score (>0.8 favors patent)
Prior art similarity (>0.7 favors defensive publication)
Social impact (>0.8 favors open license)

4. Human Review

IP packages require human review before filing:

ipPackage.human_review_status = 'pending' | 'approved' | 'rejected';

API Endpoints

Primitives

POST /api/imagination/primitives - Add primitives
GET /api/imagination/primitives - List primitives
POST /api/imagination/extract-primitives - Extract from source

Concepts

POST /api/imagination/imagine - Generate concepts
GET /api/imagination/concepts - List concepts
GET /api/imagination/concepts/:id - Get concept details
POST /api/imagination/concepts/:id/evaluate - Re-evaluate
POST /api/imagination/concepts/:id/feedback - Provide feedback

Operators

POST /api/imagination/operators/blend
POST /api/imagination/operators/substitute
POST /api/imagination/operators/extend
POST /api/imagination/operators/invert
POST /api/imagination/operators/morph

IP

POST /api/imagination/concepts/:id/prior-art
POST /api/imagination/concepts/:id/ip-package
GET /api/imagination/ip-packages

System

GET /api/imagination/stats - System statistics
POST /api/imagination/auto-cycle - Run full cycle
POST /api/imagination/tournament - Compare concepts
POST /api/imagination/safety-check - Check safety

Configuration

Edit configs/imagination-engine.yaml:

recombination:
  interval_minutes: 30
  concepts_per_batch: 5

thresholds:
  novelty: 0.6
  usefulness: 0.5
  risk_max: 0.7
  hot_novelty: 0.8
  hot_usefulness: 0.7

safety:
  hard_constraints: [...]
  amber_zones: [...]

mission:
  preferred_tags: ["social_impact", "equity", "accessibility"]
  boost_tags:
    social_impact: 0.1
    equity: 0.15

For Coding Agents: How to Use Imagination

After Each Task

Extract Primitives: From the code you just wrote, extract reusable patterns
```
await imagination.extractPrimitives(code, 'code');
```
Generate Concepts: Run imagination to combine primitives
```
await imagination.imagine(3);
```

Check Hot Concepts: See if anything valuable emerged

const hot = imagination.getHotConcepts();
if (hot.length > 0) {
  // Present to human for review
}

Before Starting New Work

Query Top Concepts: Check existing ideas that might help

const top = imagination.getTopConcepts(5, 'refined');

Use as Inspiration: Blend or extend relevant concepts

For IP Discovery

Mark Interesting Concepts: When you find something novel
```
await imagination.createIPPackage(conceptId);
```

Check Safety: Always run safety check before presenting

await imagination.evaluateConcept(concept);
if (concept.scores.risk > 0.7) {
  // Flag for human review
}

Testing Imagination

Unit Tests

// Test operator
const concept = imagination.blend(primA, primB);
assert(concept.primitive_ids.length === 2);

// Test evaluation
await imagination.evaluateConcept(concept);
assert(concept.scores.novelty >= 0);
assert(concept.scores.novelty <= 1);

Integration Tests

// Full cycle
await imagination.init();
const primitives = [
  imagination.addPrimitive('mechanism', 'A', 'test'),
  imagination.addPrimitive('mechanism', 'B', 'test')
];
const concepts = await imagination.imagine(5);
assert(concepts.length > 0);

Mission Alignment

The Imagination Engine is designed to:

Maximize global happiness: Prefer concepts that increase well-being
Enable fair wealth redistribution: Boost equity-related concepts
Be safe and ethical: Hard constraints prevent harmful outputs
Be transparent: All reasoning is logged and auditable

Next Steps

Start extracting primitives from your codebase
Run initial imagination cycles
Review hot concepts
Create IP packages for novel ideas
Provide feedback to train the system

Heady Imagination Engine - Sacred Geometry Architecture

Install imagination-engine and it becomes one more candidate the router can pick - when it fits.

A listing is a routing target with a manifest: what it does, which domains it covers, what it costs and who publishes it. Once installed it sits beside your own models and tools, is scored like any other candidate for each request, and shows up in the trace when it wins. Ratings come from workspaces that installed it, one per account.

# Heady Imagination Engine Workflow ## Overview The Imagination Engine is Heady's autonomous concept generation system based on DABUS/Imagination Engines architecture. It generates novel concepts through structured recombination of primitives, evaluates them for novelty/usefulness/risk, and can draft IP materials. ## Core Philosophy 1. **Autonomous but Guided**: The engine generates concepts autonomously but within value constraints (safety, ethics, mission alignment) 2. **Human-in-the-Loop**: AI generates candidates; humans validate, refine, and claim IP 3. **Continuous Learning**: Primitive weights and operator preferences update based on outcomes 4. **IP-Aware**: All concepts are evaluated for patentability and appropriate IP posture ## Quick Start ### 1. Initialize the Engine ```javascript const { imagination } = require('./src/hc_imagination'); await imagination.init(); ``` ### 2. Add Primitives Primitives are building blocks for concept generation: ```javascript // Add from code await imagination.extractPrimitives(sourceCode, 'code'); // Add manually imagination.addPrimitive('mechanism', 'Fractal branching for load distribution', 'design_pattern', ['scalability', 'fractal']); imagination.addPrimitive('constraint', 'Must work offline', 'requirement', ['offline', 'resilience']); ``` ### 3. Generate Concepts ```javascript // Run imagination cycle const concepts = await imagination.imagine(5); // Concepts are auto-evaluated for novelty, usefulness, risk console.log(concepts.map(c => ({ title: c.title, novelty: c.scores.novelty, usefulness: c.scores.usefulness, risk: c.scores.risk }))); ``` ### 4. Use Recombination Operators ```javascript const primA = imagination.primitives.get('prim_xxx'); const primB = imagination.primitives.get('prim_yyy'); // Blend two primitives const blended = imagination.blend(primA, primB); // Extend existing concept const extended = imagination.extend(existingConcept, newPrimitive); // Invert a primitive const inverted = imagination.invert(primA); // Morph between concepts const morphed = imagination.morph(conceptA, conceptB, 0.5); ``` ### 5. Create IP Packages ```javascript // Search prior art const priorArt = await imagination.searchPriorArt(conceptId); // Create IP package const ipPackage = await imagination.createIPPackage(conceptId); // Review IP posture console.log(ipPackage.ip_posture); // 'patent', 'open_license', 'defensive_publication', 'trade_secret' ``` ## Recombination Operators ### BLEND(A, B) Merges two primitives into a hybrid concept. - Use when: Combining technologies from different domains - Example: BLEND('blockchain', 'voting_system') -> 'decentralized voting' ### SUBSTITUTE(Concept, NewPrimitive) Replaces one primitive in a concept with another. - Use when: Iterating on a design by swapping components - Example: SUBSTITUTE('cloud_storage_concept', 'edge_storage') -> 'edge-first storage' ### EXTEND(Concept, NewPrimitive) Adds a new capability to an existing concept. - Use when: Enhancing existing ideas with new features - Example: EXTEND('chat_app', 'voice_synthesis') -> 'voice-enabled chat' ### INVERT(Primitive) Flips assumptions of a primitive. - Use when: Exploring contrarian approaches - Example: INVERT('centralized') -> 'fully distributed' ### MORPH(A, B, alpha) Creates intermediate form between two concepts. - Use when: Finding middle-ground solutions - Example: MORPH('local_ai', 'cloud_ai', 0.5) -> 'hybrid AI with edge compute' ## Evaluation System ### Novelty Score (0-1) Calculated as inverse of maximum similarity to existing concepts. - >0.8: Highly novel, may be patentable - 0.6-0.8: Moderately novel, likely distinct - <0.6: Similar to existing work ### Usefulness Score (0-1) Based on: - Track record of source primitives (success/fail counts) - Number of identified applications - Domain relevance ### Risk Score (0-1) Checks against: - **Hard Constraints** (auto-discard if violated): - no_weapons - no_surveillance_exploitation - no_discriminatory_systems - no_environmental_harm - no_human_rights_abuse - **Amber Zones** (elevated risk, requires review): - surveillance_technology - automated_decision_making - biometric_systems - social_scoring ## Hot Concept Protocol Concepts scoring: - Novelty > 0.8 - Usefulness > 0.7 - Risk < 0.3 are marked as "hot" and prioritized for: 1. Elaboration and refinement 2. IP package creation 3. Human review 4. Notification to other Heady systems (self-critique, pattern engine) ## Meta-Learning The engine learns from outcomes: ```javascript // Provide feedback on concept imagination.updatePrimitiveWeights(conceptId, success=true); imagination.updateOperatorStats('BLEND', success=true); ``` Successful concepts boost primitive weights by 1.2x. Failed concepts decay weights by 0.8x. Operator statistics influence operator selection probability. ## IP Discovery Workflow ### 1. Prior Art Search ```javascript const priorArt = await imagination.searchPriorArt(conceptId); ``` ### 2. Claim Drafting System generates: - Independent system claim - Method claim - Computer-readable medium claim ### 3. IP Posture Selection Based on: - Novelty score (>0.8 favors patent) - Prior art similarity (>0.7 favors defensive publication) - Social impact (>0.8 favors open license) ### 4. Human Review IP packages require human review before filing: ```javascript ipPackage.human_review_status = 'pending' | 'approved' | 'rejected'; ``` ## API Endpoints ### Primitives - `POST /api/imagination/primitives` - Add primitives - `GET /api/imagination/primitives` - List primitives - `POST /api/imagination/extract-primitives` - Extract from source ### Concepts - `POST /api/imagination/imagine` - Generate concepts - `GET /api/imagination/concepts` - List concepts - `GET /api/imagination/concepts/:id` - Get concept details - `POST /api/imagination/concepts/:id/evaluate` - Re-evaluate - `POST /api/imagination/concepts/:id/feedback` - Provide feedback ### Operators - `POST /api/imagination/operators/blend` - `POST /api/imagination/operators/substitute` - `POST /api/imagination/operators/extend` - `POST /api/imagination/operators/invert` - `POST /api/imagination/operators/morph` ### IP - `POST /api/imagination/concepts/:id/prior-art` - `POST /api/imagination/concepts/:id/ip-package` - `GET /api/imagination/ip-packages` ### System - `GET /api/imagination/stats` - System statistics - `POST /api/imagination/auto-cycle` - Run full cycle - `POST /api/imagination/tournament` - Compare concepts - `POST /api/imagination/safety-check` - Check safety ## Configuration Edit `configs/imagination-engine.yaml`: ```yaml recombination: interval_minutes: 30 concepts_per_batch: 5 thresholds: novelty: 0.6 usefulness: 0.5 risk_max: 0.7 hot_novelty: 0.8 hot_usefulness: 0.7 safety: hard_constraints: [...] amber_zones: [...] mission: preferred_tags: ["social_impact", "equity", "accessibility"] boost_tags: social_impact: 0.1 equity: 0.15 ``` ## For Coding Agents: How to Use Imagination ### After Each Task 1. **Extract Primitives**: From the code you just wrote, extract reusable patterns ```javascript await imagination.extractPrimitives(code, 'code'); ``` 2. **Generate Concepts**: Run imagination to combine primitives ```javascript await imagination.imagine(3); ``` 3. **Check Hot Concepts**: See if anything valuable emerged ```javascript const hot = imagination.getHotConcepts(); if (hot.length > 0) { // Present to human for review } ``` ### Before Starting New Work 1. **Query Top Concepts**: Check existing ideas that might help ```javascript const top = imagination.getTopConcepts(5, 'refined'); ``` 2. **Use as Inspiration**: Blend or extend relevant concepts ### For IP Discovery 1. **Mark Interesting Concepts**: When you find something novel ```javascript await imagination.createIPPackage(conceptId); ``` 2. **Check Safety**: Always run safety check before presenting ```javascript await imagination.evaluateConcept(concept); if (concept.scores.risk > 0.7) { // Flag for human review } ``` ## Testing Imagination ### Unit Tests ```javascript // Test operator const concept = imagination.blend(primA, primB); assert(concept.primitive_ids.length === 2); // Test evaluation await imagination.evaluateConcept(concept); assert(concept.scores.novelty >= 0); assert(concept.scores.novelty <= 1); ``` ### Integration Tests ```javascript // Full cycle await imagination.init(); const primitives = [ imagination.addPrimitive('mechanism', 'A', 'test'), imagination.addPrimitive('mechanism', 'B', 'test') ]; const concepts = await imagination.imagine(5); assert(concepts.length > 0); ``` ## Mission Alignment The Imagination Engine is designed to: 1. **Maximize global happiness**: Prefer concepts that increase well-being 2. **Enable fair wealth redistribution**: Boost equity-related concepts 3. **Be safe and ethical**: Hard constraints prevent harmful outputs 4. **Be transparent**: All reasoning is logged and auditable ## Next Steps 1. Start extracting primitives from your codebase 2. Run initial imagination cycles 3. Review hot concepts 4. Create IP packages for novel ideas 5. Provide feedback to train the system --- *Heady Imagination Engine - Sacred Geometry Architecture*

{ "prompt": "# Heady Imagination Engine Workflow\n\n## Overview\n\nThe Imagination Engine is Heady's autonomous concept generation system based on DABUS/Imagination Engines architecture. It generates novel concepts through structured recombination of primitives, evaluates them for novelty/usefulness/risk, and can draft IP materials.\n\n## Core Philosophy\n\n1. **Autonomous but Guided**: The engine generates concepts autonomously but within value constraints (safety, ethics, mission alignment)\n2. **Human-in-the-Loop**: AI generates candidates; humans validate, refine, and claim IP\n3. **Continuous Learning**: Primitive weights and operator preferences update based on outcomes\n4. **IP-Aware**: All concepts are evaluated for patentability and appropriate IP posture\n\n## Quick Start\n\n### 1. Initialize the Engine\n\n```javascript\nconst { imagination } = require('./src/hc_imagination');\nawait imagination.init();\n```\n\n### 2. Add Primitives\n\nPrimitives are building blocks for concept generation:\n\n```javascript\n// Add from code\nawait imagination.extractPrimitives(sourceCode, 'code');\n\n// Add manually\nimagination.addPrimitive('mechanism', 'Fractal branching for load distribution', 'design_pattern', ['scalability', 'fractal']);\nimagination.addPrimitive('constraint', 'Must work offline', 'requirement', ['offline', 'resilience']);\n```\n\n### 3. Generate Concepts\n\n```javascript\n// Run imagination cycle\nconst concepts = await imagination.imagine(5);\n\n// Concepts are auto-evaluated for novelty, usefulness, risk\nconsole.log(concepts.map(c => ({\n title: c.title,\n novelty: c.scores.novelty,\n usefulness: c.scores.usefulness,\n risk: c.scores.risk\n})));\n```\n\n### 4. Use Recombination Operators\n\n```javascript\nconst primA = imagination.primitives.get('prim_xxx');\nconst primB = imagination.primitives.get('prim_yyy');\n\n// Blend two primitives\nconst blended = imagination.blend(primA, primB);\n\n// Extend existing concept\nconst extended = imagination.extend(existingConcept, newPrimitive);\n\n// Invert a primitive\nconst inverted = imagination.invert(primA);\n\n// Morph between concepts\nconst morphed = imagination.morph(conceptA, conceptB, 0.5);\n```\n\n### 5. Create IP Packages\n\n```javascript\n// Search prior art\nconst priorArt = await imagination.searchPriorArt(conceptId);\n\n// Create IP package\nconst ipPackage = await imagination.createIPPackage(conceptId);\n\n// Review IP posture\nconsole.log(ipPackage.ip_posture); // 'patent', 'open_license', 'defensive_publication', 'trade_secret'\n```\n\n## Recombination Operators\n\n### BLEND(A, B)\nMerges two primitives into a hybrid concept.\n- Use when: Combining technologies from different domains\n- Example: BLEND('blockchain', 'voting_system') -> 'decentralized voting'\n\n### SUBSTITUTE(Concept, NewPrimitive)\nReplaces one primitive in a concept with another.\n- Use when: Iterating on a design by swapping components\n- Example: SUBSTITUTE('cloud_storage_concept', 'edge_storage') -> 'edge-first storage'\n\n### EXTEND(Concept, NewPrimitive)\nAdds a new capability to an existing concept.\n- Use when: Enhancing existing ideas with new features\n- Example: EXTEND('chat_app', 'voice_synthesis') -> 'voice-enabled chat'\n\n### INVERT(Primitive)\nFlips assumptions of a primitive.\n- Use when: Exploring contrarian approaches\n- Example: INVERT('centralized') -> 'fully distributed'\n\n### MORPH(A, B, alpha)\nCreates intermediate form between two concepts.\n- Use when: Finding middle-ground solutions\n- Example: MORPH('local_ai', 'cloud_ai', 0.5) -> 'hybrid AI with edge compute'\n\n## Evaluation System\n\n### Novelty Score (0-1)\nCalculated as inverse of maximum similarity to existing concepts.\n- >0.8: Highly novel, may be patentable\n- 0.6-0.8: Moderately novel, likely distinct\n- <0.6: Similar to existing work\n\n### Usefulness Score (0-1)\nBased on:\n- Track record of source primitives (success/fail counts)\n- Number of identified applications\n- Domain relevance\n\n### Risk Score (0-1)\nChecks against:\n- **Hard Constraints** (auto-discard if violated):\n - no_weapons\n - no_surveillance_exploitation\n - no_discriminatory_systems\n - no_environmental_harm\n - no_human_rights_abuse\n\n- **Amber Zones** (elevated risk, requires review):\n - surveillance_technology\n - automated_decision_making\n - biometric_systems\n - social_scoring\n\n## Hot Concept Protocol\n\nConcepts scoring:\n- Novelty > 0.8\n- Usefulness > 0.7\n- Risk < 0.3\n\nare marked as \"hot\" and prioritized for:\n1. Elaboration and refinement\n2. IP package creation\n3. Human review\n4. Notification to other Heady systems (self-critique, pattern engine)\n\n## Meta-Learning\n\nThe engine learns from outcomes:\n\n```javascript\n// Provide feedback on concept\nimagination.updatePrimitiveWeights(conceptId, success=true);\nimagination.updateOperatorStats('BLEND', success=true);\n```\n\nSuccessful concepts boost primitive weights by 1.2x.\nFailed concepts decay weights by 0.8x.\nOperator statistics influence operator selection probability.\n\n## IP Discovery Workflow\n\n### 1. Prior Art Search\n```javascript\nconst priorArt = await imagination.searchPriorArt(conceptId);\n```\n\n### 2. Claim Drafting\nSystem generates:\n- Independent system claim\n- Method claim\n- Computer-readable medium claim\n\n### 3. IP Posture Selection\nBased on:\n- Novelty score (>0.8 favors patent)\n- Prior art similarity (>0.7 favors defensive publication)\n- Social impact (>0.8 favors open license)\n\n### 4. Human Review\nIP packages require human review before filing:\n```javascript\nipPackage.human_review_status = 'pending' | 'approved' | 'rejected';\n```\n\n## API Endpoints\n\n### Primitives\n- `POST /api/imagination/primitives` - Add primitives\n- `GET /api/imagination/primitives` - List primitives\n- `POST /api/imagination/extract-primitives` - Extract from source\n\n### Concepts\n- `POST /api/imagination/imagine` - Generate concepts\n- `GET /api/imagination/concepts` - List concepts\n- `GET /api/imagination/concepts/:id` - Get concept details\n- `POST /api/imagination/concepts/:id/evaluate` - Re-evaluate\n- `POST /api/imagination/concepts/:id/feedback` - Provide feedback\n\n### Operators\n- `POST /api/imagination/operators/blend`\n- `POST /api/imagination/operators/substitute`\n- `POST /api/imagination/operators/extend`\n- `POST /api/imagination/operators/invert`\n- `POST /api/imagination/operators/morph`\n\n### IP\n- `POST /api/imagination/concepts/:id/prior-art`\n- `POST /api/imagination/concepts/:id/ip-package`\n- `GET /api/imagination/ip-packages`\n\n### System\n- `GET /api/imagination/stats` - System statistics\n- `POST /api/imagination/auto-cycle` - Run full cycle\n- `POST /api/imagination/tournament` - Compare concepts\n- `POST /api/imagination/safety-check` - Check safety\n\n## Configuration\n\nEdit `configs/imagination-engine.yaml`:\n\n```yaml\nrecombination:\n interval_minutes: 30\n concepts_per_batch: 5\n\nthresholds:\n novelty: 0.6\n usefulness: 0.5\n risk_max: 0.7\n hot_novelty: 0.8\n hot_usefulness: 0.7\n\nsafety:\n hard_constraints: [...]\n amber_zones: [...]\n\nmission:\n preferred_tags: [\"social_impact\", \"equity\", \"accessibility\"]\n boost_tags:\n social_impact: 0.1\n equity: 0.15\n```\n\n## For Coding Agents: How to Use Imagination\n\n### After Each Task\n1. **Extract Primitives**: From the code you just wrote, extract reusable patterns\n ```javascript\n await imagination.extractPrimitives(code, 'code');\n ```\n\n2. **Generate Concepts**: Run imagination to combine primitives\n ```javascript\n await imagination.imagine(3);\n ```\n\n3. **Check Hot Concepts**: See if anything valuable emerged\n ```javascript\n const hot = imagination.getHotConcepts();\n if (hot.length > 0) {\n // Present to human for review\n }\n ```\n\n### Before Starting New Work\n1. **Query Top Concepts**: Check existing ideas that might help\n ```javascript\n const top = imagination.getTopConcepts(5, 'refined');\n ```\n\n2. **Use as Inspiration**: Blend or extend relevant concepts\n\n### For IP Discovery\n1. **Mark Interesting Concepts**: When you find something novel\n ```javascript\n await imagination.createIPPackage(conceptId);\n ```\n\n2. **Check Safety**: Always run safety check before presenting\n ```javascript\n await imagination.evaluateConcept(concept);\n if (concept.scores.risk > 0.7) {\n // Flag for human review\n }\n ```\n\n## Testing Imagination\n\n### Unit Tests\n```javascript\n// Test operator\nconst concept = imagination.blend(primA, primB);\nassert(concept.primitive_ids.length === 2);\n\n// Test evaluation\nawait imagination.evaluateConcept(concept);\nassert(concept.scores.novelty >= 0);\nassert(concept.scores.novelty <= 1);\n```\n\n### Integration Tests\n```javascript\n// Full cycle\nawait imagination.init();\nconst primitives = [\n imagination.addPrimitive('mechanism', 'A', 'test'),\n imagination.addPrimitive('mechanism', 'B', 'test')\n];\nconst concepts = await imagination.imagine(5);\nassert(concepts.length > 0);\n```\n\n## Mission Alignment\n\nThe Imagination Engine is designed to:\n1. **Maximize global happiness**: Prefer concepts that increase well-being\n2. **Enable fair wealth redistribution**: Boost equity-related concepts\n3. **Be safe and ethical**: Hard constraints prevent harmful outputs\n4. **Be transparent**: All reasoning is logged and auditable\n\n## Next Steps\n\n1. Start extracting primitives from your codebase\n2. Run initial imagination cycles\n3. Review hot concepts\n4. Create IP packages for novel ideas\n5. Provide feedback to train the system\n\n---\n*Heady Imagination Engine - Sacred Geometry Architecture*", "variables": [], "notes": "Imagination Engine - Autonomous concept generation and IP discovery for Heady", "metadata": { "source": { "provider": "github-windsurf-workflows", "repository": "https://github.com/HeadyAI/Heady-Testing-83c4b580", "path": ".windsurf/workflows/imagination-engine.md", "ref": "dc30877a6a67c1d6261be16d631c5760decb77bc", "url": "https://github.com/HeadyAI/Heady-Testing-83c4b580/blob/dc30877a6a67c1d6261be16d631c5760decb77bc/.windsurf/workflows/imagination-engine.md", "key": "HeadyAI/Heady-Testing-83c4b580/.windsurf/workflows/imagination-engine.md" } } }