sable-sphynx 0.7.0.dev0__py3-none-any.whl

sphynx/reflex_traces.py

@@ -0,0 +1,193 @@
+"""Offline ingestion of opt-in Reflex quality traces; no service or model calls."""
+from __future__ import annotations
+
+import copy
+import hashlib
+from pathlib import Path
+
+from ._rag_diagnostics_contracts import ContractError, validate_dataset
+from ._rag_diagnostics_importers import _json
+
+SCHEMA = "reflex.query-quality.v1"
+MAX_FILE_BYTES = 100_000_000
+
+
+def _need(condition, message):
+    if not condition:
+        raise ContractError(message)
+
+
+def _hash(value):
+    return isinstance(value, str) and len(value) == 64 and all(c in '0123456789abcdef' for c in value)
+
+
+def load_reflex_traces(path: str | Path) -> dict:
+    """Load finalized, unsampled, loss-free Reflex JSONL quality evidence.
+
+    Health requests are retained separately. Failed search records are explicit;
+    they cannot be substituted with successful empty rankings.
+    """
+    path = Path(path)
+    _need(path.is_file() and not path.is_symlink() and path.stat().st_size <= MAX_FILE_BYTES,
+          'Expected a regular Reflex trace file no larger than 100MB')
+    raw = path.read_bytes()
+    _need(len(raw) <= MAX_FILE_BYTES, 'Reflex trace file exceeds 100MB')
+    rows = [_json(line) for line in raw.splitlines() if line.strip()]
+    _need(len(rows) >= 2 and all(type(row) is dict for row in rows), 'Expected finalized JSONL records')
+    session, summary = rows[0], rows[-1]
+    _need(session.get('type') == 'session' and summary.get('type') == 'summary', 'Missing session or final summary')
+    _need(session.get('version') == 1 and summary.get('version') == 1, 'Unsupported Reflex timing schema')
+    _need(type(session.get('sample_every')) is int and session['sample_every'] == 1,
+          'Complete quality capture requires sample_every=1')
+    counters = ('observed', 'sampled', 'enqueued', 'written', 'dropped', 'unfinished')
+    _need(all(type(summary.get(key)) is int and summary[key] >= 0 for key in counters), 'Invalid trace counters')
+    requests = rows[1:-1]
+    _need(summary['written'] == len(requests) == summary['enqueued'], 'Written trace counts do not reconcile')
+    _need(summary['sampled'] == summary['enqueued'] + summary['dropped'] + summary['unfinished'] == summary['observed'],
+          'Sampled/observed trace counts do not reconcile')
+    _need(summary['dropped'] == summary['unfinished'] == 0, 'Dropped or unfinished evidence cannot claim complete capture')
+    ids, searches, other = set(), {}, 0
+    for row in requests:
+        rid = row.get('request_id')
+        _need(row.get('type') == 'request' and row.get('version') == 1 and type(rid) is str and rid and rid not in ids,
+              'Request IDs must be unique and nonempty')
+        ids.add(rid)
+        _need(type(row.get('elapsed_ns')) is int and row['elapsed_ns'] >= 0, 'Invalid elapsed time')
+        end = 0
+        _need(type(row.get('spans')) is list and all(type(s) is dict for s in row['spans']), 'Trace spans are required')
+        _need(row.get('outcome') in ('response_prepared', 'abandoned'), 'Invalid request outcome')
+        _need(row.get('mode') in (None, 'normal', 'speculative'), 'Unknown Reflex execution mode')
+        _need(row.get('http_status') is None or type(row['http_status']) is int and 100 <= row['http_status'] <= 599,
+              'Invalid HTTP status')
+        for span in sorted(row['spans'], key=lambda s: s.get('start_ns', -1)):
+            _need(type(span.get('start_ns')) is int and type(span.get('duration_ns')) is int
+                  and span['start_ns'] >= end and span['duration_ns'] >= 0, 'Invalid or overlapping timing spans')
+            end = span['start_ns'] + span['duration_ns']
+            _need(end <= row['elapsed_ns'], 'Timing span exceeds request duration')
+        if row.get('mode') not in ('normal', 'speculative'):
+            other += 1
+            continue
+        quality = row.get('quality')
+        if quality is None and row.get('http_status') != 200:
+            # Decode/admission failures have no executed query pipeline. Keep the
+            # request in the census; pairing cannot invent its missing query.
+            searches[rid] = copy.deepcopy(row)
+            continue
+        _need(type(quality) is dict and quality.get('schema_version') == SCHEMA,
+              'Search is missing opt-in Reflex quality evidence')
+        _need(type(quality.get('query')) is str and 0 < len(quality['query']) <= 20000, 'Missing or oversized exact query')
+        _need(_hash(quality.get('snapshot_sha256')), 'Exact served snapshot identity is required')
+        _need(type(quality.get('indexed_passages')) is int and quality['indexed_passages'] >= 0, 'Invalid index population')
+        _need(type(quality.get('top_k')) is int and 1 <= quality['top_k'] <= 100, 'Invalid requested result limit')
+        _need(type(quality.get('reranking_applied')) is bool, 'Reranking execution must be explicit')
+        _need(quality.get('capture_status') in ('complete', 'incomplete', 'content_limit'), 'Invalid capture status')
+        _need(quality['capture_status'] != 'content_limit', 'Quality content limit reached; capture is incomplete')
+        stages = quality.get('stages')
+        _need(type(stages) is dict and set(stages) == {'retrieved', 'reranked', 'selected'}, 'Explicit stage records required')
+        documents, previous = {}, None
+        for stage in ('retrieved', 'reranked', 'selected'):
+            ranking = stages[stage]
+            if ranking is None:
+                continue
+            _need(type(ranking) is list and len(ranking) <= 10000, 'Invalid stage ranking')
+            current = set()
+            for hit in ranking:
+                _need(type(hit) is dict and _hash(hit.get('chunk_sha256')) and type(hit.get('position')) is int
+                      and 0 <= hit['position'] < quality['indexed_passages'], 'Invalid passage identity')
+                _need(_hash(hit.get('artifact_sha256')) and type(hit.get('chunk_index')) is int
+                      and hit['chunk_index'] >= 0, 'Original artifact/chunk coordinates required')
+                _need(type(hit.get('text')) is str and type(hit.get('searchable_text')) is str, 'Exact passage texts required')
+                score = hit.get('score')
+                _need(type(score) in (int, float), 'Finite stage score required')
+                identity = f"{quality['snapshot_sha256']}:{hit['position']}"
+                _need(identity not in current, 'Duplicate stage passage identity')
+                current.add(identity)
+                document = {'id': identity, 'text': hit['text'], 'searchable_text': hit['searchable_text'],
+                            'chunk_sha256': hit['chunk_sha256'], 'artifact_sha256': hit['artifact_sha256'],
+                            'chunk_index': hit['chunk_index']}
+                _need(identity not in documents or documents[identity] == document, 'Passage content changed between stages')
+                documents[identity] = document
+            _need(previous is None or current <= previous, 'A later stage invents a passage')
+            previous = current
+        _need(stages['reranked'] is None or quality['reranking_applied'], 'Unexecuted reranking cannot claim a ranking')
+        if row.get('outcome') == 'response_prepared' and row.get('http_status') == 200:
+            _need(quality['capture_status'] == 'complete' and stages['retrieved'] is not None and stages['selected'] is not None,
+                  'Successful search is missing stage evidence')
+            _need(not quality['reranking_applied'] or stages['reranked'] is not None, 'Missing reranked stage')
+            _need(len(stages['selected']) <= quality['top_k'], 'Selected count exceeds requested limit')
+            upstream = stages['reranked'] if quality['reranking_applied'] else stages['retrieved']
+            _need(stages['selected'] == upstream[:quality['top_k']], 'Selected output is not the exact final ranking prefix')
+        searches[rid] = copy.deepcopy(row)
+    return {'schema_version': 'sphynx.reflex-trace-file.v1', 'requests': searches,
+            'nonsearch_requests': other, 'source_sha256': hashlib.sha256(raw).hexdigest(),
+            'source_bytes': len(raw), 'summary': summary}
+
+
+def pair_reflex_traces(baseline: dict, candidate: dict, case_requests: dict, *, release: str,
+                       execution_identities: dict) -> dict:
+    """Pair exact request IDs, without deriving labels or matching by query text.
+
+    Each case mapping supplies baseline/candidate request IDs and a cluster ID.
+    Cluster IDs describe grouping; they never authorize population inference.
+    """
+    _need(type(release) is str and release and type(case_requests) is dict and case_requests, 'Release and explicit case map required')
+    _need(type(execution_identities) is dict and set(execution_identities) == {'baseline', 'candidate'},
+          'Both execution identity manifests are required')
+    for identity in execution_identities.values():
+        _need(type(identity) is dict and type(identity.get('source_commit')) is str
+              and len(identity['source_commit']) == 40 and all(c in '0123456789abcdef' for c in identity['source_commit'])
+              and _hash(identity.get('binary_sha256')) and _hash(identity.get('query_plan_sha256')),
+              'Pin exact source commit, executable bytes, and query plan')
+        _need(type(identity.get('model_artifacts_sha256')) is dict
+              and all(type(k) is str and k and _hash(v) for k, v in identity['model_artifacts_sha256'].items()),
+              'Explicit model artifact hashes required (empty only for model-free execution)')
+    cases, used = [], {'baseline': set(), 'candidate': set()}
+    for case_id, binding in case_requests.items():
+        _need(type(binding) is dict and set(binding) == {'baseline', 'candidate', 'cluster_id'}, 'Case map requires both request IDs and a cluster ID')
+        records = {}
+        for variant, source in (('baseline', baseline), ('candidate', candidate)):
+            rid = binding[variant]
+            _need(rid in source['requests'] and rid not in used[variant], 'Unknown or reused request ID')
+            used[variant].add(rid)
+            records[variant] = source['requests'][rid]
+        _need(all(type(r.get('quality')) is dict for r in records.values()),
+              'Pre-execution failure has no query to pair; retain it in the request census and resolve explicitly')
+        left, right = (records[v]['quality'] for v in ('baseline', 'candidate'))
+        _need(left['query'] == right['query'], 'Paired requests have different exact queries')
+        _need(left['snapshot_sha256'] == right['snapshot_sha256'], 'Paired requests must use the same frozen corpus snapshot')
+        documents, traces = {}, {}
+        for variant, record in records.items():
+            quality = record['quality']
+            stages = {'indexed': None, 'retrieved': None, 'reranked': None, 'selected': None, 'prompt': None}
+            for stage, ranking in quality['stages'].items():
+                if ranking is None:
+                    continue
+                stages[stage] = []
+                for hit in ranking:
+                    did = f"{quality['snapshot_sha256']}:{hit['position']}"
+                    stages[stage].append(did)
+                    document = {key: hit[key] for key in ('text', 'searchable_text', 'chunk_sha256', 'artifact_sha256', 'chunk_index')}
+                    document['id'] = did
+                    _need(did not in documents or documents[did] == document, 'Paired document bytes differ')
+                    documents[did] = document
+            ok = record.get('outcome') == 'response_prepared' and record.get('http_status') == 200
+            traces[variant] = {'id': record['request_id'], 'execution_mode': 'recorded_replay', 'stages': stages,
+                'response': {'status': 'ok' if ok else 'error', 'text': '', 'abstained': None},
+                'operational': {'origin': 'component_reported', 'latency_ms': None,
+                                'tokens': None, 'cost_usd': None},
+                'reflex_server_timing': {'elapsed_ns': record['elapsed_ns'], 'spans': copy.deepcopy(record['spans']),
+                    'scope': 'Reflex server request with content-capture overhead; excludes generation, TTS and playout',
+                    'performance_comparison_eligible': False},
+                'reflex_quality': copy.deepcopy(quality), 'answer_generation_observed': False}
+        cases.append({'id': case_id, 'suite_id': 'reflex-search', 'cluster_id': binding['cluster_id'],
+            'question': left['query'], 'documents': list(documents.values()), 'traces': traces,
+            'references': {'qrels': None, 'corpus_answerable': None, 'required_atoms': None, 'atom_support': None,
+                           'required_relations': None, 'relation_support': None, 'reviews': {'baseline': None, 'candidate': None}}})
+    _need(all(used[v] == set(source['requests']) for v, source in (('baseline', baseline), ('candidate', candidate))),
+          'Explicit case mapping must account for every search request; no silent exclusions')
+    return validate_dataset({'schema_version': 'sphynx.rag-diagnostics.dataset.v1', 'release': release,
+        'suites': [{'id': 'reflex-search', 'title': 'Recorded Reflex retrieval pipeline'}], 'cases': cases,
+        'provenance': {'baseline_sha256': baseline['source_sha256'], 'candidate_sha256': candidate['source_sha256'],
+                       'independent_clusters_verified': False, 'human_review_status': 'KIV',
+                       'execution_identities': copy.deepcopy(execution_identities),
+                       'scope': 'Reflex-owned stages only; no final prompt/answer or population claim'}})

sphynx/report_rendering.py

@@ -0,0 +1,71 @@
+"""Readable lifecycle projections without changing saved report payloads."""
+from __future__ import annotations
+
+from collections.abc import Mapping
+from html import escape
+import json
+
+
+def _cell(value):
+    if value is None:
+        return 'unavailable'
+    if isinstance(value, bool):
+        return str(value).lower()
+    return escape(str(value)).replace('|', '\\|').replace('\r', ' ').replace('\n', ' ')
+
+
+def _facts(value, prefix=''):
+    if isinstance(value, Mapping):
+        for key, item in value.items():
+            yield from _facts(item, prefix + str(key) + '.')
+    elif isinstance(value, (list, tuple)):
+        yield prefix.rstrip('.'), _cell(json.dumps(value, ensure_ascii=False, allow_nan=False))
+    elif isinstance(value, (str, int, float, bool)) or value is None:
+        yield prefix.rstrip('.'), _cell(value)
+
+
+def lifecycle_markdown(value, context=None):
+    """Display supplied facts; unknown units/coverage remain undeclared."""
+    context = context or {}
+    lines = ['# Engineering evaluation report', '']
+    identity_keys = ('suite_id', 'suite_version', 'run_id', 'grading_id', 'scope', 'mode', 'status', 'trust_tier')
+    for key in identity_keys:
+        item = context.get(key, value.get(key))
+        lines.append(_cell(key.replace('_', ' ').capitalize()) + ': ' + _cell(item))
+    for name in ('candidate', 'evaluator', 'execution_policy'):
+        supplied = context.get(name, value.get(name))
+        if isinstance(supplied, Mapping):
+            lines += ['', _cell(name.replace('_', ' ').capitalize()) + ':']
+            lines.extend('- ' + _cell(key) + ': ' + item for key, item in _facts(supplied))
+    coverage = context.get('coverage')
+    if isinstance(coverage, Mapping):
+        lines += ['', 'Grading coverage (case/trial units):']
+        lines.extend('- ' + _cell(key.replace('_', ' ')) + ': ' + item for key, item in _facts(coverage))
+    else:
+        lines += ['', 'Required/observed/missing coverage: not declared by this projection.']
+    counts = value.get('counts')
+    if isinstance(counts, Mapping):
+        lines += ['', '| Report count | Value |', '| --- | ---: |']
+        lines.extend('| ' + _cell(key) + ' | ' + item + ' |' for key, item in _facts(counts))
+    metrics = value.get('metrics')
+    if isinstance(metrics, Mapping) and metrics:
+        lines += ['', '| Metric | Value | Unit | Direction |', '| --- | ---: | --- | --- |']
+        definitions = context.get('metric_definitions', {})
+        for name, metric in metrics.items():
+            definition = definitions.get(name, {})
+            item = metric if isinstance(metric, Mapping) else {'value': metric}
+            number = item.get('value')
+            lines.append('| ' + ' | '.join(_cell(x) for x in (name,
+                number if not isinstance(number, (Mapping, list, tuple)) else 'see native details',
+                item.get('unit', definition.get('unit', 'not declared')),
+                item.get('direction', definition.get('direction', 'not declared')))) + ' |')
+    else:
+        lines += ['', 'No common numeric metric is declared. Inspect the permitted assessments and native details.']
+    for key in ('reason', 'outcome'):
+        if isinstance(value.get(key), (str, bool, int, float)):
+            lines += ['', key.capitalize() + ': ' + _cell(value[key])]
+    lines += ['', 'Execution/grading completion does not supply a ranking or acceptance verdict.', '',
+              '<details><summary>Complete permitted native projection</summary>', '', '<pre>' +
+              escape(json.dumps(value, ensure_ascii=False, allow_nan=False, sort_keys=True, indent=2)) +
+              '</pre>', '', '</details>', '']
+    return '\n'.join(lines)

sphynx/rerank_family_contracts.py

@@ -0,0 +1,150 @@
+"""Frozen, label-free ranking-family inputs and provenance.
+
+These objects declare algorithm and asset identity. They do not grant benchmark
+authority, execute models, fit coefficients, or attest to honest local execution.
+"""
+from __future__ import annotations
+
+import hashlib
+import json
+import math
+import re
+from collections.abc import Mapping
+from dataclasses import dataclass
+from pathlib import Path
+from types import MappingProxyType
+
+from .contracts import ContractError, canonical_json
+from .integration_contracts import CandidateConfiguration, _freeze, _wire, require_digest, value_digest
+
+FAMILY_INTERFACE = "sphynx.rerank-family.v1"
+FITTED_SCHEMA = "sphynx.frozen-rerank-state.v1"
+SOURCE_PINS = MappingProxyType({
+    "statistical-rerankers.ts": "sha256:28fd9a5e8c6a654fd42db96f3b898b2e1b4e3b8797e39bad41601a7c3edd2130",
+    "minilm-treatments.ts": "sha256:a78fbfa25f7884babc623486b3130244e4e888e110bcacae01ae5711f5a2830e",
+    "nextgen-rerankers.ts": "sha256:53f4d9e2052309e13678889db28d72a77beae6710a885d49f7b14ed97e0c0189",
+    "nextgen-evaluation.ts": "sha256:472424150ecff491a8d710688204f68e3e7c6aa1d4cdde05fdac402dac1e6e5c",
+    "metrics.ts": "sha256:57c3207e0bf521ae177f25702603e8556292bb9d818dd2dc2c598878f36d964e",
+    "calibrator-fit.ts": "sha256:68f3c33850e6d364b559a5a65bf2656b7c981b6366b16fb2cb9c9e2b8ad823e7",
+    "cherry/evaluate_training_free.py": "sha256:c3e9342df622c7860c711afe43336f4318543ac3adaff6cbcbd0dc06e944a805",
+})
+
+
+def finite(value, name="signal"):
+    if type(value) not in (int, float) or not math.isfinite(value):
+        raise ContractError(f"{name} must be finite numeric data")
+    return float(value)
+
+
+def validate_signals(signals, required=()):
+    """Check complete aligned source signals; no relevance labels are accepted."""
+    if not isinstance(signals, (list, tuple)) or not 1 <= len(signals) <= 100:
+        raise ContractError("ranking families require 1..100 signals")
+    forbidden = {"grade", "label", "relevance_grade", "evaluation_grade", "training_grade", "references", "gold"}
+    allowed = {"candidate_id", "dense_score", "dense_rank", "minilm_logit", "jina_logit", "bm25_score", "query_text", "passage_text", "feature_values"}
+    rows, ids, ranks = [], set(), set()
+    for signal in signals:
+        if not isinstance(signal, Mapping) or set(signal) & forbidden or set(signal) - allowed:
+            raise ContractError("signals must contain only declared label-free fields")
+        row = dict(signal)
+        identity = row.get("candidate_id")
+        if not isinstance(identity, str) or not identity or len(identity) > 256 or identity in ids:
+            raise ContractError("candidate IDs must be nonempty and unique")
+        ids.add(identity)
+        rank = row.get("dense_rank")
+        if type(rank) is not int or not 1 <= rank <= len(signals) or rank in ranks:
+            raise ContractError("dense ranks must be a permutation of 1..pool size")
+        ranks.add(rank)
+        for field in ("dense_score", *required):
+            if field not in row:
+                raise ContractError(f"missing required source signal: {field}")
+            row[field] = finite(row[field], field)
+        for field in ("minilm_logit", "jina_logit", "bm25_score"):
+            if field in row:
+                row[field] = finite(row[field], field)
+        rows.append(row)
+    return rows
+
+
+@dataclass(frozen=True)
+class FrozenFittedState:
+    """An exact external fitted artifact plus truthful caller-supplied lineage.
+
+    The payload remains external. Binding IDs does not independently prove that
+    the declared training/calibration partitions were used or reviewed.
+    """
+    method: str
+    payload: Mapping
+    artifact_digest: str
+    provenance: Mapping
+    schema_version: str = FITTED_SCHEMA
+
+    def __post_init__(self):
+        if self.schema_version != FITTED_SCHEMA or self.method not in ("T2", "T7", "T14", "T17", "T18", "T19", "T20", "T21", "T22"):
+            raise ContractError("unsupported frozen fitted-state schema or method")
+        require_digest(self.artifact_digest, "artifact_digest")
+        if not isinstance(self.payload, Mapping) or not isinstance(self.provenance, Mapping):
+            raise ContractError("fitted payload/provenance must be objects")
+        fields = {"source_digest", "fit_cohort_digest", "calibration_cohort_digest", "excluded_evaluation_cohort_digest", "family_digest", "label_mode", "authority", "original_artifact_digest", "payload_digest"}
+        if set(self.provenance) != fields:
+            raise ContractError("fitted provenance differs from the exact schema")
+        for key in fields - {"label_mode", "authority"}:
+            require_digest(self.provenance[key], key)
+        if self.provenance["label_mode"] not in ("fully_labeled", "known_judgments_only", "positive_unlabeled_diagnostic"):
+            raise ContractError("fitted label policy is unknown")
+        if self.provenance["authority"] != "caller_declared_unverified":
+            raise ContractError("local fitted lineage cannot claim verified authority")
+        if self.provenance["payload_digest"] != value_digest(self.payload):
+            raise ContractError("fitted payload differs from its binding")
+        expected_source=SOURCE_PINS['minilm-treatments.ts' if self.method in ('T2','T7','T14','T17','T18') else 'nextgen-rerankers.ts']
+        if self.provenance['source_digest']!=expected_source:
+            raise ContractError("fitted source implementation differs from the admitted family")
+        object.__setattr__(self, "payload", _freeze(self.payload,reject_secrets=True))
+        object.__setattr__(self, "provenance", _freeze(self.provenance,reject_secrets=True))
+
+    def ensure_evaluation_cohort(self, digest):
+        require_digest(digest, "evaluation cohort")
+        if digest != self.provenance["excluded_evaluation_cohort_digest"] or digest in (self.provenance["fit_cohort_digest"], self.provenance["calibration_cohort_digest"]):
+            raise ContractError("evaluation cohort differs from the declared excluded partition")
+
+    def to_dict(self):
+        return {"schema_version": self.schema_version, "method": self.method, "payload": _wire(self.payload), "artifact_digest": self.artifact_digest, "provenance": _wire(self.provenance)}
+
+
+def load_fitted_state(path, expected_sha256):
+    """Read a bounded frozen wrapper; never refit or import artifact code."""
+    require_digest(expected_sha256, "fitted state digest")
+    raw = Path(path).read_bytes()
+    if len(raw) > 8 * 1024 * 1024 or "sha256:" + hashlib.sha256(raw).hexdigest() != expected_sha256:
+        raise ContractError("fitted state bytes differ from the supplied digest")
+    def unique(pairs):
+        result = {}
+        for key, value in pairs:
+            if key in result: raise ContractError("duplicate fitted-state JSON key")
+            result[key] = value
+        return result
+    try:
+        value = json.loads(raw, object_pairs_hook=unique, parse_constant=lambda _: (_ for _ in ()).throw(ContractError("nonfinite fitted-state JSON")))
+    except ContractError:
+        raise
+    except (ValueError, UnicodeError):
+        raise ContractError("invalid fitted-state JSON") from None
+    if not isinstance(value, dict) or set(value) != {"schema_version", "method", "payload", "provenance"}:
+        raise ContractError("fitted-state wrapper fields differ")
+    return FrozenFittedState(value["method"], value["payload"], expected_sha256, value["provenance"], value["schema_version"])
+
+
+def family_configuration(method, implementation_digest, *, parameters, scorers=None, fitted_state=None):
+    dependencies = {}
+    for name, scorer in (scorers or {}).items():
+        config = getattr(scorer, "configuration", None)
+        if not isinstance(config, CandidateConfiguration):
+            raise ContractError("every source scorer must expose its immutable CandidateConfiguration")
+        dependencies[name] = config.to_dict()
+    # Original arm names contain '/' (for example MiniLM-W90/10). Keep that
+    # exact name in parameters; the SDK's stable identifier grammar uses '-'.
+    return CandidateConfiguration("rerank-family:" + method.replace("/", "-"), FAMILY_INTERFACE, implementation_digest,
+        {"method": method, "method_version": "v1", "reference_sources": dict(SOURCE_PINS),
+         "parameters": parameters, "source_scorers": dependencies,
+         "fitted_state": None if fitted_state is None else {"artifact_digest": fitted_state.artifact_digest, "provenance": _wire(fitted_state.provenance)}},
+        "recorded" if dependencies and all(value["execution_mode"] == "recorded" for value in dependencies.values()) else "trusted_local")