apsimo 1.3.0__py3-none-any.whl

apsimo/self_model/native_outcomes.py

@@ -0,0 +1,55 @@
+"""Prospective runtime observations for the existing working-judgment queue.
+
+Called only after the server rereads an owned native task. No model report,
+tool result prose, caller-supplied outcome or imported history is evidence here.
+"""
+from contextlib import closing
+from datetime import datetime, timezone
+import hashlib
+import json
+import math
+
+VERSION = 'native-runtime-observation-v1'
+
+
+def retain_outcome(review, native, state, owner):
+    binding = review.get('native_work') or {}
+    selection = binding.get('outcome_learning') or {}
+    observed = state.get('runtime_observation')
+    if selection.get('version') != VERSION or not observed:
+        return
+    started, ended = observed['started_at'], observed['ended_at']
+    if not all(type(value) in (int, float) and math.isfinite(value) for value in (started, ended)):
+        return
+    # Native run timestamps have whole-second precision. The binding marker
+    # is only set while this newly bound task has no runs.
+    if ended < started or started < math.floor(datetime.fromisoformat(selection['bound_at']).timestamp()):
+        return
+    if observed['outcome'] not in {'crashed', 'timed_out', 'spawn_failed', 'gave_up'}:
+        return
+    identity = {**native, 'native_run_id': state['native_run_id']}
+    source_id = 'native-runtime:' + hashlib.sha256(json.dumps(identity, sort_keys=True).encode()).hexdigest()
+    facts = {**observed, 'duration_seconds': ended-started, 'identity': identity,
+             'registered_action': review['review']['action']}
+    message = {'role': 'assistant', '_native_runtime_observation': VERSION,
+        'content': 'Runtime-owned internal review execution observation. '
+            'This records lifecycle and elapsed time, not the accuracy of any output. '
+            'Requested model configuration does not identify the serving processor.\n'
+            + json.dumps(facts, sort_keys=True)}
+    from apsimo.turns import get_turn_idempotency_ledger
+    from apsimo import get_state_dir
+    from apsimo.turns.idempotency import SourceErased
+    ledger = get_turn_idempotency_ledger(get_state_dir())
+    # Retain the first observation unchanged. Native task overrides can change
+    # after a run; observing it again must not rewrite that earlier evidence.
+    with closing(ledger._connect()) as conn:
+        if conn.execute('SELECT 1 FROM turn_sources WHERE turn_id=?', (source_id,)).fetchone():
+            return
+    try:
+        ledger.record_source(source_id, contact_id=owner,
+            session_id='native-runtime:'+native['native_task_id'], messages=[message],
+            occurred_at=datetime.fromtimestamp(ended, timezone.utc).isoformat(),
+            derive_claims=False, runtime_judgment=True)
+    except SourceErased:
+        # Normal observation replay must not resurrect an erased experience.
+        return

apsimo/self_model/params.py

@@ -0,0 +1,220 @@
+"""AdaptiveParamStore -- bounded, journaled runtime parameters.
+
+The meta-learning loop (CognitionPipeline -> StrategyAdjuster) needs a place
+to write tuning adjustments that running subsystems actually READ BACK. This
+store is that place: a small SQLite table of named float parameters, each
+registered by its consumer with a default and hard bounds. Every write is
+clamped to the registered bounds and journaled through the ActionJournal
+(domain "meta_learning"), so a bad self-adjustment is visible, attributable,
+and bounded -- never a silent behavior shift.
+
+Consumers read at use-time (no restart needed). Writers (the strategy
+adjuster, tools, or the owner via API) go through ``set()`` and never bypass
+the clamp.
+"""
+
+from __future__ import annotations
+
+import logging
+import sqlite3
+import threading
+import time
+from typing import Any, Dict, List, Optional
+
+from apsimo.self_model.benchmark import cognition_p4_mode
+
+logger = logging.getLogger(__name__)
+
+
+class AdaptiveParamStore:
+    """SQLite-backed named float parameters with hard bounds + journaling."""
+
+    def __init__(self, db_path: Optional[str] = None,
+                 journal: Any = None) -> None:
+        self._lock = threading.RLock()
+        self._journal = journal
+        self._experiment_writer_id: Optional[str] = None
+        self._experiment_writer_token: Any = None
+        self._conn = sqlite3.connect(str(db_path) if db_path else ":memory:",
+                                     check_same_thread=False)
+        self._conn.row_factory = sqlite3.Row
+        with self._lock:
+            self._conn.execute(
+                """CREATE TABLE IF NOT EXISTS adaptive_params (
+                    name TEXT PRIMARY KEY,
+                    value REAL,
+                    default_value REAL NOT NULL,
+                    lo REAL NOT NULL,
+                    hi REAL NOT NULL,
+                    description TEXT,
+                    reason TEXT,
+                    source TEXT,
+                    updated_at REAL
+                )""")
+            self._conn.commit()
+
+    def set_journal(self, journal: Any) -> None:
+        """Attach the ActionJournal after boot (it is created later than
+        this store in the server lifespan)."""
+        self._journal = journal
+
+    def claim_experiment_writer(self, writer_id: str) -> Any:
+        """Claim the one in-process capability that may mutate P4 knobs.
+
+        The object token is intentionally not serializable. The database still
+        records every mutation; this capability prevents legacy components
+        from racing the canonical ExperimentEngine inside one sidecar.
+        """
+
+        normalized = (writer_id or "").strip()
+        if not normalized:
+            raise ValueError("experiment writer id is required")
+        with self._lock:
+            if self._experiment_writer_id is None:
+                self._experiment_writer_id = normalized
+                self._experiment_writer_token = object()
+            elif self._experiment_writer_id != normalized:
+                raise RuntimeError(
+                    "AdaptiveParamStore already has an ExperimentEngine writer")
+            return self._experiment_writer_token
+
+    def _assert_writer(self, writer_token: Any) -> None:
+        if cognition_p4_mode() == "off":
+            return
+        if (self._experiment_writer_token is None
+                or writer_token is not self._experiment_writer_token):
+            raise PermissionError(
+                "ExperimentEngine is the sole adaptive-parameter writer "
+                "while COLONY_COGNITION_P4_MODE is enabled")
+
+    # -- registration (consumers declare their knob + safe range) ---------
+    def register(self, name: str, default: float, lo: float, hi: float,
+                 description: str = "") -> None:
+        """Idempotently declare a parameter. Bounds/default/description are
+        refreshed on re-registration; a previously set value is kept (but
+        re-clamped if the new bounds exclude it)."""
+        name = (name or "").strip()
+        if not name:
+            return
+        if lo > hi:
+            lo, hi = hi, lo
+        default = min(max(float(default), lo), hi)
+        with self._lock:
+            row = self._conn.execute(
+                "SELECT value FROM adaptive_params WHERE name=?",
+                (name,)).fetchone()
+            value = row["value"] if row is not None else None
+            if value is not None:
+                value = min(max(float(value), lo), hi)
+            self._conn.execute(
+                """INSERT INTO adaptive_params
+                     (name, value, default_value, lo, hi, description, updated_at)
+                   VALUES (?, ?, ?, ?, ?, ?, ?)
+                   ON CONFLICT(name) DO UPDATE SET
+                     value=?, default_value=?, lo=?, hi=?, description=?""",
+                (name, value, default, lo, hi, description, time.time(),
+                 value, default, lo, hi, description))
+            self._conn.commit()
+
+    # -- reads -------------------------------------------------------------
+    def get(self, name: str, default: Optional[float] = None) -> float:
+        """Current value: the set value if any, else the registered default,
+        else the caller-supplied fallback (0.0 if none)."""
+        with self._lock:
+            row = self._conn.execute(
+                "SELECT value, default_value FROM adaptive_params WHERE name=?",
+                ((name or "").strip(),)).fetchone()
+        if row is None:
+            return float(default) if default is not None else 0.0
+        if row["value"] is not None:
+            return float(row["value"])
+        return float(row["default_value"])
+
+    # -- writes (clamped + journaled) ---------------------------------------
+    def set(self, name: str, value: float, *, reason: str = "",
+            source: str = "", writer_token: Any = None) -> Optional[float]:
+        """Set a parameter. Returns the APPLIED (clamped) value, or None if
+        the parameter was never registered (unknown knobs are refused --
+        a writer cannot invent parameters no consumer reads)."""
+        self._assert_writer(writer_token)
+        name = (name or "").strip()
+        with self._lock:
+            row = self._conn.execute(
+                "SELECT lo, hi, value FROM adaptive_params WHERE name=?",
+                (name,)).fetchone()
+            if row is None:
+                logger.warning("AdaptiveParamStore: refusing unregistered "
+                               "param %r", name)
+                return None
+            applied = min(max(float(value), row["lo"]), row["hi"])
+            prior = row["value"]
+            self._conn.execute(
+                """UPDATE adaptive_params
+                   SET value=?, reason=?, source=?, updated_at=?
+                   WHERE name=?""",
+                (applied, reason, source, time.time(), name))
+            self._conn.commit()
+        clamped = abs(applied - float(value)) > 1e-9
+        logger.info("AdaptiveParamStore: %s %s -> %s%s (%s)", name,
+                    prior, applied, " [clamped]" if clamped else "",
+                    reason or source or "unattributed")
+        if self._journal is not None:
+            try:
+                self._journal.record(
+                    "meta_learning",
+                    f"adaptive param {name}: {prior} -> {applied}"
+                    + (" (clamped)" if clamped else ""),
+                    reasoning=reason, decision="acted",
+                    outcome="applied", ref=source or "adaptive_params")
+            except Exception:
+                logger.debug("param journal write failed", exc_info=True)
+        return applied
+
+    def reset(self, name: str, *, reason: str = "", source: str = "",
+              writer_token: Any = None) -> None:
+        """Clear a set value so the registered default applies again."""
+        self._assert_writer(writer_token)
+        with self._lock:
+            self._conn.execute(
+                "UPDATE adaptive_params SET value=NULL, reason=?, source=?, "
+                "updated_at=? WHERE name=?",
+                (reason, source, time.time(), (name or "").strip()))
+            self._conn.commit()
+
+    def snapshot(self) -> List[Dict[str, Any]]:
+        with self._lock:
+            rows = self._conn.execute(
+                "SELECT * FROM adaptive_params ORDER BY name").fetchall()
+        out = []
+        for r in rows:
+            d = dict(r)
+            d["effective"] = (float(d["value"]) if d["value"] is not None
+                              else float(d["default_value"]))
+            out.append(d)
+        return out
+
+    def close(self) -> None:
+        with self._lock:
+            try:
+                self._conn.close()
+            except Exception:
+                pass
+
+
+# Canonical parameter names (registered at boot; consumers read these).
+PARAM_CONSOLIDATION_THRESHOLD = "consolidation.similarity_threshold"
+PARAM_RECALL_MIN_RELEVANCE = "recall.min_relevance"
+
+
+def register_core_params(store: AdaptiveParamStore) -> None:
+    """Register the parameters core subsystems consume."""
+    store.register(
+        PARAM_CONSOLIDATION_THRESHOLD, default=0.92, lo=0.85, hi=0.98,
+        description="MemoryConsolidator merge threshold: pairs at or above "
+                    "this similarity are deduplicated. Hard floor 0.85 so a "
+                    "self-adjustment can never mass-merge distinct memories.")
+    store.register(
+        PARAM_RECALL_MIN_RELEVANCE, default=0.0, lo=0.0, hi=0.5,
+        description="ColonyGraph.recall drops vector hits scoring below "
+                    "this. 0 = no filter; capped at 0.5 so retrieval can "
+                    "never be starved by a self-adjustment.")

apsimo/self_model/perspective.py

@@ -0,0 +1,246 @@
+"""Source-backed preferences and inspectable attention.
+
+This is a portable working perspective, not feelings, a worldview or authority.
+Original owner words stay in the canonical source ledger. Only explicit owner
+preferences adjust optional research priority; prior automatic weights are history.
+"""
+from __future__ import annotations
+
+from contextlib import closing
+from copy import copy
+from datetime import datetime, timezone
+import json
+import re
+import time
+
+
+DOMAINS = frozenset({'research', 'knowledge_acquisition'})
+VERSION = 'owner-directed-perspective-v2'
+
+
+def initialize(conn):
+    conn.execute('''CREATE TABLE IF NOT EXISTS self_preference_events (
+        id INTEGER PRIMARY KEY AUTOINCREMENT, owner_id TEXT NOT NULL,
+        pref_key TEXT NOT NULL, value_json TEXT NOT NULL,
+        source_turn_id TEXT NOT NULL, message_hash TEXT NOT NULL,
+        source_at TEXT NOT NULL, supersedes INTEGER,
+        UNIQUE(owner_id,pref_key,source_turn_id,message_hash))''')
+    # A value-free marker prevents erased sourced corrections from revealing
+    # an older unprovenanced cache value for the same preference.
+    conn.execute('''CREATE TABLE IF NOT EXISTS self_preference_keys (
+        owner_id TEXT NOT NULL,pref_key TEXT NOT NULL,latest_event_id INTEGER,latest_source_at TEXT NOT NULL,
+        PRIMARY KEY(owner_id,pref_key))''')
+    conn.execute('''CREATE TABLE IF NOT EXISTS self_opinion_revisions (
+        id INTEGER PRIMARY KEY AUTOINCREMENT, domain TEXT NOT NULL,
+        weight REAL NOT NULL, basis_json TEXT NOT NULL, basis_digest TEXT NOT NULL,
+        reason TEXT NOT NULL, updated_at REAL NOT NULL, version TEXT NOT NULL)''')
+    conn.execute('''CREATE TABLE IF NOT EXISTS self_attention (
+        slot INTEGER PRIMARY KEY CHECK(slot=1), snapshot_json TEXT NOT NULL,
+        observed_at REAL NOT NULL)''')
+
+
+def erase_removed(conn, turn_id, session_id, retained):
+    from apsimo.turns.idempotency import source_message_hash
+    if not conn.execute("SELECT 1 FROM sqlite_master WHERE name='self_preference_events'").fetchone():
+        return
+    hashes = {source_message_hash(session_id, message) for message in retained}
+    rows = conn.execute('SELECT id,message_hash FROM self_preference_events WHERE source_turn_id=?', (turn_id,)).fetchall()
+    for row in rows:
+        if row['message_hash'] not in hashes:
+            conn.execute('DELETE FROM self_preference_events WHERE id=?', (row['id'],))
+    # Attention contains correction references/weights; do not retain a stale
+    # derived snapshot after deleting its source. The next decision rebuilds it.
+    conn.execute('DELETE FROM self_attention')
+
+
+def _json(value):
+    return json.dumps(value, sort_keys=True, separators=(',', ':'), ensure_ascii=True)
+
+
+class SelfPerspective:
+    def __init__(self, ledger, *, owner_id, clock=time.time):
+        self.ledger = ledger
+        self.owner_id = str(owner_id or '')
+        self.clock = clock
+        with closing(ledger._connect()) as conn, conn:
+            initialize(conn)
+        from apsimo.self_model.judgments import SelfJudgments
+        self.judgments = SelfJudgments(ledger, owner_id=self.owner_id, clock=clock)
+        from apsimo.self_model.appraisals import AppraisalStore
+        self.appraisals = AppraisalStore(ledger, owner_id=self.owner_id, clock=clock)
+
+    def observe_source(self, turn_id, learner):
+        """Learn only direct, attributed owner words; replay does not add votes."""
+        from apsimo.turns.idempotency import source_message_hash
+        if not self.owner_id:
+            return []
+        learned = []
+        with closing(self.ledger._connect()) as conn, conn:
+            conn.execute('BEGIN IMMEDIATE')
+            source = conn.execute("SELECT * FROM turn_sources WHERE turn_id=? AND contact_id=? AND scope='person'", (turn_id, self.owner_id)).fetchone()
+            if source is None:
+                return []
+            for message in json.loads(source['messages_json']):
+                if message.get('role') != 'user':
+                    continue
+                text = message.get('content', '')
+                if isinstance(text, list):
+                    text = '\n'.join(p.get('text', '') for p in text if p.get('type') in {'text', 'input_text'})
+                if not isinstance(text, str):
+                    continue
+                updates = self._directives(text, learner)
+                for key, value in updates:
+                    source_at = datetime.fromisoformat(source['occurred_at'] or source['ingested_at']).astimezone(timezone.utc).isoformat()
+                    previous = conn.execute('SELECT id FROM self_preference_events WHERE owner_id=? AND pref_key=? AND source_at<=? ORDER BY source_at DESC,id DESC LIMIT 1', (self.owner_id, key, source_at)).fetchone()
+                    cur = conn.execute('''INSERT OR IGNORE INTO self_preference_events
+                        (owner_id,pref_key,value_json,source_turn_id,message_hash,source_at,supersedes)
+                        VALUES (?,?,?,?,?,?,?)''', (self.owner_id, key, _json(value), turn_id,
+                        source_message_hash(source['session_id'], message),
+                        source_at, previous['id'] if previous else None))
+                    if cur.rowcount:
+                        conn.execute('''INSERT INTO self_preference_keys VALUES (?,?,?,?)
+                            ON CONFLICT(owner_id,pref_key) DO UPDATE SET latest_event_id=excluded.latest_event_id,
+                            latest_source_at=excluded.latest_source_at WHERE excluded.latest_source_at>=self_preference_keys.latest_source_at''',
+                            (self.owner_id, key, cur.lastrowid, source_at))
+                        learned.append((key, value))
+            return learned
+
+    @staticmethod
+    def _directives(text, learner):
+        raw = text.strip()
+        # Conservative direct-address subset. Quotation, questions, reports
+        # about another person and ambiguous negation remain raw evidence.
+        if len(raw.split()) > 40 or any(c in raw for c in ('"', '“', '”', '?', '`', '\n')):
+            return []
+        operational = re.fullmatch(r'(?:please\s+)?(prefer|deprioritize|use normal priority for)\s+(research|knowledge acquisition)\s+initiatives[.!]?', raw, re.I)
+        if operational:
+            weight = {'prefer': 1.2, 'deprioritize': 0.8, 'use normal priority for': 1.0}[operational[1].lower()]
+            return [('initiative.' + operational[2].lower().replace(' ', '_'), weight)]
+        prefix = re.match(r'^(?:(?:please|actually|from now on|going forward)[,:]?\s+)*(?:be\b|keep\b|use\b|stop\b|skip\b|avoid\b|don.t\b|do not\b|no emoji\b|no emojis\b|i prefer\b|i want\b)', raw, re.I)
+        if not prefix:
+            return []
+        # Reuse existing style vocabulary, but do not guess the direction of
+        # a negated or comparative request from bag-of-words keyword order.
+        polarity = re.sub(r'\b(?:stop\s+(?:using\s+|with\s+)?|skip\s+(?:the\s+)?|avoid\s+(?:the\s+)?|no\s+|don.t\s+use\s+|do\s+not\s+use\s+)emojis?\b', '', raw, flags=re.I)
+        if re.search(r'\b(not|never|rather|instead|than|except|without|don.t|stop|skip|avoid|no)\b', polarity, re.I):
+            return []
+        from apsimo.intelligence.components import preference_learner as vocabulary
+        words = set(re.findall(r'\b\w+\b', raw.lower()))
+        if re.search(r'\bi (?:prefer|want)$', prefix[0], re.I):
+            # First-person corrections must name general communication:
+            # "I prefer/want <style> replies/responses/answers". Artifact
+            # requests ("I want a code example") remain ordinary evidence.
+            general = re.fullmatch(r'(.+?)\s+(?:replies|responses|answers)[.!]?', raw[prefix.end():].strip(), re.I)
+            if general is None or set(re.findall(r'\b\w+\b', general[1].lower())) - (vocabulary._STYLE_KEYWORDS | {'and', 'more'}):
+                return []
+            words.discard('i')
+        style_words = vocabulary._STYLE_KEYWORDS | vocabulary._DIRECTIVE_CUES | vocabulary._NEGATION | {'and', 'the', 't', 'a', 'an', 'of', 'with', 'so', 'being', 'all', 'future', 'my', 'me', 'actually'}
+        if words - style_words:
+            return []  # Content/task-specific instructions are not standing style corrections.
+        for alternatives in ((vocabulary._LENGTH_SHORT, vocabulary._LENGTH_LONG, vocabulary._LENGTH_MEDIUM),
+                             (vocabulary._FORMAT_BULLETS, vocabulary._FORMAT_PROSE, vocabulary._FORMAT_TABLE),
+                             (vocabulary._STYLE_FORMAL, vocabulary._STYLE_CASUAL)):
+            if sum(bool(words & option) for option in alternatives) > 1:
+                return []
+        if not learner.detect_directive(raw):
+            return []
+        return [('communication_style.' + key, value) for key, value in learner._parse_all(raw)]
+
+    def preferences(self, *, history=False):
+        from apsimo.turns.idempotency import source_message_hash
+        with closing(self.ledger._connect()) as conn:
+            heads = {r[0]: r[1] for r in conn.execute('SELECT pref_key,latest_event_id FROM self_preference_keys WHERE owner_id=?', (self.owner_id,))}
+            query = '''SELECT p.*,s.session_id,s.messages_json FROM self_preference_events p
+                JOIN turn_sources s ON s.turn_id=p.source_turn_id
+                WHERE p.owner_id=? AND s.contact_id=? AND s.scope='person' '''
+            if not history:
+                query += 'AND p.id IN (SELECT latest_event_id FROM self_preference_keys WHERE owner_id=p.owner_id) '
+            query += 'ORDER BY p.source_at DESC,p.id DESC'
+            if history:
+                query += ' LIMIT 100'
+            rows = conn.execute(query, (self.owner_id, self.owner_id)).fetchall()
+            result, seen = [], set()
+            for row in rows:
+                if row['message_hash'] not in {source_message_hash(row['session_id'], m) for m in json.loads(row['messages_json'])}:
+                    continue
+                if not history and (row['pref_key'] in seen or row['id'] != heads.get(row['pref_key'])):
+                    continue
+                seen.add(row['pref_key'])
+                result.append({key: row[key] for key in ('id', 'pref_key', 'source_turn_id', 'message_hash', 'source_at', 'supersedes')} | {'value': json.loads(row['value_json']), 'basis': 'owner_correction'})
+            return result
+
+    def tracked_keys(self):
+        with closing(self.ledger._connect()) as conn:
+            return {r[0] for r in conn.execute('SELECT pref_key FROM self_preference_keys WHERE owner_id=?', (self.owner_id,))}
+
+    def opinions(self, *, history=False):
+        """Retained automatic revisions are inspectable, never governing."""
+        with closing(self.ledger._connect()) as conn:
+            query = ('SELECT * FROM self_opinion_revisions ORDER BY id DESC LIMIT 100' if history else
+                     'SELECT * FROM self_opinion_revisions WHERE id IN (SELECT max(id) FROM self_opinion_revisions GROUP BY domain) ORDER BY domain')
+            rows = conn.execute(query).fetchall()
+        return [dict(row) | {'basis': json.loads(row['basis_json']),
+                'status': 'legacy_non_governing', 'governing': False} for row in rows]
+
+    def rank(self, initiatives, *, competence=None, load=None):
+        # competence is retained as a call-compatibility argument, never consumed.
+        initiatives = [copy(item) for item in initiatives]  # no compounding on cached engine candidates
+        with closing(self.ledger._connect()) as conn, conn:
+            conn.execute('BEGIN IMMEDIATE')
+            overrides = {row['pref_key'].removeprefix('initiative.'): row for row in self.preferences() if row['pref_key'].startswith('initiative.')}
+            decisions = []
+            for item in initiatives:
+                domain = getattr(item.type, 'value', str(item.type))
+                original = float(item.priority)
+                override = overrides.get(domain)
+                weight = float(override['value']) if override else 1.0
+                # Due/urgent and non-research work keeps its existing urgency.
+                applied = override is not None and domain in DOMAINS and original < 0.9
+                item.priority = round(max(0.0, min(0.89, original * weight)), 4) if applied else original
+                decisions.append({'initiative_id': str(item.id), 'domain': domain, 'original_priority': original,
+                    'description': str(getattr(item, 'description', '') or '')[:500],
+                    'priority': item.priority, 'weight': weight if applied else 1.0,
+                    'basis': 'owner_correction' if override and applied else 'unchanged',
+                    'correction_id': override['id'] if override and applied else None,
+                    'opinion_revision': None})
+            ranked = sorted(initiatives, key=lambda item: -item.priority)
+            snapshot = {'version': VERSION, 'load': dict(load or {}), 'decisions': decisions,
+                        'ordered_ids': [str(item.id) for item in ranked], 'authority_changed': False,
+                        'load_coverage': 'existing initiative/project/queue probes; missing sources are not proven idle'}
+            conn.execute('INSERT OR REPLACE INTO self_attention VALUES (1,?,?)', (_json(snapshot), self.clock()))
+            return ranked
+
+    def status(self):
+        with closing(self.ledger._connect()) as conn:
+            row = conn.execute('SELECT * FROM self_attention WHERE slot=1').fetchone()
+        attention = None
+        if row is not None:
+            snapshot = json.loads(row['snapshot_json'])
+            attention = snapshot | {'observed_at': row['observed_at'],
+                'age_seconds': max(0, round(self.clock() - row['observed_at'], 1)),
+                'historical_only': snapshot.get('version') != VERSION}
+        return {'kind': 'operational_working_perspective', 'preferences': self.preferences(),
+                'corrections': self.preferences(history=True), 'opinions': self.opinions(),
+                'judgments_enabled': self.judgments.enabled,
+                'judgments': self.judgments.revisions(), 'judgment_history': self.judgments.revisions(history=True),
+                'judgment_processing': self.judgments.processing(),
+                'appraisals': self.appraisals.view(self.owner_id, viewer_contact_id=self.owner_id,
+                                                  history=True, limit=10),
+                'opinion_history': self.opinions(history=True), 'automatic_weighting': 'retired', 'attention': attention}
+
+    def brief(self, query='', *, source_ids=None):
+        lines = []
+        for pref in self.preferences():
+            if pref['pref_key'].startswith('initiative.'):
+                lines.append(f"Owner correction: {pref['pref_key']} priority weight {pref['value']:.2f}; source turn:{pref['source_turn_id']}; applies only to optional research ordering.")
+                if source_ids is not None:
+                    source_ids.append(pref['source_turn_id'])
+        state = self.status()['attention']
+        if state is not None and not state['historical_only']:
+            lines.append(f"Last initiative ranking, {state['age_seconds']:g}s ago: " + ', '.join(state['ordered_ids'][:8]) + '. This is a decision snapshot, not current liveness.')
+        if lines:
+            lines.append('Only explicit owner preferences adjust these priorities. Runtime history establishes neither output quality nor the competence of the current model; it grants no authority.')
+        judgments = self.judgments.brief(query, source_ids=source_ids)
+        if judgments:
+            lines.append(judgments)
+        return '\n'.join(lines)