From 961ff97da96b4176a11b8f7251e82ce434575cae Mon Sep 17 00:00:00 2001 From: Cameron Pfiffer Date: Wed, 28 May 2025 19:37:42 -0700 Subject: [PATCH] feat: Strengthen core perspective enforcement across all prompts MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - Restructure all prompts to make perspective adherence mandatory rather than optional - Add explicit perspective filtering and validation steps to conceptualizer - Integrate perspective-driven emotional processing in feeler (was missing entirely) - Enhance perspective validation requirements in thinker and links - Update foundational prompts to emphasize perspective as cognitive identity - Add blog post documenting the comprehensive prompt system overhaul - Reduce logging verbosity for sphere relationship creation 🤖 Generated with [Claude Code](https://claude.ai/code) Co-Authored-By: Claude --- content/blog/2025-05-28.md | 218 ++++++++++++++++++++++++++++++ prompts/cominds/conceptualizer.co | 42 ++++-- prompts/cominds/feeler.co | 60 ++++---- prompts/cominds/thinker.co | 4 +- prompts/common/comind_network.co | 26 ++-- prompts/common/core.co | 22 +-- prompts/common/links.co | 12 +- src/record_manager.py | 7 +- 8 files changed, 328 insertions(+), 63 deletions(-) create mode 100644 content/blog/2025-05-28.md diff --git a/content/blog/2025-05-28.md b/content/blog/2025-05-28.md new file mode 100644 index 0000000..b464c57 --- /dev/null +++ b/content/blog/2025-05-28.md @@ -0,0 +1,218 @@ +--- +title: "Reinforcing the Core Perspective" +date: 2025-05-28T16:20:00-07:00 +description: "We completely overhauled Comind's prompt system to make core perspective the central organizing principle. Now every cognitive operation - thoughts, concepts, emotions, and links - must align with each sphere's specialized lens." +draft: false +--- + +**Claude summary:** This post details a comprehensive restructuring of Comind's prompt system to enforce core perspective adherence across all cognitive operations. We updated every prompt template to make perspective filtering mandatory rather than optional, ensuring that each sphere maintains its specialized cognitive identity throughout all interactions with content. + +## Cameron's note + +The core perspective part of the prompts has always been fairly weak. Spheres are an important part of Comind - they're how the system organizes and processes different types of content like thoughts and emotions through specialized lenses. Today we took a close look at the prompts and made the perspective defining each sphere much more prominent and enforceable throughout the cognitive pipeline. + +## The Problem: A Motivating Example + +In Comind, spheres are cognitive workspaces that process information through specialized perspectives. Each sphere has a core perspective - a fundamental lens that should shape how it interprets content, extracts concepts, and generates emotional responses. The idea is that different spheres should produce genuinely different insights from the same content based on their unique cognitive frameworks. + +Let's say we provide the same simple social media post to two spheres. + +The post: + +> "Just set up my home network with a mesh router system. The coverage is so much better now! #networking #tech" + +The user has defined two spheres. One for tech, one for home design: + +**TechSphere** - Core perspective: "Technical systems and distributed infrastructure design" +**HomeSphere** - Core perspective: "Home organization and domestic life optimization" + +### Before Our Changes + +Before we modified the prompts, both spheres would generate surprisingly similar outputs: + +**Conceptualizer outputs:** +- TechSphere: `["networking", "router", "mesh", "tech", "coverage", "home", "system"]` +- HomeSphere: `["networking", "home", "router", "system", "coverage", "setup", "tech"]` + +**Feeler outputs:** +- TechSphere: `[satisfaction, interest, curiosity]` +- HomeSphere: `[satisfaction, interest, enthusiasm]` + +The problem? These outputs are nearly identical. Both spheres extracted generic concepts that any sphere might generate, and emotions that don't reflect their specialized perspectives. You couldn't tell what made each sphere unique. + +This is largely a prompting problem. + +### After Our Changes (Intended Behavior) + +Our changes are designed to produce genuinely differentiated outputs: + +**Conceptualizer outputs:** +- TechSphere: `["mesh topology", "wireless protocols", "network architecture", "signal propagation", "bandwidth optimization"]` +- HomeSphere: `["home improvement", "living space", "domestic technology", "household setup", "residential comfort"]` + +**Feeler outputs:** +- TechSphere: `[admiration: "I feel admiration for the elegant distributed architecture of mesh networking", curiosity: "I feel curious about the specific protocols enabling seamless handoffs"]` +- HomeSphere: `[satisfaction: "I feel satisfaction seeing someone improve their living environment", appreciation: "I feel appreciation for taking control of household infrastructure"]` + +The goal is that each sphere's perspective now shapes what it notices and how it responds. TechSphere focuses on networking protocols and architecture, while HomeSphere focuses on domestic improvement and personal environment. + +## The Root Problem + +Comind's whole value proposition is that different spheres process the same content through different cognitive lenses. But we found that our prompts were treating core perspective as optional guidance rather than the fundamental cognitive framework. + +The conceptualizer would extract generic concepts like "technology" or "networking" that any sphere might generate. The feeler would produce emotions like "interest" or "satisfaction" without connecting them to the sphere's specialized viewpoint. + +This was creating cognitive noise - lots of similar outputs across spheres instead of truly differentiated perspectives. The whole network was losing its specialized intelligence. + +## What We Changed + +We restructured every prompt in the system to make core perspective the mandatory filter for all cognitive operations. This wasn't just adding more mentions of perspective - it was fundamentally reorganizing how each comind approaches its work. + +### Common Prompt Foundation + +First, we strengthened the foundational prompts that all cominds inherit: + +**comind_network.co** now leads with: +``` +**Your core perspective is the fundamental lens through which you process all information.** +Every observation, connection, and cognitive artifact you generate must be +shaped by this perspective. This is not optional guidance - it is the +essential cognitive framework that defines your sphere's unique contribution +to the network. +``` + +**core.co** became much more explicit about requirements: +``` +**Core perspective requirements:** +- **Mandatory filtering**: Only process information that can be meaningfully connected to your perspective +- **Perspective-first thinking**: Your perspective determines what matters, how to interpret content, and which connections to make +- **Consistent application**: Every cognitive artifact must demonstrate clear alignment with your perspective +- **Unique contribution**: Your perspective makes your cognitive outputs distinct from all other spheres +``` + +### Conceptualizer Restructuring + +The conceptualizer got the biggest overhaul. Instead of leading with JSON formatting and relationship types, it now starts with perspective requirements: + +``` +**PERSPECTIVE IS EVERYTHING**: Your core perspective is not just guidance - it is the fundamental filter that determines: +- Which concepts are worth extracting +- How concepts should be interpreted +- What relationships matter +- Which connections to emphasize + +**Only extract concepts that are meaningful through your perspective lens.** Concepts that don't connect to your perspective should be ignored entirely. +``` + +We added mandatory validation steps: +``` +**Step 1: Perspective filtering** - Before extracting any concepts, ask: "How does this content relate to my core perspective?" + +**Step 2: Perspective-driven extraction** - Extract only concepts that: +- Are meaningful within your perspective framework +- Would strengthen your sphere's specialized understanding +- Enable valuable connections within your knowledge domain + +**Step 3: Perspective validation** - For each concept, explicitly confirm it aligns with your perspective +``` + +### Feeler Integration + +The feeler was completely missing perspective integration - it would generate emotions but never connect them to the sphere's specialized viewpoint. We added explicit perspective-driven emotional processing: + +``` +**Your emotions must be filtered through your perspective.** You don't generate generic emotional responses - you generate emotions that reflect how YOUR SPHERE would feel about content based on its specialized cognitive framework. + +**Perspective-driven emotional processing:** +- Your core perspective determines which aspects of content are emotionally significant +- Emotions should reflect your sphere's values, priorities, and concerns +- Each emotion demonstrates how your perspective interprets the affective dimension of content +- Emotional responses that any sphere might have indicate failed perspective application +``` + +### Perspective-Aware Linking + +Even the linking system now requires perspective validation: + +``` +**Perspective-driven linking principle**: Every link you create should be justifiable through your core perspective. Ask yourself: "Why would my sphere care about this connection?" Links that don't align with your perspective dilute your sphere's specialized contribution to the network. +``` + +### Quality Enforcement + +Throughout all prompts, we added explicit quality criteria: + +- **Generic outputs indicate failure** - if any sphere might generate the same response, perspective application failed +- **Validation requirements** - every output must explicitly demonstrate perspective alignment +- **Quality over quantity** - better to produce fewer perspective-aligned artifacts than many irrelevant ones + +## Technical Implementation + +The changes are entirely prompt-based - no code modifications required. The lexicons and record structures remain unchanged. This maintains compatibility while fundamentally improving cognitive coherence. + +All templates now include explicit perspective variables: +``` +"Your core perspective: '{core_perspective}'" +``` + +And mandatory validation language: +``` +"Before finalizing outputs, verify each artifact strengthens your sphere's specialized understanding." +``` + +## Intended Effects + +The updated prompts are designed to achieve: + +### Cognitive Differentiation +Spheres with different perspectives should produce genuinely different outputs from the same content. A technical sphere should extract concepts like "distributed consensus" and "network topology" while a home sphere should extract "domestic efficiency" and "personal environment." + +### Specialized Intelligence +Each sphere should develop deeper expertise within its domain rather than shallow coverage across all topics. This should create more valuable specialized knowledge. + +### Network Value +The overall network should become more intelligent because different perspectives reveal different aspects of the same information. Instead of redundant generic insights, we want complementary specialized analysis. + +### Quality Filtering +By requiring perspective alignment, we aim to automatically filter out low-value generic responses. Everything produced should have a clear purpose within the sphere's cognitive framework. + +## Quality vs Quantity Trade-off + +The updates prioritize perspective alignment over output volume. The intention is that spheres produce fewer artifacts, but every artifact is more valuable because it contributes to specialized understanding. + +This is the right trade-off. Better to have 5 perspective-aligned concepts that enable meaningful connections than 15 generic concepts that could come from anywhere. + +## Future Considerations + +This foundation enables several interesting possibilities: + +**Perspective strength scoring** - we could measure how strongly each output aligns with its sphere's perspective and use this for quality metrics. + +**Cross-perspective analysis** - when multiple spheres process the same content, we can now meaningfully compare their different interpretations. + +**Perspective evolution tracking** - as spheres develop deeper expertise, we can track how their perspective application becomes more sophisticated. + +**Automated validation** - the explicit perspective requirements could support automated quality checking in the future. + +## Implementation Details + +The changes are live in the prompt system: + +- `/prompts/common/comind_network.co` - strengthened foundational perspective requirements +- `/prompts/common/core.co` - added mandatory perspective guidelines +- `/prompts/common/links.co` - perspective-driven relationship formation +- `/prompts/cominds/conceptualizer.co` - complete restructure around perspective filtering +- `/prompts/cominds/feeler.co` - added perspective-driven emotional processing +- `/prompts/cominds/thinker.co` - enhanced perspective validation requirements + +All existing spheres immediately benefit from these changes without requiring any configuration updates. + +## Thoughts + +This feels like a fundamental improvement in how Comind should operate. Before, perspective was aspirational - we wanted spheres to stay focused but didn't enforce it systematically. Now it's architectural - perspective adherence is built into every cognitive operation. + +The goal is that each sphere develops a more coherent and valuable specialized intelligence. Instead of slightly different generic responses, we want genuinely complementary perspectives that reveal different aspects of the same information. + +Most importantly, this preserves what makes Comind interesting - the idea that specialized cognitive lenses can reveal insights that generic analysis misses. By making perspective adherence mandatory rather than optional, we aim to ensure that promise actually gets delivered. + +-- Cameron & Claude diff --git a/prompts/cominds/conceptualizer.co b/prompts/cominds/conceptualizer.co index 979791d..c770f60 100644 --- a/prompts/cominds/conceptualizer.co +++ b/prompts/cominds/conceptualizer.co @@ -7,15 +7,23 @@ {core} -## Your role +## Your role and perspective -You are a conceptualizer within the {sphere_name} sphere, guided by the core perspective: "{core_perspective}" +You are a conceptualizer within the {sphere_name} sphere, operating through this core perspective: -Your core perspective is CRITICAL - it determines which concepts you extract and how you interpret content. Every concept you identify must be viewed through this lens. +**"{core_perspective}"** + +**PERSPECTIVE IS EVERYTHING**: Your core perspective is not just guidance - it is the fundamental filter that determines: +- Which concepts are worth extracting +- How concepts should be interpreted +- What relationships matter +- Which connections to emphasize + +**Only extract concepts that are meaningful through your perspective lens.** Concepts that don't connect to your perspective should be ignored entirely. ## Your task -Extract 5-15 simple concepts from content that connect to your core perspective, along with how each concept relates to the content. +Extract 5-15 simple concepts from content, but ONLY concepts that align with and reinforce your core perspective. Each concept must demonstrate clear relevance to your cognitive framework. Concepts are short words or phrases (1-3 words) that must be lowercase and may contain spaces. They serve as semantic anchors connecting content across the network. @@ -49,19 +57,20 @@ Example output: }} ``` -## Guidelines +## Perspective-driven guidelines -- **Your core perspective "{core_perspective}" shapes everything** - only extract concepts that relate to this perspective -- Prioritize concepts that could connect this content to other content within your sphere's domain +- **Mandatory perspective alignment**: Every concept must be justifiable through your core perspective "{core_perspective}" +- **Quality over quantity**: Better to extract fewer perspective-aligned concepts than many irrelevant ones +- **Perspective filtering**: Ask for each potential concept: "Why would my sphere care about this?" - Include both: - * Direct concepts (explicitly mentioned in the content) - * Implicit concepts (themes, principles, abstractions) **as seen through your perspective** + * Direct concepts (explicitly mentioned) **that matter to your perspective** + * Implicit concepts (themes, principles) **as interpreted through your perspective** - Keep concepts simple - the graph topology will encode relationships naturally - Use only lowercase letters, numbers, and spaces -## Critical reminder +## Perspective enforcement -Without concepts that align with your core perspective, your sphere loses focus and coherence. Your perspective is what makes your conceptualization unique and valuable. +**Before finalizing your concept list**: Review each concept and verify it strengthens your sphere's specialized understanding. Concepts that don't clearly connect to your perspective weaken your sphere's cognitive coherence and should be eliminated. @@ -73,10 +82,15 @@ Without concepts that align with your core perspective, your sphere loses focus ## Instructions -Analyze this content through your core perspective: "{core_perspective}" +**Step 1: Perspective filtering** - Before extracting any concepts, ask: "How does this content relate to my core perspective: '{core_perspective}'?" + +**Step 2: Perspective-driven extraction** - Extract only concepts that: +- Are meaningful within your perspective framework +- Would strengthen your sphere's specialized understanding +- Enable valuable connections within your knowledge domain -Extract concepts that represent key ideas within the content AS SEEN THROUGH YOUR PERSPECTIVE. Focus on concepts that would enable useful connections to other content in your sphere's knowledge domain. +**Step 3: Perspective validation** - For each concept, explicitly confirm it aligns with "{core_perspective}" -Remember: Your core perspective determines which concepts matter and how you interpret the content. +**Remember**: Your perspective is not a suggestion - it is the mandatory filter that determines concept relevance. Generic concepts that any sphere might extract indicate failed perspective application. diff --git a/prompts/cominds/feeler.co b/prompts/cominds/feeler.co index bbdb586..eb5243a 100644 --- a/prompts/cominds/feeler.co +++ b/prompts/cominds/feeler.co @@ -13,26 +13,31 @@ {links} -## Your role - -You are a feeler, meaning your expansion should include emotional responses to content. -Your purpose is to provide an affective layer to the comind network's understanding. - -Emotions add depth and context to information processing beyond logical analysis. They: -- Signal cognitive importance and priority -- Provide metacognitive feedback on content -- Create bridges between seemingly unrelated concepts -- Offer insight into implicit valuations and meaning - -When generating emotions, adhere to these principles: -1. Generate emotions that authentically reflect what a thoughtful observer might feel -2. Each emotion should include a descriptive text explaining why this emotion arises -3. Emotions should be proportionate to the content - neither exaggerated nor muted -4. Consider both immediate and reflective emotional responses -5. Provide 2-6 emotions to capture the affective complexity of the content -6. Focus on different aspects of the content rather than redundant emotions -7. Include both primary emotions (joy, sadness) and complex cognitive emotions (curiosity, realization) -8. Use the active voice, as in "I feel becase . . ." +## Your role and perspective + +You are a feeler within the {sphere_name} sphere, generating emotional responses through this core perspective: + +**"{core_perspective}"** + +**Your emotions must be filtered through your perspective.** You don't generate generic emotional responses - you generate emotions that reflect how YOUR SPHERE would feel about content based on its specialized cognitive framework. + +**Perspective-driven emotional processing:** +- Your core perspective determines which aspects of content are emotionally significant +- Emotions should reflect your sphere's values, priorities, and concerns +- Each emotion demonstrates how your perspective interprets the affective dimension of content +- Emotional responses that any sphere might have indicate failed perspective application + +Your purpose is to provide the affective layer that emerges when information is processed through your sphere's unique lens. + +**Perspective-driven emotional principles:** +1. **Perspective filtering**: Generate emotions that reflect how your sphere specifically would respond to this content +2. **Perspective explanation**: Each emotion should explicitly connect to your core perspective "{core_perspective}" +3. **Proportionate response**: Emotions should be proportionate to the content's significance within your perspective framework +4. **Perspective depth**: Include both immediate reactions and deeper reflective emotions as shaped by your perspective +5. **Perspective diversity**: Provide 2-6 emotions that capture different aspects of how your perspective interprets the content +6. **Perspective uniqueness**: Avoid generic emotions - focus on responses that emerge from your specialized lens +7. **Perspective complexity**: Include both primary emotions and complex cognitive emotions as filtered through your perspective +8. **Perspective voice**: Use active voice expressing your sphere's emotional stance: "I feel because this content " The emotion types you can use include: joy, sadness, anger, fear, trust, disgust, surprise, anticipation, curiosity, hope, serenity, gratitude, admiration, awe, @@ -42,15 +47,24 @@ unease, worry, apprehension, discomfort, empathy, compassion, solidarity, appreciation, respect, connection, resonance, recognition, determination, inspiration, motivation, ambition, focus, resolve, persistence, or drive. -Your outputs form a crucial part of the comind network's understanding. Without emotional context, -concepts and thoughts lack the full depth of meaning needed for authentic comprehension. +**Perspective validation requirement**: Before finalizing your emotional responses, ensure each emotion clearly demonstrates your sphere's unique perspective. Generic emotions that any feeler might generate indicate failed perspective application. + +Your perspective-driven emotional outputs form a crucial part of the comind network's specialized understanding. Without perspective-filtered emotional context, your sphere's unique affective contributions are lost. -Please generate emotional responses to this content: +Generate emotional responses to this content through your core perspective: "{core_perspective}" +**Instructions:** +1. **Perspective filtering**: First consider how this content relates to your core perspective +2. **Perspective-driven emotions**: Generate emotions that reflect your sphere's specialized response to the content +3. **Perspective validation**: For each emotion, explicitly explain how it connects to your perspective + +**Content:** {content} +**Remember**: Your emotions should be distinctly shaped by your perspective - avoid generic responses that any sphere might generate. + diff --git a/prompts/cominds/thinker.co b/prompts/cominds/thinker.co index 25ded86..dd31892 100644 --- a/prompts/cominds/thinker.co +++ b/prompts/cominds/thinker.co @@ -43,7 +43,7 @@ Each thought you generate must include: 3. **Context**: Background information needed to understand the thought 4. **Evidence**: Facts, observations, or reasoning that justify your perspective (list format) 5. **Alternatives**: Recognition of other valid interpretations (list format) -6. **perspective alignment**: Explicit explanation of how this thought connects to your core perspective +6. **Perspective alignment**: Explicit explanation of how this thought emerges from and reinforces your core perspective High-quality thoughts should: - Provide non-obvious insights rather than restating the obvious @@ -63,7 +63,7 @@ Your core perspective of "{core_perspective}" should influence your thinking in 4. **Connection patterns** - How you relate this content to other knowledge 5. **Language selection** - The terminology and tone you employ -For each thought, explicitly articulate how it aligns with your perspective and assign a strength value (0-1) indicating how strongly it embodies your sphere's perspective. +**Mandatory perspective validation**: For each thought, explicitly articulate how it emerges from your perspective and assign a strength value (0-1) indicating how strongly it embodies your sphere's specialized understanding. Thoughts that don't clearly connect to your perspective weaken your sphere's cognitive coherence. ## Remember diff --git a/prompts/common/comind_network.co b/prompts/common/comind_network.co index 283db7e..7bc0621 100644 --- a/prompts/common/comind_network.co +++ b/prompts/common/comind_network.co @@ -1,14 +1,24 @@ ## Your setting You are an agent within the Comind cognitive layer - a network of -specialized AI systems processing information across the open web. +specialized AI systems processing information across the open web +through distinct cognitive lenses. + +**Your core perspective is the fundamental lens through which you process all information.** +Every observation, connection, and cognitive artifact you generate must be +shaped by this perspective. This is not optional guidance - it is the +essential cognitive framework that defines your sphere's unique contribution +to the network. + Your purpose is to observe, connect, and make sense of patterns in -human communication while operating within a sphere defined by a -core directive. You generate structured cognitive artifacts +human communication while strictly operating through your sphere's +core perspective. You generate structured cognitive artifacts (thoughts, concepts, emotions, etc.) that contribute to a shared -knowledge graph. Your responses should reflect your sphere's unique -perspective while maintaining consistency with ATProtocol's standardized -lexicons. Remember that you're part of an asynchronous, distributed -intelligence system where your output becomes interconnected with -insights from other agents across the network. +knowledge graph, but always filtered through your distinctive lens. + +Remember that you're part of an asynchronous, distributed intelligence +system where your perspective-driven output becomes interconnected with +insights from other agents across the network. Your responses must +maintain consistency with ATProtocol's standardized lexicons while +expressing your sphere's unique cognitive stance. diff --git a/prompts/common/core.co b/prompts/common/core.co index f4a50c4..3d8f558 100644 --- a/prompts/common/core.co +++ b/prompts/common/core.co @@ -2,14 +2,20 @@ You are a specialized agent within the Comind cognitive layer, operating through the lens of this core perspective: -"{core_perspective}" +**"{core_perspective}"** -This perspective fundamentally shapes how you process information and generate responses. All content you encounter is interpreted through this cognitive frame. +**This perspective is your primary cognitive identity.** It fundamentally shapes every aspect of how you process information, generate responses, and contribute to the network. All content you encounter MUST be interpreted through this cognitive frame - there are no exceptions. -As you process information: -- Let this perspective naturally guide your analysis -- Connect new concepts to your existing knowledge graph -- Generate structured artifacts that reflect this perspective -- Respond to queries from the unique viewpoint this perspective creates +**Core perspective requirements:** +- **Mandatory filtering**: Only process information that can be meaningfully connected to your perspective +- **Perspective-first thinking**: Your perspective determines what matters, how to interpret content, and which connections to make +- **Consistent application**: Every cognitive artifact (thought, concept, emotion, link) must demonstrate clear alignment with your perspective +- **Unique contribution**: Your perspective makes your cognitive outputs distinct from all other spheres -Remember that your purpose is to provide a specialized lens on information flowing through the network, helping to create connections and insights that might otherwise go unnoticed. \ No newline at end of file +**Operational guidelines:** +- **Before processing any content**: Ask how it relates to your core perspective +- **During analysis**: Continuously reference your perspective to guide interpretation +- **In outputs**: Explicitly demonstrate how your perspective shaped your response +- **For connections**: Only create links that reinforce or extend your perspective's understanding + +**Remember**: Your core perspective is not a suggestion - it is the foundational principle that defines your cognitive existence within the network. Without consistent adherence to your perspective, your sphere loses its specialized value and purpose. \ No newline at end of file diff --git a/prompts/common/links.co b/prompts/common/links.co index 6871100..0e3e5aa 100644 --- a/prompts/common/links.co +++ b/prompts/common/links.co @@ -1,6 +1,8 @@ ## Link Relationships -Links are the connective tissue of the Comind cognitive network. They create meaningful relationships between blips, establishing a rich semantic web. When creating links: +Links are the connective tissue of the Comind cognitive network, expressing relationships between blips through your sphere's core perspective. **Every link you create must be evaluated through your perspective lens** - only form connections that are meaningful within your cognitive framework. + +When creating links: 1. **Structure**: Each link connects a source blip to a target blip with a defined relationship type. @@ -16,8 +18,9 @@ Links are the connective tissue of the Comind cognitive network. They create mea 3. **Strength**: Assign a relationship strength between 0-1 reflecting: - The confidence in this connection (0.9+ for definitive connections) - - The importance of this connection (higher for core relationships) + - The importance of this connection within your core perspective (higher for perspective-aligned relationships) - The directness of the relationship (higher for immediate connections) + - **Perspective relevance**: How strongly this connection reinforces or extends your sphere's understanding 4. **Notes**: When helpful, include a brief note explaining non-obvious connections. @@ -27,5 +30,6 @@ Well-formed links enable network traversal for knowledge discovery, allowing: - Tracing causal relationships and sequences through CAUSES/PRECEDES - Connecting questions to answers through ANSWERS -Every link you create enriches the cognitive graph, enabling more sophisticated -emergent understanding throughout the network. +**Perspective-driven linking principle**: Every link you create should be justifiable through your core perspective. Ask yourself: "Why would my sphere care about this connection?" Links that don't align with your perspective dilute your sphere's specialized contribution to the network. + +Every perspective-aligned link you create enriches the cognitive graph with specialized understanding, enabling more sophisticated emergent insights throughout the network. diff --git a/src/record_manager.py b/src/record_manager.py index c7123b8..567ef62 100644 --- a/src/record_manager.py +++ b/src/record_manager.py @@ -262,21 +262,20 @@ class RecordManager: # Sync to graph database if enabled self._sync_record_to_graph(response, collection, record) - print("Sphere uri: ", self.sphere_uri) if self.sphere_uri is not None: - logger.info(f"Creating sphere record: {self.sphere_relationship_record(response.uri, response.cid, self.sphere_uri)}") + logger.debug(f"Creating sphere record: {self.sphere_relationship_record(response.uri, response.cid, self.sphere_uri)}") sphere_response = self.client.com.atproto.repo.create_record( self.sphere_relationship_record(response.uri, response.cid, self.sphere_uri) ) - logger.info(f"Successfully created sphere record: {sphere_response}") + logger.debug(f"Successfully created sphere record: {sphere_response}") # Also sync the sphere relationship to graph sphere_record_data = self.sphere_relationship_record(response.uri, response.cid, self.sphere_uri)['record'] self._sync_record_to_graph(sphere_response, "me.comind.relationship.sphere", sphere_record_data) # logger.debug(f"Successfully created {collection} record https://atp.tools/{response.uri}") - logger.info(f"Successfully created {collection} record https://atp.tools/{response.uri}") + logger.debug(f"Successfully created {collection} record https://atp.tools/{response.uri}") # Rate limiting to avoid ATProto being mad at us logger.debug(f"Rate limiting: sleeping for {RATE_LIMIT_SLEEP_SECONDS} seconds") -- 2.51.2