@orkastery/cli 0.2.0 → 0.4.1

package/assets/orkmind_bridge.py

@@ -0,0 +1,357 @@
+"""Transporte de fabrica: OrkMind instalado, stdin JSON, sem provider ou embedder."""
+from __future__ import annotations
+import asyncio
+import contextlib
+import hashlib
+import io
+import json
+import logging
+import os
+import sys
+
+
+class LegacyProvenanceCollision(ValueError):
+    """Mesmo conteudo sem identidade comprovada: preservar e exigir tratamento."""
+
+
+class ProspectiveMarkerInvalid(ValueError):
+    """Integridade do marcador recusada; nao e falha de transporte."""
+
+
+class NativeSchemaMismatch(ValueError):
+    """Biblioteca instalada divergiu do contrato compartilhado; atualizacao exige revisao."""
+
+
+def native_schema_fields():
+    from pathlib import Path
+    from orkmind.core.models import MemoryEntry
+    contract = json.loads(Path(__file__).with_name('orkmind-native-schema.json').read_text())
+    fields = contract.get('fields', [])
+    if (contract.get('schema') != 'ork.native-entry-fields/v1'
+            or len(fields) != len(set(fields)) or set(fields) != set(MemoryEntry.model_fields)):
+        raise NativeSchemaMismatch('memory.native.schema-mismatch')
+    return set(fields)
+
+
+def prospective_agent_valid(value):
+    import re
+    return (isinstance(value, str) and re.fullmatch('[a-z0-9.-]+:[a-z0-9.-]+', value) is not None
+            and 'human' not in value.lower())
+
+
+class QueryError(ValueError):
+    def __init__(self, code):
+        self.code = code
+        super().__init__(code)
+
+
+def error_code(error):
+    return (error.code if isinstance(error, QueryError)
+            else 'memory.native.schema-mismatch' if isinstance(error, NativeSchemaMismatch)
+            else 'memory.prospective.marker-invalid' if isinstance(error, ProspectiveMarkerInvalid)
+            else 'memory.legacy.provenance-collision' if isinstance(error, LegacyProvenanceCollision)
+            else 'memory.schema.absent' if type(error).__name__ == 'UndefinedTable' else 'memory.bridge.failed')
+
+
+def encoded(value):
+    return json.dumps(value, ensure_ascii=False, sort_keys=True, separators=(',', ':'))
+
+
+PHASES = {'GOAL', 'PLAN', 'GO', 'CHECK', 'SHIP', 'MASTER'}
+FACTORY_KEYS = {'orkastery_identity', 'orkastery_identity_version'}
+
+
+def prospective_compatible(old, entry):
+    """Recibo in-band integral preservado por duplicate sem update; nao autentica o passado."""
+    import re
+    fields = native_schema_fields()
+    try:
+        p = old.metadata['orkastery_prospective']
+        if (p['schema'] != 'ork.prospective-origin/v1' or p['historicalOrigin'] != 'unknown'
+                or p['source'] != 'agent' or p['entryId'] != old.id
+                or not re.fullmatch('[a-f0-9]{64}', p['receiptSha256'])
+                or not re.fullmatch('[a-f0-9]{40}', p['revision'])
+                or not prospective_agent_valid(p['agent'])
+                or hashlib.sha256(p['originalJson'].encode()).hexdigest() != p['originalSha256']):
+            return False
+        original = json.loads(p['originalJson'])
+        if set(original) != fields:
+            return False
+        tags = {k: sorted(set(original['tags'].get(k, [])) | set(entry.tags.get(k, [])))
+                for k in set(original['tags']) | set(entry.tags)}
+        return (old.collection == entry.collection == 'rule' and old.source == entry.source == 'agent'
+                and old.priority == entry.priority == 'high' and old.mandatory is False and old.protected is False
+                and old.visibility == original['visibility'] == 'private' and original['id'] == old.id
+                and original['content'] == old.content == entry.content and original['source'] == 'agent'
+                and original['priority'] == 'high' and original['mandatory'] is False
+                and original['protected'] is False and old.author_id == original['author_id']
+                and old.scope == original['scope'] == entry.scope and old.tags == tags
+                and old.metadata == {**entry.metadata, 'orkastery_prospective': p})
+    except (KeyError, TypeError, ValueError):
+        return False
+
+
+def fixed_tags(tags):
+    """Fase e runtime sao observacoes; tenant e demais classificacoes sao identidade."""
+    fixed = {}
+    for key, values in tags.items():
+        if key == 'agent':
+            continue
+        keep = [v for v in values if not (key == 'skill' and v in PHASES)
+                and not (key == 'situation' and v.startswith('fase:') and v[5:] in PHASES)]
+        if keep:
+            fixed[key] = sorted(set(keep))
+    return fixed
+
+
+def legacy_factory_identity(entry):
+    """Reconhece somente fingerprints comprovaveis da ponte T5, sem adotar legado."""
+    if 'orkastery_identity_version' in entry.metadata:
+        return False
+    original = {'collection': entry.collection, 'content': entry.content, 'tags': entry.tags,
+                'priority': entry.priority,
+                'metadata': {k: v for k, v in entry.metadata.items() if k not in FACTORY_KEYS}}
+    for source in (False, True):
+        for mandatory in (False, True):
+            candidate = dict(original)
+            if source:
+                candidate['source'] = entry.source
+            if mandatory:
+                candidate['mandatory'] = False
+            if hashlib.sha256(encoded(candidate).encode()).hexdigest() == entry.metadata.get('orkastery_identity'):
+                return True
+    return False
+
+
+def governance(entry):
+    if 'scope' in entry and entry['scope'] != 'project':
+        raise ValueError('scope outside project contract')
+    if entry.get('mandatory') or entry.get('source', 'agent') not in ('agent', 'human'):
+        raise ValueError('governance')
+    if entry['collection'] not in ('decision', 'handoff', 'rule', 'learning', 'roadmap'):
+        raise ValueError('collection')
+    if entry.get('priority') == 'critical' and entry['collection'] in ('rule', 'instruction'):
+        raise ValueError('critical')
+    if entry.get('source') == 'human':
+        p = entry.get('metadata', {}).get('proveniencia', {})
+        if (entry['collection'] != 'decision' or entry.get('priority') == 'critical'
+                or p.get('tipo') != 'human_gate' or p.get('source') != 'human'
+                or p.get('confirmado') is not True
+                or not all(isinstance(p.get(k), str) and p[k] for k in ('autor', 'evento', 'evidencia', 'sha256'))):
+            raise ValueError('human provenance')
+
+
+async def readback(store, p, handoff):
+    package = await store.retrieve(handoff.metadata['package_entry_id'])
+    session = await store.retrieve(handoff.parent_id)
+    if not package or not session:
+        raise ValueError('incomplete chain')
+    if (session.collection != 'session' or package.collection != 'semantic_log'
+            or package.parent_id != session.id or handoff.parent_id != session.id
+            or session.metadata['session_id'] != p['sessionId']
+            or handoff.metadata['package_id'] != package.metadata['package_id']
+            or handoff.metadata['origin'] != p['origem']
+            or handoff.metadata['destination'] != p['destino']
+            or json.loads(package.content) != p['payload']):
+        raise ValueError('readback mismatch')
+    if not all(set(values) <= set(session.tags.get(k, [])) for k, values in p['tags'].items()):
+        raise ValueError('session tags mismatch')
+    for entry in (handoff, package):
+        if entry.metadata['orkastery_identity'] != p['identidade']:
+            raise ValueError('identity mismatch')
+        if not all(set(values) <= set(entry.tags.get(k, [])) for k, values in p['tags'].items()):
+            raise ValueError('tags mismatch')
+        if not all(entry.metadata.get(k) == v for k, v in p['metadata'].items()):
+            raise ValueError('metadata mismatch')
+    return {'ok': True, 'id': handoff.id, 'collection': 'handoff', 'readback': True,
+            'session_entry_id': session.id, 'package_entry_id': package.id,
+            'package_id': package.metadata['package_id'], 'detalhe': 'G3 e readback confirmados'}
+
+
+def query_contract(request):
+    """Somente fronteiras de leitura. Nao cria requester, ACL ou filtro extra."""
+    import re
+    def text(value, maximum):
+        return (isinstance(value, str) and 0 < len(value) <= maximum
+                and re.search(r'[\x00-\x1f\x7f]', value) is None)
+    valid = isinstance(request, dict) and set(request) == {'op', 'collection', 'tags', 'limit'}
+    tags = request.get('tags') if valid else None
+    limit = request.get('limit') if valid else None
+    if (not valid or request['op'] != 'query'
+            or request['collection'] not in ('decision', 'handoff', 'rule', 'learning', 'roadmap')
+            or type(limit) is not int or not 1 <= limit <= 1000
+            or not isinstance(tags, dict) or set(tags) != {'project', 'situation'}
+            or any(not isinstance(v, list) or len(v) != 1 for v in tags.values())
+            or not text(tags['project'][0], 128) or not text(tags['situation'][0], 135)
+            or re.fullmatch(r'thread:[a-z0-9][a-z0-9_-]{0,127}', tags['situation'][0]) is None):
+        raise QueryError('memory.query.invalid')
+    return {k: list(v) for k, v in tags.items()}, request['collection'], limit
+
+
+async def execute(request, store):
+    from orkmind.core.models import MemoryEntry
+    from orkmind.core.semantic_layer import SemanticLayer
+    from orkmind.guardrails.handoff import submeter_handoff
+    layer = SemanticLayer(store, embedder=None, semantic_enabled=False)
+    op = request['op']
+    if op == 'stats':
+        return {c: await store.count(c) for c in await store.list_collections()}
+    if op == 'query':
+        tags, collection, limit = query_contract(request)
+        # GovernedStore conserva validade, anti-injection e visibilidade existentes.
+        # O transporte desta ponte usa exclusivamente pgvector; nenhum acesso inner.
+        entries = await store.search_by_tags(tags, collection=collection, limit=limit)
+        if len(entries) >= limit:
+            raise QueryError('memory.query.window-saturated')
+        if any(e.collection != collection or any(
+                not set(values) <= set(e.tags.get(k, [])) for k, values in tags.items())
+                for e in entries):
+            raise QueryError('memory.query.scope-violation')
+        return [e.model_dump(mode='json') for e in entries]
+    if op == 'export':
+        collection = request['collection']
+        count = await store.count(collection)
+        entries = await store.search_by_tags({}, collection=collection, limit=count + 1)
+        return [e.model_dump(mode='json') for e in entries]
+    if op == 'get':
+        entry = await store.retrieve(request['id'])
+        if entry and entry.collection != request['collection']:
+            raise ValueError('collection mismatch')
+        return entry.model_dump(mode='json') if entry else None
+    if op == 'add':
+        data = request['entrada']
+        governance(data)
+        if set(data['metadata']) & (FACTORY_KEYS | {'orkastery_prospective'}):
+            raise ValueError('reserved factory metadata')
+        evolving = data['collection'] == 'decision' and data.get('source', 'agent') == 'agent'
+        identity_data = data
+        if evolving:
+            if len(data['tags'].get('project', [])) != 1 or not data['tags']['project'][0]:
+                raise ValueError('decision tenant')
+            identity_data = {k: data[k] for k in ('collection', 'content', 'priority', 'metadata')}
+            identity_data.update(source='agent', tags=fixed_tags(data['tags']))
+        identity = hashlib.sha256(encoded(identity_data).encode()).hexdigest()
+        metadata = {**data['metadata'], 'orkastery_identity': identity}
+        if evolving:
+            metadata['orkastery_identity_version'] = 2
+        entry = MemoryEntry(content=data['content'], collection=data['collection'], tags=data['tags'],
+                            priority=data['priority'], source=data.get('source', 'agent'),
+                            scope='project', mandatory=False, visibility='public',
+                            metadata=metadata)
+        # A native content collision is accepted only when provenance and source agree.
+        from orkmind.core.injection import compute_content_hash
+        old = await store.find_by_content_hash(compute_content_hash(entry.content), entry.collection)
+        if old:
+            if 'orkastery_prospective' in old.metadata:
+                if not prospective_compatible(old, entry):
+                    raise ProspectiveMarkerInvalid('prospective receipt mismatch')
+                return {'ok': True, 'id': old.id, 'duplicada': True, 'collection': old.collection,
+                        'detalhe': 'duplicate; historical-origin-unknown'}
+            if not old.metadata.get('orkastery_identity'):
+                raise LegacyProvenanceCollision('unproven legacy identity')
+            if (old.content != entry.content or old.source != entry.source or old.priority != entry.priority
+                    or old.mandatory or old.scope != entry.scope or old.visibility != entry.visibility):
+                raise ValueError('existing identity mismatch')
+            if evolving:
+                provenance = {k: v for k, v in old.metadata.items() if k not in FACTORY_KEYS}
+                recognized = ((old.metadata.get('orkastery_identity_version') == 2
+                               and old.metadata.get('orkastery_identity') == identity)
+                              or legacy_factory_identity(old))
+                if not recognized or provenance != data['metadata'] or fixed_tags(old.tags) != fixed_tags(entry.tags):
+                    raise ValueError('existing decision provenance mismatch')
+                tags = {k: sorted(set(old.tags.get(k, [])) | set(entry.tags.get(k, [])))
+                        for k in set(old.tags) | set(entry.tags)}
+                if old.tags != tags or old.metadata != metadata:
+                    updated = old.model_copy(update={'tags': tags, 'metadata': metadata})
+                    if not await store.update(old.id, updated):
+                        raise ValueError('decision update rejected')
+                    saved = await store.retrieve(old.id)
+                    if (not saved or saved.tags != tags or saved.metadata != metadata or saved.content != old.content
+                            or saved.source != old.source or saved.priority != old.priority or saved.mandatory):
+                        raise ValueError('decision readback')
+            elif old.metadata != entry.metadata or old.tags != entry.tags:
+                raise ValueError('existing identity mismatch')
+            return {'ok': True, 'id': old.id, 'duplicada': True, 'collection': old.collection, 'detalhe': 'duplicate'}
+        entry_id, _ = await layer.add_memory(entry)
+        saved = await store.retrieve(entry_id)
+        if not saved or saved.metadata != entry.metadata or saved.source != entry.source:
+            raise ValueError('add readback')
+        return {'ok': True, 'id': entry_id, 'duplicada': False, 'collection': entry.collection, 'detalhe': 'created'}
+    if op != 'handoff':
+        raise ValueError('operation')
+    p = request['pedido']
+    if set(p['metadata']) & {'package_id', 'session_id', 'origin', 'destination', 'package_entry_id', 'handoff_entry_id', 'orkastery_identity'}:
+        raise ValueError('reserved G3 metadata')
+    if p['tags'].get('project') != [p['tenant']] or not p['identidade'] or not p['sessionId']:
+        raise ValueError('tenant/identity')
+    # Native lookup includes retained packages hidden from context search. The payload
+    # carries the stable factory identity, so two distinct origins cannot collide.
+    from orkmind.core.injection import compute_content_hash
+    if p['payload'].get('orkastery_identity') != p['identidade']:
+        raise ValueError('payload identity')
+    package_hash = compute_content_hash(json.dumps(p['payload'], ensure_ascii=False, indent=2, default=str))
+    existing_package = await store.find_by_content_hash(package_hash, 'semantic_log')
+    if existing_package:
+        existing = await store.retrieve(existing_package.metadata['handoff_entry_id'])
+        return {**await readback(store, p, existing), 'duplicada': True}
+    result = await submeter_handoff(layer, session_id=p['sessionId'], payload=p['payload'],
+                                    origin=p['origem'], destination=p['destino'], refacao=0)
+    if result['status'] != 'armazenado':
+        raise ValueError('G3 rejected')
+    # G3 owns validation and persistence. Only enrich entries it has just created.
+    session = await store.retrieve(result['session_entry_id'])
+    session.tags = {**session.tags, **{k: sorted(set(session.tags.get(k, [])) | set(v)) for k, v in p['tags'].items()}}
+    session.metadata = {**session.metadata, 'tenant': p['tenant']}
+    if not await store.update(session.id, session):
+        raise ValueError('session enrichment')
+    summary = await store.retrieve(result['handoff_id'])
+    package = await store.retrieve(result['package_entry_id'])
+    for entry in (summary, package):
+        entry.tags = {**entry.tags, **p['tags']}
+        entry.metadata = {**entry.metadata, **p['metadata'], 'orkastery_identity': p['identidade'],
+                          'package_entry_id': package.id, 'handoff_entry_id': summary.id}
+        entry.scope = 'project'
+        if not await store.update(entry.id, entry):
+            raise ValueError('G3 enrichment')
+    summary = await store.retrieve(summary.id)
+    return {**await readback(store, p, summary), 'duplicada': False}
+
+
+async def main(request):
+    if isinstance(request, dict) and request.get('op') == 'brain':
+        if set(request) != {'op','request'}:
+            return {'schema':'orkmind.company-brain-api/v1','state':'conflict','error':'brain.api.invalid'}
+        from orkmind.cli.company_brain import service_request
+        return service_request(request['request'])
+    if isinstance(request, dict) and request.get('op') == 'query':
+        query_contract(request)
+    native_schema_fields()
+    from orkmind.core.config import OrkMindConfig
+    from orkmind.store.factory import create_store
+    dsn = os.environ.get('ORKMIND_DATABASE_URL', '')
+    if not dsn.strip():
+        raise ValueError('missing tenant environment')
+    store = create_store(OrkMindConfig(database_url=dsn, store_backend='pgvector', embedding_provider=''))
+    try:
+        if request['op'] in ('add', 'handoff'):
+            conn = await store.inner._get_conn()
+            async with conn.transaction():
+                await conn.execute('SELECT pg_advisory_xact_lock(1869769581)')
+                return await execute(request, store)
+        return await execute(request, store)
+    finally:
+        await store.close()
+
+
+if __name__ == '__main__':
+    logging.disable(logging.CRITICAL)
+    try:
+        request = json.load(sys.stdin)
+        with contextlib.redirect_stdout(io.StringIO()), contextlib.redirect_stderr(io.StringIO()):
+            result = asyncio.run(main(request))
+        print(json.dumps(result, ensure_ascii=False))
+    except Exception as error:
+        # The factory requires an initialized tenant schema; health never provisions it.
+        code = error_code(error)
+        print(json.dumps({'error': code}))
+        sys.exit(1)

package/assets/orkmind_fixture.py

@@ -0,0 +1,67 @@
+"""Contrato de fixture externa. Apenas socket sintetico atestado; nunca DSN do ambiente."""
+import json
+import os
+from pathlib import Path
+import re
+import stat
+import time
+
+
+def receipt_file(filename):
+    try:
+        path = Path(filename)
+        root = path.parent
+        if (not path.is_absolute() or not re.fullmatch(r'receipt(?:-[a-f0-9]+)?\.json', path.name)
+                or not re.fullmatch(r'/tmp/ork-prospective-fixture-[a-zA-Z0-9-]+', str(root))
+                or root.resolve() != root or root.is_symlink()):
+            raise ValueError()
+        st = root.stat()
+        if st.st_uid != os.getuid() or stat.S_IMODE(st.st_mode) != 0o700:
+            raise ValueError()
+        fd = os.open(path, os.O_RDONLY | os.O_NOFOLLOW)
+        try:
+            st = os.fstat(fd)
+            if not stat.S_ISREG(st.st_mode) or st.st_uid != os.getuid() or stat.S_IMODE(st.st_mode) != 0o600:
+                raise ValueError()
+            with os.fdopen(fd, closefd=False) as f:
+                receipt = json.load(f)
+        finally:
+            os.close(fd)
+        if (receipt['schema'] != 'ork.native-fixture/v1' or receipt['synthetic'] is not True
+                or receipt['ownerUid'] != os.getuid() or not receipt['preparedBy'].strip()
+                or receipt['socket'] != str(root) or receipt['database'] != 'ork_i06_txn_fixture'
+                or receipt['tenant'] != 'synthetic' or receipt['expiresAt'] <= time.time()
+                or not re.fullmatch('[a-f0-9]{64}', receipt['container'])
+                or not re.fullmatch('sha256:[a-f0-9]{64}', receipt['image'])
+                or not re.fullmatch('[a-f0-9]{64}', receipt['identity'])):
+            raise ValueError()
+        socket = root / '.s.PGSQL.5432'
+        st = socket.lstat()
+        if not stat.S_ISSOCK(st.st_mode) or st.st_uid != os.getuid():
+            raise ValueError()
+        return receipt
+    except (OSError, ValueError, KeyError, TypeError):
+        raise PermissionError('runtime.fixture.invalid') from None
+
+
+def fixture_dsn(receipt):
+    # Values are validated, and credentials/operational connection strings are not inputs.
+    from psycopg.conninfo import make_conninfo
+    return make_conninfo(dbname=receipt['database'], user='postgres', host=receipt['socket'])
+
+
+async def connect_fixture(filename):
+    import psycopg
+    receipt = receipt_file(filename)
+    try:
+        conn = await psycopg.AsyncConnection.connect(fixture_dsn(receipt), autocommit=True)
+    except psycopg.OperationalError:
+        raise RuntimeError('runtime.unavailable: external fixture connection') from None
+    try:
+        row = await (await conn.execute('SELECT identity, tenant FROM public.ork_fixture_identity')).fetchone()
+        if row != (receipt['identity'], receipt['tenant']):
+            raise PermissionError('runtime.fixture.identity-mismatch')
+    except Exception:
+        await conn.close()
+        raise PermissionError('runtime.fixture.identity-mismatch') from None
+    return conn, receipt

package/assets/orkmind_prospective.py

@@ -0,0 +1,138 @@
+"""Ensaio transacional de preparacao. Sem CLI/apply e restrito a PostgreSQL sintetico.
+
+GovernedStore e responsavel por toda escrita; SQL abaixo serve somente aos locks.
+O caminho operacional depende de autoridade nativa para orfas e decisao do condutor.
+"""
+import hashlib
+import json
+import uuid
+import re
+from orkmind_fixture import receipt_file
+from orkmind_bridge import prospective_agent_valid, native_schema_fields
+from orkmind.core.models import MemoryEntry
+from orkmind.store.governance import assert_nao_protegida, assert_pode_escrever
+
+
+def digest(value):
+    return hashlib.sha256(json.dumps(value, sort_keys=True, ensure_ascii=False, separators=(',', ':')).encode()).hexdigest()
+
+
+def dump(entry):
+    return entry.model_dump(mode='json')
+
+
+def same_payload(a, b):
+    return {k: v for k, v in a.items() if k not in ('version', 'updated_at')} == {
+        k: v for k, v in b.items() if k not in ('version', 'updated_at')}
+
+
+async def rehearse(native_store, plan, requester, *, fixture_receipt=None, rollback_receipt=None, fail_after=None, locked_probe=None):
+    """Lote e compensacao EXATOS, executaveis somente em fixture; requester sempre nomeado."""
+    if not isinstance(requester, str) or not requester.strip():
+        raise PermissionError('memory.prospective.requester-required')
+    if not isinstance(fixture_receipt, str):
+        raise PermissionError('runtime.fixture.receipt-required')
+    fixture = receipt_file(fixture_receipt)
+    native_schema_fields()
+    conn = await native_store.inner._get_conn()
+    if conn.info.dbname != fixture['database'] or conn.info.host != fixture['socket']:
+        raise PermissionError('memory.prospective.operational-unavailable')
+    identity = await (await conn.execute('SELECT identity, tenant FROM public.ork_fixture_identity')).fetchone()
+    if identity != {'identity': fixture['identity'], 'tenant': fixture['tenant']}:
+        raise PermissionError('runtime.fixture.identity-mismatch')
+    items = plan['entradas']
+    ids = sorted(item['id'] for item in items)
+    if len(ids) != 3 or len(set(ids)) != 3:
+        raise ValueError('memory.prospective.scope')
+    items = sorted(items, key=lambda e: e['id'])
+    phase = 'rollback' if rollback_receipt else 'prepare-rehearsal'
+    operation_hash = digest({'plan': plan, 'requester': requester, 'rollback': rollback_receipt})
+    receipt_id = str(uuid.uuid5(uuid.NAMESPACE_URL, operation_hash + ':' + phase))
+    async with conn.transaction():
+        # ORDER BY precede o lock; todos os tres IDs sao bloqueados antes de retrieve/update.
+        rows = await (await conn.execute('SELECT id FROM memories WHERE id=ANY(%s) ORDER BY id FOR UPDATE', (ids,))).fetchall()
+        if [r['id'] for r in rows] != ids:
+            raise ValueError('memory.prospective.scope-changed')
+        if locked_probe:
+            await locked_probe(ids)
+        current = [await native_store.retrieve(i) for i in ids]
+        identities = await native_store._identidades(requester)
+        for entry in current:
+            assert_nao_protegida(entry, 'agent', 'update')
+            assert_pode_escrever(entry, requester, identities)
+            if (entry.collection != 'rule' or entry.source != 'agent' or entry.priority != 'high'
+                    or entry.mandatory or entry.visibility != 'private'):
+                raise PermissionError('memory.prospective.governance')
+        expected = [item['antes'] for item in items]
+        desired = [item['proposta'] for item in items]
+        if rollback_receipt:
+            applied = await native_store.retrieve(rollback_receipt)
+            if not applied:
+                raise ValueError('memory.prospective.receipt-missing')
+            previous = json.loads(applied.content)
+            if (previous.get('schema') != 'ork.prospective-transaction/v1'
+                    or previous.get('phase') != 'prepare-rehearsal' or previous.get('rollbackOf') is not None
+                    or previous.get('planHash') != digest(plan) or previous.get('requester') != requester):
+                raise ValueError('memory.prospective.receipt-conflict')
+            expected, desired = previous['after'], previous['before']
+        receipt = await native_store.retrieve(receipt_id)
+        if receipt:
+            previous = json.loads(receipt.content)
+            if (previous['operationHash'] != operation_hash or previous['requester'] != requester
+                    or previous['after'] != [dump(e) for e in current]):
+                raise ValueError('memory.prospective.replay-conflict')
+            return {'receiptId': receipt_id, 'replay': True, 'updated': 0}
+        if [dump(e) for e in current] != expected:
+            raise ValueError('memory.prospective.snapshot-conflict')
+        # Validacao de TODO o lote antes da primeira escrita; preservar todas as colunas.
+        targets = []
+        for old, target in zip(current, desired):
+            if set(target) != set(dump(old)):
+                raise ValueError('memory.prospective.snapshot-incomplete')
+            changed = {k for k in target if target[k] != dump(old)[k]}
+            permitted = {'tags', 'metadata'} | ({'version', 'updated_at'} if rollback_receipt else set())
+            if changed - permitted:
+                raise ValueError('memory.prospective.field-change')
+            if target['tags'].get('editors', []) != old.tags.get('editors', []):
+                raise PermissionError('memory.prospective.acl-change')
+            if not rollback_receipt:
+                try:
+                    marker = target['metadata']['orkastery_prospective']
+                    original = marker['originalJson']
+                    if (set(marker) != {'schema', 'historicalOrigin', 'source', 'entryId', 'agent', 'revision',
+                                        'receiptSha256', 'originalJson', 'originalSha256'}
+                            or marker['schema'] != 'ork.prospective-origin/v1'
+                            or marker['historicalOrigin'] != 'unknown' or marker['source'] != 'agent'
+                            or not prospective_agent_valid(marker['agent'])
+                            or not re.fullmatch('[a-f0-9]{40}', marker['revision'])
+                            or not re.fullmatch('[a-f0-9]{64}', marker['receiptSha256'])
+                            or marker['entryId'] != old.id or json.loads(original) != dump(old)
+                            or hashlib.sha256(original.encode()).hexdigest() != marker['originalSha256']):
+                        raise ValueError()
+                except (KeyError, ValueError, TypeError, AttributeError):
+                    raise ValueError('memory.prospective.marker-invalid') from None
+            targets.append(MemoryEntry.model_validate({**target, 'version': old.version, 'updated_at': dump(old)['updated_at']}))
+        for n, (old, target) in enumerate(zip(current, targets), 1):
+            if await native_store.inner._get_conn() is not conn:
+                raise RuntimeError('memory.prospective.connection-changed')
+            if not await native_store.update(old.id, target, requester_id=requester):
+                raise ValueError('memory.prospective.update-refused')
+            saved = await native_store.retrieve(old.id)
+            if saved.version != old.version + 1 or not same_payload(dump(saved), dump(target)):
+                raise ValueError('memory.prospective.readback')
+            if fail_after == n:
+                raise RuntimeError('fixture.injected-failure')
+        after = [dump(await native_store.retrieve(i)) for i in ids]
+        body = {'schema': 'ork.prospective-transaction/v1', 'phase': phase, 'operationHash': operation_hash,
+                'planHash': digest(plan), 'requester': requester, 'before': expected, 'after': after,
+                'rollbackOf': rollback_receipt, 'historicalOrigin': 'unknown'}
+        # Sidecar nativo integral, privado e duravel na MESMA transacao; nao memory_versions parcial.
+        receipt = MemoryEntry(id=receipt_id, collection='semantic_log', content=json.dumps(body, ensure_ascii=False),
+                              source='agent', priority='high', mandatory=False, visibility='private',
+                              scope='project', author_id=requester, tags={'project': current[0].tags['project']},
+                              metadata={'operationHash': operation_hash, 'historicalOrigin': 'unknown'})
+        if await native_store.store(receipt) != receipt_id:
+            raise ValueError('memory.prospective.receipt-write')
+        if json.loads((await native_store.retrieve(receipt_id)).content) != body:
+            raise ValueError('memory.prospective.receipt-readback')
+    return {'receiptId': receipt_id, 'replay': False, 'updated': 3}

package/assets/reference-tariffs-i07.json

@@ -0,0 +1,23 @@
+{
+  "schema": "ork.reference-tariffs/v1",
+  "verifiedAt": "2026-09-08T00:00:00.000Z",
+  "currency": "USD",
+  "unitTokens": 1000000,
+  "nature": "estimated_reference",
+  "models": {
+    "gpt-6-astra": {
+      "product": "Codex Enterprise reference",
+      "input": 10,
+      "cachedInput": 1,
+      "output": 50,
+      "source": "https://openai.com/business/codex-pricing/"
+    },
+    "claude-opus-5": {
+      "product": "Claude API reference",
+      "input": 5,
+      "cachedInput": 0.5,
+      "output": 25,
+      "source": "https://docs.anthropic.com/en/docs/about-claude/pricing"
+    }
+  }
+}