Remove observation number guard from entity observations

The guard required callers to compute and pass the expected next
observation number, adding an extra round trip (load + count) for
no practical benefit — agents always provide the correct sequence.
The file lock already serializes concurrent writes safely.

Co-Authored-By: Claude Opus 4.6 <[e-mail]>

apps/entities/call.py

···
 import typer
 
 from think.entities.core import entity_slug, is_valid_entity_type
-from think.entities.journal import get_or_create_journal_entity, save_journal_entity
+from think.entities.journal import (
+    get_or_create_journal_entity,
+    load_journal_entity,
+    save_journal_entity,
+)
 from think.entities.loading import load_entities
 from think.entities.matching import resolve_entity, validate_aka_uniqueness
-from think.entities.observations import (
-    ObservationNumberError,
-    add_observation,
-    load_observations,
-)
+from think.entities.observations import add_observation, load_observations
 from think.entities.relationships import (
     load_facet_relationship,
     save_facet_relationship,
···
         raise typer.Exit(1)
 
     entity_id = resolved.get("id", entity_slug(resolved_name))
-    aka_list.append(aka_value)
 
-    # Update journal entity aka (identity-level)
-    from think.entities.journal import load_journal_entity
-
+    # Update journal entity aka (identity-level, not facet-specific)
     journal_entity = load_journal_entity(entity_id)
     if journal_entity:
         existing_aka = set(journal_entity.get("aka", []))
         existing_aka.add(aka_value)
         journal_entity["aka"] = sorted(existing_aka)
         save_journal_entity(journal_entity)
-
-    # Update facet relationship (per-entity file)
-    relationship = load_facet_relationship(facet, entity_id)
-    if relationship is not None:
-        relationship["aka"] = aka_list
-        relationship["updated_at"] = now_ms()
-        save_facet_relationship(facet, entity_id, relationship)
 
     log_call_action(
         facet=facet,
···
     facet = resolve_sol_facet(facet)
     resolved = _resolve_or_exit(facet, entity)
     resolved_name = resolved.get("name", "")
-    obs = load_observations(facet, resolved_name)
-    observation_number = len(obs) + 1
 
     try:
-        add_observation(facet, resolved_name, content, observation_number, source_day)
-    except (ValueError, ObservationNumberError) as exc:
+        add_observation(facet, resolved_name, content, source_day)
+    except ValueError as exc:
         typer.echo(f"Error: {exc}", err=True)
         raise typer.Exit(1)
 
···
             "entity": entity,
             "name": resolved_name,
             "content": content,
-            "observation_number": observation_number,
         },
     )
     typer.echo(f"Observation added to '{resolved_name}'.")

tests/test_entities.py

···
 
 from think.entities import (
     DEFAULT_ACTIVITY_TS,
-    ObservationNumberError,
     add_observation,
     block_journal_entity,
     delete_journal_entity,
···
 
 
 def test_add_observation_success(fixture_journal, tmp_path):
-    """Test adding observation with correct guard."""
+    """Test adding observations sequentially."""
     os.environ["JOURNAL_PATH"] = str(tmp_path)
 
-    # First observation (observation_number=1 for empty list)
     result = add_observation(
-        "personal", "Alice", "Prefers async communication", 1, "20250113"
+        "personal", "Alice", "Prefers async communication", "20250113"
     )
     assert result["count"] == 1
     assert len(result["observations"]) == 1
···
     assert result["observations"][0]["source_day"] == "20250113"
     assert "observed_at" in result["observations"][0]
 
-    # Second observation (observation_number=2)
-    result = add_observation("personal", "Alice", "Works PST timezone", 2)
+    result = add_observation("personal", "Alice", "Works PST timezone")
     assert result["count"] == 2
     assert len(result["observations"]) == 2
 
···
     assert len(loaded) == 2
 
 
-def test_add_observation_guard_failure(fixture_journal, tmp_path):
-    """Test adding observation with wrong guard fails."""
-    os.environ["JOURNAL_PATH"] = str(tmp_path)
-
-    # First observation
-    add_observation("personal", "Alice", "First observation", 1)
-
-    # Try to add with wrong observation_number (should be 2, not 1)
-    with pytest.raises(ObservationNumberError) as exc_info:
-        add_observation("personal", "Alice", "Second observation", 1)
-
-    assert exc_info.value.expected == 2
-    assert exc_info.value.actual == 1
-
-
 def test_add_observation_empty_content(fixture_journal, tmp_path):
     """Test adding observation with empty content fails."""
     os.environ["JOURNAL_PATH"] = str(tmp_path)
 
     with pytest.raises(ValueError, match="cannot be empty"):
-        add_observation("personal", "Alice", "", 1)
+        add_observation("personal", "Alice", "")
 
     with pytest.raises(ValueError, match="cannot be empty"):
-        add_observation("personal", "Alice", "   ", 1)
+        add_observation("personal", "Alice", "   ")
 
 
 def test_observations_with_entity_rename(fixture_journal, tmp_path):
···
 
     # Create entity memory folder and add observations
     ensure_entity_memory("work", "Alice Johnson")
-    add_observation("work", "Alice Johnson", "Test observation", 1)
+    add_observation("work", "Alice Johnson", "Test observation")
 
     # Verify observation exists
     observations = load_observations("work", "Alice Johnson")

think/entities/__init__.py

···
 
 # Observations
 from think.entities.observations import (
-    ObservationNumberError,
     add_observation,
     load_observations,
     observations_file_path,
···
     save_detected_entity,
     save_entities,
     update_detected_entity,
-    update_entity_description,
 )
 
 __all__ = [
···
     "save_detected_entity",
     "save_entities",
     "update_detected_entity",
-    "update_entity_description",
     # Matching
     "find_matching_entity",
     "resolve_entity",
···
     "touch_entities_from_activity",
     "touch_entity",
     # Observations
-    "ObservationNumberError",
     "add_observation",
     "load_observations",
     "observations_file_path",

think/entities/observations.py

···
 from think.utils import now_ms
 
 
-class ObservationNumberError(Exception):
-    """Raised when observation_number doesn't match expected value."""
-
-    def __init__(self, expected: int, actual: int):
-        self.expected = expected
-        self.actual = actual
-        super().__init__(
-            f"Observation number mismatch: expected {expected}, got {actual}"
-        )
-
-
 def observations_file_path(facet: str, name: str) -> Path:
     """Return path to observations file for an entity.
 
···
     facet: str,
     name: str,
     content: str,
-    observation_number: int,
     source_day: str | None = None,
     max_retries: int = 3,
 ) -> dict[str, Any]:
-    """Add an observation to an entity with guard validation and file locking.
+    """Add an observation to an entity with file locking.
 
     Acquires an exclusive file lock to serialize concurrent writes to the
-    same entity's observations file. Requires the caller to provide the
-    expected next observation number (current count + 1) to prevent stale
-    writes.
+    same entity's observations file.
 
     Args:
         facet: Facet name
         name: Entity name
         content: The observation text
-        observation_number: Expected next number; must be current_count + 1
         source_day: Optional day (YYYYMMDD) when observation was made
         max_retries: Maximum attempts on transient OS errors (default 3)
 
···
         Dictionary with updated observations list and count
 
     Raises:
-        ObservationNumberError: If observation_number doesn't match expected
         ValueError: If content is empty
         OSError: If all retries exhausted
 
     Example:
-        >>> add_observation("work", "Alice", "Prefers morning meetings", 1, "20250113")
+        >>> add_observation("work", "Alice", "Prefers morning meetings", "20250113")
         {"observations": [...], "count": 1}
     """
     content = content.strip()
···
             with open(lock_path, "w") as lock_file:
                 fcntl.flock(lock_file, fcntl.LOCK_EX)
                 try:
-                    # Fresh load inside lock
                     observations = load_observations(facet, name)
-                    expected = len(observations) + 1
-
-                    if observation_number != expected:
-                        raise ObservationNumberError(expected, observation_number)
 
                     observation: dict[str, Any] = {
                         "content": content,
···
                     }
                 finally:
                     fcntl.flock(lock_file, fcntl.LOCK_UN)
-        except (ValueError, ObservationNumberError):
+        except ValueError:
             raise  # Logical errors — don't retry
         except OSError as exc:
             last_error = exc