Enhance dynamic factors, value field, and situation output

.github/workflows/tests.yml

@@ -0,0 +1,26 @@
+name: tests
+
+on:
+  pull_request:
+  push:
+    branches:
+      - main
+
+jobs:
+  tests:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Set up Python 3.11
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.11"
+
+      - name: Install dependencies
+        run: pip install -e '.[dev]'
+
+      - name: Run pytest
+        run: pytest

MASTER_SPEC.md

@@ -41,6 +41,19 @@ Small factors are temporary carriers of:
 They are not fixed personalities. They are dynamic, event-triggered internal
 reasoning units.
 
+### Attention Sovereignty And Input Immunity
+
+The future system should not let every incoming signal consume equal internal
+bandwidth. It needs a form of attention sovereignty:
+
+- manipulative or low-value inputs should not dominate internal expansion
+- novelty should not automatically outrank alignment and evidence
+- repeated external stimulation should be rate-limited when it bypasses current goals
+- the system should preserve the ability to stay with a long-horizon thread
+
+Input immunity does not mean ignoring the world. It means deciding how much
+internal expansion each signal deserves.
+
 ### 2. Value Field
 
 Value is not only a final approval filter. It guides the whole process.
@@ -87,6 +100,79 @@ Every run should leave a structured trace that can later support:
 - testing of new rules
 - future learning pipelines
 
+### 6. Autonomous Runtime Tiers
+
+The future 24-hour runtime should be tiered rather than treated as one flat
+mode.
+
+#### Low-Risk Runtime
+
+- offline reflection
+- local note consolidation
+- replay of growth logs
+- re-ranking of existing candidate plans
+- bounded simulation with no external effects
+
+#### Medium-Risk Runtime
+
+- proposing research tasks for later review
+- preparing code or experiment plans
+- suggesting internal rule revisions for approval
+- organizing pending work into queues or drafts
+
+#### High-Risk Runtime
+
+- autonomous networking
+- self-modification of safety boundaries
+- use of privileged tools
+- external deployment
+- actions with real-world consequences
+
+High-risk runtime must remain outside autonomous authority unless a human
+explicitly authorizes that mode.
+
+### 7. Self-Evolution Boundaries
+
+The system may eventually improve parts of itself, but not every part should be
+self-editable.
+
+#### Potentially Improveable By The System
+
+- heuristic scoring weights
+- factor-generation refinements
+- collision tuning proposals
+- test-case generation proposals
+- memory indexing strategies
+
+#### Not Self-Modifiable Without Human Approval
+
+- core safety boundaries
+- value-field top-level axes
+- human-authorization requirements
+- networking permissions
+- privileged-tool permissions
+- claims about AGI status
+
+The system may propose changes broadly, but it may only self-apply changes
+inside a tightly bounded, human-audited subset.
+
+### 8. Digital Body And Future Physical Body
+
+The long-term architecture should distinguish between:
+
+- the inner brain
+- the digital body
+- any future physical body
+
+The inner brain handles evaluation, factor competition, and decision shaping.
+The digital body would be the bounded execution layer for files, code,
+simulations, and software environments. A future physical body, if it ever
+exists, would require an even stricter safety and authorization regime because
+its actions can affect the real world directly.
+
+The current repository only models the inner-brain seed and its decision trace.
+It does not implement either a true digital body or any physical embodiment.
+
 ## Safety and Governance
 
 This repository must not claim to have achieved AGI. The current and near-term
@@ -116,5 +202,6 @@ The correct near-term strategy is:
 ## Current Truthful Claim
 
 This codebase is a bounded research prototype for structured reasoning
-experiments. It is not AGI, does not run continuously, does not self-evolve,
-and does not act in the external world.
+experiments. It is an AGI Seed prototype, not AGI. It does not run
+continuously, does not self-evolve autonomously across safety boundaries, and
+does not act in the external world.

innerbrain/collision/merger.py

@@ -26,11 +26,7 @@ def merge_factors(
     fused: list[SmallFactor] = []
 
     for index, collision in enumerate(collisions, start=1):
-        if collision.collision_type not in {
-            CollisionType.support,
-            CollisionType.fusion,
-            CollisionType.mutation,
-        }:
+        if collision.collision_type not in {CollisionType.fusion, CollisionType.mutation}:
             continue
 
         left = by_id[collision.left_factor_id]
@@ -39,6 +35,7 @@ def merge_factors(
             SmallFactor(
                 id=f"fused-{index:02d}",
                 source_input=left.source_input,
+                source_terms=sorted(set(left.source_terms + right.source_terms)),
                 activation_reason=collision.summary,
                 instinct_type=f"{left.instinct_type}+{right.instinct_type}",
                 instinct_weight=_clamp((left.instinct_weight + right.instinct_weight) / 2),